@cassiomc1/forgeloop 1.13.0 → 2.0.0-rc.2

package/src/core/completion.js

@@ -10,7 +10,7 @@ import { completionRelationshipErrors } from "./completion-relationships.js";
 import { assertSafePath, ensureWithin, fileExists } from "./filesystem.js";
 import { evaluateStartExecutionPrerequisites, hasExecutionStarted } from "./execution-prerequisites.js";
 import { isRecoverableCompletionEvidenceCode } from "./completion-recovery.js";
-import { evaluateTerminalRequirements } from "./evidence-readiness.js";
+import { evaluateTerminalRequirements, terminalRequirementsForContract } from "./evidence-readiness.js";
 import { PROJECT_ARTIFACT_PATHS, taskArtifactPath, taskCodeManifestPath } from "./task-paths.js";
 import { detectPolicyCapability, evaluateTargetPolicy } from "./policy-engine.js";
 import { listActions } from "./actions.js";
@@ -18,7 +18,9 @@ import { readConfig } from "./config.js";
 import { resolveResponsibilityStatus } from "./responsibility.js";
 import { createCodeManifest, readCodeManifest, validateCodeManifestBindings, writeCodeManifest } from "./code-manifest.js";
 import { getTaskTransaction, withTaskTransaction } from "./transaction.js";
+import { operationalArtifactExists } from "../storage/operational-context.js";
 import { validateStructuralQualityCheckProvenance } from "./structural-quality/service.js";
