@remnic/core 9.3.650 → 9.3.651

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/orchestrator.ts

@@ -7243,16 +7243,24 @@ export class Orchestrator {
     );
     // Query an LCM-backed read across the ordered read key set and return the
     // FIRST non-empty result (#1505 fallback-namespace unification). The primary
-    // overlay key is tried first; if a branch-scoped session has no rows under
-    // its branch key, the project / root fallback keys are tried in order. Each
-    // builder applies its own per-session budget/limit, so taking the first hit
-    // (rather than concatenating across keys) preserves existing budgets while
-    // recovering fallback evidence. When the set is a single key (single-user /
-    // no-overlay / explicit-namespace), this is exactly one call — unchanged.
-    // `lcmSessionId` is `string | undefined`: a SESSIONLESS recall yields the
-    // single `undefined` key so the LCM builders run ONE archive-wide read with
-    // no `session_id` filter (pre-#1505 behavior; the builders accept an optional
-    // `sessionId`). NEVER the literal "default" session id (codex P2).
+    // overlay key is tried first; if a branch-scoped session has no rows under its
+    // branch key, the project / root fallback keys are tried in order.
+    //
+    // #1505 codex P2 ("Merge LCM fallback reads instead of short-circuiting"): the
+    // query-SCORED sections (explicit-cue, targeted-facts, focused-list,
+    // response-guidance, event-order, structured message-parts) no longer use this
+    // helper — they MERGE candidates across EVERY authorized key under their single
+    // budget (a weak primary-key hit must not mask stronger fallback evidence; the
+    // section builders take `sessionIds`, structured-parts merges inline below).
+    // This first-non-empty helper now serves ONLY the compressed-history section,
+    // which is a per-session HOLISTIC DAG narrative with no per-item id to merge or
+    // dedupe on — see its call site for the rationale.
+    //
+    // When the set is a single key (single-user / no-overlay / explicit-namespace),
+    // this is exactly one call — unchanged. `lcmSessionId` is `string | undefined`:
+    // a SESSIONLESS recall yields the single `undefined` key so the read runs ONE
+    // archive-wide read with no `session_id` filter (pre-#1505 behavior). NEVER the
+    // literal "default" session id (codex P2).
     const firstNonEmptyLcmRead = async <T>(
       read: (lcmSessionId: string | undefined) => Promise<T>,
       isEmpty: (value: T) => boolean,
@@ -9513,24 +9521,21 @@ export class Orchestrator {
       (recallMode as RecallPlanMode) !== "no_recall"
     ) {
       try {
-        const explicitCueSection = await firstNonEmptyLcmRead(
-          (lcmSessionId) =>
-            buildExplicitCueRecallSection({
-              engine: this.lcmEngine,
-              // #1495 thread 3 + #1505 fallback unification: read across the
-              // ordered LCM read key set (primary overlay → coding fallbacks)
-              // so a branch-scoped session finds its own explicit-cue evidence
-              // even when archived at project/root scope (rule 39).
-              sessionId: lcmSessionId,
-              query: retrievalQuery,
-              maxChars: explicitCueMaxChars,
-              maxReferences:
-                this.getRecallSectionNumber("explicit-cue", "maxResults") ??
-                this.config.explicitCueRecallMaxReferences,
-            }),
-          (s) => !s,
-          "",
-        );
+        const explicitCueSection = await buildExplicitCueRecallSection({
+          engine: this.lcmEngine,
+          // #1495 thread 3 + #1505 fallback unification: read across the ordered
+          // LCM read key set (primary overlay → coding fallbacks) so a
+          // branch-scoped session finds its own explicit-cue evidence even when
+          // archived at project/root scope (rule 39). #1505 codex P2: the builder
+          // MERGES candidates across every key under its single budget instead of
+          // short-circuiting on the first non-empty key.
+          sessionIds: lcmReadSessionIds,
+          query: retrievalQuery,
+          maxChars: explicitCueMaxChars,
+          maxReferences:
+            this.getRecallSectionNumber("explicit-cue", "maxResults") ??
+            this.config.explicitCueRecallMaxReferences,
+        });
         if (explicitCueSection) {
           this.appendRecallSection(
             sectionBuckets,
@@ -9560,29 +9565,25 @@ export class Orchestrator {
       shouldRecallTargetedFactEvidence(retrievalQuery)
     ) {
       try {
-        const targetedFactSection = await firstNonEmptyLcmRead(
-          (lcmSessionId) =>
-            buildTargetedFactRecallSection({
-              engine: this.lcmEngine,
-              // #1495 + #1505 fallback unification: read across the ordered LCM
-              // read key set so a branch-scoped session finds its own
-              // targeted-fact evidence even when archived at project/root scope.
-              sessionId: lcmSessionId,
-              query: retrievalQuery,
-              maxChars: targetedFactMaxChars,
-              maxSearchResults:
-                this.getRecallSectionNumber("targeted-facts", "maxResults") ??
-                this.config.targetedFactRecallMaxResults,
-              maxScanWindowTurns:
-                this.getRecallSectionNumber("targeted-facts", "maxTurns") ??
-                this.config.targetedFactRecallScanWindowTurns,
-              maxScanWindowTokens:
-                this.getRecallSectionNumber("targeted-facts", "maxTokens") ??
-                this.config.targetedFactRecallScanWindowTokens,
-            }),
-          (s) => !s,
-          "",
-        );
+        const targetedFactSection = await buildTargetedFactRecallSection({
+          engine: this.lcmEngine,
+          // #1495 + #1505 fallback unification: read across the ordered LCM read
+          // key set so a branch-scoped session finds its own targeted-fact
+          // evidence even when archived at project/root scope. #1505 codex P2: the
+          // builder MERGES candidates across every key under its single budget.
+          sessionIds: lcmReadSessionIds,
+          query: retrievalQuery,
+          maxChars: targetedFactMaxChars,
+          maxSearchResults:
+            this.getRecallSectionNumber("targeted-facts", "maxResults") ??
+            this.config.targetedFactRecallMaxResults,
+          maxScanWindowTurns:
+            this.getRecallSectionNumber("targeted-facts", "maxTurns") ??
+            this.config.targetedFactRecallScanWindowTurns,
+          maxScanWindowTokens:
+            this.getRecallSectionNumber("targeted-facts", "maxTokens") ??
+            this.config.targetedFactRecallScanWindowTokens,
+        });
         if (targetedFactSection) {
           this.appendRecallSection(
             sectionBuckets,
@@ -9613,29 +9614,26 @@ export class Orchestrator {
       shouldRecallFocusedListEvidence(retrievalQuery)
     ) {
       try {
-        const focusedListSection = await firstNonEmptyLcmRead(
-          (lcmSessionId) =>
-            buildFocusedListRecallSection({
-              engine: this.lcmEngine,
-              // #1495 thread 3 + #1505 fallback unification: read across the
-              // ordered LCM read key set so a branch-scoped session reads its own
-              // focused-list/count evidence even at project/root scope (rule 39).
-              sessionId: lcmSessionId,
-              query: retrievalQuery,
-              maxChars: focusedListMaxChars,
-              maxSearchResults:
-                this.getRecallSectionNumber("focused-list", "maxResults") ??
-                this.config.focusedListRecallMaxResults,
-              maxScanWindowTurns:
-                this.getRecallSectionNumber("focused-list", "maxTurns") ??
-                this.config.focusedListRecallScanWindowTurns,
-              maxScanWindowTokens:
-                this.getRecallSectionNumber("focused-list", "maxTokens") ??
-                this.config.focusedListRecallScanWindowTokens,
-            }),
-          (s) => !s,
-          "",
-        );
+        const focusedListSection = await buildFocusedListRecallSection({
+          engine: this.lcmEngine,
+          // #1495 thread 3 + #1505 fallback unification: read across the ordered
+          // LCM read key set so a branch-scoped session reads its own
+          // focused-list/count evidence even at project/root scope (rule 39).
+          // #1505 codex P2: the builder MERGES candidates across every key under
+          // its single budget.
+          sessionIds: lcmReadSessionIds,
+          query: retrievalQuery,
+          maxChars: focusedListMaxChars,
+          maxSearchResults:
+            this.getRecallSectionNumber("focused-list", "maxResults") ??
+            this.config.focusedListRecallMaxResults,
+          maxScanWindowTurns:
+            this.getRecallSectionNumber("focused-list", "maxTurns") ??
+            this.config.focusedListRecallScanWindowTurns,
+          maxScanWindowTokens:
+            this.getRecallSectionNumber("focused-list", "maxTokens") ??
+            this.config.focusedListRecallScanWindowTokens,
+        });
         if (focusedListSection) {
           this.appendRecallSection(
             sectionBuckets,
@@ -9670,30 +9668,27 @@ export class Orchestrator {
       (responseGuidanceMatchesQuery || responseGuidanceForcedByPipeline)
     ) {
       try {
-        const responseGuidanceSection = await firstNonEmptyLcmRead(
-          (lcmSessionId) =>
-            buildResponseGuidanceRecallSection({
-              engine: this.lcmEngine,
-              // #1495 thread 3 + #1505 fallback unification: read across the
-              // ordered LCM read key set so a branch-scoped session reads its own
-              // response-guidance evidence even at project/root scope (rule 39).
-              sessionId: lcmSessionId,
-              query: retrievalQuery,
-              maxChars: responseGuidanceMaxChars,
-              maxSearchResults:
-                this.getRecallSectionNumber("response-guidance", "maxResults") ??
-                this.config.responseGuidanceRecallMaxResults,
-              maxScanWindowTurns:
-                this.getRecallSectionNumber("response-guidance", "maxTurns") ??
-                this.config.responseGuidanceRecallScanWindowTurns,
-              maxScanWindowTokens:
-                this.getRecallSectionNumber("response-guidance", "maxTokens") ??
-                this.config.responseGuidanceRecallScanWindowTokens,
-              forceGeneric: responseGuidanceForcedByPipeline,
-            }),
-          (s) => !s,
-          "",
-        );
+        const responseGuidanceSection = await buildResponseGuidanceRecallSection({
+          engine: this.lcmEngine,
+          // #1495 thread 3 + #1505 fallback unification: read across the ordered
+          // LCM read key set so a branch-scoped session reads its own
+          // response-guidance evidence even at project/root scope (rule 39).
+          // #1505 codex P2: the builder MERGES candidates across every key under
+          // its single budget.
+          sessionIds: lcmReadSessionIds,
+          query: retrievalQuery,
+          maxChars: responseGuidanceMaxChars,
+          maxSearchResults:
+            this.getRecallSectionNumber("response-guidance", "maxResults") ??
+            this.config.responseGuidanceRecallMaxResults,
+          maxScanWindowTurns:
+            this.getRecallSectionNumber("response-guidance", "maxTurns") ??
+            this.config.responseGuidanceRecallScanWindowTurns,
+          maxScanWindowTokens:
+            this.getRecallSectionNumber("response-guidance", "maxTokens") ??
+            this.config.responseGuidanceRecallScanWindowTokens,
+          forceGeneric: responseGuidanceForcedByPipeline,
+        });
         if (responseGuidanceSection) {
           this.appendRecallSection(
             sectionBuckets,
@@ -9722,13 +9717,22 @@ export class Orchestrator {
       shouldRecallEventOrderEvidence(retrievalQuery)
     ) {
       try {
+        // #1495 thread 3 + #1505 fallback unification: read across the ordered LCM
+        // read key set so a branch-scoped session reads its own chronological
+        // event-order evidence even at project/root scope. UNLIKE the relevance-
+        // ranked sections, event-order must NOT merge across keys: `turn_index` is
+        // LOCAL to each LCM `session_id` (`observe` numbers turns per session via
+        // `getMaxTurnIndex`), so interleaving two keys and sorting by `turn_index`
+        // would place an older project-scope turn after a newer branch-scope turn
+        // and misstate the chronology (#1505 codex P2). Like compressed-history,
+        // event-order is an inherently per-session ORDERED artifact, so it takes
+        // the highest-priority authorized key (primary overlay → project/root)
+        // that actually has chronological evidence — each key's timeline is
+        // internally consistent.
         const eventOrderSection = await firstNonEmptyLcmRead(
           (lcmSessionId) =>
             buildEventOrderRecallSection({
               engine: this.lcmEngine,
-              // #1495 thread 3 + #1505 fallback unification: read across the
-              // ordered LCM read key set so a branch-scoped session reads its own
-              // chronological event-order evidence even at project/root scope.
               sessionId: lcmSessionId,
               query: retrievalQuery,
               maxChars: eventOrderMaxChars,
@@ -9918,21 +9922,59 @@ export class Orchestrator {
       (recallMode as RecallPlanMode) !== "no_recall"
     ) {
       try {
-        const structuredMatches = await firstNonEmptyLcmRead(
-          (lcmSessionId) =>
-            this.lcmEngine!.searchStructuredParts(
-              // #1495 + #1505 fallback unification: read across the ordered LCM
-              // read key set so a branch-scoped session reads its own structured
-              // message-part evidence even when archived at project/root scope.
-              // Structured parts are inherently per-session (the DAG is keyed by
-              // session_id), so a SESSIONLESS read (`undefined`) normalizes to
-              // empty → no section, the correct pre-#1505 behavior (codex P2).
-              lcmSessionId ?? "",
-              retrievalQuery,
-            ),
-          (matches) => matches.length === 0,
-          [],
+        // #1495 + #1505 fallback unification: read across the ordered LCM read
+        // key set so a branch-scoped session reads its own structured
+        // message-part evidence even when archived at project/root scope.
+        // #1505 codex P2: structured matches are query-SCORED evidence, so MERGE
+        // across EVERY key (primary overlay → project/root fallbacks) instead of
+        // short-circuiting on the first non-empty key — a weak branch-key hit must
+        // not mask stronger project-fallback parts. Keys are queried in priority
+        // order; dedupe by session_id+turn_index+part_id keeps the primary key's
+        // row on collision. `formatStructuredRecall` applies the single budget
+        // below. A sessionless key (`undefined`) normalizes to "" → no matches
+        // (structured parts are inherently per-session; pre-#1505 behavior, codex
+        // P2).
+        // FAULT ISOLATION (allSettled, not all): the pre-#1505 first-non-empty read
+        // short-circuited, so a fallback key was often never queried and its latent
+        // search failure never surfaced. Querying every key eagerly must NOT let one
+        // key's failure (e.g. a SqliteError from a corrupt/locked fallback index)
+        // reject the batch and discard the OTHER keys' parts — or, since this and
+        // the compressed-history read below share one try block, silently drop the
+        // compressed-history section a healthy primary key would still produce. So
+        // read each key independently and keep the fulfilled batches.
+        const structuredSettled = await Promise.allSettled(
+          lcmReadSessionIds.map((lcmSessionId) =>
+            this.lcmEngine!.searchStructuredParts(lcmSessionId ?? "", retrievalQuery),
+          ),
         );
+        for (const settled of structuredSettled) {
+          if (settled.status === "rejected") {
+            log.debug(
+              `LCM structured-parts read failed for one key: ${settled.reason}`,
+            );
+          }
+        }
+        const seenStructuredParts = new Set<string>();
+        const structuredMatches = structuredSettled
+          .flatMap((settled) => (settled.status === "fulfilled" ? settled.value : []))
+          .filter((match) => {
+            const key = `${match.session_id} ${match.turn_index} ${match.part_id}`;
+            if (seenStructuredParts.has(key)) return false;
+            seenStructuredParts.add(key);
+            return true;
+          })
+          // Restore the archive's per-key ordering (score DESC, then turn DESC)
+          // across the MERGED set so the strongest parts win the shared budget in
+          // `formatStructuredRecall` — otherwise weak primary-key parts could crowd
+          // out stronger fallback parts. Stable sort: a single key is already in
+          // this order, so it stays byte-for-byte the pre-#1505 behavior.
+          // `?? 0` is defensive: `LcmStructuredRecallMatch.score` is always a
+          // number here, but a bare `b.score - a.score` would yield NaN (falsy)
+          // for any future unscored match and silently fall through to turn order.
+          .sort(
+            (a, b) =>
+              (b.score ?? 0) - (a.score ?? 0) || b.turn_index - a.turn_index,
+          );
         const structuredSection = this.lcmEngine.formatStructuredRecall(
           structuredMatches,
           Math.ceil(this.config.recallBudgetChars * 0.08),
@@ -9955,15 +9997,20 @@ export class Orchestrator {
             }
           }
         }
+        // #1495 + #1505 fallback unification: read across the ordered LCM read key
+        // set so a branch-scoped session reads its own compressed-history evidence
+        // even at project/root scope. UNLIKE the query-scored sections above, the
+        // compressed history is a per-session HOLISTIC DAG narrative, not a set of
+        // independently-rankable evidence items — concatenating two sessions'
+        // summaries would double-count the conversation and blow the budget, and
+        // there is no per-item id to dedupe on. So this section deliberately keeps
+        // first-non-empty semantics (#1505 codex P2 scope: "merge the query-matched
+        // sections"): the highest-priority authorized key (primary overlay →
+        // project/root) that actually has a compressed history wins. A sessionless
+        // key (`undefined`) normalizes to empty → no section (pre-#1505 behavior).
         const lcmSection = await firstNonEmptyLcmRead(
           (lcmSessionId) =>
             this.lcmEngine!.assembleRecall(
-              // #1495 + #1505 fallback unification: read across the ordered LCM
-              // read key set so a branch-scoped session reads its own
-              // compressed-history evidence even at project/root scope.
-              // Compressed history is inherently per-session (a per-session DAG),
-              // so a SESSIONLESS read (`undefined`) normalizes to empty → no
-              // section, the correct pre-#1505 behavior (codex P2).
               lcmSessionId ?? "",
               this.config.recallBudgetChars,
             ),