@remnic/core 9.45.2 → 9.45.4

package/src/connector-provenance.test.ts

@@ -16,9 +16,11 @@ import path from "node:path";
 import test from "node:test";
 
 import { EngramMcpServer } from "./access-mcp.js";
+import { getOperation } from "./access-boundary.js";
 import { memoryStoreOperation } from "./access-operations.js";
 import type {
   EngramAccessMemoryStoreRequest,
+  EngramAccessRecallRequest,
   EngramAccessService,
   EngramAccessWriteResponse,
 } from "./access-service.js";
@@ -117,6 +119,26 @@ test("memory_store via MCP with no sourceConnector (operator) → service receiv
   );
 });
 
+test("recall operation forwards only the server-resolved connector", async () => {
+  const captured: EngramAccessRecallRequest[] = [];
+  const service = {
+    recall: (request: EngramAccessRecallRequest) => {
+      captured.push(request);
+      return Promise.resolve({});
+    },
+  } as unknown as EngramAccessService;
+  const recallOperation = getOperation("recall");
+  assert.ok(recallOperation);
+
+  await recallOperation.run(
+    { query: "shared namespace query", sourceConnector: "spoofed-client" },
+    { service, sourceConnector: "chatgpt" },
+  );
+
+  assert.equal(captured.length, 1);
+  assert.equal(captured[0]?.sourceConnector, "chatgpt");
+});
+
 // ---------------------------------------------------------------------------
 // Test 4: client-supplied sourceConnector in args is IGNORED
 // ---------------------------------------------------------------------------
@@ -217,3 +239,82 @@ test("StorageManager.writeMemory without sourceConnector → frontmatter omits i
     await rm(baseDir, { recursive: true, force: true });
   }
 });
