@remnic/core 9.45.3 → 9.45.5

package/src/offline-sync.ts

@@ -54,6 +54,11 @@ export interface OfflineSyncFileDigest {
   bytes: number;
 }
 
+export interface OfflineSyncDeletionRevision {
+  path: string;
+  mtimeMs: number;
+}
+
 export interface OfflineSyncSnapshot {
   format: typeof OFFLINE_SYNC_SNAPSHOT_FORMAT;
   schemaVersion: 1;
@@ -61,6 +66,7 @@ export interface OfflineSyncSnapshot {
   sourceId: string;
   includeTranscripts: boolean;
   files: OfflineSyncFileRecord[];
+  deletions?: OfflineSyncDeletionRevision[];
 }
 
 export type OfflineSyncChange =
@@ -74,6 +80,7 @@ export type OfflineSyncChange =
       type: "delete";
       path: string;
       baseSha256: string;
+      mtimeMs?: number;
     };
 
 export interface OfflineSyncChangeset {
@@ -140,6 +147,14 @@ export interface OfflineSyncFileTarget {
   filePath: string;
 }
 
+export interface OfflineSyncFileDeleteTarget extends OfflineSyncFileTarget {
+  mtimeMs?: number;
+}
+
+export type OfflineSyncRecordDeletionRevision = (
+  target: OfflineSyncFileDeleteTarget & { mtimeMs: number },
+) => Promise<void>;
+
 export interface OfflineSyncFileWriteTarget extends OfflineSyncFileTarget {
   content: Buffer;
 }
@@ -360,6 +375,88 @@ function normalizeFileStates(input: readonly unknown[] | undefined): OfflineSync
   return input.map((entry, index) => normalizeFileState(entry, `baseFiles[${index}]`));
 }
 
