@remnic/core 9.3.650 → 9.3.652

package/src/event-order-recall.ts

@@ -3,6 +3,11 @@ import type { ExplicitCueRecallEngine } from "./explicit-cue-recall.js";
 
 export interface EventOrderRecallOptions {
   engine: ExplicitCueRecallEngine | null | undefined;
+  // event-order reads a SINGLE LCM session key. Unlike the relevance-ranked
+  // sections, its evidence must not be merged across the #1505 fallback key set:
+  // `turn_index` is local to each LCM `session_id`, so interleaving keys would
+  // misstate chronology. The orchestrator reads the ordered key set via
+  // first-non-empty instead (see the event-order call site).
   sessionId?: string;
   query: string;
   maxChars: number;
@@ -42,6 +47,9 @@ export async function buildEventOrderRecallSection(
 ): Promise<string> {
   const budget = normalizePositiveInteger(options.maxChars);
   const maxItems = normalizePositiveInteger(options.maxItems ?? DEFAULT_MAX_ITEMS);
+  // event-order reads a SINGLE session key (`turn_index` is local to each LCM
+  // `session_id`, so chronology can't be merged across the #1505 fallback set —
+  // the orchestrator drives the ordered key set via first-non-empty instead).
   if (!options.engine || !options.sessionId || budget <= 0) {
     return "";
   }

package/src/explicit-cue-recall.ts

@@ -1,4 +1,8 @@
 import { buildEvidencePack } from "./evidence-pack.js";
+import {
+  gatherAcrossReadSessions,
+  resolveLcmReadSessionIds,
+} from "./lcm-fallback-read.js";
 
 export interface ExplicitCueRecallEngine {
   expandContext(
@@ -29,6 +33,13 @@ export interface ExplicitCueRecallEngine {
 export interface ExplicitCueRecallOptions {
   engine: ExplicitCueRecallEngine | null | undefined;
   sessionId?: string;
+  /**
+   * Ordered, read-authorized LCM read key set (primary overlay → project/root
+   * fallbacks). When present, cue evidence is gathered across EVERY key into one
+   * shared accumulator and merged under this section's budget (#1505 codex P2).
+   * Falls back to `sessionId`.
+   */
+  sessionIds?: readonly (string | undefined)[];
   query: string;
   maxChars: number;
   maxItemChars?: number;
@@ -324,45 +335,75 @@ export async function buildExplicitCueRecallSection(
   }> = [];
   const seenTurns = new Set<string>();
 
-  await collectTurnReferenceEvidence({
-    engine,
-    sessionId: options.sessionId,
-    query,
-    maxReferences,
-    evidenceItems,
-    seenTurns,
-  });
-
-  if (options.includeContentLexicalCues) {
-    await collectNamedMeetingFactEvidence({
+  // #1505 codex P2: gather cue evidence across the ordered LCM read key set
+  // (primary overlay → project/root fallbacks) into ONE shared accumulator
+  // (`evidenceItems` / `seenTurns`), so a branch-scoped session's project/root
+  // fallback cues are RECOVERED instead of being skipped by the old
+  // first-non-empty short-circuit. `seenTurns` dedupes across keys by
+  // `session_id`+`turn_index`; the budget is applied exactly once in the
+  // `buildEvidencePack` call below. `gatherAcrossReadSessions` isolates a
+  // per-key read failure (a corrupt/locked fallback index must not discard the
+  // other keys' cues); single-key recall runs each collector directly, so a
+  // failure propagates exactly as before.
+  //
+  // Ordering: gather by evidence TYPE first (turn references → content cues →
+  // lexical cues), then by read-key priority within each type. This is the
+  // section's deliberate value order, and it carries across keys — so a fallback
+  // key's high-value turn references precede the primary key's lower-value
+  // lexical cues under a tight budget, while a single key is byte-for-byte the
+  // pre-#1505 insertion order. We intentionally do NOT score-sort the merged set:
+  // explicit-cue's highest-value cues (turn references / content cues) are
+  // deliberately UNSCORED while lexical search hits carry numeric scores, so a
+  // score-DESC sort would invert the priority and demote turn references below
+  // weak lexical hits (cursor[bot] / codex P2 on this PR).
+  const readSessionIds = resolveLcmReadSessionIds(options);
+  await gatherAcrossReadSessions(readSessionIds, (sessionId) =>
+    collectTurnReferenceEvidence({
       engine,
-      sessionId: options.sessionId,
+      sessionId,
       query,
       maxReferences,
       evidenceItems,
       seenTurns,
-    });
+    }),
+  );
 
-    await collectFocusedTranscriptCueEvidence({
+  if (options.includeContentLexicalCues) {
+    await gatherAcrossReadSessions(readSessionIds, (sessionId) =>
+      collectNamedMeetingFactEvidence({
+        engine,
+        sessionId,
+        query,
+        maxReferences,
+        evidenceItems,
+        seenTurns,
+      }),
+    );
+
+    await gatherAcrossReadSessions(readSessionIds, (sessionId) =>
+      collectFocusedTranscriptCueEvidence({
+        engine,
+        sessionId,
+        query,
+        evidenceItems,
+        seenTurns,
+      }),
+    );
+  }
+
+  await gatherAcrossReadSessions(readSessionIds, (sessionId) =>
+    collectLexicalCueEvidence({
       engine,
-      sessionId: options.sessionId,
+      sessionId,
       query,
+      maxReferences,
+      includeBenchmarkAnchorCues: options.includeBenchmarkAnchorCues,
+      includeContentLexicalCues: options.includeContentLexicalCues,
+      includeStructuredPlanCues: options.includeStructuredPlanCues,
       evidenceItems,
       seenTurns,
-    });
-  }
-
-  await collectLexicalCueEvidence({
-    engine,
-    sessionId: options.sessionId,
-    query,
-    maxReferences,
-    includeBenchmarkAnchorCues: options.includeBenchmarkAnchorCues,
-    includeContentLexicalCues: options.includeContentLexicalCues,
-    includeStructuredPlanCues: options.includeStructuredPlanCues,
-    evidenceItems,
-    seenTurns,
-  });
+    }),
+  );
 
   const evidenceFocusQuery = buildEvidenceFocusQuery(query, {
     includeBenchmarkAnchorCues: options.includeBenchmarkAnchorCues,

package/src/focused-list-recall.ts

@@ -4,10 +4,20 @@ import {
   type EvidencePackItem,
 } from "./evidence-pack.js";
 import type { ExplicitCueRecallEngine } from "./explicit-cue-recall.js";
+import {
+  gatherAcrossReadSessions,
+  resolveLcmReadSessionIds,
+} from "./lcm-fallback-read.js";
 
 export interface FocusedListRecallOptions {
   engine: ExplicitCueRecallEngine | null | undefined;
   sessionId?: string;
+  /**
+   * Ordered, read-authorized LCM read key set (primary overlay → project/root
+   * fallbacks). When present, evidence is gathered across EVERY key and merged
+   * under this section's budget (#1505 codex P2). Falls back to `sessionId`.
+   */
+  sessionIds?: readonly (string | undefined)[];
   query: string;
   maxChars: number;
   maxItemChars?: number;
@@ -52,7 +62,19 @@ export async function buildFocusedListRecallSection(
     return "";
   }
 
-  const items = await collectFocusedListItems(options, intent);
+  // #1505 codex P2: gather candidates across the ordered LCM read key set
+  // (primary overlay → project/root fallbacks) and UNION them into the existing
+  // rank/dedupe/budget pass, so a stronger project-fallback candidate is not
+  // masked by a weak primary-key hit. `rankAndDedupeFocusedListItems` applies
+  // the section-appropriate dedupe and relevance rank; the budget is applied
+  // exactly once below. `gatherAcrossReadSessions` isolates a per-key read
+  // failure so a corrupt/locked fallback index can't discard the primary key's
+  // candidates; the single-key path runs exactly one collect and propagates a
+  // failure as before — byte-for-byte the pre-#1505 behavior.
+  const items: EvidencePackItem[] = [];
+  await gatherAcrossReadSessions(resolveLcmReadSessionIds(options), async (sessionId) => {
+    items.push(...(await collectFocusedListItems({ ...options, sessionId }, intent)));
+  });
   const ranked = rankAndDedupeFocusedListItems(items, options.query, intent)
     .slice(0, maxResults);
   if (ranked.length === 0) {

package/src/lcm-fallback-read.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared helper for reading LCM-backed recall sections across the ordered,
+ * read-authorized fallback key set (#1505 codex P2 "Merge LCM fallback reads
+ * instead of short-circuiting").
+ *
+ * Background: a branch-scoped session archives its LCM rows under whichever
+ * coding-overlay namespace was effective at write time, so its evidence can be
+ * split across the primary overlay key AND the project / root fallback keys.
+ * Normal QMD/file recall already searches the primary namespace PLUS
+ * `codingOverlay.readFallbacks` and MERGES the rows. The LCM read path must do
+ * the same: query EVERY authorized read key and merge the candidate evidence
+ * into each section's existing dedupe + rank + budget pass, instead of stopping
+ * at the first key that happens to yield a (possibly weak) hit.
+ *
+ * Each section already owns a section-appropriate dedupe (a `seen` set or a
+ * `rankAndDedupe…` step), so the fan-out only needs to resolve the ordered,
+ * deduped read-key set and UNION the per-key candidates into that existing
+ * pipeline — the budget is then applied exactly once to the union. Centralizing
+ * the key-set resolution here (rather than re-implementing per builder) follows
+ * CLAUDE.md rule 22 (scope resolution must be deduplicated).
+ */
+
+/** A recall section's LCM read target: either a single key or an ordered set. */
+export interface LcmReadSessionTarget {
+  /**
+   * The single LCM read `session_id` (pre-#1505 behavior). `undefined` means a
+   * sessionless, archive-wide read with no `session_id` filter.
+   */
+  sessionId?: string;
+  /**
+   * The ordered, read-authorized LCM read key set (primary overlay key first,
+   * then project / root fallbacks) the orchestrator derived from the same
+   * readable namespace set normal recall searches. When present and non-empty,
+   * it supersedes `sessionId`.
+   */
+  sessionIds?: readonly (string | undefined)[];
+}
+
+// `undefined` (a sessionless, archive-wide read) is a distinct, legitimate read
+// target, so it needs a non-string sentinel in the dedupe set. A leading space
+// keeps it disjoint from every real session key / namespaced LCM key (which are
+// `[A-Za-z0-9._-]` plus the U+001F namespace sentinel, never leading-space).
+const UNDEFINED_SESSION_SENTINEL = " <lcm-sessionless>";
+
+/**
+ * Resolve the ordered, deduped set of LCM read `session_id`s a recall section
+ * must query.
+ *
+ * When `sessionIds` is provided (the #1505 fallback unification), it is used
+ * verbatim, deduped while preserving first-seen order so the caller queries
+ * keys in priority order (primary overlay → fallbacks) without re-querying an
+ * identical key (e.g. when two namespaces both collapse to the default store).
+ * Otherwise the section reads under the single `sessionId`, so the result is
+ * `[sessionId]` — byte-for-byte the pre-#1505 single-key behavior, including a
+ * single `undefined` for a sessionless archive-wide read.
+ */
+export function resolveLcmReadSessionIds(
+  target: LcmReadSessionTarget,
+): Array<string | undefined> {
+  const source =
+    target.sessionIds && target.sessionIds.length > 0
+      ? target.sessionIds
+      : [target.sessionId];
+  const seen = new Set<string>();
+  const out: Array<string | undefined> = [];
+  for (const sessionId of source) {
+    const key = sessionId === undefined ? UNDEFINED_SESSION_SENTINEL : sessionId;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(sessionId);
+  }
+  // Defensive: an all-empty `sessionIds` still collapses to the single-key path.
+  return out.length > 0 ? out : [target.sessionId];
+}
+
+/**
+ * Run a per-key LCM `gather` across the resolved read-key set with FAULT
+ * ISOLATION across keys (#1505 codex P2 review follow-up).
+ *
+ * A recall section that reads every key in a bare `for…await` loop loses the
+ * WHOLE section if any one key throws (e.g. a `SqliteError` from a corrupt or
+ * locked fallback index) — even when the primary overlay key already gathered
+ * evidence. The pre-#1505 first-non-empty read never had this problem: it
+ * returned the primary key's non-empty result without ever touching a failing
+ * fallback. This helper restores that resilience for the merged path: when more
+ * than one key is read, a per-key failure is contained so the other keys'
+ * evidence survives (best-effort recall — a total failure degrades to an empty
+ * section, which the orchestrator already treats as "no evidence").
+ *
+ * SINGLE-KEY is byte-for-byte the pre-#1505 behavior: the gather runs directly,
+ * so a failure PROPAGATES exactly as before (the caller / orchestrator catch
+ * still logs it). Fault isolation only engages once there is a fallback key that
+ * could fail independently of the primary.
+ */
+export async function gatherAcrossReadSessions(
+  sessionIds: ReadonlyArray<string | undefined>,
+  gather: (sessionId: string | undefined) => Promise<void>,
+): Promise<void> {
+  if (sessionIds.length <= 1) {
+    for (const sessionId of sessionIds) {
+      await gather(sessionId);
+    }
+    return;
+  }
+  for (const sessionId of sessionIds) {
+    try {
+      await gather(sessionId);
+    } catch {
+      // One read key failed; keep the evidence already gathered from the other
+      // keys instead of discarding the whole section.
+    }
+  }
+}

package/src/namespaces/search.test.ts

@@ -6,17 +6,22 @@ import type {
   SearchExecutionOptions,
   SearchQueryOptions,
 } from "../search/port.js";
+import type { QmdCapabilities, QmdVersionStatus } from "../qmd.js";
 import type { PluginConfig, QmdSearchResult } from "../types.js";
 
 type CollectionState = "present" | "missing" | "unknown" | "skipped";
 
 class FakeBackend implements SearchBackend {
   updates = 0;
+  disposed = 0;
+  available = true;
   calls: Array<{
     method: string;
     collection: string | undefined;
     maxResults: number | undefined;
   }> = [];
+  availabilitySignals: Array<AbortSignal | undefined> = [];
+  probeCalls = 0;
   ensureSignals: Array<AbortSignal | undefined> = [];
   ensureCollections: Array<string | undefined> = [];
   checkSignals: Array<AbortSignal | undefined> = [];
@@ -29,6 +34,11 @@ class FakeBackend implements SearchBackend {
       check?: CollectionState;
       ensure?: CollectionState;
     } = {},
+    private readonly daemonMode = false,
+    private readonly diagnostics: {
+      debugStatus?: string;
+      versionStatus?: QmdVersionStatus;
+    } = {},
   ) {}
 
   private limitedResults(maxResults: number | undefined): QmdSearchResult[] {
@@ -38,15 +48,33 @@ class FakeBackend implements SearchBackend {
   }
 
   async probe(): Promise<boolean> {
-    return true;
+    this.probeCalls += 1;
+    return this.available;
+  }
+
+  async checkAvailability(execution?: SearchExecutionOptions): Promise<boolean> {
+    this.availabilitySignals.push(execution?.signal);
+    return this.available;
   }
 
   isAvailable(): boolean {
-    return true;
+    return this.available;
   }
 
   debugStatus(): string {
-    return "fake";
+    return this.diagnostics.debugStatus ?? "fake";
+  }
+
+  isDaemonMode(): boolean {
+    return this.daemonMode;
+  }
+
+  getVersionStatus(): QmdVersionStatus | null {
+    return this.diagnostics.versionStatus ?? null;
+  }
+
+  async dispose(): Promise<void> {
+    this.disposed += 1;
   }
 
   async search(
@@ -154,6 +182,41 @@ function config(): PluginConfig {
   } as PluginConfig;
 }
 
+function qmdCapabilities(enabled: boolean): QmdCapabilities {
+  return {
+    version: enabled ? "2.5.3" : null,
+    parsedVersion: enabled ? [2, 5, 3] : null,
+    stableSdk: enabled,
+    unifiedSearch: enabled,
+    getDocumentBody: enabled,
+    maintenanceApi: enabled,
+    legacySkillInstall: enabled,
+    intentHints: enabled,
+    explainTraces: enabled,
+    candidateLimit: enabled,
+    v2McpQueryTool: enabled,
+    structuredSearches: enabled,
+    queryRerankToggle: enabled,
+    chunkStrategy: enabled,
+    qmdBench: enabled,
+    perCollectionModels: enabled,
+    jsonLineNumbers: enabled,
+    editorLinks: enabled,
+    doctor: enabled,
+    versionedSkills: enabled,
+    absoluteSnippetLines: enabled,
+    fullQueryOutput: enabled,
+    forceCpu: enabled,
+    gpuBackendOverride: enabled,
+    embedParallelism: enabled,
+    modelEnvConsistency: enabled,
+    scopedEmbed: enabled,
+    safeStatusDeviceProbe: enabled,
+    mcpIndexSelection: enabled,
+    outputFormatFlag: enabled,
+  };
+}
+
 test("updateNamespaces runs a global-update backend only once", async () => {
   const created: FakeBackend[] = [];
   const router = new NamespaceSearchRouter(
@@ -304,6 +367,198 @@ test("legacy default namespace root fail-opens missing guarded collections", asy
   assert.deepEqual(backend.ensureCollections, []);
 });
 
+test("healthForNamespace checks namespace collection without auto-creating or caching state", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = new FakeBackend(false, [], created.length === 0
+        ? { check: "missing" }
+        : { ensure: "present" });
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  const health = await router.healthForNamespace("shared");
+
+  assert.equal(health.collectionState, "missing");
+  assert.equal(health.collection, "openclaw-engram--ns-736861726564");
+  assert.deepEqual(created[0]?.checkCollections, ["openclaw-engram--ns-736861726564"]);
+  assert.deepEqual(created[0]?.ensureCollections, []);
+  assert.equal(created[0]?.probeCalls, 0);
+  assert.equal(created[0]?.availabilitySignals.length, 1);
+  assert.equal(created[0]?.disposed, 1);
+
+  const ensured = await router.ensureNamespaceCollection("shared");
+
+  assert.equal(ensured, "present");
+  assert.equal(created.length, 2);
+  assert.deepEqual(created[1]?.ensureCollections, ["openclaw-engram--ns-736861726564"]);
+});
+
+test("healthForNamespace reports daemon mode from live cached namespace backend", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = created.length === 0
+        ? new FakeBackend(false, [
+          {
+            path: "facts/a.md",
+            docid: "a",
+            score: 1,
+            snippet: "a",
+          },
+        ], { ensure: "present" }, true, {
+          debugStatus: "live-daemon",
+          versionStatus: {
+            installedVersion: "qmd 2.5.3",
+            supportedVersion: "2.5.3",
+            supported: true,
+            newerThanSupported: false,
+            upgradeAvailable: false,
+            capabilities: qmdCapabilities(true),
+          },
+        })
+        : new FakeBackend(false, [], { check: "present" }, false, {
+          debugStatus: "probe-unavailable",
+          versionStatus: {
+            installedVersion: null,
+            supportedVersion: "2.5.3",
+            supported: false,
+            newerThanSupported: false,
+            upgradeAvailable: false,
+            capabilities: qmdCapabilities(false),
+          },
+        });
+      if (created.length === 1) {
+        backend.available = false;
+      }
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  await router.searchAcrossNamespaces({
+    query: "a",
+    namespaces: ["shared"],
+    maxResults: 1,
+  });
+  const health = await router.healthForNamespace("shared");
+
+  assert.equal(health.available, true);
+  assert.equal(health.daemonMode, true);
+  assert.equal(health.debugStatus, "live-daemon");
+  assert.equal(health.installedVersion, "qmd 2.5.3");
+  assert.equal(health.supportedVersion, "2.5.3");
+  assert.equal(health.supported, true);
+  assert.equal(health.upgradeAvailable, false);
+  assert.equal(health.doctorAvailable, true);
+  assert.equal(health.collectionState, "unknown");
+  assert.equal(created.length, 2);
+  assert.equal(created[0]?.disposed, 0);
+  assert.equal(created[1]?.disposed, 1);
+  assert.deepEqual(created[1]?.checkCollections, []);
+});
+
+test("healthForNamespace preserves cached missing collection state", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = created.length === 0
+        ? new FakeBackend(false, [], { ensure: "missing" }, true)
+        : new FakeBackend(false, [], { check: "present" }, false);
+      created.push(backend);
+      return backend;
+    },
+  );
+
+  assert.deepEqual(
+    await router.searchAcrossNamespaces({
+      query: "a",
+      namespaces: ["shared"],
+      maxResults: 1,
+    }),
+    [],
+  );
+  const health = await router.healthForNamespace("shared");
+
+  assert.equal(health.available, true);
+  assert.equal(health.daemonMode, true);
+  assert.equal(health.collectionState, "missing");
+  assert.equal(created.length, 2);
+  assert.deepEqual(created[1]?.checkCollections, ["openclaw-engram--ns-736861726564"]);
+});
+
+test("healthForNamespace stops waiting when namespace availability probe aborts", async () => {
+  const backend = new class extends FakeBackend {
+    override async checkAvailability(execution?: SearchExecutionOptions): Promise<boolean> {
+      this.availabilitySignals.push(execution?.signal);
+      return await new Promise<boolean>(() => {});
+    }
+  }(false);
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => backend,
+  );
+  const controller = new AbortController();
+  controller.abort();
+
+  const health = await router.healthForNamespace("shared", {
+    signal: controller.signal,
+  });
+
+  assert.equal(health.available, false);
+  assert.equal(health.collectionState, "unknown");
+  assert.equal(backend.probeCalls, 0);
+  assert.equal(backend.availabilitySignals[0], controller.signal);
+  assert.deepEqual(backend.checkCollections, []);
+  assert.deepEqual(backend.ensureCollections, []);
+  assert.equal(backend.disposed, 1);
+});
+
+test("ensureNamespaceCollection does not cache aborted namespace backend probes", async () => {
+  const created: FakeBackend[] = [];
+  const router = new NamespaceSearchRouter(
+    config(),
+    { storageFor: async (namespace: string) => ({ dir: `/tmp/remnic/${namespace}` }) },
+    () => {
+      const backend = created.length === 0
+        ? new class extends FakeBackend {
+          override async probe(): Promise<boolean> {
+            return await new Promise<boolean>(() => {});
+          }
+        }(false)
+        : new FakeBackend(false, [], { ensure: "present" });
+      created.push(backend);
+      return backend;
+    },
+  );
+  const controller = new AbortController();
+  controller.abort();
+
+  await assert.rejects(
+    () => router.ensureNamespaceCollection("shared", { signal: controller.signal }),
+    /operation aborted/,
+  );
+
+  assert.equal(created[0]?.disposed, 1);
+  assert.deepEqual(created[0]?.checkCollections, []);
+  assert.deepEqual(created[0]?.ensureCollections, []);
+
+  const ensured = await router.ensureNamespaceCollection("shared");
+
+  assert.equal(ensured, "present");
+  assert.equal(created.length, 2);
+  assert.deepEqual(created[1]?.ensureCollections, ["openclaw-engram--ns-736861726564"]);
+});
+
 test("legacy default namespace root filters nested namespace search results", async () => {
   const router = new NamespaceSearchRouter(
     config(),