@cassiomc1/forgeloop 1.14.0 → 2.0.0-rc.2

package/src/core/command-input.js

@@ -324,6 +324,25 @@ export function defaultCommandInputValues() {
   };
 }
 
+function validateStorageRestoreInput(command, options, help) {
+  if (command === "storage-restore-resume" && !help && (options.writersQuiesced !== true || typeof options.operationId !== "string" || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(options.operationId) || typeof options.expectedOwnerId !== "string" || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(options.expectedOwnerId))) throw inputError("storage-restore-resume requires exact --operation and --expected-owner UUIDs and explicit --writers-quiesced");
+  if (["storage-restore", "storage-restore-resume"].includes(command) && options.replaceActive !== undefined && typeof options.replaceActive !== "boolean") throw inputError("Active replacement selection must be a boolean");
+  if (command === "storage-restore" && !help && (typeof options.source !== "string" || !options.source || options.writersQuiesced !== true)) throw inputError("storage-restore requires --source and explicit --writers-quiesced");
+  if (command === "storage-backup" && !help && (typeof options.destination !== "string" || !options.destination)) throw inputError("storage-backup requires --destination");
+}
+
+function validateStorageMigrationInput(command, options, help) {
+  if (command === "storage-rollback-resume" && !help && !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(options.expectedOwnerId ?? "")) throw inputError("storage-rollback-resume requires exact --expected-owner UUID");
+  if (["storage-rollback", "storage-rollback-resume"].includes(command) && !help && (typeof options.destination !== "string" || !options.destination || typeof options.legacyRoot !== "string" || !options.legacyRoot || options.writersQuiesced !== true || options.nativeWritesExcluded !== true)) throw inputError("storage-rollback requires --destination, --legacy-root, explicit --writers-quiesced and --native-writes-excluded");
+  if (command === "storage-migrate" && !help && (typeof options.destination !== "string" || !options.destination || options.writersQuiesced !== true)) throw inputError("storage-migrate requires --destination and explicit --writers-quiesced");
+  if (command === "storage-migration-resume" && !help && (typeof options.destination !== "string" || !options.destination || options.writersQuiesced !== true || typeof options.expectedOwnerId !== "string" || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(options.expectedOwnerId))) throw inputError("storage-migration-resume requires --destination, exact --expected-owner UUID and explicit --writers-quiesced");
+  validateUnboundHandoffAcknowledgement(command, options);
+}
+
+function validateUnboundHandoffAcknowledgement(command, options) {
+  if (command === "storage-migration-resume" && options.acknowledgeUnboundHandoff !== undefined && typeof options.acknowledgeUnboundHandoff !== "boolean") throw inputError("--reconcile-unbound-handoff must be a boolean acknowledgement");
+}
+
 /**
  * Canonical semantic validation shared by the CLI argv parser and
  * programmatic integrations. JSON-Schema style checks cannot express these
@@ -332,7 +351,8 @@ export function defaultCommandInputValues() {
 export function validateForgeLoopCommandInput({ command, input, help = false } = {}) {
   const options = input ?? {};
   if (!command) return;
-
+  validateStorageRestoreInput(command, options, help);
+  validateStorageMigrationInput(command, options, help);
   validatePolicyInput(command, options);
   validateTaskCreationInput(command, options, help);
   validateGateRecordInput(command, options, help);

package/src/core/completion-artifacts.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { getTaskTransaction, withTaskTransaction } from "./transaction.js";
 import {
   ARTIFACT_PATHS,
   canonicalFingerprint,
@@ -80,10 +81,18 @@ function requiredString(value, label) {
   return value;
 }
 
+async function readBoundReceiptArtifact(target, receiptRel, packageRoot) {
+  try { return await readJsonArtifact(target, receiptRel, "execution-receipt", packageRoot); }
+  catch (error) {
+    if (error.code === "E_STORAGE_PAYLOAD_MISMATCH" && error.taskIdentityMismatch) throw artifactError("E_RECEIPT_TASK_MISMATCH", "Execution receipt does not belong to the current contract task", [receiptRel]);
+    throw error;
+  }
+}
+
 async function readCurrentReceipt(target, packageRoot, options = {}) {
   const receiptRel = options.receiptPath ?? (options.taskId ? taskArtifactPath(options.taskId, "receipt") : ARTIFACT_PATHS.receipt);
   try {
-    return await readJsonArtifact(target, receiptRel, "execution-receipt", packageRoot);
+    return await readBoundReceiptArtifact(target, receiptRel, packageRoot);
   } catch (error) {
     if (error.code === "ARTIFACT_MISSING") {
       throw artifactError(
@@ -245,7 +254,21 @@ export async function requiredEvidenceForTarget({
   ])].sort();
 }
 
-export async function prepareCompletion({
+async function resolveCompletionTaskOptions(options) {
+  if (options.taskId) return options;
+  const state = await readWorkState(options.target, { packageRoot: options.packageRoot, statePath: options.statePath });
+  return { ...options, taskId: state?.taskId };
+}
+
+export async function prepareCompletion(options = {}) {
+  options = await resolveCompletionTaskOptions(options);
+  if (!options.taskId) return prepareSelectedCompletion(options);
+  return withTaskTransaction({ target: options.target, packageRoot: options.packageRoot,
+    taskId: options.taskId, operation: "prepare-completion", recordCommitEvent: true },
+  () => prepareSelectedCompletion(options));
+}
+
+async function prepareSelectedCompletion({
   target,
   packageRoot,
   authorityContext,
@@ -255,6 +278,7 @@ export async function prepareCompletion({
   routePath = null,
   statePath = null,
   receiptPath = null,
+  eventsPath,
 }) {
   const contract = await readContract(target, packageRoot, { taskId, contractPath });
   const route = await readPersistedRoute(target, packageRoot, { taskId, routePath });
@@ -266,12 +290,12 @@ export async function prepareCompletion({
     throw artifactError("E_STATE_MISSING", "Work state is required before preparing completion", [stateRel]);
   }
   if (hasExecutionStarted(state.phase)) {
-    await assertExecutionPrerequisites({ target, state, packageRoot, taskId, statePath, contractPath, routePath });
+    await assertExecutionPrerequisites({ target, state, packageRoot, taskId, statePath, contractPath, routePath, eventsPath });
   }
 
   let existing = null;
   try {
-    existing = await readJsonArtifact(target, receiptRel, "execution-receipt", packageRoot);
+    existing = await readBoundReceiptArtifact(target, receiptRel, packageRoot);
     await validateReceipt(existing.value, packageRoot, {
       target,
       taskId: contract.value.taskId,
@@ -463,7 +487,7 @@ export async function assertRecordCheckPrerequisites({
       [stateRel],
     );
   }
-  await assertExecutionPrerequisites({ target, state, packageRoot, taskId, statePath, contractPath, routePath });
+  await assertExecutionPrerequisites({ target, state, packageRoot, taskId, statePath, contractPath, routePath, eventsPath });
 
   const contract = await readContract(target, packageRoot, { taskId, contractPath });
   const route = await readPersistedRoute(target, packageRoot, { taskId, routePath });
@@ -521,29 +545,15 @@ export async function assertRecordCheckPrerequisites({
   };
 }
 
-export async function recordCheck({
-  target,
-  packageRoot,
-  id,
-  kind = "command",
-  requirement,
-  status,
-  evidenceKind,
-  command,
-  result,
-  exitCode,
-  details,
-  executionRef,
-  provenance,
-  authorityContext,
-  runtimeContext,
-  taskId = null,
-  contractPath = null,
-  routePath = null,
-  statePath = null,
-  receiptPath = null,
-  eventsPath = null,
-}) {
+export async function recordCheck(options) {
+  validateRecordCheckInput(options);
+  options = await resolveCompletionTaskOptions(options);
+  if (!options.taskId) return recordValidatedCheck(options);
+  return withTaskTransaction({ target: options.target, packageRoot: options.packageRoot,
+    taskId: options.taskId, operation: "record-check", recordCommitEvent: true }, () => recordValidatedCheck(options));
+}
+
+function validateRecordCheckInput({ id, kind = "command", requirement, status, evidenceKind, command, result, details, executionRef, provenance }) {
   requiredString(id, "check id");
   requiredString(kind, "check kind");
   requiredString(requirement, "check requirement");
@@ -568,7 +578,31 @@ export async function recordCheck({
     && (typeof result !== "string" || result.trim() === "")) {
     throw artifactError("E_CHECK_INVALID", "record-check requires --command or --result");
   }
+}
 
+async function recordValidatedCheck({
+  target,
+  packageRoot,
+  id,
+  kind = "command",
+  requirement,
+  status,
+  evidenceKind,
+  command,
+  result,
+  exitCode,
+  details,
+  executionRef,
+  provenance,
+  authorityContext,
+  runtimeContext,
+  taskId = null,
+  contractPath = null,
+  routePath = null,
+  statePath = null,
+  receiptPath = null,
+  eventsPath = null,
+}) {
   const context = await assertRecordCheckPrerequisites({
     target,
     packageRoot,
@@ -780,7 +814,15 @@ export async function recordCheck({
   };
 }
 
-export async function recordTerminalResult({
+export async function recordTerminalResult(options = {}) {
+  if (!options.target) return recordTerminalResultInTransaction(options);
+  if (await getTaskTransaction(options.target)) return recordTerminalResultInTransaction(options);
+  const state = await readWorkState(options.target, { packageRoot: options.packageRoot, taskId: options.taskId, statePath: options.statePath });
+  if (!state) return recordTerminalResultInTransaction(options);
+  return withTaskTransaction({ target: options.target, taskId: state.taskId, packageRoot: options.packageRoot, operation: "record-terminal-result" }, () => recordTerminalResultInTransaction({ ...options, taskId: options.taskId ?? state.taskId }));
+}
+
+async function recordTerminalResultInTransaction({
   target,
   packageRoot,
   requirement,

package/src/core/completion-ownership.js

@@ -1,7 +1,19 @@
+import { isLedgerEventCollection } from "./ledger-event-collection.js";
 import { LIFECYCLE_MILESTONES, validateStateLedgerCoherence } from "./events.js";
 
 export const CANONICAL_COMPLETION_EVENT = "COMPLETION_VALIDATED";
 
+function completionCandidates(events, taskId) {
+  let count = 0;
+  let candidate = null;
+  for (const event of events) {
+    if (event.event !== CANONICAL_COMPLETION_EVENT || event.taskId !== taskId) continue;
+    count += 1;
+    candidate = event;
+  }
+  return { count, candidate };
+}
+
 /**
  * Canonical completion ownership proof: the minimal, validator-backed evidence
  * that the lifecycle itself officially reached COMPLETE. This is intentionally
@@ -28,31 +40,30 @@ export function validateCompletionOwnershipProof({ taskId, state, ledger }) {
   }
 
   let completionEvent = null;
-  if (ledger && Array.isArray(ledger.events)) {
+  if (ledger && isLedgerEventCollection(ledger.events)) {
     if (ledger.events.some((event) => event.taskId !== taskId)) {
       errors.push({
         code: "E_COMPLETION_OWNERSHIP_UNPROVEN",
         message: "Ledger contains an event belonging to a different task",
       });
     }
-    const candidates = ledger.events
-      .filter((event) => event.event === CANONICAL_COMPLETION_EVENT && event.taskId === taskId);
-    if (candidates.length === 0) {
+    const { count, candidate } = completionCandidates(ledger.events, taskId);
+    if (count === 0) {
       errors.push({
         code: "E_COMPLETION_OWNERSHIP_UNPROVEN",
         message: `No canonical ${CANONICAL_COMPLETION_EVENT} event exists for this task`,
       });
-    } else if (candidates.length > 1) {
+    } else if (count > 1) {
       errors.push({
         code: "E_COMPLETION_OWNERSHIP_UNPROVEN",
         message: `Multiple ${CANONICAL_COMPLETION_EVENT} events exist; completion is ambiguous`,
       });
     } else {
-      completionEvent = candidates[0];
+      completionEvent = candidate;
     }
   }
 
-  if (state && ledger && Array.isArray(ledger.events)) {
+  if (state && ledger && isLedgerEventCollection(ledger.events)) {
     const coherenceErrors = validateStateLedgerCoherence(state, ledger.events);
     if (coherenceErrors.length > 0) {
       for (const error of coherenceErrors) {
@@ -67,7 +78,7 @@ export function validateCompletionOwnershipProof({ taskId, state, ledger }) {
   // No contradictory lifecycle activity may follow the canonical completion:
   // any milestone at or after VERIFICATION_RECORDED occurring after the
   // completion event means the lifecycle moved past terminal state.
-  if (completionEvent && ledger && Array.isArray(ledger.events)) {
+  if (completionEvent && ledger && isLedgerEventCollection(ledger.events)) {
     const completionIndex = ledger.events.indexOf(completionEvent);
     const contradiction = ledger.events.slice(completionIndex + 1).find((event) => {
       const index = LIFECYCLE_MILESTONES.indexOf(event.event);

package/src/core/completion-recovery-rebind.js

@@ -3,6 +3,7 @@ import { appendProtocolEvent, validateCompletionRecoveryAuthorization, validateE
 import { createReceipt } from "./receipt.js";
 import { taskArtifactPath } from "./task-paths.js";
 import { mutateWorkState, readWorkState } from "./work-state.js";
+import { getTaskTransaction, withTaskTransaction } from "./transaction.js";
 
 function resolveArtifactPath(key, taskId, override) {
   if (override) return override;
@@ -65,7 +66,16 @@ function findMatchingRejectionEvent(events, attempt, cycle) {
  *     rejection carrying the current fingerprints is appended,
  *   - the execution receipt is re-bound to the current checkpoint when present.
  */
-export async function rebindCompletionRejectionSnapshot({
+export async function rebindCompletionRejectionSnapshot(options = {}) {
+  if (await getTaskTransaction(options.target)) return rebindRejectionInTransaction(options);
+  const state = await readWorkState(options.target, { packageRoot: options.packageRoot,
+    taskId: options.taskId, statePath: resolveArtifactPath("state", options.taskId, options.statePath) });
+  if (!state) return { rebound: false };
+  return withTaskTransaction({ target: options.target, taskId: options.taskId ?? state.taskId,
+    packageRoot: options.packageRoot, operation: "rebind-completion-rejection" }, () => rebindRejectionInTransaction(options));
+}
+
+async function rebindRejectionInTransaction({
   target,
   packageRoot,
   taskId = null,

package/src/core/completion.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 });
@@ -557,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);
@@ -853,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/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/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 };
+  });
 }