pi-mega-compact 0.20.86 → 0.20.88

package/dist/config.js

@@ -110,6 +110,15 @@ export const RAG_HYDE_ENABLED = () => ragEnabled("MEGACOMPACT_HYDE");
 /** Spec 1: vbrainstorm visual design migration for the dashboard. */
 export const NEW_UI = () => ragEnabled("MEGACOMPACT_NEW_UI");
 // ---------------------------------------------------------------------------
+// 3WF-3 same-repo recall cosine floor. SEPARATE from the S17 cross-repo floor
+// (config.crossRepoCosine, default 0.90 — stricter, cross-repo only). This is
+// the same-repo floor the 3-source validator applies to the top winner. A low
+// default (0.12) keeps recall permissive within a repo while still rejecting
+// effectively-unrelated hits. Call-time read so tests can set the env per-test.
+// ---------------------------------------------------------------------------
+/** Same-repo recall cosine floor: top winner must be >= this to be injected. */
+export const RECALL_MIN_COSINE = () => Number(process.env.MEGACOMPACT_RECALL_MIN_COSINE ?? "0.12");
+// ---------------------------------------------------------------------------
 // Vector-cortex flags + breaker constants (VC0A+). Positive sprint flags,
 // default ON, `=0`/`_DISABLED` off. Re-exported from src/config/vector-cortex.ts
 // so root consumers share one source of truth.

package/dist/extensions/dashboard-server/routes-rag-settings-helpers.js

