@remnic/core 9.3.515 → 9.3.516

package/src/offline-sync.test.ts

@@ -16,6 +16,7 @@ import {
   buildOfflineSyncSnapshotForPaths,
   OFFLINE_SYNC_MAX_MTIME_MS,
   readOfflineSyncFileContentChunk,
+  shouldPreferIncomingOfflineRuntimeFile,
   summarizeOfflineSyncPendingChanges,
   summarizeOfflineSyncPendingFiles,
 } from "./offline-sync.js";
@@ -110,6 +111,32 @@ test("offline snapshot captures source-of-truth files and excludes private/inter
   }
 });
 
+test("offline snapshot abort signal stops filesystem snapshot work", async () => {
+  const root = await tempDir("remnic-offline-snapshot-abort");
+  try {
+    await write(root, "facts/a.md", "alpha");
+    const controller = new AbortController();
+
+    await assert.rejects(
+      buildOfflineSyncSnapshot({
+        root,
+        sourceId: "remote",
+        signal: controller.signal,
+        readFileDigest: async () => {
+          controller.abort();
+          return {
+            sha256: createHash("sha256").update("alpha").digest("hex"),
+            bytes: Buffer.byteLength("alpha"),
+          };
+        },
+      }),
+      /offline sync request aborted/,
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("offline sync includes retrieval debug snapshots for full-fidelity offline recall", async () => {
   const root = await tempDir("remnic-offline-debug-snapshots");
   try {
@@ -313,7 +340,7 @@ test("offline snapshot from base avoids rehashing unchanged files", async () =>
       sourceId: "remote",
       includeContent: false,
     });
-    const baseCapturedAt = new Date(Date.now() + 60_000);
+    const baseCapturedAt = new Date();
     let readCount = 0;
 
     const unchanged = await buildOfflineSyncSnapshotFromBase({
@@ -438,7 +465,7 @@ test("offline snapshot from base trusts mtime precision drift without rehashing"
       root,
       sourceId: "remote",
       baseFiles: [driftedBase],
-      baseCapturedAt: new Date(Date.now() + 60_000),
+      baseCapturedAt: new Date(),
       includeContent: false,
       readFileDigest: async () => {
         throw new Error("unchanged file should reuse trusted mtime metadata");
@@ -451,6 +478,47 @@ test("offline snapshot from base trusts mtime precision drift without rehashing"
   }
 });
 
+test("offline snapshot from base rehashes metadata-only ctime churn", async () => {
+  const root = await tempDir("remnic-offline-fast-base-ctime-only");
+  try {
+    await write(root, "facts/a.md", "alpha");
+    const filePath = path.join(root, "facts/a.md");
+    const baseSnapshot = await buildOfflineSyncSnapshot({
+      root,
+      sourceId: "remote",
+      includeContent: false,
+    });
+    const baseFile = baseSnapshot.files.find((file) => file.path === "facts/a.md");
+    assert.ok(baseFile);
+    const baseCapturedAt = new Date();
+    await new Promise<void>((resolve) => setTimeout(resolve, 1_100));
+    await chmod(filePath, 0o600);
+    await chmod(filePath, 0o644);
+
+    let digestReadCount = 0;
+    const rehashed = await buildOfflineSyncSnapshotFromBase({
+      root,
+      sourceId: "remote",
+      baseFiles: baseSnapshot.files,
+      baseCapturedAt,
+      includeContent: false,
+      readFileDigest: async ({ filePath }) => {
+        digestReadCount += 1;
+        const bytes = await readFile(filePath);
+        return {
+          sha256: createHash("sha256").update(bytes).digest("hex"),
+          bytes: bytes.byteLength,
+        };
+      },
+    });
+
+    assert.equal(digestReadCount, 1);
+    assert.equal(rehashed.files[0]?.sha256, baseFile.sha256);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("offline snapshot from base rehashes preserved-mtime rewrites when ctime changed after capture", async () => {
   const root = await tempDir("remnic-offline-fast-base-preserved-mtime");
   try {
@@ -463,6 +531,8 @@ test("offline snapshot from base rehashes preserved-mtime rewrites when ctime ch
     });
     const baseFile = baseSnapshot.files[0];
     assert.ok(baseFile);
+    const baseCapturedAt = new Date();
+    await new Promise<void>((resolve) => setTimeout(resolve, 20));
     await write(root, "facts/a.md", "bravo");
     await utimes(filePath, baseFile.mtimeMs / 1000, baseFile.mtimeMs / 1000);
 
@@ -471,7 +541,7 @@ test("offline snapshot from base rehashes preserved-mtime rewrites when ctime ch
       root,
       sourceId: "remote",
       baseFiles: baseSnapshot.files,
-      baseCapturedAt: new Date(0),
+      baseCapturedAt,
       includeContent: false,
       readFileDigest: async ({ filePath }) => {
         digestReadCount += 1;
@@ -525,7 +595,7 @@ test("offline snapshot apply preserves incoming mtime for future fast-base reuse
       root,
       sourceId: "local",
       baseFiles: applied.nextBaseFiles,
-      baseCapturedAt: new Date(capturedAtMs),
+      baseCapturedAt: new Date(),
       includeContent: false,
       readFileDigest: async () => {
         throw new Error("applied file should reuse preserved mtime metadata");
@@ -1526,6 +1596,50 @@ test("offline pull skips local runtime drift when remote still matches base", as
   }
 });
 
+test("offline pull treats last intent as remote-authoritative runtime state", async () => {
+  const root = await tempDir("remnic-offline-runtime-last-intent");
+  try {
+    const relPath = "state/last_intent.json";
+    const baseContent = Buffer.from("{\"intent\":\"base\"}");
+    const localContent = Buffer.from("{\"intent\":\"local\"}");
+    const remoteContent = Buffer.from("{\"intent\":\"remote\"}");
+    await write(root, relPath, localContent);
+    const baseFile = {
+      path: relPath,
+      sha256: createHash("sha256").update(baseContent).digest("hex"),
+      bytes: baseContent.byteLength,
+      mtimeMs: 1,
+    };
+    const incomingFile = {
+      path: relPath,
+      sha256: createHash("sha256").update(remoteContent).digest("hex"),
+      bytes: remoteContent.byteLength,
+      mtimeMs: 2,
+      contentBase64: remoteContent.toString("base64"),
+    };
+
+    assert.equal(shouldPreferIncomingOfflineRuntimeFile(relPath), true);
+    const pull = await applyOfflineSyncSnapshot({
+      root,
+      snapshot: {
+        format: "remnic.offline-sync.snapshot.v1",
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        sourceId: "remote",
+        includeTranscripts: true,
+        files: [incomingFile],
+      },
+      baseFiles: [baseFile],
+    });
+
+    assert.equal(pull.upserted, 1);
+    assert.equal(pull.conflicts.length, 0);
+    assert.equal(await readUtf8(root, relPath), remoteContent.toString("utf-8"));
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("offline pull applies snapshots with content only for remote-changed files", async () => {
   const remote = await tempDir("remnic-offline-partial-remote");
   const local = await tempDir("remnic-offline-partial-local");
@@ -2108,14 +2222,13 @@ test("offline sync applies and snapshots through secure storage hooks", async ()
   }
 });
 
-test("offline snapshot fast-base rehashes when encrypted header probe fails", async () => {
-  const root = await tempDir("remnic-offline-fast-base-probe-error");
+test("offline snapshot fast-base does not probe file headers for trusted metadata", async () => {
+  const root = await tempDir("remnic-offline-fast-base-no-header-probe");
   const relPath = "facts/same-size.md";
-  const oldContent = Buffer.from("old!");
-  const newContent = Buffer.from("new!");
+  const content = Buffer.from("fact");
   const filePath = path.join(root, relPath);
   try {
-    await write(root, relPath, newContent);
+    await write(root, relPath, content);
     await chmod(filePath, 0o000);
     const st = await stat(filePath);
     let digestReads = 0;
@@ -2125,24 +2238,21 @@ test("offline snapshot fast-base rehashes when encrypted header probe fails", as
       sourceId: "remote",
       baseFiles: [{
         path: relPath,
-        sha256: createHash("sha256").update(oldContent).digest("hex"),
-        bytes: newContent.byteLength,
+        sha256: createHash("sha256").update(content).digest("hex"),
+        bytes: content.byteLength,
         mtimeMs: st.mtimeMs,
       }],
-      baseCapturedAt: new Date(),
+      baseCapturedAt: new Date(Date.now() + 60_000),
       readFileDigest: async ({ path: targetPath, filePath: targetFilePath }) => {
         assert.equal(targetPath, relPath);
         assert.equal(targetFilePath, filePath);
         digestReads += 1;
-        return {
-          sha256: createHash("sha256").update(newContent).digest("hex"),
-          bytes: newContent.byteLength,
-        };
+        throw new Error("trusted metadata should not read the file header or digest");
       },
     });
 
-    assert.equal(digestReads, 1);
-    assert.equal(snapshot.files[0]?.sha256, createHash("sha256").update(newContent).digest("hex"));
+    assert.equal(digestReads, 0);
+    assert.equal(snapshot.files[0]?.sha256, createHash("sha256").update(content).digest("hex"));
   } finally {
     await chmod(filePath, 0o600).catch(() => {});
     await rm(root, { recursive: true, force: true });

package/src/offline-sync.ts

@@ -183,11 +183,13 @@ interface OfflineSyncFileRecordOptions {
   includeContent: boolean;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }
 
 const SYNC_INTERNAL_DIR = ".offline-sync";
 const OFFLINE_SYNC_UPLOAD_STAGING_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 const OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS = 1_000;
+const OFFLINE_SYNC_FAST_BASE_CTIME_TOLERANCE_MS = 1;
 const EXCLUDED_FILE_NAMES = new Set([
   ".sync-state.json",
 ]);
@@ -205,6 +207,11 @@ function sha256Buffer(buffer: Buffer): { sha256: string; bytes: number } {
   return sha256Bytes(buffer);
 }
 
+function throwIfOfflineSyncAborted(signal: AbortSignal | undefined): void {
+  if (!signal?.aborted) return;
+  throw new Error("offline sync request aborted");
+}
+
 function compareByPath<T extends { path: string }>(left: T, right: T): number {
   return left.path.localeCompare(right.path);
 }
@@ -480,6 +487,7 @@ const REMOTE_AUTHORITATIVE_RUNTIME_STATE_FILES = new Set([
   "buffer.json",
   "embeddings.json",
   "index_time.json",
+  "last_intent.json",
   "last_recall.json",
   "memory-lifecycle-ledger.jsonl",
   "recall_impressions.jsonl",
@@ -508,22 +516,23 @@ function canReuseFastBaseFileState(
     return false;
   }
   if (baseCapturedAtMs === null) return false;
-  return st.ctimeMs - baseCapturedAtMs <= OFFLINE_SYNC_FAST_BASE_MTIME_TOLERANCE_MS;
+  // Node reports stat times as fractional milliseconds while Date snapshots are
+  // whole milliseconds, so allow only a tiny precision window around capture.
+  return st.ctimeMs - baseCapturedAtMs <= OFFLINE_SYNC_FAST_BASE_CTIME_TOLERANCE_MS;
 }
 
 async function canReuseFastBaseFileStateFromDisk(
   baseEntry: OfflineSyncFileState,
-  filePath: string,
   st: { size: number; mtimeMs: number; ctimeMs: number },
   baseCapturedAtMs: number | null,
 ): Promise<boolean> {
-  if (!canReuseFastBaseFileState(baseEntry, st, baseCapturedAtMs)) return false;
-  return !(await fileIsSecureStoreEncrypted(filePath).catch(() => true));
+  return canReuseFastBaseFileState(baseEntry, st, baseCapturedAtMs);
 }
 
 async function readOfflineSyncFileRecord(
   options: OfflineSyncFileRecordOptions,
 ): Promise<OfflineSyncFileRecord> {
+  throwIfOfflineSyncAborted(options.signal);
   const relPath = validateArchiveRelativePath(options.relPath, "offlineSyncFile.path");
   let content: Buffer | null = null;
   let digest: OfflineSyncFileDigest;
@@ -531,16 +540,20 @@ async function readOfflineSyncFileRecord(
     content = options.readFile
       ? await options.readFile({ root: options.root.abs, path: relPath, filePath: options.filePath })
       : await readFile(options.filePath);
+    throwIfOfflineSyncAborted(options.signal);
     digest = sha256Buffer(content);
   } else if (options.readFileDigest) {
     digest = await options.readFileDigest({ root: options.root.abs, path: relPath, filePath: options.filePath });
+    throwIfOfflineSyncAborted(options.signal);
   } else if (options.readFile) {
     content = await options.readFile({ root: options.root.abs, path: relPath, filePath: options.filePath });
+    throwIfOfflineSyncAborted(options.signal);
     digest = sha256Buffer(content);
     content = null;
   } else {
-    digest = await sha256File(options.filePath);
+    digest = await sha256File(options.filePath, options.signal);
   }
+  throwIfOfflineSyncAborted(options.signal);
   const st = await stat(options.filePath);
   return {
     path: relPath,
@@ -551,14 +564,16 @@ async function readOfflineSyncFileRecord(
   };
 }
 
-async function sha256File(filePath: string): Promise<OfflineSyncFileDigest> {
+async function sha256File(filePath: string, signal?: AbortSignal): Promise<OfflineSyncFileDigest> {
   const hash = createHash("sha256");
   let bytes = 0;
   for await (const chunk of createReadStream(filePath)) {
+    throwIfOfflineSyncAborted(signal);
     const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
     hash.update(buffer);
     bytes += buffer.length;
   }
+  throwIfOfflineSyncAborted(signal);
   return {
     sha256: hash.digest("hex"),
     bytes,
@@ -600,15 +615,19 @@ export async function* iterateOfflineSyncSnapshotFileRecords(options: {
   includeTranscripts?: boolean;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }): AsyncIterable<OfflineSyncFileRecord> {
+  throwIfOfflineSyncAborted(options.signal);
   const rootAbs = path.resolve(options.root);
   const root = await prepareSafeArchiveRoot(rootAbs, "iterateOfflineSyncSnapshotFileRecords", "root");
   const includeTranscripts = options.includeTranscripts !== false;
 
   async function* walk(dirAbs: string): AsyncIterable<OfflineSyncFileRecord> {
+    throwIfOfflineSyncAborted(options.signal);
     let entries = await readdir(dirAbs, { withFileTypes: true });
     entries = entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
+      throwIfOfflineSyncAborted(options.signal);
       const abs = path.join(dirAbs, entry.name);
       const relPosix = path.relative(root.abs, abs).split(path.sep).join("/");
       if (shouldExcludeRelPath(relPosix, includeTranscripts)) continue;
@@ -625,6 +644,7 @@ export async function* iterateOfflineSyncSnapshotFileRecords(options: {
         includeContent: options.includeContent === true,
         readFile: options.readFile,
         readFileDigest: options.readFileDigest,
+        signal: options.signal,
       });
     }
   }
@@ -640,10 +660,13 @@ export async function buildOfflineSyncSnapshot(options: {
   now?: Date;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }): Promise<OfflineSyncSnapshot> {
+  throwIfOfflineSyncAborted(options.signal);
   const includeTranscripts = options.includeTranscripts !== false;
   const files: OfflineSyncFileRecord[] = [];
   for await (const file of iterateOfflineSyncSnapshotFileRecords(options)) files.push(file);
+  throwIfOfflineSyncAborted(options.signal);
 
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
@@ -665,7 +688,9 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
   now?: Date;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }): Promise<OfflineSyncSnapshot> {
+  throwIfOfflineSyncAborted(options.signal);
   const rootAbs = path.resolve(options.root);
   const root = await prepareSafeArchiveRoot(rootAbs, "buildOfflineSyncSnapshotFromBase", "root");
   const includeTranscripts = options.includeTranscripts !== false;
@@ -680,9 +705,11 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
   const files: OfflineSyncFileRecord[] = [];
 
   async function walk(dirAbs: string): Promise<void> {
+    throwIfOfflineSyncAborted(options.signal);
     let entries = await readdir(dirAbs, { withFileTypes: true });
     entries = entries.sort((left, right) => left.name.localeCompare(right.name));
     for (const entry of entries) {
+      throwIfOfflineSyncAborted(options.signal);
       const abs = path.join(dirAbs, entry.name);
       const relPosix = path.relative(root.abs, abs).split(path.sep).join("/");
       if (shouldExcludeRelPath(relPosix, includeTranscripts)) continue;
@@ -698,7 +725,7 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
         options.includeContent !== true &&
         baseEntry &&
         baseCapturedAtMs !== null &&
-        await canReuseFastBaseFileStateFromDisk(baseEntry, abs, st, baseCapturedAtMs)
+        await canReuseFastBaseFileStateFromDisk(baseEntry, st, baseCapturedAtMs)
       ) {
         files.push(baseEntry);
         continue;
@@ -710,11 +737,13 @@ export async function buildOfflineSyncSnapshotFromBase(options: {
         includeContent: options.includeContent === true,
         readFile: options.readFile,
         readFileDigest: options.readFileDigest,
+        signal: options.signal,
       }));
     }
   }
 
   await walk(root.abs);
+  throwIfOfflineSyncAborted(options.signal);
 
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,
@@ -735,7 +764,9 @@ export async function buildOfflineSyncSnapshotForPaths(options: {
   now?: Date;
   readFile?: (target: OfflineSyncFileTarget) => Promise<Buffer>;
   readFileDigest?: (target: OfflineSyncFileTarget) => Promise<OfflineSyncFileDigest>;
+  signal?: AbortSignal;
 }): Promise<OfflineSyncSnapshot> {
+  throwIfOfflineSyncAborted(options.signal);
   const rootAbs = path.resolve(options.root);
   const root = await prepareSafeArchiveRoot(rootAbs, "buildOfflineSyncSnapshotForPaths", "root");
   const includeTranscripts = options.includeTranscripts !== false;
@@ -743,6 +774,7 @@ export async function buildOfflineSyncSnapshotForPaths(options: {
   const seen = new Set<string>();
 
   for (const rawPath of options.paths) {
+    throwIfOfflineSyncAborted(options.signal);
     const relPath = normalizeRelativePath(rawPath, "paths[]");
     if (seen.has(relPath)) continue;
     seen.add(relPath);
@@ -762,8 +794,10 @@ export async function buildOfflineSyncSnapshotForPaths(options: {
       includeContent: options.includeContent === true,
       readFile: options.readFile,
       readFileDigest: options.readFileDigest,
+      signal: options.signal,
     }));
   }
+  throwIfOfflineSyncAborted(options.signal);
 
   return {
     format: OFFLINE_SYNC_SNAPSHOT_FORMAT,

package/src/operator-toolkit.ts

@@ -87,7 +87,10 @@ function resolveOpenClawRemnicPluginEntry(raw: unknown): Record<string, unknown>
 interface QmdRuntimeLike {
   probe(): Promise<boolean>;
   isAvailable(): boolean;
-  ensureCollection(memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+  ensureCollection(
+    memoryDir: string,
+    execution?: { signal?: AbortSignal },
+  ): Promise<"present" | "missing" | "unknown" | "skipped">;
   debugStatus(): string;
 }
 

package/src/orchestrator.ts

@@ -680,6 +680,56 @@ async function raceRecallAbort<T>(
 
 /** Maximum age (ms) before a compaction-reset signal file is considered stale and removed. */
 const COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour
+const DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = 10_000;
+
+type SearchCollectionState = "present" | "missing" | "unknown" | "skipped";
+
+function qmdStartupCollectionCheckTimeoutMs(): number {
+  const raw =
+    process.env.REMNIC_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS ??
+    process.env.ENGRAM_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+  if (raw === undefined) return DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 1_000
+    ? Math.floor(parsed)
+    : DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS;
+}
+
+async function qmdStartupCollectionCheckWithTimeout(
+  promise: Promise<SearchCollectionState>,
+  controller: AbortController,
+  label: string,
+): Promise<SearchCollectionState> {
+  const timeoutMs = qmdStartupCollectionCheckTimeoutMs();
+  let timer: NodeJS.Timeout | undefined;
+  let settled = false;
+
+  const timeoutPromise = new Promise<SearchCollectionState>((resolve) => {
+    timer = setTimeout(() => {
+      if (settled) return;
+      controller.abort();
+      log.warn(
+        `QMD startup collection check for ${label} timed out after ${timeoutMs}ms; keeping search enabled fail-open`,
+      );
+      resolve("unknown");
+    }, timeoutMs);
+    timer.unref?.();
+  });
+
+  const checkedPromise = promise
+    .catch((err): SearchCollectionState => {
+      log.warn(
+        `QMD startup collection check for ${label} failed; keeping search enabled fail-open: ${err}`,
+      );
+      return "unknown";
+    })
+    .finally(() => {
+      settled = true;
+      if (timer) clearTimeout(timer);
+    });
+
+  return await Promise.race([checkedPromise, timeoutPromise]);
+}
 
 /** Default workspace directory when no per-agent or config workspace is available. */
 export function defaultWorkspaceDir(): string {
@@ -2453,14 +2503,22 @@ export class Orchestrator {
             ? this.configuredNamespaces()
             : [this.config.defaultNamespace];
           const states = await Promise.all(
-            namespaces.map(async (namespace) => ({
-              namespace,
-              state: this.config.namespacesEnabled
-                ? await this.namespaceSearchRouter.ensureNamespaceCollection(
-                    namespace,
-                  )
-                : await this.qmd.ensureCollection(this.config.memoryDir),
-            })),
+            namespaces.map(async (namespace) => {
+              const collectionCheckAbort = new AbortController();
+              const state = await qmdStartupCollectionCheckWithTimeout(
+                this.config.namespacesEnabled
+                  ? this.namespaceSearchRouter.ensureNamespaceCollection(
+                      namespace,
+                      { signal: collectionCheckAbort.signal },
+                    )
+                  : this.qmd.ensureCollection(this.config.memoryDir, {
+                      signal: collectionCheckAbort.signal,
+                    }),
+                collectionCheckAbort,
+                namespace,
+              );
+              return { namespace, state };
+            }),
           );
           const defaultState =
             states.find(
@@ -2800,8 +2858,8 @@ export class Orchestrator {
       namespaces.map(async (namespace) => ({
         namespace,
         state: this.config.namespacesEnabled
-          ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace)
-          : await this.qmd.ensureCollection(this.config.memoryDir),
+          ? await this.namespaceSearchRouter.ensureNamespaceCollection(namespace, { signal })
+          : await this.qmd.ensureCollection(this.config.memoryDir, { signal }),
       })),
     );
 

package/src/qmd.ts

@@ -2595,12 +2595,15 @@ export class QmdClient implements SearchBackend {
     }
   }
 
-  async ensureCollection(memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped"> {
+  async ensureCollection(
+    memoryDir: string,
+    execution?: SearchExecutionOptions,
+  ): Promise<"present" | "missing" | "unknown" | "skipped"> {
     if (this.available === false && !this.daemonAvailable) return "unknown";
     // If only daemon is available (no CLI), skip collection check
     if (this.available === false) return "skipped";
     try {
-      const { stdout } = await this.runQmdCommand(["collection", "list"], QMD_TIMEOUT_MS);
+      const { stdout } = await this.runQmdCommand(["collection", "list"], QMD_TIMEOUT_MS, execution?.signal);
       // Parse text output: "openclaw-engram (qmd://openclaw-engram/)"
       const collectionRegex = new RegExp(
         `^${this.collection}\\s+\\(qmd://`,

package/src/search/lancedb-backend.ts

@@ -218,7 +218,10 @@ export class LanceDbBackend implements SearchBackend {
     }
   }
 
-  async ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped"> {
+  async ensureCollection(
+    _memoryDir: string,
+    _execution?: SearchExecutionOptions,
+  ): Promise<"present" | "missing" | "unknown" | "skipped"> {
     try {
       await this.ensureTable();
       return "present";

package/src/search/meilisearch-backend.ts

@@ -189,7 +189,10 @@ export class MeilisearchBackend implements SearchBackend {
     // manages embeddings server-side per index (collection).
   }
 
-  async ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped"> {
+  async ensureCollection(
+    _memoryDir: string,
+    _execution?: SearchExecutionOptions,
+  ): Promise<"present" | "missing" | "unknown" | "skipped"> {
     if (!this.available) return "skipped";
     try {
       const client = await this.ensureClient();

package/src/search/noop-backend.ts

@@ -51,7 +51,7 @@ export class NoopSearchBackend implements SearchBackend {
   async embed(): Promise<void> {}
   async embedCollection(_collection: string): Promise<void> {}
 
-  async ensureCollection(_memoryDir: string): Promise<"skipped"> {
+  async ensureCollection(_memoryDir: string, _execution?: SearchExecutionOptions): Promise<"skipped"> {
     return "skipped";
   }
 }

package/src/search/orama-backend.ts

@@ -251,7 +251,10 @@ export class OramaBackend implements SearchBackend {
     await this.persistDbForCollection(db, collection);
   }
 
-  async ensureCollection(_memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped"> {
+  async ensureCollection(
+    _memoryDir: string,
+    _execution?: SearchExecutionOptions,
+  ): Promise<"present" | "missing" | "unknown" | "skipped"> {
     try {
       await this.ensureModules();
       await this.ensureDb();

package/src/search/port.ts

@@ -82,5 +82,8 @@ export interface SearchBackend {
   embedCollection(collection: string): Promise<void>;
 
   // ── Collection management ──
-  ensureCollection(memoryDir: string): Promise<"present" | "missing" | "unknown" | "skipped">;
+  ensureCollection(
+    memoryDir: string,
+    execution?: SearchExecutionOptions,
+  ): Promise<"present" | "missing" | "unknown" | "skipped">;
 }

package/src/search/remote-backend.ts

@@ -82,7 +82,7 @@ export class RemoteSearchBackend implements SearchBackend {
   async embed(): Promise<void> {}
   async embedCollection(_collection: string): Promise<void> {}
 
-  async ensureCollection(_memoryDir: string): Promise<"skipped"> {
+  async ensureCollection(_memoryDir: string, _execution?: SearchExecutionOptions): Promise<"skipped"> {
     return "skipped";
   }