@remnic/core 9.6.29 → 9.6.31

package/src/focused-list-recall.ts

@@ -8,6 +8,7 @@ import {
   gatherAcrossReadSessions,
   resolveLcmReadSessionIds,
 } from "./lcm-fallback-read.js";
+import { isSameLcmRow, lcmEvidenceIdentity } from "./lcm/evidence-identity.js";
 
 export interface FocusedListRecallOptions {
   engine: ExplicitCueRecallEngine | null | undefined;
@@ -134,27 +135,35 @@ async function collectFocusedListItems(
       result.turn_index + searchWindowAfter,
       searchWindowTokens,
     );
+    const searchIdentity = lcmEvidenceIdentity(result, result.session_id);
     const searchHit: EvidencePackItem = {
-      id: `${result.session_id}:${result.turn_index}`,
+      ...searchIdentity,
       sessionId: result.session_id,
       turnIndex: result.turn_index,
       role: result.role,
       content: result.content,
       ...(typeof result.score === "number" ? { score: result.score } : {}),
     };
-    const candidates: EvidencePackItem[] = expanded.map((message) => ({
-      id: `${result.session_id}:${message.turn_index}`,
-      sessionId: result.session_id,
-      turnIndex: message.turn_index,
-      role: message.role,
-      content: message.content,
-      ...(message.turn_index === result.turn_index &&
-      typeof result.score === "number"
-        ? { score: result.score }
-        : {}),
-    }));
-    const hitIndex = candidates.findIndex((candidate) =>
-      candidate.turnIndex === result.turn_index
+    const candidates: EvidencePackItem[] = expanded.map((message) => {
+      const matchesSearchHit = isSameLcmRow(
+        message,
+        result.session_id,
+        result,
+        result.session_id,
+      );
+      return {
+        ...lcmEvidenceIdentity(message, result.session_id),
+        sessionId: message.session_id ?? result.session_id,
+        turnIndex: message.turn_index,
+        role: message.role,
+        content: message.content,
+        ...(matchesSearchHit && typeof result.score === "number"
+          ? { score: result.score }
+          : {}),
+      };
+    });
+    const hitIndex = expanded.findIndex((message) =>
+      isSameLcmRow(message, result.session_id, result, result.session_id)
     );
     if (hitIndex >= 0) {
       candidates[hitIndex] = searchHit;
@@ -221,8 +230,8 @@ async function collectFocusedListScanItems(
   );
   for (const message of messages) {
     const candidate = {
-      id: `${options.sessionId}:${message.turn_index}`,
-      sessionId: options.sessionId,
+      ...lcmEvidenceIdentity(message, options.sessionId),
+      sessionId: message.session_id ?? options.sessionId,
       turnIndex: message.turn_index,
       role: message.role,
       content: message.content,

package/src/index.ts

@@ -58,6 +58,8 @@ export {
   buildEvidencePack,
   type EvidencePackItem,
   type EvidencePackOptions,
+  type EvidencePackSelectedItem,
+  type EvidencePackSelectionReceipt,
 } from "./evidence-pack.js";
 export {
   buildExplicitCueRecallSection,
@@ -74,6 +76,7 @@ export {
   type ExplicitCueRecallOptions,
   type ExplicitTurnReference,
   type TrajectoryAnalysisRecallOptions,
+  type TrajectoryAnalysisLineReceipt,
 } from "./explicit-cue-recall.js";
 export {
   buildTargetedFactRecallSection,

package/src/lcm/engine.ts

@@ -3,7 +3,11 @@ import { openLcmDatabase, ensureLcmStateDir } from "./schema.js";
 import { LcmArchive, type LcmStructuredRecallMatch } from "./archive.js";
 import { LcmDag } from "./dag.js";
 import { LcmSummarizer, type SummarizeFn } from "./summarizer.js";
-import { assembleCompressedHistory, type LcmRecallConfig } from "./recall.js";
+import {
+  assembleCompressedHistoryWithTrace,
+  type LcmRecallConfig,
+  type LcmRecallWithTraceResult,
+} from "./recall.js";
 import { LcmWorkQueue, type LcmObserveMessage } from "./queue.js";
 import type { PluginConfig } from "../types.js";
 import { log } from "../logger.js";
@@ -336,17 +340,25 @@ export class LcmEngine {
     sessionId: string,
     budgetChars: number,
   ): Promise<string> {
-    if (!this.config.enabled) return "";
+    return (await this.assembleRecallWithTrace(sessionId, budgetChars)).text;
+  }
+
+  /** Build compressed recall plus content-free selected-summary receipts. */
+  async assembleRecallWithTrace(
+    sessionId: string,
+    budgetChars: number,
+  ): Promise<LcmRecallWithTraceResult> {
+    if (!this.config.enabled) return { text: "", selectedSummaries: [] };
     const normalizedSessionId = normalizeLcmSessionId(sessionId);
-    if (!normalizedSessionId) return "";
+    if (!normalizedSessionId) return { text: "", selectedSummaries: [] };
     await this.ensureInitialized();
 
     const effectiveBudget = Math.ceil(
       budgetChars * this.config.recallBudgetShare,
     );
-    if (effectiveBudget <= 0) return "";
+    if (effectiveBudget <= 0) return { text: "", selectedSummaries: [] };
 
-    return assembleCompressedHistory(this.dag!, this.archive!, normalizedSessionId, {
+    return assembleCompressedHistoryWithTrace(this.dag!, this.archive!, normalizedSessionId, {
       freshTailTurns: this.config.freshTailTurns,
       budgetChars: effectiveBudget,
     });

package/src/lcm/evidence-identity.ts

@@ -0,0 +1,59 @@
+export interface LcmRowIdentity {
+  id?: number;
+  session_id?: string;
+  turn_index: number;
+}
+
+export interface LcmEvidenceIdentity {
+  id: string;
+  archiveRowId?: number;
+}
+
+export function lcmArchiveRowId(row: Pick<LcmRowIdentity, "id">): number | undefined {
+  const value = row.id;
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0
+    ? value
+    : undefined;
+}
+
+function resolveSessionId(row: LcmRowIdentity, fallbackSessionId: string): string {
+  return row.session_id ?? fallbackSessionId;
+}
+
+/**
+ * Build the non-rendered evidence identity for an LCM archive row.
+ *
+ * Older adapters and test doubles may omit the SQLite row id. Those callers
+ * retain the historical session+turn identity until they adopt row lineage.
+ */
+export function lcmEvidenceIdentity(
+  row: LcmRowIdentity,
+  fallbackSessionId: string,
+): LcmEvidenceIdentity {
+  const sessionId = resolveSessionId(row, fallbackSessionId);
+  const archiveRowId = lcmArchiveRowId(row);
+  if (archiveRowId === undefined) {
+    return { id: `${sessionId}:${row.turn_index}` };
+  }
+  return {
+    id: JSON.stringify(["lcm-row", sessionId, archiveRowId]),
+    archiveRowId,
+  };
+}
+
+/** Match a search hit to its expanded archive row without conflating siblings. */
+export function isSameLcmRow(
+  left: LcmRowIdentity,
+  leftFallbackSessionId: string,
+  right: LcmRowIdentity,
+  rightFallbackSessionId: string,
+): boolean {
+  const leftRowId = lcmArchiveRowId(left);
+  const rightRowId = lcmArchiveRowId(right);
+  const leftSessionId = resolveSessionId(left, leftFallbackSessionId);
+  const rightSessionId = resolveSessionId(right, rightFallbackSessionId);
+  if (leftRowId !== undefined && rightRowId !== undefined) {
+    return leftRowId === rightRowId && leftSessionId === rightSessionId;
+  }
+  return leftSessionId === rightSessionId && left.turn_index === right.turn_index;
+}

package/src/lcm/index.ts

@@ -4,9 +4,21 @@ export {
   type LcmEngineConfig,
   type LcmExpandedMessage,
 } from "./engine.js";
+export {
+  isSameLcmRow,
+  lcmArchiveRowId,
+  lcmEvidenceIdentity,
+  type LcmEvidenceIdentity,
+  type LcmRowIdentity,
+} from "./evidence-identity.js";
 export { LcmArchive, estimateTokens } from "./archive.js";
 export { LcmDag, type SummaryNode } from "./dag.js";
 export { LcmSummarizer, type SummarizeFn } from "./summarizer.js";
-export { assembleCompressedHistory } from "./recall.js";
+export {
+  assembleCompressedHistory,
+  assembleCompressedHistoryWithTrace,
+  type LcmRecallWithTraceResult,
+  type LcmSummarySelectionReceipt,
+} from "./recall.js";
 export { registerLcmTools } from "./tools.js";
 export { openLcmDatabase, ensureLcmStateDir } from "./schema.js";

package/src/lcm/recall.ts

@@ -7,6 +7,21 @@ export interface LcmRecallConfig {
   budgetChars: number;
 }
 
+export interface LcmSummarySelectionReceipt {
+  id: string;
+  depth: number;
+  msgStart: number;
+  msgEnd: number;
+  /** Half-open offsets within the returned compressed-history string. */
+  entryStart: number;
+  entryEnd: number;
+}
+
+export interface LcmRecallWithTraceResult {
+  text: string;
+  selectedSummaries: LcmSummarySelectionReceipt[];
+}
+
 /**
  * Assemble a compressed session history section from the summary DAG.
  *
@@ -21,14 +36,24 @@ export function assembleCompressedHistory(
   sessionId: string,
   config: LcmRecallConfig,
 ): string {
+  return assembleCompressedHistoryWithTrace(dag, archive, sessionId, config).text;
+}
+
+export function assembleCompressedHistoryWithTrace(
+  dag: LcmDag,
+  archive: LcmArchive,
+  sessionId: string,
+  config: LcmRecallConfig,
+): LcmRecallWithTraceResult {
   const maxTurn = archive.getMaxTurnIndex(sessionId);
-  if (maxTurn < 0) return "";
+  if (maxTurn < 0) return { text: "", selectedSummaries: [] };
 
   const allNodes = dag.getAllNodes(sessionId);
-  if (allNodes.length === 0) return "";
+  if (allNodes.length === 0) return { text: "", selectedSummaries: [] };
 
   const freshTailStart = Math.max(0, maxTurn - config.freshTailTurns + 1);
   const sections: string[] = [];
+  const selectedNodes: SummaryNode[] = [];
   let usedChars = 0;
 
   // Collect nodes covering the "old" portion (before fresh tail)
@@ -39,6 +64,7 @@ export function assembleCompressedHistory(
       const entry = `**${label}** (depth ${node.depth}):\n${node.summary_text}`;
       if (usedChars + entry.length > config.budgetChars) break;
       sections.push(entry);
+      selectedNodes.push(node);
       usedChars += entry.length;
     }
   }
@@ -58,12 +84,29 @@ export function assembleCompressedHistory(
     const entry = `**${label}**:\n${node.summary_text}`;
     if (usedChars + entry.length > config.budgetChars) break;
     sections.push(entry);
+    selectedNodes.push(node);
     usedChars += entry.length;
   }
 
-  if (sections.length === 0) return "";
-
-  return `## Session History (Compressed)\n\n${sections.join("\n\n")}`;
+  if (sections.length === 0) return { text: "", selectedSummaries: [] };
+
+  const prefix = "## Session History (Compressed)\n\n";
+  const text = `${prefix}${sections.join("\n\n")}`;
+  let entryStart = prefix.length;
+  const selectedSummaries = selectedNodes.map((node, index) => {
+    const entryEnd = entryStart + sections[index]!.length;
+    const receipt: LcmSummarySelectionReceipt = {
+      id: node.id,
+      depth: node.depth,
+      msgStart: node.msg_start,
+      msgEnd: node.msg_end,
+      entryStart,
+      entryEnd,
+    };
+    entryStart = entryEnd + 2;
+    return receipt;
+  });
+  return { text, selectedSummaries };
 }
 
 /**

package/src/lcm-engine.test.ts

@@ -676,6 +676,52 @@ test("expandContext preserves first, middle, and last row identity when truncate
   }
 });
 
+test("assembleRecallWithTrace preserves text and reports selected summary metadata", async () => {
+  const memoryDir = await mkdtemp(
+    path.join(os.tmpdir(), "engram-lcm-summary-receipts-"),
+  );
+
+  try {
+    const engine = new LcmEngine(
+      createPluginConfig(memoryDir),
+      async () => "private summary body",
+    );
+    await engine.observeMessages(
+      "private-session",
+      Array.from({ length: 8 }, (_, index) => ({
+        role: index % 2 === 0 ? "user" : "assistant",
+        content: `private message ${index}`,
+      })),
+    );
+    await engine.waitForSessionObserveIdle("private-session");
+
+    const baseline = await engine.assembleRecall("private-session", 10_000);
+    const traced = await engine.assembleRecallWithTrace(
+      "private-session",
+      10_000,
+    );
+
+    assert.equal(traced.text, baseline);
+    assert.ok(traced.selectedSummaries.length > 0);
+    assert.ok(
+      traced.selectedSummaries.every((receipt) =>
+        receipt.entryStart < receipt.entryEnd &&
+        receipt.msgStart <= receipt.msgEnd
+      ),
+    );
+    assert.equal(
+      JSON.stringify(traced.selectedSummaries).includes("private summary body"),
+      false,
+    );
+    assert.equal(
+      JSON.stringify(traced.selectedSummaries).includes("private-session"),
+      false,
+    );
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
 test("close prevents deferred observe work from reinitializing the engine", async () => {
   const memoryDir = await mkdtemp(
     path.join(os.tmpdir(), "engram-lcm-engine-close-"),

package/src/lcm-recall.test.ts

@@ -6,7 +6,10 @@ import test from "node:test";
 
 import { LcmArchive } from "./lcm/archive.js";
 import { LcmDag } from "./lcm/dag.js";
-import { assembleCompressedHistory } from "./lcm/recall.js";
+import {
+  assembleCompressedHistory,
+  assembleCompressedHistoryWithTrace,
+} from "./lcm/recall.js";
 import { ensureLcmStateDir, openLcmDatabase } from "./lcm/schema.js";
 
 test("assembleCompressedHistory excludes old summaries that straddle the fresh tail", async () => {
@@ -58,12 +61,56 @@ test("assembleCompressedHistory excludes old summaries that straddle the fresh t
       freshTailTurns: 16,
       budgetChars: 10_000,
     });
+    const traced = assembleCompressedHistoryWithTrace(
+      dag,
+      archive,
+      sessionId,
+      { freshTailTurns: 16, budgetChars: 10_000 },
+    );
 
+    assert.equal(traced.text, section);
     assert.doesNotMatch(section, /parent summary 0-31/);
     assert.match(section, /leaf summary 0-7/);
     assert.match(section, /leaf summary 8-15/);
     assert.match(section, /leaf summary 16-23/);
     assert.match(section, /leaf summary 24-31/);
+    assert.deepEqual(
+      traced.selectedSummaries.map(({ id, depth, msgStart, msgEnd }) => ({
+        id,
+        depth,
+        msgStart,
+        msgEnd,
+      })),
+      [
+        { id: "leaf-0-7", depth: 0, msgStart: 0, msgEnd: 7 },
+        { id: "leaf-8-15", depth: 0, msgStart: 8, msgEnd: 15 },
+        { id: "leaf-16-23", depth: 0, msgStart: 16, msgEnd: 23 },
+        { id: "leaf-24-31", depth: 0, msgStart: 24, msgEnd: 31 },
+      ],
+    );
+    for (const receipt of traced.selectedSummaries) {
+      assert.ok(receipt.entryStart < receipt.entryEnd);
+      const expectedSummary = receipt.id.replace("leaf-", "leaf summary ");
+      assert.equal(
+        traced.text.slice(receipt.entryStart, receipt.entryEnd).includes(expectedSummary),
+        true,
+      );
+      assert.equal("summary" in receipt, false);
+      assert.equal("sessionId" in receipt, false);
+    }
+
+    const first = traced.selectedSummaries[0]!;
+    const firstEntryBudget = first.entryEnd - first.entryStart;
+    const limited = assembleCompressedHistoryWithTrace(
+      dag,
+      archive,
+      sessionId,
+      { freshTailTurns: 16, budgetChars: firstEntryBudget },
+    );
+    assert.deepEqual(
+      limited.selectedSummaries.map((receipt) => receipt.id),
+      ["leaf-0-7"],
+    );
   } finally {
     db.close();
     await rm(memoryDir, { recursive: true, force: true });

package/src/lcm-retrieval-lineage.test.ts

@@ -0,0 +1,236 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { AccessLcmSurface, type AccessLcmSurfaceDeps } from "./access-lcm-surface.js";
+import {
+  AccessRecallSurface,
+  type AccessRecallSurfaceDeps,
+} from "./access-recall-surface.js";
+import { buildEventOrderRecallSection } from "./event-order-recall.js";
+import { buildExplicitCueRecallSection, type ExplicitCueRecallEngine } from "./explicit-cue-recall.js";
+import { buildFocusedListRecallSection } from "./focused-list-recall.js";
+import {
+  isSameLcmRow,
+  lcmEvidenceIdentity,
+} from "./lcm/evidence-identity.js";
+import { buildResponseGuidanceRecallSection } from "./response-guidance-recall.js";
+import { buildTargetedFactRecallSection } from "./targeted-fact-recall.js";
+
+interface TestRow {
+  id?: number;
+  session_id: string;
+  turn_index: number;
+  role: string;
+  content: string;
+}
+
+class LineageEngine implements ExplicitCueRecallEngine {
+  constructor(
+    private readonly rows: TestRow[],
+    private readonly searchRowId?: number,
+    private readonly searchContent?: string,
+  ) {}
+
+  async expandContext(
+    sessionId: string,
+    fromTurn: number,
+    toTurn: number,
+    _maxTokens: number,
+  ): Promise<TestRow[]> {
+    return this.rows.filter((row) =>
+      row.session_id === sessionId &&
+      row.turn_index >= fromTurn &&
+      row.turn_index <= toTurn
+    );
+  }
+
+  async searchContextFull(): Promise<
+    Array<TestRow & { score: number }>
+  > {
+    const row = this.rows.find((candidate) => candidate.id === this.searchRowId);
+    return row
+      ? [{
+          ...row,
+          content: this.searchContent ?? row.content,
+          score: 99,
+        }]
+      : [];
+  }
+
+  async getStats(sessionId?: string): Promise<{
+    totalMessages: number;
+    maxTurnIndex?: number;
+  }> {
+    const rows = sessionId
+      ? this.rows.filter((row) => row.session_id === sessionId)
+      : this.rows;
+    return {
+      totalMessages: rows.length,
+      maxTurnIndex: rows.length > 0
+        ? Math.max(...rows.map((row) => row.turn_index))
+        : undefined,
+    };
+  }
+}
+
+test("LCM evidence identity distinguishes sibling rows and preserves the legacy fallback", () => {
+  const first = { id: 41, session_id: "session", turn_index: 7 };
+  const second = { id: 42, session_id: "session", turn_index: 7 };
+  assert.notEqual(
+    lcmEvidenceIdentity(first, "session").id,
+    lcmEvidenceIdentity(second, "session").id,
+  );
+  assert.equal(isSameLcmRow(first, "session", second, "session"), false);
+  assert.equal(
+    lcmEvidenceIdentity({ turn_index: 7 }, "session").id,
+    "session:7",
+  );
+  assert.equal(
+    isSameLcmRow(
+      { turn_index: 7 },
+      "session",
+      { turn_index: 7 },
+      "session",
+    ),
+    true,
+  );
+});
+
+test("explicit-cue recall keeps distinct archive rows that share a turn", async () => {
+  const engine = new LineageEngine([
+    { id: 101, session_id: "s", turn_index: 7, role: "user", content: "First row at the referenced turn." },
+    { id: 102, session_id: "s", turn_index: 7, role: "assistant", content: "Second row at the referenced turn." },
+  ]);
+  const recalled = await buildExplicitCueRecallSection({
+    engine,
+    sessionId: "s",
+    query: "Review turn 7",
+    maxChars: 4_000,
+  });
+  assert.match(recalled, /First row at the referenced turn/);
+  assert.match(recalled, /Second row at the referenced turn/);
+});
+
+test("targeted recall replaces and scores only the matching same-turn row", async () => {
+  const engine = new LineageEngine([
+    { id: 101, session_id: "s", turn_index: 7, role: "user", content: "I earn approximately $100,000 CAD annually as a senior engineer." },
+    { id: 102, session_id: "s", turn_index: 7, role: "user", content: "My recent raise to $110,000 CAD as a senior engineer at Saint Pierre Manufacturing Ltd is now effective." },
+  ], 102, "The matching row records my recent raise to $110,000 CAD as a senior engineer at Saint Pierre Manufacturing Ltd.");
+  const recalled = await buildTargetedFactRecallSection({
+    engine,
+    sessionId: "s",
+    query: "What is my annual salary as a senior engineer at Saint Pierre Manufacturing Ltd?",
+    maxChars: 6_000,
+  });
+  assert.match(recalled, /earn approximately \$100,000 CAD annually/);
+  assert.match(recalled, /matching row records my recent raise to \$110,000 CAD/);
+});
+
+test("focused-list recall keeps distinct same-turn calculations while matching the search row", async () => {
+  const engine = new LineageEngine([
+    { id: 101, session_id: "s", turn_index: 7, role: "user", content: "Can you help me calculate P(both heads) = 1/2 x 1/2 = 1/4 so I can make sure I get it right?" },
+    { id: 102, session_id: "s", turn_index: 7, role: "user", content: "I am trying to verify if P(rolling a number greater than 4) = 2/6 = 1/3 is correct." },
+  ], 102, "I confirmed P(rolling a number greater than 4) = 2/6 = 1/3.");
+  const recalled = await buildFocusedListRecallSection({
+    engine,
+    sessionId: "s",
+    query: "In my questions about tossing coins and rolling dice, how many different probability calculations did I try to confirm?",
+    maxChars: 6_000,
+  });
+  assert.match(recalled, /P\(both heads\)/);
+  assert.match(recalled, /P\(rolling a number greater than 4\)/);
+});
+
+test("response guidance keeps distinct same-turn rows while preserving its existing filters", async () => {
+  const engine = new LineageEngine([
+    { id: 101, session_id: "s", turn_index: 7, role: "user", content: "I prefer a structured daily routine with a written priority list each morning." },
+    { id: 102, session_id: "s", turn_index: 7, role: "user", content: "My structured daily routine schedules focused work blocks and buffer time between meetings." },
+  ], 102, "My structured daily routine schedules focused work blocks and buffer time between meetings.");
+  const recalled = await buildResponseGuidanceRecallSection({
+    engine,
+    sessionId: "s",
+    query: "How should I organize my day to stay on track?",
+    maxChars: 6_000,
+  });
+  assert.match(recalled, /written priority list each morning/);
+  assert.match(recalled, /focused work blocks/);
+});
+
+test("event-order recall keeps distinct same-turn chronological rows", async () => {
+  const engine = new LineageEngine([
+    { id: 101, session_id: "s", turn_index: 7, role: "user", content: "Patrick suggested a March workshop on workflow optimization." },
+    { id: 102, session_id: "s", turn_index: 7, role: "user", content: "Patrick and I planned an interview tips meeting for tomorrow." },
+  ]);
+  const recalled = await buildEventOrderRecallSection({
+    engine,
+    sessionId: "s",
+    query: "Walk me through my interactions with Patrick in order.",
+    maxChars: 6_000,
+  });
+  assert.match(recalled, /workshop suggestion/);
+  assert.match(recalled, /interview tips meeting/);
+});
+
+function accessSearchDeps(rows: TestRow[]): AccessLcmSurfaceDeps {
+  const orchestrator = {
+    config: {
+      defaultNamespace: "default",
+      namespaces: false,
+    },
+    lcmEngine: {
+      enabled: true,
+      searchContextFull: async () => rows,
+    },
+  };
+  return {
+    orchestrator,
+    lcmSessionIdsForNamespaces: () => ["primary", "fallback"],
+    resolveImplicitLcmReadFallbackNamespace: () => "default",
+    resolveLcmReadNamespace: () => "default",
+    resolveLcmReadSessionIds: () => ["primary", "fallback"],
+    resolveLcmReadSessionKey: () => "primary",
+    resolveReadableNamespace: () => "default",
+    resolveRequestPrincipal: () => "default",
+    resolveScopeProfileLcmReadNamespaces: () => null,
+  } as unknown as AccessLcmSurfaceDeps;
+}
+
+test("access LCM search dedupes repeated rows but retains same-turn siblings", async () => {
+  const rows: TestRow[] = [
+    { id: 101, session_id: "s", turn_index: 7, role: "user", content: "first sibling" },
+    { id: 102, session_id: "s", turn_index: 7, role: "assistant", content: "second sibling" },
+  ];
+  const response = await new AccessLcmSurface(accessSearchDeps(rows)).lcmSearch({
+    query: "sibling",
+    sessionKey: "s",
+  });
+  assert.deepEqual(response.results.map((row) => row.content), [
+    "first sibling",
+    "second sibling",
+  ]);
+});
+
+test("raw excerpts dedupe repeated rows but retain same-turn siblings", async () => {
+  const rows: TestRow[] = [
+    { id: 101, session_id: "s", turn_index: 7, role: "user", content: "first sibling" },
+    { id: 102, session_id: "s", turn_index: 7, role: "assistant", content: "second sibling" },
+  ];
+  const deps = {
+    orchestrator: {
+      config: { defaultNamespace: "default" },
+      lcmEngine: {
+        enabled: true,
+        searchContextFull: async () => rows,
+      },
+    },
+  } as unknown as AccessRecallSurfaceDeps;
+  const excerpts = await new AccessRecallSurface(deps).fetchRawExcerpts("raw", {
+    query: "sibling",
+    sessionKey: "s",
+    lcmSessionIds: ["primary", "fallback"],
+  });
+  assert.deepEqual(excerpts?.map((row) => row.content), [
+    "first sibling",
+    "second sibling",
+  ]);
+});