@remnic/core 9.45.2 → 9.45.4

package/src/access-surface-catalog.ts

@@ -130,6 +130,7 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "compression_guidelines_optimize", operation: "compression_guidelines_optimize" },
   { tool: "compression_guidelines_activate", operation: "compression_guidelines_activate" },
   { tool: "memory_search", operation: "memory_search" },
+  { tool: "external_wiki_search", operation: "external_wiki_search" },
   { tool: "memory_profile", operation: "memory_profile" },
   { tool: "memory_entities_list", operation: "memory_entities_list" },
   { tool: "memory_questions", operation: "memory_questions" },
@@ -175,10 +176,12 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
 export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   { method: "GET", pathname: "/engram/v1/adapters", operation: "adapters_status" },
   { method: "POST", pathname: "/engram/v1/recall", operation: "recall" },
+  { method: "POST", pathname: "/engram/v1/external-wikis/search", operation: "external_wiki_search" },
   { method: "POST", pathname: "/engram/v1/coding-context", operation: "set_coding_context" },
   { method: "POST", pathname: "/engram/v1/capsules/export", operation: "capsule_export" },
   { method: "POST", pathname: "/engram/v1/capsules/import", operation: "capsule_import" },
   { method: "GET", pathname: "/engram/v1/offline-sync/snapshot", operation: "offline_sync_snapshot" },
+  { method: "GET", pathname: "/engram/v1/offline-sync/capabilities", operation: "offline_sync_snapshot" },
     { method: "POST", pathname: "/engram/v1/offline-sync/snapshot", operation: "offline_sync_snapshot" },
   { method: "POST", pathname: "/engram/v1/offline-sync/files", operation: "offline_sync_files" },
   { method: "POST", pathname: "/engram/v1/offline-sync/file-content", operation: "offline_sync_file_content" },
@@ -252,6 +255,7 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   // The operation registration makes them visible to the boundary; the
   // streaming lifecycle is owned by the HTTP transport (handleGraphEventsSSE).
   { method: "GET", pathname: "/engram/v1/offline-sync/snapshot-stream", operation: "offline_sync_snapshot_stream" },
+  { method: "GET", pathname: "/engram/v1/offline-sync/manifest-stream", operation: "offline_sync_snapshot_stream" },
   { method: "GET", pathname: "/engram/v1/graph/events", operation: "graph_events" },
   { method: "POST", pathname: "/engram/v1/chat/message", operation: "chat_message" },
   { method: "GET", pathname: "/engram/v1/chat/events/:id", operation: "chat_events" },

package/src/admin/admin-surfaces.ts

@@ -783,6 +783,7 @@ export interface PromotionStorageProvider {
        */
       lineage: string[];
       sourceConnector?: string;
+      toolScoped?: true;
     }
   ): Promise<string>;
 }
@@ -920,6 +921,7 @@ export async function promoteMemory(options: PromoteMemoryOptions): Promise<Memo
         validAt: sourceMemory.frontmatter.valid_at,
         lineage: [options.sourceMemoryId],
         ...(sourceMemory.frontmatter.sourceConnector ? { sourceConnector: sourceMemory.frontmatter.sourceConnector } : {}),
+        ...(sourceMemory.frontmatter.toolScoped ? { toolScoped: true as const } : {}),
       });
       target.promoted = true;
       target.promotedMemoryId = promotedId;

package/src/binary-lifecycle/pipeline.test.ts

@@ -7,8 +7,9 @@ import test from "node:test";
 
 import { runBinaryLifecyclePipeline } from "./pipeline.js";
 import { manifestPath, writeManifest } from "./manifest.js";
-import type { BinaryLifecycleConfig } from "./types.js";
+import type { BinaryLifecycleConfig, PipelineResult } from "./types.js";
 import type { BinaryStorageBackend } from "./backend.js";
+import { withEntityCanonicalMutationLock } from "../storage/entity-canonical-id-lock.js";
 
 const baseConfig: BinaryLifecycleConfig = {
   enabled: true,
@@ -666,6 +667,110 @@ test("binary lifecycle fails closed without overwriting an invalid manifest", as
   }
 });
 