+function normalizeDeletionRevisions(
+  input: unknown,
+  fieldPrefix: string,
+): OfflineSyncDeletionRevision[] | undefined {
+  if (input === undefined) return undefined;
+  if (!Array.isArray(input)) {
+    throw new Error(`${fieldPrefix} must be an array`);
+  }
+  const deletions = input.map((entry, index): OfflineSyncDeletionRevision => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`${fieldPrefix}[${index}] must be an object`);
+    }
+    const obj = entry as Record<string, unknown>;
+    return {
+      path: normalizeRelativePath(obj.path, `${fieldPrefix}[${index}].path`),
+      mtimeMs: assertOfflineSyncMtimeMs(obj.mtimeMs, `${fieldPrefix}[${index}].mtimeMs`),
+    };
+  });
+  assertUniquePaths(deletions, fieldPrefix);
+  return deletions.sort(compareByPath);
+}
+
+function snapshotBuilderDeletions(options: {
+  deletions?: readonly OfflineSyncDeletionRevision[];
+  files: readonly OfflineSyncFileState[];
+  paths?: readonly string[];
+  includeTranscripts: boolean;
+  excludeNodeLocalState?: boolean;
+  userExcludeRegexps?: readonly RegExp[];
+}): OfflineSyncDeletionRevision[] | undefined {
+  const deletions = normalizeDeletionRevisions(options.deletions, "deletions");
+  if (deletions === undefined) return undefined;
+  if (deletions.length === 0) return deletions;
+  const presentPaths = new Set(options.files.map((file) => file.path.toLowerCase()));
+  const scopedPaths = options.paths
+    ? new Set(options.paths.map((relPath) => relPath.toLowerCase()))
+    : undefined;
+  return deletions.filter((deletion) =>
+    (scopedPaths === undefined || scopedPaths.has(deletion.path.toLowerCase())) &&
+    !presentPaths.has(deletion.path.toLowerCase()) &&
+    !(options.excludeNodeLocalState === false
+      ? shouldExcludeRelPath(deletion.path, options.includeTranscripts)
+      : shouldExcludePushRelPath(
+          deletion.path,
+          options.includeTranscripts,
+          options.userExcludeRegexps,
+        )));
+}
+
+export async function filterOfflineSyncDeletionRevisions(options: {
+  root: string;
+  deletions: readonly OfflineSyncDeletionRevision[];
+  includeTranscripts?: boolean;
+  userExcludeRegexps?: readonly RegExp[];
+}): Promise<OfflineSyncDeletionRevision[]> {
+  const deletions = normalizeDeletionRevisions(options.deletions, "deletions");
+  if (deletions === undefined) throw new Error("deletions must be an array");
+  if (deletions.length === 0) return deletions;
+  const root = await prepareSafeArchiveRoot(
+    path.resolve(options.root),
+    "filterOfflineSyncDeletionRevisions",
+    "root",
+  );
+  const includeTranscripts = options.includeTranscripts !== false;
+  const filtered: OfflineSyncDeletionRevision[] = [];
+  for (const deletion of deletions) {
+    if (shouldExcludePushRelPath(deletion.path, includeTranscripts, options.userExcludeRegexps)) {
+      continue;
+    }
+    const filePath = path.join(root.abs, ...deletion.path.split("/"));
+    const present = await lstat(filePath).then(
+      () => true,
+      (error: unknown) => {
+        if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+        throw error;
+      },
+    );
+    if (!present) filtered.push(deletion);
+  }
+  return filtered;
+}
+
 export function normalizeOfflineSyncSnapshot(
   input: unknown,
   options: { requireContent?: boolean } = {},
@@ -385,16 +482,21 @@ export function normalizeOfflineSyncSnapshot(
       normalizeFileRecord(entry, `files[${index}]`, options.requireContent === true))
     .filter((file) => !shouldIgnoreIncomingRuntimePath(file.path))
     .sort(compareByPath);
-  assertUniquePaths(files, "offline sync snapshot");
+  const deletions = normalizeDeletionRevisions(obj.deletions, "deletions")
+    ?.filter((deletion) => !shouldIgnoreIncomingRuntimePath(deletion.path));
+  const entries = deletions && deletions.length > 0 ? [...files, ...deletions] : files;
+  assertUniquePaths(entries, "offline sync snapshot");
   if (!includeTranscripts) {
-    const transcriptPath = files.find((file) => file.path.split("/")[0] === "transcripts")?.path;
+    const transcriptPath = entries
+      .find((entry) => entry.path.split("/")[0] === "transcripts")?.path;
     if (transcriptPath) {
       throw new Error(
         `offline sync snapshot includeTranscripts is false but contains transcript path: ${transcriptPath}`,
       );
     }
   }
-  const excludedPath = files.find((file) => shouldExcludeRelPath(file.path, true))?.path;
+  const excludedPath = entries
+    .find((entry) => shouldExcludeRelPath(entry.path, true))?.path;
   if (excludedPath) {
     throw new Error(`offline sync snapshot contains excluded path: ${excludedPath}`);
   }
@@ -405,6 +507,7 @@ export function normalizeOfflineSyncSnapshot(
     sourceId,
     includeTranscripts,
     files,
+    ...(deletions === undefined ? {} : { deletions }),
   };
 }
 
@@ -455,10 +558,14 @@ export function normalizeOfflineSyncChangeset(
       };
     }
     if (type === "delete") {
+      const mtimeMs = change.mtimeMs === undefined
+        ? undefined
+        : assertOfflineSyncMtimeMs(change.mtimeMs, `changes[${index}].mtimeMs`);
       return {
         type: "delete",
         path: relPath,
         baseSha256: assertSha256(change.baseSha256, `changes[${index}].baseSha256`),
+        ...(mtimeMs === undefined ? {} : { mtimeMs }),
       };
     }
     throw new Error(`changes[${index}].type must be "upsert" or "delete"`);
@@ -515,7 +622,16 @@ function assertUniquePaths(entries: readonly { path: string }[], context: string
   }
 }
 