@@ -93,6 +93,7 @@ export const SETTINGS = [
             num("MEGACOMPACT_L2_THRESHOLD", "L2 Cosine Threshold", "L2 semantic dedup firing point", 0.85, 0, 1),
             num("MEGACOMPACT_L1_JACCARD", "L1 Jaccard Threshold", "L1 MinHash near-dup threshold", 0.8, 0, 1),
             num("MEGACOMPACT_DEDUP_SIM", "Dedup Similarity", "Legacy content-similarity fallback", 0.9, 0, 1),
+            num("MEGACOMPACT_RECALL_MIN_COSINE", "Recall Min Cosine (same-repo)", "3WF-3 same-repo floor the 3-source validator applies to the top winner (cross-repo 0.90 stays separate)", 0.12, 0, 1),
             num("MEGACOMPACT_MMR_LAMBDA", "MMR Lambda", "Maximal Marginal Relevance diversity", 0.5, 0, 1),
             num("MEGACOMPACT_SEMDEDUP_COSINE", "SemDeDup Cosine", "Offline SemDeDup pair threshold", 0.95, 0, 1),
             num("MEGACOMPACT_CONSOLIDATE_COSINE", "Consolidate Cosine", "Memory consolidation merge threshold", 0.7, 0, 1),

package/dist/extensions/mega-config.js

@@ -181,6 +181,12 @@ export function loadConfig() {
         autoWikiEnabled: envBool("MEGACOMPACT_AUTO_WIKI", true),
         crossRepoEnabled: envBool("MEGACOMPACT_CROSSREPO_ENABLED", true),
         crossRepoCosine: Number(process.env.MEGACOMPACT_CROSSREPO_COSINE ?? "0.90"),
+        // 3WF-3: SAME-repo recall cosine floor applied by the 3-source validator to
+        // the top winner. SEPARATE from crossRepoCosine (S17, default 0.90, stricter
+        // and cross-repo only). This same-repo floor is permissive by default (0.12)
+        // so recall still surfaces loosely-relevant within-repo context while
+        // rejecting effectively-unrelated hits. Mirrors src/config.ts RECALL_MIN_COSINE.
+        recallMinCosine: Number(process.env.MEGACOMPACT_RECALL_MIN_COSINE ?? "0.12"),
         memoryAutoReview: envBool("MEGACOMPACT_MEMORY_AUTO_REVIEW", true),
         memoryReviewInterval: envFlag("MEGACOMPACT_MEMORY_REVIEW_INTERVAL", 10),
         recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),

package/dist/extensions/mega-events/context-handler/injectionConfirm.fixture.js

@@ -0,0 +1,63 @@
+/**
+ * context-handler/injectionConfirm.fixture.ts — shared fixtures for the 3WF-4
+ * InjectionConfirm tests.
+ *
+ * Split out so each test file stays under the extensions/300-soft-cap the way
+ * src/recall/recall3wf.fixture.ts does for 3WF-3. These are REAL fixtures, not
+ * mocks/stubs: a REAL VectorStore over a temp stateDir with REAL checkpoints
+ * persisted via compactSession; the MegaRuntime is a minimal typed stub exposing
+ * only the fields confirmInjection touches (store, pendingRecallBlock,
+ * pendingMemoryRecallBlock, appendEvent), matching the triggerGuard/thrashGuard
+ * test conventions.
+ */
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { VectorStore } from "../../../src/vectorStore.js";
+import { compactSession } from "../../../src/engine.js";
+/** Real EngineMessage fixture. */
+export function msg(role, text) {
+    return { role, text };
+}
+/** A user-role AgentMessage carrying `text` (the tail-block shape). */
+export function userMsg(text) {
+    return { role: "user", content: text, timestamp: 1 };
+}
+/** Fresh isolated state dir per VectorStore. */
+export function freshStore() {
+    const dir = mkdtempSync(join(tmpdir(), "mc-inject-"));
+    return { store: new VectorStore({ dedupSim: 0.9, stateDir: dir }), dir };
+}
+/** Persist N distinct checkpoints with ascending timestamps. */
+export function seed(store, topics, sid = "sess_inject") {
+    topics.forEach((t, i) => {
+        compactSession({
+            sessionId: sid,
+            messages: [msg("user", t), msg("assistant", "ok")],
+            keepFrom: 2,
+            timestamp: i + 1,
+        }, store);
+    });
+}
+/** Minimal MegaRuntime stub exposing only the confirmInjection touch-points. */
+export function runtimeStub(store, over = {}) {
+    const events = [];
+    const runtime = {
+        store,
+        pendingRecallBlock: over.pendingRecallBlock,
+        pendingMemoryRecallBlock: over.pendingMemoryRecallBlock,
+        perfTurnStart: undefined,
+        rt: { recallInjectedThisTurn: false },
+        appendEvent: (name, payload) => {
+            events.push({ name, payload });
+        },
+    };
+    return { runtime, events };
+}
+/** Config stub: only the flags confirmInjection reads. */
+export function configStub(over = {}) {
+    return {
+        threeWayFailback: over.threeWayFailback ?? true,
+        recallTailInject: over.recallTailInject ?? true,
+    };
+}

package/dist/extensions/mega-events/context-handler/injectionConfirm.js

@@ -0,0 +1,107 @@
+import { vectorList } from "../../../src/vectorStore.js";
+import { normalizeSessionId } from "../../../src/store.js";
+import { buildFloorBlock } from "../../../src/failback/floor.js";
+import { withRecallTail } from "../recall-tail.js";
+import { messageContentText } from "./messageText.js";
+/**
+ * The marker substring used to locate a staged block inside a message. The
+ * block's first non-empty line, capped, so prompt reshapes (cache striping /
+ * message separation) that regroup messages cannot defeat the match, while a
+ * genuinely dropped block still fails it.
+ */
+export function blockMarker(block) {
+    const line = block
+        .split("\n")
+        .map((l) => l.trim())
+        .find((l) => l.length > 0);
+    return (line ?? "").slice(0, 80);
+}
+/**
+ * PURE decision function: did the staged block land in this view, and if not,
+ * which rung should repair it? Takes the already-extracted message texts so it
+ * stays free of pi types and is directly unit-testable.
+ */
+export function decideInjection(input, messageTexts, hasPendingBlocks) {
+    const marker = input.staged ? blockMarker(input.staged) : "";
+    // Nothing staged => nothing to assert; NOT a miss. Injecting a floor here
+    // would push provenance text into sessions that never had recall to lose.
+    if (!marker)
+        return { landed: true, recovered: "none" };
+    const landed = messageTexts.some((t) => t.includes(marker));
+    if (landed)
+        return { landed: true, recovered: "none" };
+    // Absent: recompose when the runtime still holds pending blocks, else floor.
+    return { landed: false, recovered: hasPendingBlocks ? "recomposed" : "floor" };
+}
+/** Append `text` as a user-role tail message (same shape as recall-tail.ts). */
+function withFloorTail(view, text) {
+    const tailMsg = {
+        role: "user",
+        content: text,
+        timestamp: Date.now(),
+    };
+    return { messages: [...view.messages, tailMsg] };
+}
+/**
+ * Thin caller: verify (and if needed repair) one composed view. Returns the view
+ * to actually return from the handler. `sessionId` sources the floor checkpoints.
+ *
+ * The recompose rung deliberately re-appends via `withRecallTail` onto the
+ * ALREADY-COMPOSED view rather than re-running `buildTailResult`: the reshape
+ * stages (cache striping / message separation) are the realistic way a tail
+ * message gets regrouped away, and re-running the same composition would
+ * reproduce the same loss. Appending after the reshape is the actual repair, and
+ * it keeps the PREVENT-PI-001/002 tail-append invariant (a single user-role
+ * message after a complete prefix can never split a toolCall/toolResult pair).
+ */
+export function confirmInjection(runtime, config, view, sessionId) {
+    try {
+        if (!config.threeWayFailback)
+            return view;
+        // What the tail composition was supposed to inject. BOTH staged blocks
+        // count: withRecallTail joins recall + memory blocks into one tail
+        // message, so either one going missing is a real injection failure.
+        const staged = runtime.pendingRecallBlock ?? runtime.pendingMemoryRecallBlock ?? null;
+        // Can the recompose rung actually re-append? Only when a block is still
+        // staged on the runtime. When it is not (blocks consumed between
+        // composition and this check), or when withRecallTail declines to append,
+        // the ladder falls through to the floor rung below.
+        const hasPending = runtime.pendingRecallBlock != null ||
+            runtime.pendingMemoryRecallBlock != null;
+        // Legacy prepend mode: the block is not expected in the message list —
+        // verify our composed return value contains it instead (A3 degrade path).
+        if (!config.recallTailInject) {
+            const composed = view.messages.map(messageContentText).join("\n");
+            const marker = staged ? blockMarker(staged) : "";
+            runtime.appendEvent("injection_confirmed", {
+                mode: "prepend",
+                landed: marker ? composed.includes(marker) : true,
+            });
+            return view;
+        }
+        const verdict = decideInjection({ staged, tailMode: true }, view.messages.map(messageContentText), hasPending);
+        if (verdict.landed) {
+            runtime.appendEvent("injection_confirmed", { mode: "tail", landed: true });
+            return view;
+        }
+        if (verdict.recovered === "recomposed") {
+            const rebuilt = withRecallTail(view.messages, runtime, config);
+            // withRecallTail returns the input array unchanged on failure; only
+            // treat a genuine append as a recovery.
+            if (rebuilt.length > view.messages.length) {
+                runtime.appendEvent("injection_recovered", { via: "recomposed" });
+                return { messages: rebuilt };
+            }
+        }
+        const floor = buildFloorBlock(vectorList(runtime.store, normalizeSessionId(sessionId)));
+        runtime.appendEvent("injection_recovered", {
+            via: "floor",
+            basis: floor.basis,
+        });
+        return withFloorTail(view, floor.text);
+    }
+    catch {
+        // Non-fatal: return the unverified view (pre-sprint behavior).
+        return view;
+    }
+}

package/dist/extensions/mega-events/context-handler/triggerGuard.js

@@ -2,6 +2,7 @@ import { normalizeSessionId } from "../../../src/store.js";
 import { recall } from "../../../src/engine.js";
 import { formatRecallBlock } from "../../../src/recall.js";
 import { vectorStats, vectorList } from "../../../src/vectorStore.js";
+import { buildFloorBlock as sharedFloorBlock, FLOOR_UNAVAILABLE_TEXT, } from "../../../src/failback/floor.js";
 import { recentUserQuery } from "../../mega-runtime.js";
 /** One-shot completion marker per MegaRuntime (dies with the runtime). */
 const guardDone = new WeakMap();
@@ -61,26 +62,19 @@ export function runTriggerGuard(runtime, config, ctx) {
         /* never throws; best-effort guard */
     }
 }