+test("binary lifecycle entity redirects wait for the canonical mutation lock", async () => {
+  const targetDir = await mkdtemp(path.join(os.tmpdir(), "remnic-binary-entity-lock-"));
+  const controlDir = await mkdtemp(path.join(os.tmpdir(), "remnic-binary-control-"));
+  const entityPath = path.join(targetDir, "entities", "binary-lock-target.md");
+  const originalEntity = "entity before redirect\n\n![img](../image.png)\n";
+  const redirectedEntity = "entity before redirect\n\n![img](remote/image.png)\n";
+  let targetPromise: Promise<PipelineResult> | undefined;
+
+  try {
+    await Promise.all([
+      mkdir(path.dirname(entityPath), { recursive: true }),
+      mkdir(path.join(targetDir, "state"), { recursive: true }),
+    ]);
+    await Promise.all([
+      writeFile(path.join(targetDir, "image.png"), "image", "utf8"),
+      writeFile(entityPath, originalEntity, "utf8"),
+      writeFile(path.join(controlDir, "image.png"), "image", "utf8"),
+      writeFile(path.join(controlDir, "note.md"), "![img](image.png)\n", "utf8"),
+    ]);
+    const manifest = {
+      version: 1 as const,
+      assets: [
+        {
+          originalPath: "image.png",
+          mirroredPath: "remote/image.png",
+          contentHash: sha256("image"),
+          sizeBytes: "image".length,
+          mimeType: "image/png",
+          mirroredAt: "2026-01-01T00:00:00.000Z",
+          status: "mirrored" as const,
+        },
+      ],
+    };
+    await Promise.all([
+      writeManifest(targetDir, manifest),
+      writeManifest(controlDir, manifest),
+    ]);
+
+    const redirectPrepared = Promise.withResolvers<void>();
+    const continueRedirect = Promise.withResolvers<void>();
+    let targetFinished = false;
+
+    await withEntityCanonicalMutationLock(path.join(targetDir, "state"), async () => {
+      targetPromise = runBinaryLifecyclePipeline(
+        targetDir,
+        baseConfig,
+        nestedRemoteBackend,
+        noopLogger,
+        {
+          readMarkdownFile: async (filePath) => {
+            const content = await readFile(filePath, "utf8");
+            if (filePath === entityPath) {
+              redirectPrepared.resolve();
+              await continueRedirect.promise;
+            }
+            return content;
+          },
+        },
+      );
+      void targetPromise.then(
+        () => {
+          targetFinished = true;
+        },
+        () => undefined,
+      );
+
+      await redirectPrepared.promise;
+      continueRedirect.resolve();
+      const controlResult = await runBinaryLifecyclePipeline(
+        controlDir,
+        baseConfig,
+        nestedRemoteBackend,
+        noopLogger,
+      );
+      assert.equal(controlResult.redirected, 1);
+      assert.equal(
+        await readFile(path.join(controlDir, "note.md"), "utf8"),
+        "![img](remote/image.png)\n",
+      );
+      assert.equal(
+        targetFinished,
+        false,
+        "the target redirect must not finish while its entity mutation lock is held",
+      );
+      assert.equal(
+        await readFile(entityPath, "utf8"),
+        originalEntity,
+        "the entity redirect write must not enter while the canonical mutation lock is held",
+      );
+    });
+
+    assert.ok(targetPromise);
+    const targetResult = await targetPromise;
+    assert.equal(targetResult.redirected, 1);
+    assert.equal(await readFile(entityPath, "utf8"), redirectedEntity);
+  } finally {
+    await targetPromise?.catch(() => undefined);
+    await Promise.all([
+      rm(targetDir, { recursive: true, force: true }),
+      rm(controlDir, { recursive: true, force: true }),
+    ]);
+  }
+});
+
 const noopLogger = {
   info: () => {},
   warn: () => {},

package/src/binary-lifecycle/pipeline.ts

@@ -27,6 +27,7 @@ import {
   repairContentAfterJournalMove,
   requestEntityCanonicalIdReconcile,
 } from "../storage/entity-canonical-id-references.js";
+import { withRawEntityPageMutation } from "../storage/entity-canonical-id-lock.js";
 
 // Write-boundary journal cache for redirect rewrites (issue #2213).
 const historicalIdCache = new HistoricalEntityCanonicalIdCache();
@@ -338,6 +339,7 @@ async function stageRedirect(
         // keep their bytes (plus the redirect) untouched, and entities/ pages
         // get the bounded reconcile marker instead — their migrated surface
         // is relationship targets, not an entityRef frontmatter field.
+        await withRawEntityPageMutation(memoryDir, update.mdPath, async () => {
         const stateDir = path.join(memoryDir, "state");
         const kind = classifyEntityRefWritePath(memoryDir, update.mdPath);
         if (kind === "memory") {
@@ -371,6 +373,7 @@ async function stageRedirect(
             await requestEntityCanonicalIdReconcile(stateDir);
           }
         }
+        });
         // The redirect rewrote an on-disk memory file out-of-band (not through a
         // StorageManager mutation). Bump the corpus sentinel per write so a warm
         // hot-memories cache rescans — mid-batch too, never serving pre-redirect

package/src/coding/git-context.test.ts

@@ -331,6 +331,53 @@ test("resolveGitContext: custom invoker throwing on a later call → returns nul
   assert.equal(ctx, null);
 });
 
+test("#2206 resolveGitContext forwards caller cancellation to an active git probe", async () => {
+  const abortController = new AbortController();
+  let forwardedSignal: AbortSignal | undefined;
+  const pendingProbe = Promise.withResolvers<{ stdout: string; exitCode: number }>();
+  const invoker: GitInvoker = (_cwd, _args, options) => {
+    forwardedSignal = options?.abortSignal;
+    options?.abortSignal?.addEventListener(
+      "abort",
+      () => pendingProbe.reject(options.abortSignal?.reason),
+      { once: true },
+    );
+    return pendingProbe.promise;
+  };
+
+  const resolving = resolveGitContext("/work/repo", {
+    invoker,
+    abortSignal: abortController.signal,
+  });
+  await Promise.resolve();
+  abortController.abort(new Error("caller cancelled"));
+
+  await assert.rejects(resolving, /caller cancelled/);
+  assert.equal(forwardedSignal, abortController.signal);
+});
+
+test("#2206 resolveGitContext gives each probe only the remaining deadline budget", async () => {
+  const timeouts: number[] = [];
+  let now = 1_000;
+  const invoker: GitInvoker = (cwd, args, options) => {
+    timeouts.push(options?.timeoutMs ?? -1);
+    now += 100;
+    const command = args.join(" ");
+    if (command === "rev-parse --show-toplevel") return { stdout: cwd, exitCode: 0 };
+    if (command === "rev-parse --abbrev-ref HEAD") return { stdout: "main", exitCode: 0 };
+    return { stdout: "", exitCode: 1 };
+  };
+
+  const context = await resolveGitContext("/work/repo", {
+    invoker,
+    deadlineMs: 1_400,
+    now: () => now,
+  });
+
+  assert.ok(context);
+  assert.deepEqual(timeouts, [400, 300, 200, 100]);
+});
+
 // ──────────────────────────────────────────────────────────────────────────
 // resolveGitContext — happy path (origin, branch, default branch)
 // ──────────────────────────────────────────────────────────────────────────

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,