recallnest 2.2.0 → 2.2.1

package/src/__tests__/consolidation-engine.test.ts

@@ -1,181 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { ConsolidationEngine, DEFAULT_CONSOLIDATION_CONFIG, formatConsolidationResult, type ConsolidationResult } from "../consolidation-engine.js";
-import type { MemoryEntry, MemorySearchResult } from "../store.js";
-
-function makeEntry(overrides: Partial<MemoryEntry> & { id: string; text: string }): MemoryEntry {
-  return {
-    vector: [1, 0, 0],
-    category: "events",
-    scope: "project:test",
-    importance: 0.7,
-    timestamp: Date.now(),
-    metadata: "{}",
-    ...overrides,
-  };
-}
-
-function createMockStore(entries: MemoryEntry[], similarityMap: Map<string, Map<string, number>> = new Map()) {
-  const data = new Map(entries.map(e => [e.id, { ...e }]));
-  const updates: Array<{ id: string; metadata: string }> = [];
-
-  return {
-    updates,
-    store: {
-      async list(scopeFilter?: string[], _category?: string, limit = 500, _offset = 0) {
-        return [...data.values()]
-          .filter(e => !scopeFilter || scopeFilter.some(s => e.scope === s))
-          .slice(0, limit);
-      },
-      async getById(id: string) {
-        return data.get(id) ?? null;
-      },
-      async vectorSearch(vector: number[], limit = 5, minScore = 0.3, scopeFilter?: string[]) {
-        // Use the similarity map to compute fake scores
-        const sourceEntry = [...data.values()].find(e =>
-          e.vector.length === vector.length && e.vector.every((v, i) => v === vector[i])
-        );
-        if (!sourceEntry) return [];
-
-        const sourceMap = similarityMap.get(sourceEntry.id);
-        if (!sourceMap) return [];
-
-        const results: MemorySearchResult[] = [];
-        for (const [targetId, score] of sourceMap) {
-          if (score < minScore) continue;
-          const target = data.get(targetId);
-          if (!target) continue;
-          if (scopeFilter && !scopeFilter.some(s => target.scope === s)) continue;
-          results.push({ entry: target, score });
-        }
-        return results.sort((a, b) => b.score - a.score).slice(0, limit);
-      },
-      async update(id: string, upd: { metadata?: string }) {
-        const entry = data.get(id);
-        if (!entry) return null;
-        if (upd.metadata) {
-          entry.metadata = upd.metadata;
-          updates.push({ id, metadata: upd.metadata });
-        }
-        return entry;
-      },
-    },
-  };
-}
-
-describe("ConsolidationEngine", () => {
-  it("returns empty result for empty scope", async () => {
-    const { store } = createMockStore([]);
-    const engine = new ConsolidationEngine(store);
-    const result = await engine.run("project:test");
-    expect(result.originalCount).toBe(0);
-    expect(result.clustersFound).toBe(0);
-  });
-
-  it("skips single-entry categories", async () => {
-    const entries = [makeEntry({ id: "a", text: "only one" })];
-    const { store } = createMockStore(entries);
-    const engine = new ConsolidationEngine(store);
-    const result = await engine.run("project:test");
-    expect(result.originalCount).toBe(1);
-    expect(result.clustersFound).toBe(0);
-  });
-
-  it("merges near-duplicates above mergeThreshold", async () => {
-    const entryA = makeEntry({ id: "a", text: "I prefer TypeScript", vector: [1, 0, 0], importance: 0.9 });
-    const entryB = makeEntry({ id: "b", text: "I prefer TypeScript language", vector: [0.99, 0.1, 0], importance: 0.5 });
-
-    const simMap = new Map([
-      ["a", new Map([["b", 0.95]])],
-      ["b", new Map([["a", 0.95]])],
-    ]);
-
-    const { store, updates } = createMockStore([entryA, entryB], simMap);
-    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, mergeThreshold: 0.92 });
-    const result = await engine.run("project:test");
-
-    expect(result.clustersFound).toBe(1);
-    expect(result.mergedCount).toBe(1);
-    // Tier 3.3: Both entries now coexist in a version group instead of archiving.
-    // Both A and B should have version_group metadata.
-    const updateA = updates.find(u => u.id === "a");
-    const updateB = updates.find(u => u.id === "b");
-    expect(updateA).toBeTruthy();
-    expect(updateB).toBeTruthy();
-    const metaA = JSON.parse(updateA!.metadata);
-    const metaB = JSON.parse(updateB!.metadata);
-    expect(metaA.version_group).toBeTruthy();
-    expect(metaB.version_group).toBe(metaA.version_group);
-    // Canonical (A, higher importance) should have higher rank
-    expect(metaA.version_rank).toBeGreaterThan(metaB.version_rank);
-  });
-
-  it("links related entries below mergeThreshold but above clusterThreshold", async () => {
-    const entryA = makeEntry({ id: "a", text: "TypeScript config", vector: [1, 0, 0] });
-    const entryB = makeEntry({ id: "b", text: "TypeScript setup", vector: [0.9, 0.1, 0] });
-
-    const simMap = new Map([
-      ["a", new Map([["b", 0.85]])],
-      ["b", new Map([["a", 0.85]])],
-    ]);
-
-    const { store, updates } = createMockStore([entryA, entryB], simMap);
-    const engine = new ConsolidationEngine(store, { ...DEFAULT_CONSOLIDATION_CONFIG, clusterThreshold: 0.82, mergeThreshold: 0.92 });
-    const result = await engine.run("project:test");
-
-    expect(result.clustersFound).toBe(1);
-    expect(result.mergedCount).toBe(0);
-    expect(result.relationsAdded).toBe(1);
-    // Both should have clustering metadata
-    const linkUpdate = updates.find(u => u.id === "b");
-    expect(linkUpdate).toBeTruthy();
-    const meta = JSON.parse(linkUpdate!.metadata);
-    expect(meta.clustered_with).toBe("a");
-  });
-
-  it("detects heuristic contradictions", async () => {
-    const entryA = makeEntry({ id: "a", text: "Always use strict mode in TypeScript projects", vector: [1, 0, 0] });
-    const entryB = makeEntry({ id: "b", text: "Never use strict mode in TypeScript projects", vector: [0.98, 0.1, 0] });
-
-    const simMap = new Map([
-      ["a", new Map([["b", 0.95]])],
-      ["b", new Map([["a", 0.95]])],
-    ]);
-
-    const { store } = createMockStore([entryA, entryB], simMap);
-    const engine = new ConsolidationEngine(store, DEFAULT_CONSOLIDATION_CONFIG);
-    const result = await engine.run("project:test");
-
-    expect(result.conflictsDetected.length).toBe(1);
-    expect(result.conflictsDetected[0].type).toBe("heuristic_contradiction");
-  });
-
-  it("skips archived entries", async () => {
-    const entryA = makeEntry({ id: "a", text: "active entry here", vector: [1, 0, 0] });
-    const entryB = makeEntry({ id: "b", text: "archived entry here", vector: [0.95, 0.1, 0], metadata: JSON.stringify({ evolution: { status: "archived" } }) });
-
-    const { store } = createMockStore([entryA, entryB]);
-    const engine = new ConsolidationEngine(store);
-    const result = await engine.run("project:test");
-
-    expect(result.originalCount).toBe(1); // only active
-  });
-});
-
-describe("formatConsolidationResult", () => {
-  it("formats a result with conflicts", () => {
-    const result: ConsolidationResult = {
-      originalCount: 100,
-      clustersFound: 5,
-      mergedCount: 3,
-      relationsAdded: 7,
-      conflictsDetected: [{ memoryA: "aaaa-bbbb", memoryB: "cccc-dddd", type: "heuristic_contradiction" }],
-      scope: "project:test",
-    };
-    const text = formatConsolidationResult(result);
-    expect(text).toContain("Scanned: 100");
-    expect(text).toContain("Clusters found: 5");
-    expect(text).toContain("Merged (versioned): 3");
-    expect(text).toContain("Conflicts:");
-  });
-});

