@remnic/core 9.45.3 → 9.45.5

package/src/coding/git-context.ts

@@ -23,8 +23,9 @@
  */
 import path from "node:path";
 
+import { abortError } from "../abort-error.js";
+import { launchProcess, launchProcessSync } from "../runtime/child-process.js";
 import { expandTildePath } from "../utils/path.js";
-import { launchProcessSync } from "../runtime/child-process.js";
 
 // Re-export so existing callers / tests that imported `expandTildePath` from
 // this module keep working. CLAUDE.md #17 requires consistent `~` expansion
@@ -64,19 +65,30 @@ export interface GitContext {
   defaultBranch: string | null;
 }
 
+export interface GitInvokeOptions {
+  abortSignal?: AbortSignal;
+  timeoutMs?: number;
+}
+
+export interface GitInvokeResult {
+  stdout: string;
+  exitCode: number;
+}
+
 /**
- * Injectable git-invocation surface. Only the commands `resolveGitContext`
- * actually needs are exposed. Tests inject a mock implementation to avoid
- * spawning a real git process.
+ * Run `git <args>` with `cwd` as the working directory. Implementations
+ * should return non-zero exit codes rather than throwing for command failure.
  */
 export interface GitInvoker {
-  /**
-   * Run `git <args>` with `cwd` as the working directory. Must return
-   * `{ stdout, exitCode }` with `stdout` trimmed by the caller as needed.
-   * Implementations should NOT throw for non-zero exit codes — they should
-   * return the exit code so the resolver can decide how to recover.
-   */
-  (cwd: string, args: string[]): { stdout: string; exitCode: number };
+  (
+    cwd: string,
+    args: string[],
+    options?: GitInvokeOptions,
+  ): GitInvokeResult | Promise<GitInvokeResult>;
+}
+
+export interface SyncGitInvoker {
+  (cwd: string, args: string[]): GitInvokeResult;
 }
 
 // ──────────────────────────────────────────────────────────────────────────