+export function isInternalRemnicStatePath(relPosix: string): boolean {
+  const normalized = relPosix.includes("\\") ? relPosix.replaceAll("\\", "/") : relPosix;
+  return normalized === ".remnic"
+    || normalized.startsWith(".remnic/")
+    || normalized.endsWith("/.remnic")
+    || normalized.includes("/.remnic/");
+}
+
 function shouldExcludeRelPath(relPosix: string, includeTranscripts: boolean): boolean {
+  if (isInternalRemnicStatePath(relPosix)) return true;
   const parts = relPosix.split("/");
   if (parts.some((part) => DEFAULT_TRANSFER_EXCLUDE_DIRS.has(part))) return true;
   if (parts.some((part) => part === SYNC_INTERNAL_DIR)) return true;
@@ -615,6 +731,7 @@ export function parseOfflineSyncExcludes(raw: unknown): string[] {
 }
 
 function shouldIgnoreIncomingRuntimePath(relPosix: string): boolean {
+  if (isInternalRemnicStatePath(relPosix)) return true;
   const parts = relPosix.split("/");
   const basename = parts[parts.length - 1] ?? "";
   return isCanonicalRuntimeStatePath(parts) && basename.includes(".tmp-");
@@ -826,6 +943,7 @@ export async function buildOfflineSyncSnapshot(options: {
   root: string;
   sourceId: string;
   includeContent?: boolean;
+  deletions?: readonly OfflineSyncDeletionRevision[];
   includeTranscripts?: boolean;
   now?: Date;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
@@ -847,13 +965,22 @@ export async function buildOfflineSyncSnapshot(options: {
   for await (const file of iterateOfflineSyncSnapshotFileRecords(options)) files.push(file);
   throwIfOfflineSyncAborted(options.signal);
 
+  const sortedFiles = files.sort(compareByPath);
+  const deletions = snapshotBuilderDeletions({
+    deletions: options.deletions,
+    files: sortedFiles,
+    includeTranscripts,
+    excludeNodeLocalState: options.excludeNodeLocalState,
+    userExcludeRegexps: options.userExcludeRegexps,
+  });
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
     schemaVersion: 1,
     createdAt: (options.now ?? new Date()).toISOString(),
     sourceId: normalizeSourceId(options.sourceId, "sourceId"),
     includeTranscripts,
-    files: files.sort(compareByPath),
+    files: sortedFiles,
+    ...(deletions === undefined ? {} : { deletions }),
   };
 }
 
@@ -861,6 +988,7 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
   root: string;
   sourceId: string;
   baseFiles?: readonly OfflineSyncFileState[];
+  deletions?: readonly OfflineSyncDeletionRevision[];
   baseCapturedAt?: Date;
   includeContent?: boolean;
   includeTranscripts?: boolean;
@@ -937,13 +1065,22 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
   await walk(root.abs);
   throwIfOfflineSyncAborted(options.signal);
 
+  const sortedFiles = files.sort(compareByPath);
+  const deletions = snapshotBuilderDeletions({
+    deletions: options.deletions,
+    files: sortedFiles,
+    includeTranscripts,
+    excludeNodeLocalState: options.excludeNodeLocalState,
+    userExcludeRegexps: options.userExcludeRegexps,
+  });
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
     schemaVersion: 1,
     createdAt: (options.now ?? new Date()).toISOString(),
     sourceId: normalizeSourceId(options.sourceId, "sourceId"),
     includeTranscripts,
-    files: files.sort(compareByPath),
+    files: sortedFiles,
+    ...(deletions === undefined ? {} : { deletions }),
   };
 }
 
@@ -951,6 +1088,7 @@ export async function buildOfflineSyncSnapshotForPaths(options: {
   root: string;
   sourceId: string;
   paths: readonly string[];
+  deletions?: readonly OfflineSyncDeletionRevision[];
   includeContent?: boolean;
   includeTranscripts?: boolean;
   now?: Date;
@@ -1004,13 +1142,23 @@ export async function buildOfflineSyncSnapshotForPaths(options: {
   }
   throwIfOfflineSyncAborted(options.signal);
 
+  const sortedFiles = files.sort(compareByPath);
+  const deletions = snapshotBuilderDeletions({
+    deletions: options.deletions,
+    files: sortedFiles,
+    paths: [...seen],
+    includeTranscripts,
+    excludeNodeLocalState: options.excludeNodeLocalState,
+    userExcludeRegexps: options.userExcludeRegexps,
+  });
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
     schemaVersion: 1,
     createdAt: (options.now ?? new Date()).toISOString(),
     sourceId: normalizeSourceId(options.sourceId, "sourceId"),
     includeTranscripts,
-    files: files.sort(compareByPath),
+    files: sortedFiles,
+    ...(deletions === undefined ? {} : { deletions }),
   };
 }
 
@@ -1106,6 +1254,7 @@ export async function buildOfflineSyncChangeset(options: {
   root: string;
   sourceId: string;
   baseFiles?: readonly OfflineSyncFileState[];
+  deletions?: readonly OfflineSyncDeletionRevision[];
   baseCapturedAt?: Date;
   excludePaths?: readonly string[];
   includeTranscripts?: boolean;
@@ -1127,6 +1276,7 @@ export async function buildOfflineSyncChangeset(options: {
     root: options.root,
     sourceId: options.sourceId,
     baseFiles: options.baseFiles,
+    deletions: options.deletions,
     baseCapturedAt: options.baseCapturedAt,
     includeContent: false,
     includeTranscripts,
@@ -1140,6 +1290,7 @@ export async function buildOfflineSyncChangeset(options: {
     sourceId: options.sourceId,
     baseFiles: options.baseFiles,
     currentFiles: current.files,
+    deletions: current.deletions,
     excludePaths: options.excludePaths,
     includeTranscripts,
     now: options.now,
@@ -1153,6 +1304,7 @@ export async function buildOfflineSyncChangesetFromSnapshot(options: {
   sourceId: string;
   currentFiles: readonly OfflineSyncFileState[];
   baseFiles?: readonly OfflineSyncFileState[];
+  deletions?: readonly OfflineSyncDeletionRevision[];
   excludePaths?: readonly string[];
   includeTranscripts?: boolean;
   now?: Date;
@@ -1179,6 +1331,10 @@ export async function buildOfflineSyncChangesetFromSnapshot(options: {
     normalizeFileStates(options.currentFiles),
     includeTranscripts,
   ));
+  const deletions = normalizeDeletionRevisions(options.deletions, "deletions");
+  const deletionMtimeByPath = deletions === undefined
+    ? undefined
+    : new Map(deletions.map((deletion) => [deletion.path, deletion.mtimeMs] as const));
   const changes: OfflineSyncChange[] = [];
 
   for (const relPath of unionPaths(base, currentMap)) {
@@ -1216,10 +1372,12 @@ export async function buildOfflineSyncChangesetFromSnapshot(options: {
       continue;
     }
     if (!currentEntry && baseEntry) {
+      const mtimeMs = deletionMtimeByPath?.get(relPath);
       changes.push({
         type: "delete",
         path: relPath,
         baseSha256: baseEntry.sha256,
+        ...(mtimeMs === undefined ? {} : { mtimeMs }),
       });
     }
   }
@@ -1343,7 +1501,8 @@ export async function applyOfflineSyncSnapshot(options: {
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
   writeFile?: (target: OfflineSyncFileWriteTarget) => Promise<void>;
-  deleteFile?: (target: OfflineSyncFileTarget) => Promise<void>;
+  deleteFile?: (target: OfflineSyncFileDeleteTarget) => Promise<void>;
+  recordDeletionRevision?: OfflineSyncRecordDeletionRevision;
 }): Promise<OfflineSyncApplySnapshotResult> {
   const snapshot = normalizeOfflineSyncSnapshot(options.snapshot);
   const baseMap = byPath(filterBaseFilesForMode(
@@ -1351,6 +1510,9 @@ export async function applyOfflineSyncSnapshot(options: {
     snapshot.includeTranscripts,
   ));
   const incomingMap = byPath(snapshot.files);
+  const deletionMtimeByPath = snapshot.deletions === undefined
+    ? undefined
+    : new Map(snapshot.deletions.map((deletion) => [deletion.path, deletion.mtimeMs] as const));
   const incomingBuffers = verifyRecordContents(snapshot.files, "offline sync snapshot", {
     requireContent: false,
   });
@@ -1368,6 +1530,23 @@ export async function applyOfflineSyncSnapshot(options: {
       })).files;
   const currentMap = byPath(currentFiles);
   const deferredPaths = new Set(options.deferredPaths ?? []);
+  if (deletionMtimeByPath && options.recordDeletionRevision) {
+    for (const [relPath, mtimeMs] of deletionMtimeByPath) {
+      if (
+        currentMap.has(relPath) ||
+        deferredPaths.has(relPath) ||
+        matchesOfflineSyncDefaultExclude(relPath)
+      ) {
+        continue;
+      }
+      await options.recordDeletionRevision({
+        root: root.abs,
+        path: relPath,
+        filePath: await resolveSafeArchiveTarget(root, relPath),
+        mtimeMs,
+      });
+    }
+  }
   const nextBase = new Map(baseMap);
   const conflicts: OfflineSyncConflict[] = [];
   let upserted = 0;
@@ -1490,7 +1669,12 @@ export async function applyOfflineSyncSnapshot(options: {
       shouldPreferIncomingOfflineRuntimeFile(relPath) &&
       (base || shouldDeleteAbsentIncomingOfflineRuntimeFile(relPath))
     ) {
-      await deleteSafeFile(root, relPath, options.deleteFile);
+      await deleteSafeFile(
+        root,
+        relPath,
+        options.deleteFile,
+        deletionMtimeByPath?.get(relPath),
+      );
       nextBase.delete(relPath);
       deleted += 1;
       continue;
@@ -1501,7 +1685,12 @@ export async function applyOfflineSyncSnapshot(options: {
       continue;
     }
     if (base && currentEntry.sha256 === base.sha256) {
-      await deleteSafeFile(root, relPath, options.deleteFile);
+      await deleteSafeFile(
+        root,
+        relPath,
+        options.deleteFile,
+        deletionMtimeByPath?.get(relPath),
+      );
       nextBase.delete(relPath);
       deleted += 1;
       continue;
@@ -1539,7 +1728,8 @@ export async function applyOfflineSyncChangeset(options: {
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
   writeFile?: (target: OfflineSyncFileWriteTarget) => Promise<void>;
-  deleteFile?: (target: OfflineSyncFileTarget) => Promise<void>;
+  deleteFile?: (target: OfflineSyncFileDeleteTarget) => Promise<void>;
+  recordDeletionRevision?: OfflineSyncRecordDeletionRevision;
 }): Promise<OfflineSyncApplyChangesetResult> {
   let changeset: OfflineSyncChangeset;
   try {
@@ -1630,11 +1820,19 @@ export async function applyOfflineSyncChangeset(options: {
     }
 
     if (!currentEntry) {
+      if (change.mtimeMs !== undefined && options.recordDeletionRevision) {
+        await options.recordDeletionRevision({
+          root: root.abs,
+          path: change.path,
+          filePath: await resolveSafeArchiveTarget(root, change.path),
+          mtimeMs: change.mtimeMs,
+        });
+      }
       skipped += 1;
       continue;
     }
     if (currentEntry.sha256 === change.baseSha256) {
-      await deleteSafeFile(root, change.path, options.deleteFile);
+      await deleteSafeFile(root, change.path, options.deleteFile, change.mtimeMs);
       currentMap.delete(change.path);
       appliedDeletes += 1;
       continue;
@@ -2310,11 +2508,17 @@ async function writeOfflineUploadContent(options: {
 async function deleteSafeFile(
   root: SafeArchiveRoot,
   relPath: string,
-  deleteFile?: (target: OfflineSyncFileTarget) => Promise<void>,
+  deleteFile?: (target: OfflineSyncFileDeleteTarget) => Promise<void>,
+  mtimeMs?: number,
 ): Promise<void> {
   const target = await resolveSafeArchiveTarget(root, relPath);
   if (deleteFile) {
-    await deleteFile({ root: root.abs, path: relPath, filePath: target });
+    await deleteFile({
+      root: root.abs,
+      path: relPath,
+      filePath: target,
+      ...(mtimeMs === undefined ? {} : { mtimeMs }),
+    });
     return;
   }
   await unlink(target).catch((error: unknown) => {

package/src/orchestration/external-wiki-recall-guard.test.ts

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { mkdir, symlink } from "node:fs/promises";
+import path from "node:path";
+import test from "node:test";
+
+import type { QmdSearchResult } from "../types.js";
+import * as wikiGuard from "../external-wiki-guard.js";
+import { withTempDir } from "../testing/tmp-dir.js";
+import {
+  filterRecallCandidates,
+  isExternalWikiCollectionName,
+  isGenericRecallExcludedPath,
+} from "./generic-recall-paths.js";
+
+const { assertExternalWikiRootOutsideMemoryDir } = wikiGuard;
+const assertCanonicalIsolation = (
+  wikiGuard as typeof wikiGuard & {
+    assertExternalWikiRootOutsideMemoryDirCanonical(memoryDir: string, rootDir: string): Promise<void>;
+  }
+).assertExternalWikiRootOutsideMemoryDirCanonical;
+
+function hit(path: string, snippet: string): QmdSearchResult {
+  return { docid: path, path, score: 1, snippet };
+}
+
+const OVERLAPPING_QUERY = "bounded context budgets";
+const MEMORY_HIT = hit("openclaw-engram/facts/context-budget.md", `The operator chose ${OVERLAPPING_QUERY}.`);
+const WIKI_HIT = hit(
+  "qmd://external-wiki-reading/wiki/context-budgets.md",
+  `A compiled guide to ${OVERLAPPING_QUERY}.`
+);
+
+const MEMORY_POLICY = {
+  qmdCollection: "openclaw-engram",
+  qmdColdCollection: "openclaw-engram-cold",
+};
+
+test("default recall excludes overlapping external wiki hits before applying its limit", () => {
+  const recalled = filterRecallCandidates([WIKI_HIT, MEMORY_HIT], {
+    namespacesEnabled: false,
+    recallNamespaces: [],
+    resolveNamespace: () => "default",
+    limit: 1,
+    pathPolicy: MEMORY_POLICY,
+  });
+
+  assert.deepEqual(recalled, [MEMORY_HIT]);
+  assert.equal(isGenericRecallExcludedPath(WIKI_HIT.path, MEMORY_POLICY, "qmd"), true);
+});
+
+test("the recall-only guard leaves on-demand external wiki search results available", () => {
+  const onDemandResults = [WIKI_HIT];
+
+  assert.equal(onDemandResults[0]?.path, WIKI_HIT.path);
+  assert.match(onDemandResults[0]?.snippet ?? "", new RegExp(OVERLAPPING_QUERY));
+});
+
+test("external wiki collection ids cannot masquerade as memory collections", () => {
+  assert.equal(isExternalWikiCollectionName("external-wiki-reading"), true);
+  assert.equal(isExternalWikiCollectionName("external-wiki-reading--default"), true);
+  assert.equal(isExternalWikiCollectionName("openclaw-engram"), false);
+  assert.equal(isExternalWikiCollectionName("my-external-wiki-reading"), false);
+});
+
+test("external wiki roots cannot enter the primary memory collection walk", () => {
+  assert.throws(
+    () => assertExternalWikiRootOutsideMemoryDir("/data/memory", "/data/memory"),
+    /must be outside memoryDir/
+  );
+  assert.throws(
+    () => assertExternalWikiRootOutsideMemoryDir("/data/memory", "/data/memory/compiled-wiki"),
+    /must be outside memoryDir/
+  );
+  assert.doesNotThrow(() => assertExternalWikiRootOutsideMemoryDir("/data/memory", "/data/compiled-wiki"));
+});
+
+test("external wiki root isolation resolves filesystem aliases", async () => {
+  assert.equal(typeof assertCanonicalIsolation, "function");
+  await withTempDir(async (rootDir) => {
+    const memoryDir = path.join(rootDir, "memory");
+    const nestedWiki = path.join(memoryDir, "compiled-wiki");
+    const wikiAlias = path.join(rootDir, "wiki-alias");
+    await mkdir(nestedWiki, { recursive: true });
+    await symlink(nestedWiki, wikiAlias);
+    const memoryAlias = path.join(rootDir, "memory-alias");
+    await symlink(memoryDir, memoryAlias);
+
+    await assert.rejects(() => assertCanonicalIsolation(memoryDir, wikiAlias), /must be outside memoryDir/);
+    await assert.rejects(
+      () => assertCanonicalIsolation(memoryDir, path.join(memoryAlias, "future-wiki")),
+      /must be outside memoryDir/
+    );
+  }, "remnic-external-wiki-guard-");
+});

package/src/orchestration/extraction-persist.ts

@@ -419,6 +419,7 @@ export class ExtractionPersistCoordinator {
       source: string;
       sources?: ProvenanceSource[];
       provenance?: "verified" | "unverified" | "none";
+      toolScoped?: true;
     }): Promise<void> => {
       if (
         !scopeProfileWritePlan ||
@@ -536,6 +537,7 @@ export class ExtractionPersistCoordinator {
             contentHashSource: options.category === "fact" ? dedupContent : rawContent,
             ...(options.sources && options.sources.length > 0 ? { sources: options.sources } : {}),
             ...(options.provenance ? { provenance: options.provenance } : {}),
+            ...(options.toolScoped ? { toolScoped: true as const } : {}),
           });
           const promotedId = targetPromotion.id;
           // #1645: if the TARGET namespace's own tombstone blocked this promotion,
@@ -615,8 +617,12 @@ export class ExtractionPersistCoordinator {
       sources?: ProvenanceSource[];
       provenance?: "verified" | "unverified" | "none";
     }): Promise<void> => {
-      await promoteMemoryToProfileTargets(options);
-      if (lifecycleCaps.extractionScopeClassification && withholdToolScopedFromSharedNamespace(options)) return;
+      const toolScoped = withholdToolScopedFromSharedNamespace(options);
+      await promoteMemoryToProfileTargets({
+        ...options,
+        ...(toolScoped ? { toolScoped: true as const } : {}),
+      });
+      if (lifecycleCaps.extractionScopeClassification && toolScoped) return;
       if (
         !shouldPromoteToShared(
           this.deps.config,
@@ -939,6 +945,7 @@ export class ExtractionPersistCoordinator {
           // Claim-level provenance spans (issue #1575 PR 2).
           ...(options.sources && options.sources.length > 0 ? { sources: options.sources } : {}),
           ...(options.provenance ? { provenance: options.provenance } : {}),
+          ...(toolScoped ? { toolScoped: true as const } : {}),
         });
         const promotedId = sharedPromotion.id;
         // #1645: if the shared namespace's own tombstone blocked this promotion,
@@ -2019,6 +2026,11 @@ export class ExtractionPersistCoordinator {
           ? "extraction-proactive"
           : "extraction";
       const extractionSourceConnector = sourceContext?.sourceConnector;
+      const factToolScoped = withholdToolScopedFromSharedNamespace({
+        content: fact.content,
+        sourceConnector: extractionSourceConnector,
+        procedureSteps: fact.procedureSteps,
+      });
 
       // Check for contradictions before writing (Phase 2B).
       // NOTE: This block was moved above the chunking branch so that the
@@ -2227,6 +2239,7 @@ export class ExtractionPersistCoordinator {
             // PR #2016: never defer here — fallible chunk/artifact writes follow this
             // durable parent .md; flush the hash now so a throw can't strand it (dup).
             deferHashIndexSave: false,
+            ...(factToolScoped ? { toolScoped: true as const } : {}),
           });
           const parentId = parentWrite.id;
           // #1645: surface the tombstone block and gate active post-write paths
@@ -2310,6 +2323,7 @@ export class ExtractionPersistCoordinator {
                   ...(fact.sources && fact.sources.length > 0 ? { sources: fact.sources } : {}),
                   ...(fact.provenance ? { provenance: fact.provenance } : {}),
                   ...(extractionSourceConnector ? { sourceConnector: extractionSourceConnector } : {}),
+                  ...(factToolScoped ? { toolScoped: true as const } : {}),
                 },
               );
             }
@@ -2457,6 +2471,7 @@ export class ExtractionPersistCoordinator {
                 intentActionType: inferredIntent?.actionType,
                 intentEntityTypes: inferredIntent?.entityTypes,
                 ...(extractionSourceConnector ? { sourceConnector: extractionSourceConnector } : {}),
+                ...(factToolScoped ? { toolScoped: true as const } : {}),
               });
             }
             // v8.2: graph edge building for chunked memories. #1576: skip pending_review.
@@ -2598,6 +2613,7 @@ export class ExtractionPersistCoordinator {
         // #1909: defer the per-fact index flush to the batch save only when
         // fact dedup is on (the batch saver is a no-op otherwise).
         deferHashIndexSave: factDedupEnabled,
+        ...(factToolScoped ? { toolScoped: true as const } : {}),
       });
       const memoryId = factWrite.id;
       // #1645: surface the tombstone block; gate active post-write paths like #1576
@@ -2762,6 +2778,7 @@ export class ExtractionPersistCoordinator {
             intentActionType: inferredIntent?.actionType,
             intentEntityTypes: inferredIntent?.entityTypes,
             ...(extractionSourceConnector ? { sourceConnector: extractionSourceConnector } : {}),
+            ...(factToolScoped ? { toolScoped: true as const } : {}),
           });
         }
         // Register in the target storage content-hash index after successful