+
+test("StorageManager classifies connector-attributed tool memories at write time", async () => {
+  StorageManager.clearAllStaticCaches();
+  const baseDir = await mkdtemp(path.join(os.tmpdir(), "prov-tool-scope-"));
+  try {
+    const storage = new StorageManager(baseDir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory(
+      "fact",
+      "Use the search tool with a path argument.",
+      { sourceConnector: "chatgpt" },
+    );
+
+    assert.equal((await storage.getMemoryById(id))?.frontmatter.toolScoped, true);
+  } finally {
+    StorageManager.clearAllStaticCaches();
+    await rm(baseDir, { recursive: true, force: true });
+  }
+});
+
+test("StorageManager leaves unattributed tool-like memories unpartitioned", async () => {
+  StorageManager.clearAllStaticCaches();
+  const baseDir = await mkdtemp(path.join(os.tmpdir(), "prov-tool-scope-"));
+  try {
+    const storage = new StorageManager(baseDir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory(
+      "fact",
+      "Use the search tool with a path argument.",
+    );
+
+    assert.equal((await storage.getMemoryById(id))?.frontmatter.toolScoped, undefined);
+  } finally {
+    StorageManager.clearAllStaticCaches();
+    await rm(baseDir, { recursive: true, force: true });
+  }
+});
+
+test("StorageManager preserves an explicit structured tool classification", async () => {
+  StorageManager.clearAllStaticCaches();
+  const baseDir = await mkdtemp(path.join(os.tmpdir(), "prov-tool-scope-"));
+  try {
+    const storage = new StorageManager(baseDir);
+    await storage.ensureDirectories();
+
+    const { id } = await storage.writeMemory(
+      "procedure",
+      "Workflow for locating an implementation",
+      { sourceConnector: "chatgpt", toolScoped: true },
+    );
+
+    assert.equal((await storage.getMemoryById(id))?.frontmatter.toolScoped, true);
+  } finally {
+    StorageManager.clearAllStaticCaches();
+    await rm(baseDir, { recursive: true, force: true });
+  }
+});
+test("StorageManager preserves connector partition metadata on artifacts", async () => {
+  StorageManager.clearAllStaticCaches();
+  const baseDir = await mkdtemp(path.join(os.tmpdir(), "prov-artifact-tool-scope-"));
+  try {
+    const storage = new StorageManager(baseDir);
+    await storage.ensureDirectories();
+    const id = await storage.writeArtifact("Use the search tool with a path argument.", {
+      sourceConnector: "chatgpt",
+      toolScoped: true,
+    });
+    const artifact = (await storage.searchArtifacts("search tool", 10)).find(
+      (candidate) => candidate.frontmatter.id === id,
+    );
+    assert.equal(artifact?.frontmatter.sourceConnector, "chatgpt");
+    assert.equal(artifact?.frontmatter.toolScoped, true);
+  } finally {
+    StorageManager.clearAllStaticCaches();
+    await rm(baseDir, { recursive: true, force: true });
+  }
+});

package/src/consolidation-undo.ts

@@ -27,6 +27,7 @@ import type { StorageManager } from "./storage.js";
 import type { VersioningConfig } from "./page-versioning.js";
 import { bumpMemoryCorpusVersionForDir } from "./memory-corpus-version.js";
 import { requestEntityCanonicalIdReconcile } from "./storage/entity-canonical-id-references.js";
+import { withRawEntityPageMutation } from "./storage/entity-canonical-id-lock.js";
 import { getVersion } from "./page-versioning.js";
 
 /**
@@ -643,6 +644,7 @@ export async function runConsolidationUndo(options: {
       }
       try {
         await mkdir(path.dirname(p.sourcePath), { recursive: true });
+        await withRawEntityPageMutation(memoryDir, p.sourcePath, async () => {
         // Use exclusive create (wx / O_EXCL) so that if another process
         // recreates the source file between planning and execution, this
         // write fails with EEXIST instead of silently overwriting the new
@@ -658,6 +660,7 @@ export async function runConsolidationUndo(options: {
         // Restored bytes predate the current migration journal and can carry
         // legacy entity references (issue #2213) — request one reconcile pass.
         await requestEntityCanonicalIdReconcile(path.join(memoryDir, "state"));
+        });
         result.restores.push({
           entry: p.entry,
           sourcePath: p.sourcePath,

package/src/converge-conflict-policy-type.test.ts

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import type { ReconcileConflictPolicy } from "./reconcile/plan.js";
+import type { ConvergeConflictPolicy } from "./types.js";
+
+type Equal<Left, Right> = (<Value>() => Value extends Left ? 1 : 2) extends <Value>() => Value extends Right ? 1 : 2
+  ? true
+  : false;
+
+const conflictPolicyNamesAreEquivalent: Equal<ReconcileConflictPolicy, ConvergeConflictPolicy> = true;
+
+test("ReconcileConflictPolicy remains a type alias for ConvergeConflictPolicy", () => {
+  assert.equal(conflictPolicyNamesAreEquivalent, true);
+});

package/src/convergence-refresh.ts

@@ -9,12 +9,24 @@ type ConvergenceStorage = NonNullable<RebuildMemoryProjectionOptions["storage"]>
 export async function refreshConvergedNamespaces(
   namespaces: readonly string[],
   namespaceSearchRouter: Pick<NamespaceSearchRouter, "updateNamespacesDetailed">,
-  getStorage: (namespace: string) => Promise<ConvergenceStorage>
+  getStorage: (namespace: string) => Promise<ConvergenceStorage>,
+  searchEnabled: boolean,
 ): Promise<void> {
   const targetNamespaces = Array.from(new Set(namespaces.map((namespace) => namespace.trim()).filter(Boolean)));
   if (targetNamespaces.length === 0) return;
 
-  await namespaceSearchRouter.updateNamespacesDetailed(targetNamespaces, undefined, { strict: true });
+  const searchResult = await namespaceSearchRouter.updateNamespacesDetailed(
+    targetNamespaces,
+    undefined,
+    { strict: true },
+  );
+  if (searchEnabled) {
+    const eligible = new Set(searchResult.eligibleNamespaces);
+    const skipped = targetNamespaces.filter((namespace) => !eligible.has(namespace));
+    if (skipped.length > 0) {
+      throw new Error(`search refresh skipped namespaces: ${skipped.join(", ")}`);
+    }
+  }
 
   for (const namespace of targetNamespaces) {
     const storage = await getStorage(namespace);

package/src/correction/correction-access-wiring.ts

@@ -25,7 +25,8 @@ import { throwIfAborted } from "../abort-error.js";
 import { composeMemoryEnvelope, isMemoryCategory } from "../write-envelope.js";
 import { log } from "../logger.js";
 import { createHash } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
+import { REDACTION_RULES_SUBDIR } from "../extraction-redaction-rules.js";
+import { writeFileAtomically } from "../maintenance/atomic-file.js";
 import type { Orchestrator } from "../orchestrator.js";
 import type { MemoryFile, MemoryStatus, PluginConfig } from "../types.js";
 import { stripAttributesSuffix } from "../structured-attributes.js";
@@ -568,6 +569,7 @@ async function rescopeMemoryFn(
       ...(fm.entityRef ? { entityRef: fm.entityRef } : {}),
       ...(fm.structuredAttributes ? { structuredAttributes: fm.structuredAttributes } : {}),
       ...(fm.valid_at ? { validAt: fm.valid_at } : {}),
+      ...(fm.sourceConnector ? { sourceConnector: fm.sourceConnector } : {}),
     },
     { source: `correction:rescope:${namespace}` },
     { salvage: true },
@@ -581,6 +583,7 @@ async function rescopeMemoryFn(
     ...(fm.memoryKind ? { memoryKind: fm.memoryKind } : {}),
     ...(Array.isArray(fm.links) ? { links: fm.links } : {}),
     ...(fm.intentGoal ? { intentGoal: fm.intentGoal } : {}),
+    ...(fm.toolScoped ? { toolScoped: true as const } : {}),
   });
   if (destBlocked) {
     // #1645: destination tombstone-blocked the rescope (pending_review). Don't
@@ -703,14 +706,14 @@ async function registerRedactionRuleFn(
   namespace: string,
   pattern: string,
   abortSignal?: AbortSignal,
+  writeRule: (outputPath: string, content: string) => Promise<unknown> = writeFileAtomically,
 ): Promise<void> {
   // Persist the redaction rule under state/ so extraction consults it the
   // same way tombstones are consulted (route through the same chokepoint).
   throwIfAborted(abortSignal, "correction apply aborted");
   const storage = await wiring.orchestrator.getStorage(namespace);
   throwIfAborted(abortSignal, "correction apply aborted");
-  const dir = path.join(storage.dir, "state", "corrections", "redaction-rules");
-  await mkdir(dir, { recursive: true });
+  const dir = path.join(storage.dir, REDACTION_RULES_SUBDIR);
   throwIfAborted(abortSignal, "correction apply aborted");
   // Idempotent: filename is a slug + short hash of the full pattern so
   // re-registering the same pattern overwrites rather than duplicates, while
@@ -721,12 +724,10 @@ async function registerRedactionRuleFn(
   const patternHash = createHash("sha256").update(pattern).digest("hex").slice(0, 16);
   const slug = `${slugBase}-${patternHash}`;
   throwIfAborted(abortSignal, "correction apply aborted");
-  await writeFile(
+  await writeRule(
     path.join(dir, `${slug}.json`),
     `${JSON.stringify({ pattern, namespace, createdAt: new Date().toISOString() })}\n`,
-    "utf-8",
   );
-  throwIfAborted(abortSignal, "correction apply aborted");
 }
 
 async function appendAuditRecordFn(
@@ -761,7 +762,6 @@ async function appendAuditRecordFn(
     ),
     {},
   );
-  throwIfAborted(abortSignal, "correction apply aborted");
   return id;
 }
 
@@ -1081,6 +1081,8 @@ export {
   isEligibleCorrectionCandidate,
   applyEditMemory,
   appendTombstoneFn,
+  appendAuditRecordFn,
+  registerRedactionRuleFn,
   retireMemoryFn,
   rescopeMemoryFn,
   writeReplacementMemory,

package/src/correction/correction-executor.test.ts

@@ -516,6 +516,69 @@ test("supersede retries loser retirement after a transient failure", async () =>
   });
 });
 
+test("#2206 cancellation terminalizes a plan after a replacement commits but retirement fails", async () => {
+  await withTempDir(async (dir) => {
+    const candidates = new Map<string, PlannerCandidate>([
+      ["mem-old", { memoryId: "mem-old", path: "facts/mem-old.md", content: "old", excerpt: "old", score: 1 }],
+    ]);
+    const state: FakeState = {
+      memories: new Map([["mem-old", fakeMemory({ memoryId: "mem-old", content: "old" })]]),
+      tombstones: [],
+      redactionRules: [],
+      auditRecords: [],
+      propagateCalls: 0,
+      writtenReplacements: [],
+    };
+    const plannerDeps: PlannerDeps = {
+      ...makePlannerDeps(dir, candidates),
+      classifyAndDraft: async () => ({
+        classification: "outdated",
+        confidence: 0.9,
+        actions: [
+          { kind: "supersede", loserId: "mem-old", replacement: { content: "new" } },
+          { kind: "redaction_rule", pattern: "later-action" },
+        ],
+        relevance: [{ memoryId: "mem-old", why: "x" }],
+        warnings: [],
+      }),
+    };
+    const planner = new CorrectionPlanner(plannerDeps);
+    const plan = await planner.plan({ text: "old", targetIds: ["mem-old"] }, ["default"]);
+    const abortController = new AbortController();
+    const deps = makeExecutorDeps(state);
+    let retirementAttempted = false;
+    deps.retireMemory = async () => {
+      retirementAttempted = true;
+      abortController.abort(new Error("correction deadline exceeded"));
+      throw new Error("injected retirement failure");
+    };
+
+    const outcome = await new CorrectionExecutor(deps, planner).apply("default", plan.planId, {
+      confirm: true,
+      abortSignal: abortController.signal,
+    });
+
+    assert.equal(retirementAttempted, true, "the cancellation must be injected from retirement");
+    assert.equal(outcome.status, "partial");
+    assert.equal((await planner.loadPlan("default", plan.planId))?.status, "partial");
+    assert.equal(state.writtenReplacements.length, 1);
+    assert.equal(state.memories.get("mem-old")?.status, "active");
+    assert.deepEqual(state.redactionRules, []);
+    assert.equal(
+      outcome.results.some((result) => result.action.kind === "redaction_rule" && result.status === "skipped"),
+      true,
+    );
+    const supersedeResults = outcome.results.filter((result) => result.action.kind === "supersede");
+    assert.deepEqual(
+      supersedeResults.map((result) => result.status),
+      ["applied", "failed"],
+      "the outcome must expose the committed replacement and failed retirement",
+    );
+    assert.match(supersedeResults[1]?.error ?? "", /injected retirement failure/);
+    assert.equal(state.auditRecords.length, 1);
+  });
+});
+
 test("tombstone emitted per retract; validUntil absent when bi-temporal OFF", async () => {
   await withTempDir(async (dir) => {
     const candidates = new Map<string, PlannerCandidate>([
@@ -934,7 +997,7 @@ test("#2128 cancellation after tombstone commit terminalizes the correction plan
   });
 });
 
-test("#2128 late cancellation before any mutation restores an applying plan to pending", async () => {
+test("#2206 cancellation after audit commit terminalizes an empty correction plan", async () => {
   await withTempDir(async (dir) => {
     const state: FakeState = {
       memories: new Map(),
@@ -950,8 +1013,40 @@ test("#2128 late cancellation before any mutation restores an applying plan to p
     const deps = makeExecutorDeps(state);
     const appendAuditRecord = deps.appendAuditRecord;
     deps.appendAuditRecord = async (namespace, record, signal) => {
+      const auditId = await appendAuditRecord(namespace, record, signal);
       abortController.abort(new Error("caller disconnected"));
-      return appendAuditRecord(namespace, record, signal);
+      return auditId;
+    };
+    const executor = new CorrectionExecutor(deps, planner);
+
+    const outcome = await executor.apply("default", plan.planId, {
+      confirm: true,
+      abortSignal: abortController.signal,
+    });
+    assert.equal(outcome.status, "applied");
+    assert.equal(state.auditRecords.length, 1);
+    assert.equal((await planner.loadPlan("default", plan.planId))?.status, "applied");
+  });
+});
+
+test("#2206 cancellation before audit commit restores an empty correction plan to pending", async () => {
+  await withTempDir(async (dir) => {
+    const state: FakeState = {
+      memories: new Map(),
+      tombstones: [],
+      redactionRules: [],
+      auditRecords: [],
+      propagateCalls: 0,
+      writtenReplacements: [],
+    };
+    const planner = new CorrectionPlanner(makePlannerDeps(dir, new Map()));
+    const plan = await planner.plan({ text: "nothing matches" }, ["default"]);
+    const abortController = new AbortController();
+    const deps = makeExecutorDeps(state);
+    deps.appendAuditRecord = async () => {
+      const reason = new Error("caller disconnected");
+      abortController.abort(reason);
+      throw reason;
     };
     const executor = new CorrectionExecutor(deps, planner);
 
@@ -959,6 +1054,7 @@ test("#2128 late cancellation before any mutation restores an applying plan to p
       () => executor.apply("default", plan.planId, { confirm: true, abortSignal: abortController.signal }),
       /caller disconnected/,
     );
+    assert.equal(state.auditRecords.length, 0);
     assert.equal((await planner.loadPlan("default", plan.planId))?.status, "pending");
   });
 });
@@ -1140,9 +1236,117 @@ test("#2128 cancellation skips unstarted actions after a committed edit", async
     assert.equal(state.memories.get("mem-edit")?.content, "edited");
     assert.deepEqual(state.redactionRules, [], "the cancelled plan must not start its second action");
     assert.equal(state.auditRecords.length, 1);
+    const skipped = outcome.results.filter((result) => result.status === "skipped");
+    assert.deepEqual(skipped.map((result) => result.action), [
+      { kind: "redaction_rule", pattern: "secret-token-\\d+" },
+    ]);
+    assert.deepEqual(state.auditRecords[0]?.outcome.results, outcome.results);
   });
 });
 
+test("#2206 cancellation interrupts rescope authorization before any destination write", async () => {
+  for (const priorEditCommitted of [false, true]) {
+    await withTempDir(async (dir) => {
+      const candidates = new Map<string, PlannerCandidate>([
+        ["mem-rescope", {
+          memoryId: "mem-rescope",
+          path: "facts/mem-rescope.md",
+          content: "move me",
+          excerpt: "move me",
+          score: 1,
+        }],
+      ]);
+      if (priorEditCommitted) {
+        candidates.set("mem-edit", {
+          memoryId: "mem-edit",
+          path: "facts/mem-edit.md",
+          content: "edit me",
+          excerpt: "edit me",
+          score: 1,
+        });
+      }
+      const state: FakeState = {
+        memories: new Map([
+          ["mem-rescope", fakeMemory({ memoryId: "mem-rescope", content: "move me" })],
+          ...(priorEditCommitted
+            ? [["mem-edit", fakeMemory({ memoryId: "mem-edit", content: "edit me" })] as const]
+            : []),
+        ]),
+        tombstones: [],
+        redactionRules: [],
+        auditRecords: [],
+        propagateCalls: 0,
+        writtenReplacements: [],
+      };
+      const actions: CorrectionAction[] = [
+        ...(priorEditCommitted
+          ? [{ kind: "edit", memoryId: "mem-edit", patch: "edited" } as const]
+          : []),
+        { kind: "rescope", memoryId: "mem-rescope", toNamespace: "destination" },
+      ];
+      const plannerDeps: PlannerDeps = {
+        ...makePlannerDeps(dir, candidates),
+        classifyAndDraft: async () => ({
+          classification: "outdated",
+          confidence: 0.9,
+          actions,
+          relevance: [...candidates.values()].map((candidate) => ({
+            memoryId: candidate.memoryId,
+            why: "test",
+          })),
+          warnings: [],
+        }),
+      };
+      const planner = new CorrectionPlanner(plannerDeps);
+      const plan = await planner.plan(
+        { text: "move memory", targetIds: [...candidates.keys()] },
+        ["default"],
+      );
+      const abortController = new AbortController();
+      const started = Promise.withResolvers<void>();
+      const authorization = Promise.withResolvers<boolean>();
+      let forwardedSignal: AbortSignal | undefined;
+      const applyResult = new CorrectionExecutor(makeExecutorDeps(state), planner)
+        .apply("default", plan.planId, {
+          confirm: true,
+          abortSignal: abortController.signal,
+          canWriteDestination: async (_namespace, abortSignal) => {
+            forwardedSignal = abortSignal;
+            started.resolve();
+            return authorization.promise;
+          },
+        })
+        .then(
+          (outcome) => ({ ok: true as const, outcome }),
+          (error: unknown) => ({ ok: false as const, error }),
+        );
+
+      await started.promise;
+      abortController.abort(new Error("correction deadline exceeded"));
+      assert.equal(forwardedSignal, abortController.signal);
+      assert.equal(forwardedSignal?.aborted, true);
+      authorization.resolve(true);
+      const result = await applyResult;
+      assert.equal(state.memories.get("mem-rescope")?.status, "active");
+      if (priorEditCommitted) {
+        assert.equal(result.ok, true);
+        assert.equal(result.outcome?.status, "partial");
+        assert.equal(
+          result.outcome?.results.some(
+            (entry) => entry.action.kind === "rescope" && entry.status === "skipped",
+          ),
+          true,
+        );
+        assert.equal((await planner.loadPlan("default", plan.planId))?.status, "partial");
+      } else {
+        assert.equal(result.ok, false);
+        assert.match(String(result.error), /correction deadline exceeded|correction apply aborted/);
+        assert.equal((await planner.loadPlan("default", plan.planId))?.status, "pending");
+      }
+    });
+  }
+});
+
 test("Of0pz: supersede with a missing loser writes NO replacement (preflight before write)", async () => {
   await withTempDir(async (dir) => {
     const candidates = new Map<string, PlannerCandidate>([

package/src/correction/correction-executor.ts

@@ -24,7 +24,7 @@
  * (`markConsumed`) under `serializeMutations` keyed by plan id (rule 40).
  */
 
-import { throwIfAborted } from "../abort-error.js";
+import { raceAbort, throwIfAborted } from "../abort-error.js";
 import { log } from "../logger.js";
 import { serializeMutations } from "../utils/serialize-mutations.js";
 import {
@@ -201,7 +201,7 @@ export class CorrectionExecutor {
        * thread: authorize-rescope-destination). Defaults to allow when the
        * source namespace already resolves to a writable scope (single-tenant).
        */
-      canWriteDestination?: (namespace: string) => Promise<boolean>;
+      canWriteDestination?: (namespace: string, abortSignal?: AbortSignal) => Promise<boolean>;
     }
   ): Promise<CorrectionOutcome> {
     throwIfAborted(opts.abortSignal, "correction apply aborted");
@@ -220,7 +220,7 @@ export class CorrectionExecutor {
   private async applyInternal(
     namespace: string,
     planId: string,
-    canWriteDestination?: (namespace: string) => Promise<boolean>,
+    canWriteDestination?: (namespace: string, abortSignal?: AbortSignal) => Promise<boolean>,
     abortSignal?: AbortSignal
   ): Promise<CorrectionOutcome> {
     throwIfAborted(abortSignal, "correction apply aborted");
@@ -307,10 +307,9 @@ export class CorrectionExecutor {
       }
     };
     let mutationCommitted = false;
-    let cancellationSafeAfterCommit = false;
     let cancellationRequestedAfterCommit = false;
     const throwIfAbortedBeforeCommit = (): void => {
-      if (!mutationCommitted || !cancellationSafeAfterCommit) {
+      if (!mutationCommitted) {
         throwIfAborted(abortSignal, "correction apply aborted");
       }
     };
@@ -409,7 +408,6 @@ export class CorrectionExecutor {
             retirementResult.status === "applied"
           ) {
             retiredReplacementActions.add(action);
-            cancellationSafeAfterCommit = true;
           }
         } catch (err) {
           if (abortSignal?.aborted) {
@@ -435,7 +433,6 @@ export class CorrectionExecutor {
             abortSignal
           );
           mutationCommitted = true;
-          cancellationSafeAfterCommit = true;
           results.push({ action, status: "applied", memoryId: editedId });
           appliedTouched.push(editedId);
         } catch (err) {
@@ -457,7 +454,6 @@ export class CorrectionExecutor {
             abortSignal
           );
           mutationCommitted = true;
-          cancellationSafeAfterCommit = true;
           results.push({ action, status: "applied" });
         } catch (err) {
           if (abortSignal?.aborted) {
@@ -501,7 +497,6 @@ export class CorrectionExecutor {
         );
         if (results.at(-1)?.status === "applied") {
           mutationCommitted = true;
-          cancellationSafeAfterCommit = true;
         }
         if (results.at(-1)?.action === action && results.at(-1)?.status === "applied") {
           removeFailedResultsFor(action);
@@ -518,7 +513,6 @@ export class CorrectionExecutor {
         );
         if (results.at(-1)?.status === "applied") {
           mutationCommitted = true;
-          cancellationSafeAfterCommit = true;
         }
         if (results.at(-1)?.action === action && results.at(-1)?.status === "applied") {
           removeFailedResultsFor(action);
@@ -530,7 +524,13 @@ export class CorrectionExecutor {
           // the write ACL (review thread: authorize-rescope-destination).
           // canWriteDestination defaults to allow when absent (single-tenant,
           // where the source namespace already resolved to a writable scope).
-          const allowed = canWriteDestination ? await canWriteDestination(action.toNamespace) : true;
+          const allowed = canWriteDestination
+            ? await raceAbort(
+                canWriteDestination(action.toNamespace, abortSignal),
+                abortSignal,
+                "correction apply aborted",
+              )
+            : true;
           if (!allowed) {
             results.push({
               action,
@@ -546,7 +546,6 @@ export class CorrectionExecutor {
             abortSignal
           );
           mutationCommitted = true;
-          cancellationSafeAfterCommit = true;
           // #1678 (thread OiiV6): report the DESTINATION memory id, not the
           // source. The source is archived by the move; callers that re-fetch
           // the reported id need the live (destination) memory, otherwise they
@@ -589,14 +588,25 @@ export class CorrectionExecutor {
     const propagationWarnings: string[] = [];
     if (appliedTouched.length > 0) {
       try {
-        await this.deps.propagate(namespace, appliedTouched, cancellationSafeAfterCommit ? undefined : abortSignal);
+        await this.deps.propagate(namespace, appliedTouched, mutationCommitted ? undefined : abortSignal);
       } catch (err) {
-        if ((!mutationCommitted || !cancellationSafeAfterCommit) && abortSignal?.aborted) throw err;
+        if (!mutationCommitted && abortSignal?.aborted) throw err;
         propagationWarnings.push(`propagation failed (non-fatal): ${errMsg(err)}`);
       }
     }
 
     await throwIfAbortedBeforeCommitAndReset();
+    if (cancellationRequestedAfterCommit) {
+      const recordedActions = new Set(results.map((result) => result.action));
+      for (const action of plan.actions) {
+        if (recordedActions.has(action)) continue;
+        results.push({
+          action,
+          status: "skipped",
+          error: "correction apply cancelled before action started",
+        });
+      }
+    }
     // ── Phase 4: audit record ─────────────────────────────────────────────
     const anyFailed = results.some((r) => r.status === "failed");
     const status: CorrectionOutcome["status"] =
@@ -621,20 +631,19 @@ export class CorrectionExecutor {
           outcome,
           requestText: plan.request.text,
         },
-        cancellationSafeAfterCommit ? undefined : abortSignal
+        mutationCommitted ? undefined : abortSignal
       );
       outcome.auditMemoryId = auditId;
     } catch (err) {
-      if ((!mutationCommitted || !cancellationSafeAfterCommit) && abortSignal?.aborted) throw err;
-      // The audit record is part of the contract but a failure to write it
-      // must NOT propagate — applied corrections are already durable. Record
-      // as a warning instead.
+      if (!mutationCommitted && abortSignal?.aborted) {
+        await resetApplying();
+        throw err;
+      }
       (outcome as CorrectionOutcome & { warnings?: string[] }).warnings = [
         ...propagationWarnings,
         `audit record write failed (non-fatal): ${errMsg(err)}`,
       ];
     }
-    await throwIfAbortedBeforeCommitAndReset();
 
     // ── Phase 5: mark plan consumed ───────────────────────────────────────
     // Corrections are already applied (phases 1-4 succeeded). A markConsumed