package/src/__tests__/constructive-retrieval.test.ts

@@ -1,509 +0,0 @@
-/**
- * Phase 4: Constructive Retrieval — tests for candidate expansion,
- * source-map grounding, contradiction detection, and reconstruction pipeline.
- */
-import { describe, test, expect } from "bun:test";
-import {
-  expandCandidates,
-  detectContradictions,
-  computeSourceMapCoverage,
-  buildPrompt,
-  reconstruct,
-  extractCitedIds,
-  shouldReconstruct,
-  type CandidateExpansionDeps,
-  type ReconstructionInput,
-  type ReconstructionLLMClient,
-  type ReconstructionOutput,
-} from "../context-reconstructor.js";
-import type { RetrievalResult } from "../retriever.js";
-
-// ============================================================================
-// Test Helpers
-// ============================================================================
-
-function makeResult(id: string, text: string, importance = 0.7, score = 0.8): RetrievalResult {
-  return {
-    entry: {
-      id,
-      text,
-      importance,
-      category: "entities",
-      scope: "test",
-      timestamp: Date.now(),
-      metadata: "{}",
-      vector: new Float32Array(0),
-    },
-    score,
-    sources: {},
-  };
-}
-
-function makeMockLLM(response: string | null): ReconstructionLLMClient {
-  return {
-    generateReconstruction: async () => response,
-  };
-}
-
-// ============================================================================
-// expandCandidates
-// ============================================================================
-
-describe("expandCandidates", () => {
-  test("tags direct results and returns source map", async () => {
-    const direct = [makeResult("a", "memory A"), makeResult("b", "memory B")];
-    const { results, sourceMap } = await expandCandidates(direct, {});
-    expect(results).toHaveLength(2);
-    expect(sourceMap.get("a")).toEqual({ type: "direct" });
-    expect(sourceMap.get("b")).toEqual({ type: "direct" });
-  });
-
-  test("expands via KG neighbors", async () => {
-    const direct = [makeResult("a", "memory A")];
-    const deps: CandidateExpansionDeps = {
-      expandViaKG: async () => [makeResult("kg1", "KG neighbor")],
-    };
-    const { results, sourceMap } = await expandCandidates(direct, deps);
-    expect(results).toHaveLength(2);
-    expect(sourceMap.get("kg1")).toEqual({ type: "kg_neighbor" });
-  });
-
-  test("expands via evolution chains", async () => {
-    const direct = [makeResult("a", "memory A")];
-    const deps: CandidateExpansionDeps = {
-      expandViaEvolution: async () => [makeResult("evo1", "evolution successor")],
-    };
-    const { results, sourceMap } = await expandCandidates(direct, deps);
-    expect(results).toHaveLength(2);
-    expect(sourceMap.get("evo1")).toEqual({ type: "evolution_chain" });
-  });
-
-  test("expands via clusters", async () => {
-    const direct = [makeResult("a", "memory A")];
-    const deps: CandidateExpansionDeps = {
-      expandViaClusters: async () => [makeResult("cl1", "cluster member")],
-    };
-    const { results, sourceMap } = await expandCandidates(direct, deps);
-    expect(results).toHaveLength(2);
-    expect(sourceMap.get("cl1")).toEqual({ type: "cluster_member" });
-  });
-
-  test("expands via narrative siblings", async () => {
-    const direct = [makeResult("a", "memory A")];
-    const deps: CandidateExpansionDeps = {
-      expandViaNarrative: async () => [makeResult("ns1", "narrative sibling")],
-    };
-    const { results, sourceMap } = await expandCandidates(direct, deps);
-    expect(results).toHaveLength(2);
-    expect(sourceMap.get("ns1")).toEqual({ type: "narrative_sibling" });
-  });
-
-  test("deduplicates across expansion sources", async () => {
-    const direct = [makeResult("a", "memory A")];
-    const deps: CandidateExpansionDeps = {
-      expandViaKG: async () => [makeResult("shared", "from KG")],
-      expandViaEvolution: async () => [makeResult("shared", "from evo")],
-    };
-    const { results, sourceMap } = await expandCandidates(direct, deps);
-    expect(results).toHaveLength(2);
-    // First expansion wins
-    expect(sourceMap.get("shared")).toEqual({ type: "kg_neighbor" });
-  });
-
-  test("respects EXPANSION_CAP of 20", async () => {
-    const direct = Array.from({ length: 15 }, (_, i) => makeResult(`d${i}`, `direct ${i}`));
-    const deps: CandidateExpansionDeps = {
-      expandViaKG: async () => Array.from({ length: 10 }, (_, i) => makeResult(`kg${i}`, `kg ${i}`)),
-    };
-    const { results } = await expandCandidates(direct, deps);
-    expect(results.length).toBeLessThanOrEqual(20);
-  });
-
-  test("handles expansion failures gracefully", async () => {
-    const direct = [makeResult("a", "memory A")];
-    const deps: CandidateExpansionDeps = {
-      expandViaKG: async () => { throw new Error("KG unavailable"); },
-      expandViaEvolution: async () => [makeResult("evo1", "evolution ok")],
-    };
-    const { results } = await expandCandidates(direct, deps);
-    expect(results).toHaveLength(2); // direct + evolution (KG failed silently)
-  });
-
-  test("no expansion deps returns only direct results", async () => {
-    const direct = [makeResult("a", "A"), makeResult("b", "B")];
-    const { results, sourceMap } = await expandCandidates(direct, {});
-    expect(results).toHaveLength(2);
-    expect(sourceMap.size).toBe(2);
-  });
-
-  test("parallel expansion sources all contribute", async () => {
-    const direct = [makeResult("a", "memory A")];
-    const deps: CandidateExpansionDeps = {
-      expandViaKG: async () => [makeResult("kg1", "KG")],
-      expandViaEvolution: async () => [makeResult("evo1", "evo")],
-      expandViaClusters: async () => [makeResult("cl1", "cluster")],
-      expandViaNarrative: async () => [makeResult("ns1", "narrative")],
-    };
-    const { results, sourceMap } = await expandCandidates(direct, deps);
-    expect(results).toHaveLength(5);
-    expect(sourceMap.get("kg1")?.type).toBe("kg_neighbor");
-    expect(sourceMap.get("evo1")?.type).toBe("evolution_chain");
-    expect(sourceMap.get("cl1")?.type).toBe("cluster_member");
-    expect(sourceMap.get("ns1")?.type).toBe("narrative_sibling");
-  });
-});
-
-// ============================================================================
-// detectContradictions
-// ============================================================================
-
-describe("detectContradictions", () => {
-  test("detects negation-pattern contradiction", () => {
-    const results = [
-      makeResult("a", "You should always use TypeScript for projects"),
-      makeResult("b", "You should not always use TypeScript for every project"),
-    ];
-    const contradictions = detectContradictions(results);
-    expect(contradictions.length).toBeGreaterThanOrEqual(1);
-    expect(contradictions[0].memoryIds).toEqual(["a", "b"]);
-  });
-
-  test("no contradictions for compatible memories", () => {
-    const results = [
-      makeResult("a", "User prefers dark mode"),
-      makeResult("b", "User uses Bun runtime"),
-    ];
-    expect(detectContradictions(results)).toHaveLength(0);
-  });
-
-  test("caps at 5 contradictions", () => {
-    // Create many contradicting pairs
-    const results: RetrievalResult[] = [];
-    for (let i = 0; i < 12; i++) {
-      const text = i % 2 === 0
-        ? `Feature ${Math.floor(i / 2)} must always be enabled for deployment`
-        : `Feature ${Math.floor(i / 2)} should never be enabled for deployment`;
-      results.push(makeResult(`m${i}`, text));
-    }
-    const contradictions = detectContradictions(results);
-    expect(contradictions.length).toBeLessThanOrEqual(5);
-  });
-
-  test("handles empty results", () => {
-    expect(detectContradictions([])).toHaveLength(0);
-  });
-
-  test("handles single result", () => {
-    expect(detectContradictions([makeResult("a", "solo")])).toHaveLength(0);
-  });
-});
-
-// ============================================================================
-// computeSourceMapCoverage
-// ============================================================================
-
-describe("computeSourceMapCoverage", () => {
-  test("full coverage when all sentences have valid citations", () => {
-    const text = "User works on RecallNest [src:a]. They use Bun runtime [src:b].";
-    const validIds = new Set(["a", "b"]);
-    expect(computeSourceMapCoverage(text, validIds)).toBe(1.0);
-  });
-
-  test("partial coverage when some sentences lack citations", () => {
-    const text = "User works on RecallNest [src:a]. No citation here. Another fact [src:b].";
-    const validIds = new Set(["a", "b"]);
-    const coverage = computeSourceMapCoverage(text, validIds);
-    expect(coverage).toBeGreaterThan(0.5);
-    expect(coverage).toBeLessThan(1.0);
-  });
-
-  test("zero coverage when no valid citations", () => {
-    const text = "Some text [src:invalid]. More text [src:also_invalid].";
-    const validIds = new Set(["real_id"]);
-    expect(computeSourceMapCoverage(text, validIds)).toBe(0);
-  });
-
-  test("handles empty text", () => {
-    expect(computeSourceMapCoverage("", new Set(["a"]))).toBe(0);
-  });
-
-  test("filters out short sentences (<=5 chars)", () => {
-    const text = "OK. User works on RecallNest [src:a].";
-    const coverage = computeSourceMapCoverage(text, new Set(["a"]));
-    expect(coverage).toBe(1.0); // "OK." is filtered, only the cited sentence counts
-  });
-});
-
-// ============================================================================
-// buildPrompt (checkpoint context injection)
-// ============================================================================
-
-describe("buildPrompt with checkpoint context", () => {
-  const baseInput: ReconstructionInput = {
-    query: "test query",
-    results: [makeResult("a", "memory A"), makeResult("b", "memory B"), makeResult("c", "memory C")],
-    mode: "resume",
-  };
-
-  test("includes open loops in system prompt", () => {
-    const input: ReconstructionInput = {
-      ...baseInput,
-      checkpointContext: {
-        openLoops: ["Fix CI pipeline", "Review PR #42"],
-      },
-    };
-    const { system } = buildPrompt(input);
-    expect(system).toContain("Open loops");
-    expect(system).toContain("Fix CI pipeline");
-    expect(system).toContain("Review PR #42");
-  });
-
-  test("includes next actions in system prompt", () => {
-    const input: ReconstructionInput = {
-      ...baseInput,
-      checkpointContext: {
-        nextActions: ["Deploy to staging", "Run integration tests"],
-      },
-    };
-    const { system } = buildPrompt(input);
-    expect(system).toContain("Next actions");
-    expect(system).toContain("Deploy to staging");
-  });
-
-  test("includes scope in system prompt", () => {
-    const input: ReconstructionInput = {
-      ...baseInput,
-      checkpointContext: { scope: "project:recallnest" },
-    };
-    const { system } = buildPrompt(input);
-    expect(system).toContain("Active scope: project:recallnest");
-  });
-
-  test("no checkpoint context = no checkpoint hint", () => {
-    const { system } = buildPrompt(baseInput);
-    expect(system).not.toContain("Checkpoint state");
-  });
-
-  test("empty checkpoint context = no checkpoint hint", () => {
-    const input: ReconstructionInput = {
-      ...baseInput,
-      checkpointContext: {},
-    };
-    const { system } = buildPrompt(input);
-    expect(system).not.toContain("Checkpoint state");
-  });
-});
-
-// ============================================================================
-// reconstruct (full pipeline)
-// ============================================================================
-
-describe("reconstruct pipeline", () => {
-  const baseResults = [
-    makeResult("m1", "User prefers TypeScript"),
-    makeResult("m2", "Project uses Bun runtime"),
-    makeResult("m3", "Deploy target is Docker"),
-  ];
-
-  test("returns reconstructed text with typed sources", async () => {
-    const llm = makeMockLLM(
-      "The user prefers TypeScript [src:m1]. The project uses Bun [src:m2]. Deployed via Docker [src:m3]."
-    );
-    const result = await reconstruct(
-      { query: "project setup", results: baseResults, mode: "search" },
-      llm,
-    );
-    expect(result.reconstructed).toBeTruthy();
-    expect(result.sources.length).toBeGreaterThanOrEqual(1);
-    // Sources have typed structure
-    for (const s of result.sources) {
-      expect(s).toHaveProperty("id");
-      expect(s).toHaveProperty("source");
-      expect(s.source).toHaveProperty("type");
-      expect(s).toHaveProperty("contribution");
-    }
-  });
-
-  test("returns contradictions array (even when empty)", async () => {
-    const llm = makeMockLLM("Summary [src:m1]. Info [src:m2]. Details [src:m3].");
-    const result = await reconstruct(
-      { query: "test", results: baseResults, mode: "search" },
-      llm,
-    );
-    expect(result).toHaveProperty("contradictions");
-    expect(Array.isArray(result.contradictions)).toBe(true);
-  });
-
-  test("returns coverage score", async () => {
-    const llm = makeMockLLM("Cited fact [src:m1]. Another fact [src:m2]. Third fact [src:m3].");
-    const result = await reconstruct(
-      { query: "test", results: baseResults, mode: "search" },
-      llm,
-    );
-    expect(result).toHaveProperty("coverage");
-    expect(typeof result.coverage).toBe("number");
-  });
-
-  test("fallback on LLM empty response", async () => {
-    const llm = makeMockLLM(null);
-    const result = await reconstruct(
-      { query: "test", results: baseResults, mode: "search" },
-      llm,
-    );
-    expect(result.reconstructed).toBeNull();
-    expect(result.fallbackReason).toBe("llm_empty");
-    expect(result.sources).toHaveLength(0);
-    expect(result.contradictions).toHaveLength(0);
-  });
-
-  test("fallback on low grounding coverage", async () => {
-    // Response with no valid citations
-    const llm = makeMockLLM("Some text without any citations. Another ungrounded sentence.");
-    const result = await reconstruct(
-      { query: "test", results: baseResults, mode: "search" },
-      llm,
-    );
-    expect(result.reconstructed).toBeNull();
-    expect(result.fallbackReason).toBe("low_grounding");
-  });
-
-  test("removes sentences with invalid IDs and lowers confidence", async () => {
-    const llm = makeMockLLM(
-      "Valid fact [src:m1]. Fake source [src:FAKE]. Another valid [src:m2]. Third valid [src:m3]."
-    );
-    const result = await reconstruct(
-      { query: "test", results: baseResults, mode: "search" },
-      llm,
-    );
-    if (result.reconstructed) {
-      expect(result.reconstructed).not.toContain("[src:FAKE]");
-      expect(result.confidence).toBeLessThan(1.0);
-    }
-  });
-
-  test("respects 3s timeout", async () => {
-    const slowLLM: ReconstructionLLMClient = {
-      generateReconstruction: async () => {
-        await new Promise(r => setTimeout(r, 4000));
-        return "too late [src:m1]";
-      },
-    };
-    const result = await reconstruct(
-      { query: "test", results: baseResults, mode: "search" },
-      slowLLM,
-    );
-    expect(result.fallbackReason).toBe("timeout");
-  }, 6000);
-
-  test("with expansion deps — expanded candidates used in reconstruction", async () => {
-    const expanded = makeResult("exp1", "expanded info");
-    const deps: CandidateExpansionDeps = {
-      expandViaKG: async () => [expanded],
-    };
-    const llm = makeMockLLM(
-      "Main fact [src:m1]. KG expanded [src:exp1]. More info [src:m2]. Detail [src:m3]."
-    );
-    const result = await reconstruct(
-      { query: "test", results: baseResults, mode: "search" },
-      llm,
-      deps,
-    );
-    expect(result.reconstructed).toBeTruthy();
-    // Check that expanded source is tracked as kg_neighbor
-    const expSource = result.sources.find(s => s.id === "exp1");
-    expect(expSource).toBeTruthy();
-    expect(expSource!.source.type).toBe("kg_neighbor");
-  });
-
-  test("source contributions extracted from cited sentences", async () => {
-    const llm = makeMockLLM(
-      "The user loves TypeScript and uses it everywhere [src:m1]. Bun is the runtime [src:m2]. Docker deploys [src:m3]."
-    );
-    const result = await reconstruct(
-      { query: "test", results: baseResults, mode: "search" },
-      llm,
-    );
-    if (result.sources.length > 0) {
-      const m1Source = result.sources.find(s => s.id === "m1");
-      expect(m1Source?.contribution).toBeTruthy();
-      expect(m1Source?.contribution).toContain("TypeScript");
-    }
-  });
-
-  test("checkpoint context passed through to LLM", async () => {
-    let capturedSystem = "";
-    const spy: ReconstructionLLMClient = {
-      generateReconstruction: async (system, _user) => {
-        capturedSystem = system;
-        return "Fact [src:m1]. Detail [src:m2]. Info [src:m3].";
-      },
-    };
-    await reconstruct(
-      {
-        query: "test",
-        results: baseResults,
-        mode: "resume",
-        checkpointContext: {
-          openLoops: ["Fix bug #99"],
-          scope: "project:test",
-        },
-      },
-      spy,
-    );
-    expect(capturedSystem).toContain("Fix bug #99");
-    expect(capturedSystem).toContain("project:test");
-  });
-});
-
-// ============================================================================
-// Integration: ReconstructionOutput shape contract
-// ============================================================================
-
-describe("ReconstructionOutput shape", () => {
-  test("successful reconstruction has all required fields", async () => {
-    const results = [
-      makeResult("a", "fact A"),
-      makeResult("b", "fact B"),
-      makeResult("c", "fact C"),
-    ];
-    const llm = makeMockLLM("Summary of A [src:a]. Summary of B [src:b]. Summary of C [src:c].");
-    const output = await reconstruct(
-      { query: "test", results, mode: "search" },
-      llm,
-    );
-
-    // Shape validation
-    expect(output).toHaveProperty("reconstructed");
-    expect(output).toHaveProperty("sources");
-    expect(output).toHaveProperty("confidence");
-    expect(output).toHaveProperty("contradictions");
-    expect(output).toHaveProperty("coverage");
-    expect(output).toHaveProperty("raw");
-
-    // Type validation
-    expect(typeof output.confidence).toBe("number");
-    expect(typeof output.coverage).toBe("number");
-    expect(Array.isArray(output.sources)).toBe(true);
-    expect(Array.isArray(output.contradictions)).toBe(true);
-    expect(Array.isArray(output.raw)).toBe(true);
-  });
-
-  test("failed reconstruction has all required fields", async () => {
-    const results = [
-      makeResult("a", "fact A"),
-      makeResult("b", "fact B"),
-      makeResult("c", "fact C"),
-    ];
-    const llm = makeMockLLM(null);
-    const output = await reconstruct(
-      { query: "test", results, mode: "search" },
-      llm,
-    );
-
-    expect(output.reconstructed).toBeNull();
-    expect(output.sources).toHaveLength(0);
-    expect(output.contradictions).toHaveLength(0);
-    expect(output.coverage).toBe(0);
-    expect(output.fallbackReason).toBeTruthy();
-  });
-});