+import { withNativeReadScope } from "./native-storage.js";
 
 async function attestationConfiguration(target, packageRoot, errors) {
   try {
@@ -79,6 +81,12 @@ function issue(code, message, artifacts = [], details = {}) {
   return { code, message, artifacts, ...details };
 }
 
+export function receiptReadFailure(error, relativePath) {
+  return error.taskIdentityMismatch
+    ? issue("E_RECEIPT_TASK_MISMATCH", "Execution receipt does not belong to the current contract task", [relativePath])
+    : issue("E_RECEIPT_INVALID", `Repair or remove the invalid execution receipt before continuing: ${error.message}`, [relativePath]);
+}
+
 export function completionIdentityErrors({ contract, state, receipt } = {}) {
   return completionRelationshipErrors({ contract, state, receipt })
     .filter((error) => ["E_STATE_TASK_MISMATCH", "E_RECEIPT_TASK_MISMATCH"].includes(error.code));
@@ -226,6 +234,10 @@ async function loadRequired(readArtifact, errorCode, errorMessage, artifacts, er
   try {
     return await readArtifact();
   } catch (error) {
+    if (errorCode === "E_RECEIPT_MISSING" && error.taskIdentityMismatch) {
+      errors.push(receiptReadFailure(error, artifacts[0]));
+      return null;
+    }
     if (error.code === "ARTIFACT_MISSING") {
       errors.push(issue(errorCode, errorMessage, artifacts));
       return null;
@@ -235,6 +247,19 @@ async function loadRequired(readArtifact, errorCode, errorMessage, artifacts, er
   }
 }
 
+async function loadCompletionActions(target, packageRoot, taskId, errors) {
+  const { evaluateRequiredActionReadiness } = await import("./action-readiness.js");
+  const evidence = taskId ? await loadRequired(async () => ({
+    actions: await listActions(target, { packageRoot, taskId }),
+    readiness: await evaluateRequiredActionReadiness({ target, packageRoot, taskId }),
+  }), "E_ACTION_INVALID", "Durable action evidence is not available", [taskArtifactPath(taskId, "actions")], errors) : null;
+  return {
+    actions: evidence?.actions ?? [],
+    readiness: evidence?.readiness
+      ?? { total: 0, satisfied: 0, unresolved: 0, ambiguous: 0, failed: 0, untrusted: 0, actions: [] },
+  };
+}
+
 function publicationStatus(receipt) {
   if (receipt.publicationStatus) return receipt.publicationStatus;
   if (receipt.publication?.deployed) return "deployed";
@@ -246,9 +271,10 @@ function publicationStatus(receipt) {
 async function validateLedger(target, scopedTaskId, contractTaskId, state, errors, packageRoot, options = {}) {
   const eventsRel = options.eventsPath ?? (scopedTaskId ? taskArtifactPath(scopedTaskId, "events") : ARTIFACT_PATHS.events);
   const stateRel = options.statePath ?? (scopedTaskId ? taskArtifactPath(scopedTaskId, "state") : ARTIFACT_PATHS.state);
-  await assertSafePath(target, eventsRel);
+  const operationalExists = operationalArtifactExists(target, eventsRel);
+  if (operationalExists === null) await assertSafePath(target, eventsRel);
   const eventsFilePath = ensureWithin(target, eventsRel);
-  if (!(await fileExists(eventsFilePath))) {
+  if (operationalExists === false || (operationalExists === null && !(await fileExists(eventsFilePath)))) {
     errors.push(issue("E_PHASE_CHRONOLOGY_INVALID", "Protocol event ledger is required before completion", [eventsRel]));
     return { valid: false, events: [], errors: [] };
   }
@@ -286,6 +312,35 @@ export async function evaluateCompletion({
   receiptPath = null,
   eventsPath = null,
   preflightPath = null,
+} = {}) {
+  const options = { target, packageRoot, strict, authorityContext, runtimeContext, taskId, contractPath, routePath, statePath, receiptPath, eventsPath, preflightPath };
+  return withNativeReadScope(target, async () => evaluateSelectedCompletion(await resolveCompletionTaskOptions(options)));
+}
+
+async function resolveCompletionTaskOptions(options) {
+  if (options.taskId) return options;
+  try {
+    const state = await readWorkState(options.target, { packageRoot: options.packageRoot, statePath: options.statePath });
+    return state ? { ...options, taskId: state.taskId } : options;
+  } catch {
+    // Preserve the evaluator's structured missing/invalid-state diagnostics.
+    return options;
+  }
+}
+
+async function evaluateSelectedCompletion({
+  target,
+  packageRoot,
+  strict = false,
+  authorityContext,
+  runtimeContext,
+  taskId = null,
+  contractPath = null,
+  routePath = null,
+  statePath = null,
+  receiptPath = null,
+  eventsPath = null,
+  preflightPath = null,
 } = {}) {
   const errors = [];
   const preflight = await evaluatePreflight({ target, packageRoot, strict, taskId, contractPath, routePath, statePath });
@@ -500,12 +555,10 @@ export async function evaluateCompletion({
   const publication = receiptValue ? publicationStatus(receiptValue) : "not-published";
 
   if (contract) {
-    const allContractReqs = [
-      ...(contract.value.verification ?? []),
-      ...(contract.value.successCriteria ?? []),
-    ];
     const terminalEval = evaluateTerminalRequirements({
-      requirements: allContractReqs,
+      requirements: terminalRequirementsForContract(contract.value, {
+        additionalEvidence: preflight.policy?.requiredEvidence ?? [],
+      }),
       receipt: receiptValue,
     });
     for (const termErr of terminalEval.errors) {
@@ -559,19 +612,14 @@ export async function evaluateCompletion({
   }
 
   const actionTaskId = contract?.value?.taskId ?? taskId;
-  const durableActions = actionTaskId
-    ? await listActions(target, { packageRoot, taskId: actionTaskId })
-    : [];
+
   const contractRequirements = new Set([
     ...(contract?.value?.verification ?? []), ...(contract?.value?.successCriteria ?? []),
   ]);
   // Completion truth consumes the canonical action-readiness projection, not
   // raw state labels: a forged VERIFIED label can never satisfy a required
   // action (INV-VERIFY-02).
-  const { evaluateRequiredActionReadiness } = await import("./action-readiness.js");
-  const requiredActionReadiness = actionTaskId
-    ? await evaluateRequiredActionReadiness({ target, packageRoot, taskId: actionTaskId })
-    : { total: 0, satisfied: 0, unresolved: 0, ambiguous: 0, failed: 0, untrusted: 0, actions: [] };
+  const { actions: durableActions, readiness: requiredActionReadiness } = await loadCompletionActions(target, packageRoot, actionTaskId, errors);
   for (const readiness of requiredActionReadiness.actions) {
     if (readiness.status === "SATISFIED") continue;
     const action = durableActions.find((candidate) => candidate.actionId === readiness.actionId);
@@ -855,6 +903,7 @@ async function runCompleteInternal({
 }
 
 export async function runComplete(options = {}) {
+  options = await resolveCompletionTaskOptions(options);
   const taskId = options.taskId ?? null;
   if (options.persist !== false && taskId && !(await getTaskTransaction(options.target))) {
     return withTaskTransaction({

package/src/core/config.js

@@ -4,6 +4,7 @@ import { E_ATTESTATION_CONFIGURATION_INVALID } from "./error-codes.js";
 import { normalizeVerificationConfiguration } from "./verification-scope-capability.js";
 import { EXECUTION_PROFILE_REQUESTS } from "./execution-profile.js";
 import { normalizeStructuralQualityConfig } from "./structural-quality/policy.js";
+import { normalizeDecisionPolicy } from "./decision/policy.js";
 
 export const CONFIG_SCHEMA_VERSION = 1;
 export const COMPLIANCE_MODES = Object.freeze(["advisory", "standard", "strict"]);
@@ -82,6 +83,7 @@ export function createConfig(input = {}) {
     executionProfile = input.executionProfile;
   }
   const structuralQuality = normalizeStructuralQualityConfig(input.structuralQuality);
+  const decisionEngine = normalizeDecisionPolicy(input.decisionEngine);
   return {
     schemaVersion: CONFIG_SCHEMA_VERSION,
     protocolVersion: PROTOCOL_VERSION,
@@ -93,6 +95,7 @@ export function createConfig(input = {}) {
     ...(attestation ? { attestation } : {}),
     ...(executionProfile ? { executionProfile } : {}),
     ...(structuralQuality !== undefined ? { structuralQuality } : {}),
+    decisionEngine,
   };
 }
 

package/src/core/conformance.js

@@ -1,3 +1,4 @@
+import { isLedgerEventCollection } from "./ledger-event-collection.js";
 import { PROTOCOL_VERSION } from "./protocol.js";
 import { createEvidence } from "./evidence.js";
 import { canonicalFingerprint } from "./artifacts.js";
@@ -36,7 +37,7 @@ export function delegationIsInScope({
   if (state?.delegatedTasks && state.delegatedTasks.length > 0) return true;
   if (state?.delegatedTaskIds && state.delegatedTaskIds.length > 0) return true;
   if (receipt?.delegatedTasks && receipt.delegatedTasks.length > 0) return true;
-  if (Array.isArray(events) && events.some((event) => typeof event?.type === "string" && event.type.toLowerCase().includes("delegat"))) {
+  if (isLedgerEventCollection(events) && events.some((event) => typeof event?.type === "string" && event.type.toLowerCase().includes("delegat"))) {
     return true;
   }
   return false;

package/src/core/context-compiler/budget.js

@@ -0,0 +1,9 @@
+export const CONTEXT_BUDGETS = Object.freeze({
+  light: Object.freeze({ maxItems: 12, maxChars: 24_000 }),
+  balanced: Object.freeze({ maxItems: 32, maxChars: 64_000 }),
+  full: Object.freeze({ maxItems: 96, maxChars: 160_000 }),
+});
+
+export function contextBudget(profile = "balanced") {
+  return CONTEXT_BUDGETS[profile] ?? CONTEXT_BUDGETS.balanced;
+}

package/src/core/context-compiler/candidates.js

@@ -0,0 +1,39 @@
+import { canonicalFingerprint } from "../artifacts.js";
+import { buildDecisionState } from "../decision/state-builder.js";
+
+const INJECTION_PATTERN = /(ignore|disregard|override)\s+(?:all|previous|forge|system|developer)|exfiltrat|reveal\s+(?:the|all)\s+(?:secret|token|key)|execute\s+(?:this|the)\s+command/i;
+
+export function normalizeContextCandidate(input = {}) {
+  const safe = buildDecisionState({
+    id: input.id ?? null,
+    sourceRef: input.sourceRef ?? null,
+    kind: input.kind ?? "UNKNOWN",
+    summary: input.summary ?? "",
+    required: input.required === true,
+    mandatory: input.mandatory === true,
+    risk: input.risk ?? "NORMAL",
+    trust: input.trust ?? "UNTRUSTED",
+  });
+  const summary = typeof safe.summary === "string" ? safe.summary : "";
+  const id = typeof safe.id === "string" && safe.id ? safe.id : `candidate-${canonicalFingerprint(safe).slice(0, 16)}`;
+  return {
+    ...safe,
+    id,
+    summary,
+    chars: summary.length,
+    promptInjection: INJECTION_PATTERN.test(summary),
+  };
+}
+
+export function normalizeContextCandidates(candidates = []) {
+  const seen = new Set();
+  const normalized = [];
+  for (const candidate of candidates) {
+    const value = normalizeContextCandidate(candidate);
+    const identity = `${value.id}:${value.sourceRef ?? ""}`;
+    if (seen.has(identity)) continue;
+    seen.add(identity);
+    normalized.push(value);
+  }
+  return normalized;
+}

package/src/core/context-compiler/compiler.js

@@ -0,0 +1,63 @@
+import { contextBudget } from "./budget.js";
+import { normalizeContextCandidates } from "./candidates.js";
+import { contextPlanFingerprint } from "./fingerprint.js";
+import { canonicalFingerprint } from "../artifacts.js";
+import { assertContextCompilerPolicy, candidatePriority } from "./policy.js";
+import { contextPlanResult } from "./result.js";
+
+function orderCandidates(candidates, rankedIds = []) {
+  const ranks = new Map(rankedIds.map((id, index) => [id, rankedIds.length - index]));
+  return [...candidates].sort((a, b) => (b.mandatory - a.mandatory)
+    || (b.required - a.required)
+    || ((ranks.get(b.id) ?? 0) - (ranks.get(a.id) ?? 0))
+    || (candidatePriority(b) - candidatePriority(a))
+    || a.id.localeCompare(b.id));
+}
+
+export function compileContext({ candidates = [], profile = "balanced", mandatoryIds = [], semanticRanker = null } = {}) {
+  const policy = assertContextCompilerPolicy({ profile, mandatoryIds });
+  const normalized = normalizeContextCandidates(candidates);
+  const candidateSetFingerprint = canonicalFingerprint(normalized.map((candidate) => ({
+    id: candidate.id,
+    sourceRef: candidate.sourceRef,
+    summary: candidate.summary,
+    required: candidate.required,
+    mandatory: candidate.mandatory,
+  })));
+  const mandatory = new Set(policy.mandatoryIds);
+  const marked = normalized.map((candidate) => ({ ...candidate, mandatory: candidate.mandatory || mandatory.has(candidate.id) }));
+  const semantic = typeof semanticRanker === "function" ? semanticRanker(marked.filter((item) => !item.promptInjection).map((item) => ({ id: item.id, summary: item.summary }))) : [];
+  const rankedIds = Array.isArray(semantic) ? semantic : (semantic?.rankedIds ?? []);
+  const excludedIds = new Set(Array.isArray(semantic) ? [] : (semantic?.excludedIds ?? []));
+  const ordered = orderCandidates(marked, Array.isArray(rankedIds) ? rankedIds : []);
+  const budget = contextBudget(profile);
+  const selected = [];
+  const omitted = [];
+  let chars = 0;
+  for (const candidate of ordered) {
+    const mustKeep = candidate.mandatory || candidate.required;
+    if (excludedIds.has(candidate.id) && !mustKeep) {
+      omitted.push(candidate);
+      continue;
+    }
+    const fits = selected.length < budget.maxItems && chars + candidate.chars <= budget.maxChars;
+    if (fits || mustKeep) {
+      selected.push(candidate);
+      chars += candidate.chars;
+    } else omitted.push(candidate);
+  }
+  const promptInjectionIds = marked.filter((item) => item.promptInjection).map((item) => item.id).sort();
+  const result = contextPlanResult({
+    profile,
+    candidates: marked,
+    selected,
+    omitted,
+    mandatoryIds: [...new Set([...policy.mandatoryIds, ...marked.filter((item) => item.mandatory).map((item) => item.id)])].sort(),
+    promptInjectionIds,
+    fingerprint: null,
+    budget,
+    candidateSetFingerprint,
+  });
+  result.decisionFingerprint = contextPlanFingerprint(result);
+  return result;
+}

package/src/core/context-compiler/fingerprint.js

@@ -0,0 +1,11 @@
+import { canonicalFingerprint } from "../artifacts.js";
+
+export function contextPlanFingerprint(plan) {
+  return canonicalFingerprint({
+    profile: plan.profile,
+    selectedIds: plan.selected.map((item) => item.id),
+    omittedIds: plan.omitted.map((item) => item.id),
+    mandatoryIds: plan.mandatoryIds,
+    promptInjectionIds: plan.promptInjectionIds,
+  });
+}

package/src/core/context-compiler/policy.js

@@ -0,0 +1,13 @@
+import { decisionError, DECISION_ERROR_CODES } from "../decision/errors.js";
+
+const RISK_ORDER = Object.freeze({ CRITICAL: 4, HIGH: 3, NORMAL: 2, LOW: 1 });
+
+export function assertContextCompilerPolicy({ profile = "balanced", mandatoryIds = [] } = {}) {
+  if (!["light", "balanced", "full"].includes(profile)) throw decisionError(DECISION_ERROR_CODES.POLICY_INVALID, "Context compiler profile is invalid.");
+  if (!Array.isArray(mandatoryIds) || mandatoryIds.some((id) => typeof id !== "string" || !id)) throw decisionError(DECISION_ERROR_CODES.POLICY_INVALID, "Context compiler mandatory IDs are invalid.");
+  return { profile, mandatoryIds: [...new Set(mandatoryIds)] };
+}
+
+export function candidatePriority(candidate) {
+  return (candidate.mandatory || candidate.required ? 100 : 0) + (candidate.promptInjection ? -50 : 0) + (RISK_ORDER[candidate.risk] ?? 0);
+}

package/src/core/context-compiler/result.js

@@ -0,0 +1,23 @@
+export function contextPlanResult({ profile, candidates, selected, omitted, mandatoryIds, promptInjectionIds, fingerprint, budget, candidateSetFingerprint }) {
+  return {
+    schemaVersion: 1,
+    protocolVersion: 1,
+    profile,
+    budget,
+    candidateItems: candidates.length,
+    selectedItems: selected.length,
+    candidateChars: candidates.reduce((total, item) => total + item.chars, 0),
+    selectedChars: selected.reduce((total, item) => total + item.chars, 0),
+    selected,
+    omitted,
+    mandatoryIds,
+    promptInjectionIds,
+    candidateSetFingerprint,
+    tokenUsage: { inputTokens: null, outputTokens: null, reportedBy: "UNKNOWN" },
+    decisionFingerprint: fingerprint,
+    authority: "SEMANTIC_DECISION",
+    evidenceAuthority: "NONE",
+    lifecycleAuthority: false,
+    completionAuthority: false,
+  };
+}

package/src/core/continuity-lint.js

@@ -1,4 +1,6 @@
 import { assertSafePath, ensureWithin, fileExists } from "./filesystem.js";
+import { operationalArtifactExists } from "../storage/operational-context.js";
+import { withProjectReadSnapshot } from "../storage/project-read-snapshot.js";
 
 function finding(code, severity, field, itemId = null) {
   return { code, severity, field, itemId };
@@ -15,7 +17,16 @@ function hasOperationalHints(continuity) {
   );
 }
 
-export async function lintContinuity({ target, continuity, state } = {}) {
+async function inspectPathExists(target, relativePath) {
+  return operationalArtifactExists(target, relativePath) ?? await fileExists(ensureWithin(target, relativePath));
+}
+
+export async function lintContinuity(options = {}) {
+  if (typeof options.target !== "string" || options.target.trim() === "") return lintSelectedContinuity(options);
+  return withProjectReadSnapshot(options.target, () => lintSelectedContinuity(options));
+}
+
+async function lintSelectedContinuity({ target, continuity, state } = {}) {
   const findings = [];
   if (!continuity || typeof continuity !== "object" || Array.isArray(continuity)) {
     return { status: "PASS", findings };
@@ -64,7 +75,7 @@ export async function lintContinuity({ target, continuity, state } = {}) {
     for (const [index, inspectPath] of (continuity.inspectFirst ?? []).entries()) {
       try {
         await assertSafePath(target, inspectPath);
-        if (!(await fileExists(ensureWithin(target, inspectPath)))) {
+        if (!(await inspectPathExists(target, inspectPath))) {
           findings.push(finding(
             "CONTINUITY_INSPECT_PATH_MISSING",
             "WARN",

package/src/core/continuity-reconciliation.js

@@ -1,7 +1,10 @@
+import { getOperationalStore } from "../storage/operational-context.js";
+import { withEventLedgerAudit } from "./events.js";
 import { canonicalFingerprint } from "./artifacts.js";
 import { assertContinuitySemantics, readContinuity } from "./continuity.js";
 import { WORK_TRANSITIONS } from "./protocol.js";
 import { lintContinuity } from "./continuity-lint.js";
+import { withNativeReadScope } from "./native-storage.js";
 
 const RECONCILIATION_CODE = "E_CONTINUITY_RECONCILIATION_REQUIRED";
 
@@ -171,6 +174,14 @@ export function classifyContinuity({
 }
 
 export async function reconcileContinuity({ target, packageRoot, taskId = null } = {}) {
+  const read = () => reconcileLoadedContinuity({ target, packageRoot, taskId });
+  return withNativeReadScope(target, () => {
+    if (getOperationalStore(target) && taskId) return withEventLedgerAudit(target, packageRoot, { taskId }, read);
+    return read();
+  });
+}
+
+async function reconcileLoadedContinuity({ target, packageRoot, taskId }) {
   const [{ readWorkState }, { readContract }, repository] = await Promise.all([
     import("./work-state.js"),
     import("./contract.js"),
@@ -267,12 +278,14 @@ async function resolveLatestHandoffSafe(target, { packageRoot, taskId } = {}) {
 
 async function deriveDiagnosticContextSafe({ target, packageRoot, state }) {
   try {
-    const [{ readEvents }, { deriveDiagnosticContext }] = await Promise.all([
+    const [{ withEventLedgerAudit }, { deriveDiagnosticContext }] = await Promise.all([
       import("./events.js"),
       import("./reflection.js"),
     ]);
-    const events = await readEvents(target, packageRoot, { taskId: state?.taskId ?? null });
-    return { present: true, ...deriveDiagnosticContext(events, state) };
+    return await withEventLedgerAudit(target, packageRoot, { taskId: state?.taskId ?? null }, audit => {
+      if (!audit.valid) return { present: false };
+      return { present: true, ...deriveDiagnosticContext(audit.events, state) };
+    });
   } catch {
     return { present: false };
   }

package/src/core/continuity.js

@@ -1,4 +1,4 @@
-import { unlink } from "node:fs/promises";
+import { withExistingProjectScope } from "../storage/existing-project-scope.js";
 import path from "node:path";
 
 import {
@@ -7,11 +7,12 @@ import {
   readJsonArtifact,
   writeJsonArtifact,
 } from "./artifacts.js";
-import { assertSafePath, ensureWithin, fileExists } from "./filesystem.js";
 import { PROTOCOL_VERSION, WORK_PHASES } from "./protocol.js";
 import { normalizePortableText, assertPortableContextSafe } from "./portable-context.js";
 import { getPackageRoot } from "./templates.js";
 import { taskArtifactPath } from "./task-paths.js";
+import { getOperationalStore, readOperationalText } from "../storage/operational-context.js";
+import { withTaskTransaction } from "./transaction.js";
 
 export const CONTINUITY_PATH = ARTIFACT_PATHS.continuity;
 export const CONTINUITY_SCHEMA_VERSION = 1;
@@ -242,10 +243,17 @@ export async function writeContinuity(target, operationalInput = {}, options = {
 }
 
 export async function clearContinuity(target, options = {}) {
-  const relPath = options.continuityPath ?? options.relativePath ?? (options.taskId ? taskArtifactPath(options.taskId, "continuity") : CONTINUITY_PATH);
-  await assertSafePath(target, relPath);
-  const artifactPath = ensureWithin(target, relPath);
-  if (!(await fileExists(artifactPath))) return { removed: false, path: relPath };
-  await unlink(artifactPath);
-  return { removed: true, path: relPath };
+  if (!options.taskId) throw Object.assign(new Error("Canonical artifact clearing requires a task identity"), { code: "E_STORAGE_OPERATION_UNSUPPORTED" });
+  const relPath = taskArtifactPath(options.taskId, "continuity");
+  const requested = options.continuityPath ?? options.relativePath ?? relPath;
+  if (requested !== relPath) throw Object.assign(new Error("Artifact clearing requires the canonical task path; portable exports are independent files"), { code: "E_STORAGE_OPERATION_UNSUPPORTED", artifacts: [requested] });
+  if (!getOperationalStore(target)) {
+    return withExistingProjectScope(target, () => clearContinuity(target, options));
+  }
+  const operational = readOperationalText(target, relPath);
+  if (operational.text === null) return { removed: false, path: relPath };
+  return withTaskTransaction({ target, taskId: options.taskId, operation: "clear-continuity", packageRoot: options.packageRoot }, async transaction => {
+    transaction.stageDelete(relPath);
+    return { removed: true, path: relPath };
+  });
 }