-/** Build the provenance floor string from the session's newest checkpoint. */
+/**
+ * Build the provenance floor string from the session's newest checkpoint.
+ *
+ * 3WF-4: the text construction moved to the SHARED pure builder
+ * (src/failback/floor.ts) — this keeps the store read (`vectorList`, unfiltered,
+ * exactly as 3WF-1 shipped) and the string return type, so output is
+ * byte-identical to the pre-refactor version.
+ */
 function buildFloorBlock(runtime, sid) {
     try {
-        const cps = vectorList(runtime.store, sid);
-        let newest = cps[0];
-        for (const cp of cps) {
-            if (!newest || (cp.timestamp ?? 0) > (newest.timestamp ?? 0))
-                newest = cp;
-        }
-        const summary = newest?.summary?.trim();
-        if (summary) {
-            return ("The following compacted context is the most recent checkpoint from " +
-                "this session (recall found no query-relevant match):\n\n" + summary);
-        }
-        return ("This session has compacted context but recall could not surface a " +
-            "checkpoint relevant to the current request; the most recent checkpoint " +
-            "summary is unavailable.");
+        return sharedFloorBlock(vectorList(runtime.store, sid)).text;
     }
     catch {
-        return ("This session has compacted context but recall could not surface a " +
-            "checkpoint relevant to the current request.");
+        return FLOOR_UNAVAILABLE_TEXT;
     }
 }