@@ -85,7 +97,7 @@ export interface GitInvoker {
 
 const DEFAULT_GIT_TIMEOUT_MS = 2_000;
 
-export function defaultGitInvoker(): GitInvoker {
+export function defaultGitInvokerSync(): SyncGitInvoker {
   return (cwd: string, args: string[]) => {
     const result = launchProcessSync("git", args, {
       cwd,
@@ -93,10 +105,7 @@ export function defaultGitInvoker(): GitInvoker {
       timeout: DEFAULT_GIT_TIMEOUT_MS,
       shell: false,
     });
-    if (result.error) {
-      // Spawn failure (git not on PATH, timeout, etc.). Surface as non-zero.
-      return { stdout: "", exitCode: 127 };
-    }
+    if (result.error) return { stdout: "", exitCode: 127 };
     return {
       stdout: typeof result.stdout === "string" ? result.stdout : "",
       exitCode: typeof result.status === "number" ? result.status : 1,
@@ -104,6 +113,73 @@ export function defaultGitInvoker(): GitInvoker {
   };
 }
 
+export function defaultGitInvoker(): GitInvoker {
+  return (cwd, args, options = {}) => {
+    if (options.abortSignal?.aborted) {
+      throw options.abortSignal.reason instanceof Error
+        ? options.abortSignal.reason
+        : abortError("git context resolution aborted");
+    }
+
+    const child = launchProcess("git", args, {
+      cwd,
+      encoding: "utf-8",
+      shell: false,
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    const { promise, resolve, reject } = Promise.withResolvers<GitInvokeResult>();
+    let stdout = "";
+    let settled = false;
+    let timer: NodeJS.Timeout | undefined;
+
+    const cleanup = (): void => {
+      clearTimeout(timer);
+      options.abortSignal?.removeEventListener("abort", onAbort);
+    };
+    const finish = (result: GitInvokeResult): void => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(result);
+    };
+    const fail = (error: Error): void => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(error);
+    };
+    const onAbort = (): void => {
+      child.kill("SIGTERM");
+      fail(
+        options.abortSignal?.reason instanceof Error
+          ? options.abortSignal.reason
+          : abortError("git context resolution aborted"),
+      );
+    };
+
+    child.stdout?.setEncoding("utf-8");
+    child.stdout?.on("data", (chunk: string | Buffer) => {
+      stdout += chunk.toString();
+    });
+    child.once("error", () => finish({ stdout: "", exitCode: 127 }));
+    child.once("close", (exitCode: number | null) => {
+      finish({ stdout, exitCode: typeof exitCode === "number" ? exitCode : 1 });
+    });
+    options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+
+    const timeoutMs = Math.max(
+      1,
+      Math.min(DEFAULT_GIT_TIMEOUT_MS, options.timeoutMs ?? DEFAULT_GIT_TIMEOUT_MS),
+    );
+    timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      finish({ stdout: "", exitCode: 124 });
+    }, timeoutMs);
+    if (options.abortSignal?.aborted) onAbort();
+    return promise;
+  };
+}
+
 // ──────────────────────────────────────────────────────────────────────────
 // Stable hashing
 // ──────────────────────────────────────────────────────────────────────────
@@ -239,17 +315,21 @@ export function normalizeOriginUrl(rawUrl: string): string {
 export interface ResolveGitContextOptions {
   /** Inject a git invoker (tests). Defaults to spawning real `git`. */
   invoker?: GitInvoker;
+  abortSignal?: AbortSignal;
+  /** Absolute epoch deadline shared with the extraction lifecycle. */
+  deadlineMs?: number;
+  /** Injectable clock for deadline tests. */
+  now?: () => number;
 }
 
 /**
  * Detect the git project + branch for `cwd`.
  *
- * Returns `null` when:
- *   - `cwd` is not an absolute path (invalid input, CLAUDE.md #51)
- *   - `cwd` is not inside a git worktree
- *   - `git` is not available on PATH
+ * Returns `null` when `cwd` is invalid, outside a worktree, or git is
+ * unavailable. Unexpected command failures also resolve to `null`.
  *
- * Never throws.
+ * Caller cancellation and an exhausted deadline reject so lifecycle callers
+ * can stop promptly instead of treating an interrupted probe as "not a repo".
  */
 export async function resolveGitContext(
   cwd: string,
@@ -272,9 +352,24 @@ export async function resolveGitContext(
     if (!path.isAbsolute(expanded)) return null;
 
     const invoker = options.invoker ?? defaultGitInvoker();
+    const now = options.now ?? Date.now;
+    const invoke = async (probeCwd: string, args: string[]): Promise<GitInvokeResult> => {
+      if (options.abortSignal?.aborted) {
+        throw options.abortSignal.reason instanceof Error
+          ? options.abortSignal.reason
+          : abortError("git context resolution aborted");
+      }
+      const remainingMs =
+        options.deadlineMs === undefined ? DEFAULT_GIT_TIMEOUT_MS : options.deadlineMs - now();
+      if (remainingMs <= 0) throw abortError("git context resolution deadline exceeded");
+      return invoker(probeCwd, args, {
+        abortSignal: options.abortSignal,
+        timeoutMs: Math.min(DEFAULT_GIT_TIMEOUT_MS, remainingMs),
+      });
+    };
 
     // 1. Locate the repo root.
-    const topLevel = invoker(expanded, ["rev-parse", "--show-toplevel"]);
+    const topLevel = await invoke(expanded, ["rev-parse", "--show-toplevel"]);
     if (topLevel.exitCode !== 0) return null;
     const rootPath = topLevel.stdout.trim();
     if (!rootPath) return null;
@@ -284,13 +379,13 @@ export async function resolveGitContext(
     //    HEAD ref is unborn and `--abbrev-ref HEAD` fails, but
     //    `symbolic-ref HEAD` still returns the target branch. Fall back
     //    so newly-initialized repos get a sensible branch name.
-    const branchResult = invoker(rootPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const branchResult = await invoke(rootPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
     let branch: string | null = null;
     if (branchResult.exitCode === 0) {
       const raw = branchResult.stdout.trim();
       branch = raw && raw !== "HEAD" ? raw : null;
     } else {
-      const unbornRef = invoker(rootPath, ["symbolic-ref", "--quiet", "HEAD"]);
+      const unbornRef = await invoke(rootPath, ["symbolic-ref", "--quiet", "HEAD"]);
       if (unbornRef.exitCode === 0) {
         const raw = unbornRef.stdout.trim();
         const prefix = "refs/heads/";
@@ -302,7 +397,7 @@ export async function resolveGitContext(
     }
 
     // 3. Origin URL — optional. Used to derive a stable `projectId`.
-    const originResult = invoker(rootPath, ["remote", "get-url", "origin"]);
+    const originResult = await invoke(rootPath, ["remote", "get-url", "origin"]);
     let projectId: string;
     if (originResult.exitCode === 0) {
       const normalized = normalizeOriginUrl(originResult.stdout);
@@ -312,7 +407,7 @@ export async function resolveGitContext(
     }
 
     // 4. Default branch — best effort.
-    const headRef = invoker(rootPath, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+    const headRef = await invoke(rootPath, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
     let defaultBranch: string | null = null;
     if (headRef.exitCode === 0) {
       const raw = headRef.stdout.trim();
@@ -330,7 +425,14 @@ export async function resolveGitContext(
       defaultBranch,
     };
   } catch {
-    // Never throws — any unexpected error falls back to "not in a repo".
+    if (options.abortSignal?.aborted) {
+      throw options.abortSignal.reason instanceof Error
+        ? options.abortSignal.reason
+        : abortError("git context resolution aborted");
+    }
+    if (options.deadlineMs !== undefined && (options.now ?? Date.now)() >= options.deadlineMs) {
+      throw abortError("git context resolution deadline exceeded");
+    }
     return null;
   }
 }

package/src/config.test.ts

@@ -533,6 +533,30 @@ test("parseConfig initGateTimeoutMs defaults to OpenClaw cold-start budget", ()
   assert.equal(result.initGateTimeoutMs, 30_000);
 });
 
+test("parseConfig keeps external wiki merge out of default recall", () => {
+  assert.equal(parseConfig({}).wikiMergeIntoRecall, false);
+  assert.equal(parseConfig({ wikiMergeIntoRecall: false }).wikiMergeIntoRecall, false);
+  assert.throws(
+    () => parseConfig({ wikiMergeIntoRecall: true }),
+    /wikiMergeIntoRecall=true is not supported/,
+  );
+  assert.throws(
+    () => parseConfig({ wikiMergeIntoRecall: "maybe" }),
+    /wikiMergeIntoRecall must be a boolean-like value/,
+  );
+});
+
+test("parseConfig rejects external wiki collections as default memory collections", () => {
+  assert.throws(
+    () => parseConfig({ qmdCollection: "external-wiki-reading" }),
+    /qmdCollection must be a memory collection/,
+  );
+  assert.throws(
+    () => parseConfig({ qmdColdCollection: "external-wiki-archive" }),
+    /qmdColdCollection must be a memory collection/,
+  );
+});
+
 test("parseConfig qmdSearchStrategy defaults to hybrid and validates the enum", () => {
   // Default must equal the historical lex+vec+hyde behavior. Issue #1335.
   assert.equal(parseConfig({}).qmdSearchStrategy, "hybrid");

package/src/config.ts

@@ -27,6 +27,7 @@ import type {
   TrustWeights,
 } from "./types.js";
 import { parseConvergeConfig } from "./converge-config.js";
+import { parseExternalWikiRecallGuard } from "./external-wiki-guard.js";
 import { log } from "./logger.js";
 import { cloneDefaultSessionObserverBands } from "./session-observer-bands.js";
 import { readEnvVar, resolveHomeDir } from "./runtime/env.js";
@@ -62,6 +63,7 @@ import { parseCodingKnowledgeConfig } from "./coding/coding-knowledge-config.js"
 import { parseChatConfig } from "./chat/chat-config.js";
 import { parseCorrectionIntentConfig, parseFaithfulnessGateConfig } from "./faithfulness-config.js";
 import { parseOfflineSyncExcludes } from "./offline-sync.js";
+import { parseExternalWikiRoots } from "./external-wiki-config.js";
 import {
   parseScopeProfiles,
   parseScopeTeams,
@@ -1558,6 +1560,9 @@ export function parseConfig(
     "maintenance.namespaceLockStaleMs",
   );
 
+  const { wikiMergeIntoRecall, qmdCollection, qmdColdCollection } =
+    parseExternalWikiRecallGuard(cfg);
+
   return {
     openaiApiKey: apiKey,
     openaiBaseUrl: baseUrl,
@@ -1608,13 +1613,8 @@ export function parseConfig(
       typeof cfg.maxMemoryTokens === "number" ? cfg.maxMemoryTokens : 2000,
     memoryOsPreset,
     qmdEnabled: cfg.qmdEnabled !== false,
-    qmdCollection:
-      typeof cfg.qmdCollection === "string"
-        ? cfg.qmdCollection
-        // TODO(#403): Keep legacy collection name for backwards compat so existing
-        // installs don't lose their QMD vector store data on upgrade. New installs
-        // can override via qmdCollection config. Consider migrating in a future PR.
-        : "openclaw-engram",
+    qmdCollection,
+    wikiMergeIntoRecall,
     qmdMaxResults:
       typeof cfg.qmdMaxResults === "number" ? cfg.qmdMaxResults : 8,
     qmdEmbeddingBacklogThreshold: (() => {
@@ -1627,11 +1627,7 @@ export function parseConfig(
       return Number.isFinite(n) && Number.isInteger(n) && n >= 0 ? n : 1000;
     })(),
     qmdColdTierEnabled: cfg.qmdColdTierEnabled === true,
-    qmdColdCollection:
-      typeof cfg.qmdColdCollection === "string" && cfg.qmdColdCollection.length > 0
-        ? cfg.qmdColdCollection
-        // TODO(#403): Keep legacy collection name for backwards compat.
-        : "openclaw-engram-cold",
+    qmdColdCollection,
     qmdColdMaxResults:
       typeof cfg.qmdColdMaxResults === "number" ? cfg.qmdColdMaxResults : 8,
     // Issue #678 PR 2/4: gate hot/cold tier migration (a deep-sleep activity)
@@ -1705,6 +1701,7 @@ export function parseConfig(
         ? cfg.qmdPath
         : undefined,
     memoryDir,
+    externalWikis: parseExternalWikiRoots(cfg.externalWikis, memoryDir),
     debug: cfg.debug === true,
     identityEnabled: cfg.identityEnabled !== false,
     identityContinuityEnabled,

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/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,