@remnic/core 9.69.50 → 9.69.52

package/src/lifecycle/seed-graduation.ts

@@ -31,20 +31,18 @@ import { stripAttributesSuffix } from "../storage.js";
 import { STRUCTURED_ATTRIBUTE_LIMITS } from "../write-envelope.js";
 import { excludeSupportPassportPrivateMemories } from "../support-passport/card-projection.js";
 import type { MemoryFile, MemoryFrontmatter, MemoryStatus } from "../types.js";
+import type { SeedGraduationConfig } from "./seed-graduation-config-types.js";
 
 // ---------------------------------------------------------------------------
 // Config
 // ---------------------------------------------------------------------------
 
-export interface SeedGraduationConfig {
-  /** Master gate. Default false: review-mode stays the only promotion path. */
-  enabled: boolean;
-  /**
-   * Independent corroborating memories required before a seed graduates.
-   * `Infinity` is not a config value — `enabled: false` is the disabled state.
-   */
-  minCorroborations: number;
-}
+// Canonical definitions live in seed-graduation-config-types.ts (a leaf) so
+// types.ts can consume them without this module's storage.js import cycle.
+export type {
+  SeedGraduationConfig,
+  SeedGraduationSettings,
+} from "./seed-graduation-config-types.js";
 
 export const SEED_GRADUATION_DEFAULTS: SeedGraduationConfig = {
   enabled: false,

package/src/orchestration/lifecycle-policy-coordinator.ts

@@ -49,6 +49,8 @@ import type {
   MemorySummary,
 } from "../types.js";
 import { excludeSupportPassportPrivateMemories } from "../support-passport/card-projection.js";
+import { runSeedGraduationPass } from "../lifecycle/seed-graduation.js";
+import type { RecallHandleHistoryStore } from "../recall-state.js";
 
 /** Dependencies injected by the orchestrator. All stable references or
  *  live accessors. */
@@ -76,6 +78,8 @@ export interface LifecyclePolicyCoordinatorDeps {
   ) => Promise<void>;
   /** Persist all dirty content-hash indexes to disk. */
   saveContentHashIndexes: () => Promise<void>;
+  /** Recall-handle ring used to suppress quoted-back echo during seed graduation. */
+  getHandleHistory?: () => RecallHandleHistoryStore;
 }
 
 /**
@@ -256,6 +260,14 @@ export class LifecyclePolicyCoordinator {
       if (wrote) updatedCount += 1;
     }
 
+    const history = this.deps.getHandleHistory?.();
+    await runSeedGraduationPass({
+      memories: allMemories,
+      storage,
+      config: this.config.seedGraduation,
+      recalledBySession: history ? (sessionKey) => history.recent(sessionKey) : undefined,
+    });
+
     // Report how many memories had frontmatter rewritten so callers can record a
     // catalog write touch for lifecycle-only passes (codex NR-tS).
     if (!lifecycleCaps.lifecycleMetrics) return updatedCount;

package/src/orchestration/recall-entry.ts

@@ -22,7 +22,12 @@ import type { RecallResultFormatter } from "./recall-result-formatter.js";
 import type { IdentityInjectionMode, PluginConfig, QmdSearchResult } from "../types.js";
 import { stateViewPacketActive } from "../recall-state-view-anchors.js";
 import { resultStateViewKey, stateViewPacketKeys } from "../recall-state-view.js";
- import { applyRecallStateViews } from "../recall-state-view-wire.js";
+import { applyRecallStateViews } from "../recall-state-view-wire.js";
+import { composeRecallContext } from "../recall-context-composition.js";
+import {
+  notifyContextComposition,
+  recallFailureComposition,
+} from "../recall-composition-decision.js";
 
 export interface RecallEntryDeps {
   appendRecallSection(
@@ -197,7 +202,16 @@ export class RecallEntryCoordinator {
       // endTrace() is safe here: if no trace is active (disabled or already
       // closed by recallInternal's try/finally), it returns null immediately.
       this.deps.profiler.endTrace();
-      return ""; // Return empty context on timeout/error
+      // Caller-cancelled recalls stay quiet: the failure was the caller's
+      // abort, not a recall degradation (issue #2972 contract).
+      const missing = options.abortSignal?.aborted
+        ? null
+        : recallFailureComposition(err);
+      if (!missing) return "";
+      notifyContextComposition(options.onContextComposition, missing, (observerErr) => {
+        log.warn("recall: context composition observer failed open", observerErr);
+      });
+      return composeRecallContext(missing);
     } finally {
       options.abortSignal?.removeEventListener("abort", onAbort);
     }

package/src/orchestration/recall-internal.ts

@@ -45,9 +45,14 @@ import { buildQmdRecallCacheKey, getCachedQmdRecall, setCachedQmdRecall } from "
 import { MEMORY_ID_PATTERN } from "../recall-handles.js";
 import { shouldRecordRecallAuthorityHistory } from "../recall-navigation-config.js";
 import {
-  boundRecallContextComposition, composeRecallContext, contextBudgetForFooter,
+  contextBudgetForFooter,
   formatCuriosityFooter, renderAuthorityBoundContent, selectCuriosityQuestion,
 } from "../recall-context-composition.js";
+import {
+  compactRecallContextFromBuckets,
+  decideRecallContextComposition,
+  notifyContextComposition,
+} from "../recall-composition-decision.js";
 import {
   createBoundedCoreSectionRunner,
   createRecallSectionMetricRecorder,
@@ -110,6 +115,7 @@ import {
 import type { RecallInternalDeps } from "./recall-internal-deps.js";
 import { appendEpisodicContextSection } from "./episodic-context-section.js";
 import { resolveCompositeProfileStorage } from "./recall-profile-storage.js";
+import { fetchQmdMemoryResultsWithRecognitionSwap } from "./recall-recognition-search.js";
 
 export class RecallInternalCoordinator {
   private readonly securityCapabilities: SecurityCapabilitySet;
@@ -2141,7 +2147,8 @@ export class RecallInternalCoordinator {
 
         try {
           const filteredResults =
-            await this.deps.fetchQmdMemoryResultsWithArtifactTopUp(
+            await fetchQmdMemoryResultsWithRecognitionSwap(
+              this.deps,
               retrievalQuery,
               qmdFetchLimit,
               qmdHybridFetchLimit,
@@ -4951,23 +4958,16 @@ export class RecallInternalCoordinator {
       recalledMemoryNamespaces,
     );
     const recalledContext = assembledRecall.sections.join("\n\n---\n\n");
-    const composition = boundRecallContextComposition({
-      context: recalledContext, footer: curiosityFooter, maxChars: recallBudgetChars,
-    });
-    const context = composeRecallContext(composition);
-    try {
-      const observerResult = options.onContextComposition?.(composition);
-      if (observerResult && typeof observerResult.then === "function") {
-        void Promise.resolve(observerResult).catch((err) => log.warn(
-          "recall: context composition observer rejected", err,
-        ));
-      }
-    } catch (err) {
+    const { composition, context, truncated: compositionTruncated } =
+      decideRecallContextComposition({
+        context: recalledContext,
+        compactContext: compactRecallContextFromBuckets(sectionBuckets),
+        footer: curiosityFooter,
+        maxChars: recallBudgetChars,
+      });
+    notifyContextComposition(options.onContextComposition, composition, (err) => {
       log.warn("recall: context composition observer failed open", err);
-    }
-    const compositionTruncated = context.length < composeRecallContext({
-      context: recalledContext, footer: curiosityFooter,
-    }).length;
+    });
     const includedSections = [...assembledRecall.includedIds];
     const omittedSections = [...assembledRecall.omittedIds];
     if (composition.footer && !includedSections.includes("questions")) includedSections.push("questions");
@@ -5202,6 +5202,9 @@ export class RecallInternalCoordinator {
             chars: this.deps.getRecallBudgetChars(options.budgetCharsOverride),
             used: context.length,
           },
+          ...(composition.degradation
+            ? { degradation: composition.degradation }
+            : {}),
           sessionKey,
           namespace: selfNamespace,
           traceId,

package/src/orchestration/recall-recognition-search.test.ts

@@ -0,0 +1,290 @@
+/**
+ * recall-recognition-search.test.ts — issue #2975 recall-slice wiring.
+ *
+ * Pins the fetchQmdMemoryResultsWithArtifactTopUp seam:
+ *  - gate off: original fetch only (zero extra I/O, same options object);
+ *  - under-threshold index: recognition pass, no vector fetch for that ns;
+ *  - above-threshold index: vector fetch, no recognizer call.
+ */
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, rm } from "node:fs/promises";
+import test from "node:test";
+
+import { saveRecognitionIndex, type RecognitionIndex } from "../recall-recognition-tier.js";
+import {
+  fetchQmdMemoryResultsWithRecognitionSwap,
+  type RecognitionSearchDeps,
+} from "./recall-recognition-search.js";
+import type { QmdSearchResult } from "../types.js";
+
+function vec(namespace: string, filePath: string, score = 1): QmdSearchResult {
+  return { docid: `${namespace}:${filePath}`, namespace, path: filePath, score, snippet: filePath };
+}
+
+function indexOf(ids: string[]): RecognitionIndex {
+  return {
+    version: 1,
+    entries: ids.map((id) => ({ id, description: `trigger for ${id}` })),
+  };
+}
+
+async function tmpDir(): Promise<string> {
+  return mkdtemp(path.join(os.tmpdir(), "remnic-recognition-search-"));
+}
+
+function makeDeps(args: {
+  recallRecognitionTier: boolean;
+  recognitionIndexMaxEntries?: number;
+  storages: Record<string, { dir: string; pathsById: Record<string, string> }>;
+  vectorResults?: QmdSearchResult[];
+  recognize?: (prompt: string) => Promise<string>;
+  recognizeError?: Error;
+}) {
+  const fetchCalls: Array<{
+    prompt: string;
+    qmdFetchLimit: number;
+    qmdHybridFetchLimit: number;
+    options: unknown;
+  }> = [];
+  const recognizePrompts: string[] = [];
+  const storageForCalls: string[] = [];
+
+  const deps = {
+    config: {
+      recallRecognitionTier: args.recallRecognitionTier,
+      recognitionIndexMaxEntries: args.recognitionIndexMaxEntries ?? 500,
+    },
+    storageRouter: {
+      storageFor: async (namespace: string) => {
+        storageForCalls.push(namespace);
+        const storage = args.storages[namespace];
+        if (!storage) throw new Error(`unknown namespace ${namespace}`);
+        return {
+          dir: storage.dir,
+          findExistingMemoryPaths: async (ids: string[]) => {
+            const found = new Map<string, string[]>();
+            for (const id of ids) {
+              const filePath = storage.pathsById[id];
+              if (filePath) found.set(id, [filePath]);
+            }
+            return found;
+          },
+        };
+      },
+    },
+    fastLlmForRerank: {
+      chatCompletion: async (messages: Array<{ role: string; content: string }>) => {
+        if (args.recognizeError) throw args.recognizeError;
+        const prompt = messages[0]?.content ?? "";
+        recognizePrompts.push(prompt);
+        return { content: await (args.recognize ?? (async () => ""))(prompt) };
+      },
+    },
+    fetchQmdMemoryResultsWithArtifactTopUp: async (
+      prompt: string,
+      qmdFetchLimit: number,
+      qmdHybridFetchLimit: number,
+      options: unknown,
+    ) => {
+      fetchCalls.push({ prompt, qmdFetchLimit, qmdHybridFetchLimit, options });
+      return args.vectorResults ?? [];
+    },
+  } as unknown as RecognitionSearchDeps;
+
+  return { deps, fetchCalls, recognizePrompts, storageForCalls };
+}
+
+const baseOptions = {
+  namespacesEnabled: true,
+  recallNamespaces: ["alpha"],
+  resolveNamespace: (filePath: string) => (filePath.startsWith("beta/") ? "beta" : "alpha"),
+};
+
+test("off-path: gate off calls original fetch once with the same options object", async () => {
+  const options = { ...baseOptions };
+  const { deps, fetchCalls, recognizePrompts, storageForCalls } = makeDeps({
+    recallRecognitionTier: false,
+    storages: {},
+    vectorResults: [vec("alpha", "facts/from-vector.md")],
+  });
+
+  const out = await fetchQmdMemoryResultsWithRecognitionSwap(deps, "q", 7, 9, options);
+
+  assert.equal(fetchCalls.length, 1);
+  assert.equal(fetchCalls[0].prompt, "q");
+  assert.equal(fetchCalls[0].qmdFetchLimit, 7);
+  assert.equal(fetchCalls[0].qmdHybridFetchLimit, 9);
+  assert.equal(fetchCalls[0].options, options);
+  assert.equal(recognizePrompts.length, 0);
+  assert.equal(storageForCalls.length, 0);
+  assert.deepEqual(out.map((r) => r.path), ["facts/from-vector.md"]);
+});
+
+test("acceptance: under-threshold namespace uses recognition, not vector search", async () => {
+  const dir = await tmpDir();
+  try {
+    await saveRecognitionIndex(dir, indexOf(["m-001", "m-002", "m-003"]));
+    const { deps, fetchCalls, recognizePrompts } = makeDeps({
+      recallRecognitionTier: true,
+      recognitionIndexMaxEntries: 10,
+      storages: {
+        alpha: {
+          dir,
+          pathsById: {
+            "m-001": path.join(dir, "facts/m-001.md"),
+            "m-002": path.join(dir, "facts/m-002.md"),
+            "m-003": path.join(dir, "facts/m-003.md"),
+          },
+        },
+      },
+      recognize: async () => "m-002, m-003",
+      vectorResults: [vec("alpha", "facts/must-not-appear.md")],
+    });
+
+    const out = await fetchQmdMemoryResultsWithRecognitionSwap(deps, "which memories?", 5, 5, {
+      ...baseOptions,
+    });
+
+    assert.equal(fetchCalls.length, 0, "vector search must not run on the recognition tier");
+    assert.equal(recognizePrompts.length, 1);
+    assert.ok(recognizePrompts[0].includes("m-001: trigger for m-001"));
+    assert.ok(recognizePrompts[0].includes("m-002: trigger for m-002"));
+    assert.ok(recognizePrompts[0].includes("m-003: trigger for m-003"));
+    assert.deepEqual(
+      out.map((r) => r.path),
+      ["facts/m-002.md", "facts/m-003.md"],
+    );
+    assert.deepEqual(
+      out.map((r) => r.namespace),
+      ["alpha", "alpha"],
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("acceptance: above-threshold namespace uses vector search, not the recognizer", async () => {
+  const dir = await tmpDir();
+  try {
+    await saveRecognitionIndex(dir, indexOf(["a", "b", "c", "d", "e"]));
+    const options = { ...baseOptions };
+    const { deps, fetchCalls, recognizePrompts } = makeDeps({
+      recallRecognitionTier: true,
+      recognitionIndexMaxEntries: 4,
+      storages: { alpha: { dir, pathsById: {} } },
+      vectorResults: [vec("alpha", "facts/vector-hit.md")],
+    });
+
+    const out = await fetchQmdMemoryResultsWithRecognitionSwap(deps, "q", 3, 3, options);
+
+    assert.equal(recognizePrompts.length, 0);
+    assert.equal(fetchCalls.length, 1);
+    assert.equal(fetchCalls[0].options, options);
+    assert.deepEqual(out.map((r) => r.path), ["facts/vector-hit.md"]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("acceptance: missing index falls back to vector search with original options", async () => {
+  const dir = await tmpDir();
+  try {
+    const options = { ...baseOptions };
+    const { deps, fetchCalls, recognizePrompts } = makeDeps({
+      recallRecognitionTier: true,
+      storages: { alpha: { dir, pathsById: {} } },
+      vectorResults: [vec("alpha", "facts/fallback.md")],
+    });
+
+    const out = await fetchQmdMemoryResultsWithRecognitionSwap(deps, "q", 2, 2, options);
+
+    assert.equal(recognizePrompts.length, 0);
+    assert.equal(fetchCalls.length, 1);
+    assert.equal(fetchCalls[0].options, options);
+    assert.deepEqual(out.map((r) => r.path), ["facts/fallback.md"]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("mixed namespaces: small ns recognizes; large ns stays on vector search", async () => {
+  const small = await tmpDir();
+  const large = await tmpDir();
+  try {
+    await saveRecognitionIndex(small, indexOf(["s-1", "s-2"]));
+    await saveRecognitionIndex(large, indexOf(["l-1", "l-2", "l-3"]));
+    const { deps, fetchCalls, recognizePrompts } = makeDeps({
+      recallRecognitionTier: true,
+      recognitionIndexMaxEntries: 2,
+      storages: {
+        alpha: {
+          dir: small,
+          pathsById: { "s-1": path.join(small, "facts/s-1.md") },
+        },
+        beta: { dir: large, pathsById: {} },
+      },
+      recognize: async () => "s-1",
+      vectorResults: [vec("beta", "facts/large-hit.md")],
+    });
+
+    const out = await fetchQmdMemoryResultsWithRecognitionSwap(deps, "q", 10, 10, {
+      namespacesEnabled: true,
+      recallNamespaces: ["alpha", "beta"],
+      resolveNamespace: (filePath) => (filePath.includes("large") ? "beta" : "alpha"),
+    });
+
+    assert.equal(recognizePrompts.length, 1);
+    assert.equal(fetchCalls.length, 1);
+    assert.deepEqual(
+      (fetchCalls[0].options as { recallNamespaces: string[] }).recallNamespaces,
+      ["beta"],
+    );
+    assert.deepEqual(
+      out.map((r) => `${r.namespace}:${r.path}`),
+      ["alpha:facts/s-1.md", "beta:facts/large-hit.md"],
+    );
+  } finally {
+    await rm(small, { recursive: true, force: true });
+    await rm(large, { recursive: true, force: true });
+  }
+});
+
+test("loud degradation: recognizer throw routes that namespace back to vector search", async () => {
+  const dir = await tmpDir();
+  try {
+    await saveRecognitionIndex(dir, indexOf(["m-001"]));
+    const { deps, fetchCalls, recognizePrompts } = makeDeps({
+      recallRecognitionTier: true,
+      storages: { alpha: { dir, pathsById: { "m-001": path.join(dir, "facts/m-001.md") } } },
+      recognizeError: new Error("model down"),
+      vectorResults: [vec("alpha", "facts/degraded.md")],
+    });
+
+    const out = await fetchQmdMemoryResultsWithRecognitionSwap(deps, "q", 4, 4, { ...baseOptions });
+
+    assert.equal(recognizePrompts.length, 0);
+    assert.equal(fetchCalls.length, 1);
+    assert.deepEqual(out.map((r) => r.path), ["facts/degraded.md"]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("namespaces disabled: gate on still calls original fetch with the same options object", async () => {
+  const options = { ...baseOptions, namespacesEnabled: false };
+  const { deps, fetchCalls, recognizePrompts, storageForCalls } = makeDeps({
+    recallRecognitionTier: true,
+    storages: {},
+    vectorResults: [vec("alpha", "facts/from-vector.md")],
+  });
+
+  const out = await fetchQmdMemoryResultsWithRecognitionSwap(deps, "q", 2, 2, options);
+
+  assert.equal(fetchCalls.length, 1);
+  assert.equal(fetchCalls[0].options, options);
+  assert.equal(recognizePrompts.length, 0);
+  assert.equal(storageForCalls.length, 0);
+  assert.deepEqual(out.map((r) => r.path), ["facts/from-vector.md"]);
+});

package/src/orchestration/recall-recognition-search.ts

@@ -0,0 +1,160 @@
+/**
+ * Recognition-tier swap at fetchQmdMemoryResultsWithArtifactTopUp (issue #2975).
+ *
+ * Off-path (recallRecognitionTier !== true): original fetch only — no index
+ * load, no model call. On-path: namespaces whose index is at or under
+ * recognitionIndexMaxEntries go through one recognizer call; the rest keep
+ * vector search. A failing recognizer degrades that namespace to vector search.
+ */
+import path from "node:path";
+
+import { log } from "../logger.js";
+import { dedupeResultsByNamespace } from "../recall-memory-map.js";
+import {
+  decideRecognitionTier,
+  loadRecognitionIndex,
+  runRecognitionTier,
+  type RecognitionIndex,
+} from "../recall-recognition-tier.js";
+import type { QmdSearchResult } from "../types.js";
+import { throwIfRecallAborted } from "./orchestrator-helpers.js";
+import type { RecallInternalDeps } from "./recall-internal-deps.js";
+
+export type RecognitionSearchDeps = Pick<
+  RecallInternalDeps,
+  "config" | "storageRouter" | "fastLlmForRerank" | "fetchQmdMemoryResultsWithArtifactTopUp"
+>;
+
+type ArtifactTopUpOptions = Parameters<
+  RecognitionSearchDeps["fetchQmdMemoryResultsWithArtifactTopUp"]
+>[3];
+
+type RecognitionStorage = {
+  dir: string;
+  findExistingMemoryPaths(ids: string[]): Promise<Map<string, string[]>>;
+};
+
+export async function fetchQmdMemoryResultsWithRecognitionSwap(
+  deps: RecognitionSearchDeps,
+  prompt: string,
+  qmdFetchLimit: number,
+  qmdHybridFetchLimit: number,
+  options: ArtifactTopUpOptions,
+): Promise<QmdSearchResult[]> {
+  if (
+    deps.config.recallRecognitionTier !== true ||
+    options.collection ||
+    options.namespacesEnabled !== true
+  ) {
+    return deps.fetchQmdMemoryResultsWithArtifactTopUp(
+      prompt,
+      qmdFetchLimit,
+      qmdHybridFetchLimit,
+      options,
+    );
+  }
+
+  const namespaces = options.recallNamespaces.filter(Boolean);
+  if (namespaces.length === 0) {
+    return deps.fetchQmdMemoryResultsWithArtifactTopUp(
+      prompt,
+      qmdFetchLimit,
+      qmdHybridFetchLimit,
+      options,
+    );
+  }
+
+  throwIfRecallAborted(options.abortSignal);
+  const maxEntries = deps.config.recognitionIndexMaxEntries;
+  const recognitionNs: Array<{ namespace: string; storage: RecognitionStorage; index: RecognitionIndex }> = [];
+  const vectorNs: string[] = [];
+
+  for (const namespace of namespaces) {
+    throwIfRecallAborted(options.abortSignal);
+    const storage = (await deps.storageRouter.storageFor(namespace)) as RecognitionStorage;
+    const index = await loadRecognitionIndex(storage.dir);
+    const decision = decideRecognitionTier(index, { maxEntries });
+    if (index !== null && decision.tier === "recognition") {
+      recognitionNs.push({ namespace, storage, index });
+    } else {
+      vectorNs.push(namespace);
+    }
+  }
+
+  if (recognitionNs.length === 0) {
+    return deps.fetchQmdMemoryResultsWithArtifactTopUp(
+      prompt,
+      qmdFetchLimit,
+      qmdHybridFetchLimit,
+      options,
+    );
+  }
+
+  const recognize = async (recognitionPrompt: string): Promise<string | null | undefined> => {
+    const reply = await deps.fastLlmForRerank.chatCompletion(
+      [{ role: "user", content: recognitionPrompt }],
+      { operation: "recognition-tier", priority: "recall-critical" },
+    );
+    return reply?.content;
+  };
+
+  const recognized: QmdSearchResult[] = [];
+  for (const { namespace, storage, index } of recognitionNs) {
+    throwIfRecallAborted(options.abortSignal);
+    try {
+      const run = await runRecognitionTier(prompt, index.entries, recognize);
+      recognized.push(
+        ...(await hitsFromIds(namespace, storage, index, run.ids)),
+      );
+    } catch (err) {
+      log.warn(
+        `recognition tier degraded to vector search: recognizer failed${
+          err instanceof Error ? ` (${err.message})` : ""
+        }`,
+      );
+      vectorNs.push(namespace);
+    }
+  }
+
+  const vectorResults =
+    vectorNs.length === 0
+      ? []
+      : await deps.fetchQmdMemoryResultsWithArtifactTopUp(
+          prompt,
+          qmdFetchLimit,
+          qmdHybridFetchLimit,
+          { ...options, recallNamespaces: vectorNs },
+        );
+
+  return dedupeResultsByNamespace(
+    [...recognized, ...vectorResults],
+    options.resolveNamespace,
+    qmdFetchLimit,
+  );
+}
+
+async function hitsFromIds(
+  namespace: string,
+  storage: RecognitionStorage,
+  index: RecognitionIndex,
+  ids: readonly string[],
+): Promise<QmdSearchResult[]> {
+  if (ids.length === 0) return [];
+  const pathsById = await storage.findExistingMemoryPaths([...ids]);
+  const descriptionById = new Map(index.entries.map((entry) => [entry.id, entry.description]));
+  const hits: QmdSearchResult[] = [];
+  for (const [offset, id] of ids.entries()) {
+    const absPath = pathsById.get(id)?.[0];
+    if (!absPath) continue;
+    const rel = path.relative(storage.dir, absPath).split(path.sep).join("/");
+    if (!rel || rel.startsWith("..")) continue;
+    hits.push({
+      docid: `${namespace}:${rel}`,
+      namespace,
+      path: rel,
+      score: ids.length - offset,
+      snippet: descriptionById.get(id) ?? id,
+    });
+  }
+  return hits;
+}

package/src/orchestrator.ts

@@ -1711,6 +1711,7 @@ export class Orchestrator {
       removeContentHashForMemory: (targetStorage, memory, context) =>
         this.removeContentHashForMemory(targetStorage, memory, context),
       saveContentHashIndexes: () => this.saveContentHashIndexes(),
+      getHandleHistory: () => this.handleHistory,
     });
     this.threading = new ThreadingManager(
       path.join(config.memoryDir, "threads"),