package/dist/extensions/mega-events/context-handler.js

@@ -2,6 +2,7 @@ import { estimateSessionTokens } from "../../src/tokens.js";
 import { piCompactWouldNoop } from "../mega-pipeline.js";
 import { buildTailResult } from "./context-handler/tailResult.js";
 import { runTriggerGuard } from "./context-handler/triggerGuard.js";
+import { confirmInjection } from "./context-handler/injectionConfirm.js";
 import { persistEpochAndMaintain } from "./context-handler/afterCompact.js";
 import { appendMirrorAndLedger } from "./context-handler/dbMirrorAppend.js";
 import { evaluateGate, thrashGuardBlocks } from "./context-handler/gateCheck.js";
@@ -43,7 +44,22 @@ export function registerContextHandler(pi, runtime, config) {
         // tail message at any view-return point. Returns undefined when nothing
         // is staged (or the flag is OFF) so the caller falls through to its
         // normal return.
-        const tailResult = buildTailResult(runtime, config, messages);
+        const composeTail = buildTailResult(runtime, config, messages);
+        // 3WF-4 InjectionConfirm: wrap the tail factory so EVERY return point of
+        // this handler (gate / replay / debounce / thrash-guard / pipeline /
+        // live-trim) is verified — the staged block's marker must be present in
+        // the message list pi will send (tail mode), else we re-compose from the
+        // runtime's pending blocks and finally fall back to the shared floor.
+        // A composition that yields nothing staged (undefined) is passed through
+        // untouched, so flag-OFF and no-recall paths are byte-identical.
+        const tailResult = config.threeWayFailback
+            ? (msgs) => {
+                const view = composeTail(msgs);
+                if (!view)
+                    return view;
+                return confirmInjection(runtime, config, view, ctx.sessionManager.getSessionId());
+            }
+            : composeTail;
         // Always track context for the dashboard/widget, even when auto is off.
         // (v0.8 regression: !config.auto gate sat above this, leaving ctx stats
         // null -> widget '?% / ?/?' when auto disabled. Track first, THEN gate.)

package/dist/extensions/mega-pipeline/recall/impl.js

@@ -0,0 +1,258 @@
+/**
+ * recall/impl.ts — unified Layer-5 recall pipeline implementation (3WF-3 split).
+ *
+ * Behavior is UNCHANGED from the pre-split recall.ts. `doRecall` is the ONE path
+ * that injects (sync). `doRecallAsync` augments with optional cross-repo HNSW
+ * on resume / /mega-recall --cross-repo. Both mutate the shared MegaRuntime
+ * (token accounting, ticker, dashboard events). The shell recall.ts re-exports
+ * these names so `export * from "./mega-pipeline/recall.js"` stays byte-stable.
+ */
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+import { recallAndInline, recallAndInlineAsync, formatRecallBlock, } from "../../../src/recall.js";
+import { normalizeSessionId } from "../../../src/store.js";
+import { incRecallInjected, incCacheHitTokens, getIndexDir, } from "../../../src/store/sqlite.js";
+import { ensureConversationIdFor, recordTurnWrite, recordRecallWrite, } from "../../mega-turn-store.js";
+import { C } from "../../mega-runtime.js";
+import { recordRecallLatency } from "../../mega-runtime/vc-observer.js";
+/**
+ * Unified recall (Layer 5). The ONE path that injects. Returns the recall
+ * result; callers decide whether to stage it for before_agent_start (resume)
+ * or report it (command).
+ */
+export function doRecall(runtime, config, ctx, query, source) {
+    runtime.bindRepo(ctx.cwd);
+    const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
+    // Live window text for inline dedupe (Fix C): drop recalled checkpoints that
+    // are already resident in the session, so recall never re-injects context the
+    // model can already see. Best-effort — an empty window just skips dedupe.
+    const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
+    const recallStartMs = Date.now();
+    const result = recallAndInline({
+        sessionId: sid,
+        query,
+        limit: config.autoInlineK,
+        source,
+        skipInjected: true,
+        recallMaxTokens: config.recallMaxTokens,
+        windowDedupe: config.windowDedupe,
+        liveWindow,
+        dedupSim: config.dedupSim,
+    }, runtime.store);
+    runtime.dashboard.event("recall", {
+        source,
+        query: query.slice(0, 120),
+        injected: result.toInject.length,
+        empty: result.empty,
+    });
+    if (config.ragRecallMetrics && result.hydeInfo) {
+        runtime.dashboard.event("hyde_executed", {
+            sessionId: sid,
+            ran: result.hydeInfo.ran,
+            skipped: result.hydeInfo.skipped,
+            reason: result.hydeInfo.reason,
+            hypotheticalDoc: result.hydeInfo.hypotheticalDoc.slice(0, 400),
+            generationMs: result.hydeInfo.generationMs,
+            rawHitCount: result.hydeInfo.rawHitCount,
+            hydeHitCount: result.hydeInfo.hydeHitCount,
+            fusedHitCount: result.hydeInfo.fusedHitCount,
+            lift: result.hydeInfo.lift,
+        });
+    }
+    if (config.ragRecallMetrics && result.recallMetrics) {
+        runtime.dashboard.event("recall_metrics", {
+            sessionId: sid,
+            hitCount: result.recallMetrics.hitCount,
+            score: result.recallMetrics.score,
+            pass: result.recallMetrics.pass,
+            relevance: result.recallMetrics.relevance,
+            coverage: result.recallMetrics.coverage,
+            diversity: result.recallMetrics.diversity,
+            specificity: result.recallMetrics.specificity,
+        });
+    }
+    if (!result.empty && result.toInject.length > 0) {
+        const top = result.toInject[0];
+        const scorePct = Math.round((top.score ?? 0) * 100);
+        const files = top.checkpoint.filesModified ?? [];
+        const label = files.length
+            ? files
+                .map((f) => f.split("/").pop() ?? f)
+                .slice(0, 2)
+                .join(", ")
+            : top.checkpoint.checkpointId;
+        runtime.pushTicker(`${C.amber}↩${C.reset} recalled ${top.checkpoint.checkpointId} · ${scorePct}% · ${label}`);
+        runtime.lastWhy = `why: recalled@${scorePct}% (${result.toInject.length} chkpt)`;
+    }
+    let sumTokens = 0;
+    for (const h of result.toInject)
+        sumTokens += h.checkpoint.tokenEstimate;
+    if (result.toInject.length > 0) {
+        runtime.rt.recallInjections += result.toInject.length;
+        runtime.rt.cacheHitTokens += sumTokens;
+        incRecallInjected(result.toInject.length, runtime.currentStateDir);
+        incCacheHitTokens(sumTokens, runtime.currentStateDir);
+    }
+    // S43: record recall provenance — which checkpoints/summaries served this
+    // turn, their score + source path. Linked to the turn row written at
+    // turn_end via the conversation+turnIndex. Best-effort + non-fatal.
+    // Persists telemetry (HyDE + recall metrics) even when recall returned
+    // no hits, so empty-recall HyDE invocations are still visible in the
+    // dashboard Turns/Metrics tabs.
+    const hasTelemetry = result.hydeInfo != null || result.recallMetrics != null;
+    if (result.toInject.length > 0 || hasTelemetry) {
+        try {
+            const convId = ensureConversationIdFor(config, sid, runtime.currentStateDir);
+            const turnId = recordTurnWrite(config, {
+                conversationId: convId,
+                sessionId: sid,
+                turnIndex: runtime.currentTurn,
+                role: "assistant",
+                startedAt: Date.now(),
+                hyde: result.hydeInfo ?? undefined,
+                recallMetrics: result.recallMetrics ?? undefined,
+            }, runtime.currentStateDir);
+            if (result.toInject.length > 0) {
+                recordRecallWrite(config, turnId, result.toInject.map((h) => ({
+                    checkpointId: h.checkpoint.checkpointId,
+                    score: h.score,
+                    source: h.raptorLevel !== undefined
+                        ? "raptor"
+                        : h.repoId
+                            ? "cross-repo"
+                            : "flat",
+                    raptorLevel: h.raptorLevel,
+                })), runtime.currentStateDir);
+            }
+        }
+        catch {
+            /* non-fatal: recall provenance never breaks the recall path */
+        }
+    }
+    // VC0A: record recall latency on the eval observer (mode A) so the dashboard
+    // histogram reflects real data. No-op when the observer is absent (flag off /
+    // construction failure).
+    try {
+        recordRecallLatency(runtime, Date.now() - recallStartMs, sid, 0);
+    }
+    catch {
+        /* non-fatal: latency recording never breaks recall */
+    }
+    return result;
+}
+/**
+ * S17: async recall with optional cross-repo augmentation. Used on resume
+ * (session_start) and /mega-recall --cross-repo — NEVER from the mid-turn
+ * context handler (that stays sync). Runs the sync same-repo scan first; if it
+ * returns < config.autoInlineK hits AND crossRepo is enabled, awaits the PGlite
+ * HNSW cross-repo path and merges (source-labeled, deduped by checkpointId). The
+ * recallMaxTokens cap + windowDedupe apply to the merged set so cross-repo can
+ * never net-inflate the window. Cross-repo uses a stricter cosine floor
+ * (config.crossRepoCosine) than same-repo. Non-fatal: any async failure returns
+ * the same-repo result unchanged.
+ */
+export async function doRecallAsync(runtime, config, ctx, query, source, opts = {}) {
+    runtime.bindRepo(ctx.cwd);
+    const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
+    const liveWindow = config.windowDedupe ? extractLiveWindow(ctx) : undefined;
+    // Sync same-repo first (fast, never blocks).
+    const sameRepo = recallAndInline({
+        sessionId: sid,
+        query,
+        limit: config.autoInlineK,
+        source,
+        skipInjected: true,
+        recallMaxTokens: config.recallMaxTokens,
+        windowDedupe: config.windowDedupe,
+        liveWindow,
+        dedupSim: config.dedupSim,
+    }, runtime.store);
+    if (!config.crossRepoEnabled || !opts.crossRepo)
+        return sameRepo;
+    if (sameRepo.toInject.length >= config.autoInlineK)
+        return sameRepo; // same-repo satisfied
+    // Augment: cross-repo HNSW (async) with the stricter floor. Non-fatal.
+    try {
+        const x = await recallAndInlineAsync({
+            sessionId: sid,
+            query,
+            limit: config.autoInlineK,
+            source,
+            skipInjected: true,
+            recallMaxTokens: config.recallMaxTokens,
+            windowDedupe: config.windowDedupe,
+            liveWindow,
+            dedupSim: config.crossRepoCosine,
+            crossRepo: true,
+            // F2: resolve the machine-wide index dir via the shared resolver so the
+            // cross-repo injected-set dedup works even when MEGACOMPACT_INDEX_DIR is
+            // unset. The env var still wins when set (getIndexDir checks it first);
+            // the default (~/.mega-compact-index) is the same DB mega-commands and the
+            // dashboard read, so injection counts stay consistent. Without this, a
+            // bare `process.env` read returns undefined → cross-repo hits re-inject in
+            // every new session (the global injected-set is never consulted).
+            globalIndexDir: getIndexDir(),
+        }, runtime.store);
+        runtime.dashboard.event("recall-crossrepo", {
+            source,
+            query: query.slice(0, 120),
+            injected: x.toInject.length,
+            sourceRepos: x.toInject.map((h) => h.repoId).filter(Boolean),
+        });
+        // Merge, dedup by checkpointId, respect the same token cap by reformatting.
+        const seen = new Set(sameRepo.toInject.map((h) => h.checkpoint.checkpointId));
+        const merged = [...sameRepo.toInject];
+        for (const h of x.toInject) {
+            if (!seen.has(h.checkpoint.checkpointId)) {
+                merged.push(h);
+                seen.add(h.checkpoint.checkpointId);
+            }
+        }
+        const block = merged.length ? formatRecallBlock(merged) : "";
+        if (merged.length > 0) {
+            let sumTokens = 0;
+            for (const h of merged)
+                sumTokens += h.checkpoint.tokenEstimate;
+            runtime.rt.recallInjections += merged.length;
+            runtime.rt.cacheHitTokens += sumTokens;
+            incRecallInjected(merged.length, runtime.currentStateDir);
+            incCacheHitTokens(sumTokens, runtime.currentStateDir);
+        }
+        return {
+            toInject: merged,
+            report: merged.map((h) => `  • ${h.checkpoint.checkpointId}${h.repoId ? ` (from ${h.repoId.split("/").filter(Boolean).pop()})` : ""}`),
+            block,
+            empty: merged.length === 0,
+            // H1: merged cross-repo result reuses the same-repo pass's telemetry.
+            hydeInfo: sameRepo.hydeInfo,
+            recallMetrics: sameRepo.recallMetrics,
+        };
+    }
+    catch {
+        return sameRepo; // cross-repo failure → same-repo only (non-fatal)
+    }
+}
+/**
+ * Extract the live-window message texts from the session manager (Fix C),
+ * for inline-dedupe of recalled checkpoints. Best-effort: returns [] on any
+ * error so recall falls back to unbounded (still correct, just no dedupe).
+ * Mirrors recentUserQuery's use of sessionEntryToContextMessages.
+ */
+export function extractLiveWindow(ctx) {
+    try {
+        const entries = ctx.sessionManager.getEntries();
+        const texts = [];
+        for (const e of entries) {
+            for (const m of sessionEntryToContextMessages(e)) {
+                const c = m.content;
+                if (typeof c === "string")
+                    texts.push(c);
+                else if (Array.isArray(c))
+                    texts.push(c.map((b) => b.text ?? "").join(" "));
+            }
+        }
+        return texts;
+    }
+    catch {
+        return [];
+    }
+}