pi-mega-compact 0.6.9 → 0.7.1

package/dist/extensions/mega-events.js

@@ -8,13 +8,13 @@
  */
 import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
-import { estimateSessionTokens } from "../src/tokens.js";
-import { recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
-import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop, runMemoryReview } from "./mega-pipeline.js";
+import { estimateSessionTokens, estimateBlockTokens } from "../src/tokens.js";
+import { recentUserQuery, WIDGET_KEY, } from "./mega-runtime.js";
+import { runCompact, doRecall, doRecallAsync, piCompactWouldNoop, runMemoryReview, } from "./mega-pipeline.js";
 import { recallMemoriesAndInline } from "../src/recall.js";
-import { driveNativeCompaction } from "./mega-compact-driver.js";
+import { driveNativeCompaction, } from "./mega-compact-driver.js";
 import { computeLiveTrimCut, liveTrimSummaryMessage } from "./mega-trim.js";
-import { pressureFromPct, memoryReviewCadence } from "./mega-config.js";
+import { pressureFromPct, memoryReviewCadence, } from "./mega-config.js";
 /**
  * DIAG accessor for the headless test harness: the most recently constructed
  * MegaRuntime, so a test that loads the compiled extension via its default
@@ -52,19 +52,30 @@ export function registerEventHandlers(pi, runtime, config) {
                 // S17: use the async variant on resume so cross-repo HNSW recall can
                 // augment when this repo's store is thin. session_start is an async-safe
                 // point (unlike the mid-turn context handler, which stays sync).
-                const r = await doRecallAsync(runtime, config, ctx, query, "resume", { crossRepo: config.crossRepoEnabled });
+                const r = await doRecallAsync(runtime, config, ctx, query, "resume", {
+                    crossRepo: config.crossRepoEnabled,
+                });
                 if (!r.empty) {
                     runtime.pendingRecallBlock = r.block;
-                    const crossLabel = r.toInject.some((h) => h.repoId) ? " (cross-repo)" : "";
+                    const crossLabel = r.toInject.some((h) => h.repoId)
+                        ? " (cross-repo)"
+                        : "";
                     runtime.setStatus(ctx, `mega-compact: recalled ${r.toInject.length} chkpt${crossLabel}`);
-                    runtime.logger.info("auto-inline", { reason: event.reason, query, injected: r.toInject.map((h) => h.checkpoint.checkpointId), crossRepo: r.toInject.some((h) => h.repoId) });
+                    runtime.logger.info("auto-inline", {
+                        reason: event.reason,
+                        query,
+                        injected: r.toInject.map((h) => h.checkpoint.checkpointId),
+                        crossRepo: r.toInject.some((h) => h.repoId),
+                    });
                 }
             }
             // S21: parallel memory recall. Same async context so we can await without
             // breaking the handler contract. Best-effort — never throws.
             try {
                 const mr = await recallMemoriesAndInline({
-                    query, stateDir: runtime.getStateDir(), limit: 5,
+                    query,
+                    stateDir: runtime.getStateDir(),
+                    limit: 5,
                     crossRepo: config.crossRepoEnabled,
                     crossRepoCosine: config.crossRepoCosine,
                 });
@@ -75,7 +86,10 @@ export function registerEventHandlers(pi, runtime, config) {
                 runtime.logger.warn("memory-recall skipped", { err: String(err) });
             }
         }
-        runtime.dashboard.event("session_start", { reason: event.reason, sessionId: runtime.rt.sessionId });
+        runtime.dashboard.event("session_start", {
+            reason: event.reason,
+            sessionId: runtime.rt.sessionId,
+        });
         runtime.snapshot(ctx);
     });
     pi.on("session_tree", async (_event, ctx) => {
@@ -89,11 +103,21 @@ export function registerEventHandlers(pi, runtime, config) {
                 const r = doRecall(runtime, config, ctx, query, "resume");
                 if (!r.empty) {
                     runtime.pendingRecallBlock = r.block;
-                    runtime.logger.info("auto-inline", { reason: "session_tree", query, injected: r.toInject.map((h) => h.checkpoint.checkpointId) });
+                    runtime.logger.info("auto-inline", {
+                        reason: "session_tree",
+                        query,
+                        injected: r.toInject.map((h) => h.checkpoint.checkpointId),
+                    });
                 }
                 // S21: parallel memory recall. Trigram embedder is sub-ms; await is fine.
                 try {
-                    const mr = await recallMemoriesAndInline({ query, stateDir: runtime.getStateDir(), limit: 5, crossRepo: config.crossRepoEnabled, crossRepoCosine: config.crossRepoCosine });
+                    const mr = await recallMemoriesAndInline({
+                        query,
+                        stateDir: runtime.getStateDir(),
+                        limit: 5,
+                        crossRepo: config.crossRepoEnabled,
+                        crossRepoCosine: config.crossRepoCosine,
+                    });
                     if (!mr.empty)
                         runtime.pendingMemoryRecallBlock = mr.block;
                 }
@@ -102,7 +126,9 @@ export function registerEventHandlers(pi, runtime, config) {
                 }
             }
         }
-        runtime.dashboard.event("session_tree", { sessionId: runtime.rt.sessionId });
+        runtime.dashboard.event("session_tree", {
+            sessionId: runtime.rt.sessionId,
+        });
         runtime.snapshot(ctx);
     });
     // ---- Auto-inline injection point: prepend staged recall to systemPrompt ----
@@ -126,7 +152,9 @@ export function registerEventHandlers(pi, runtime, config) {
     // ---- Agent tracking for real-time widget + status-line updates ---------
     pi.on("agent_start", async (_event, ctx) => {
         runtime.activeAgents++;
-        runtime.dashboard.event("agent_start", { activeAgents: runtime.activeAgents });
+        runtime.dashboard.event("agent_start", {
+            activeAgents: runtime.activeAgents,
+        });
         // Surface live agent activity on the status line (toolbar), not just the
         // above-editor widget — otherwise concurrent agents look frozen.
         runtime.setStatus(ctx, `mega-compact: ▶ ${runtime.activeAgents} agent${runtime.activeAgents === 1 ? "" : "s"}`);
@@ -134,7 +162,9 @@ export function registerEventHandlers(pi, runtime, config) {
     });
     pi.on("agent_end", async (_event, ctx) => {
         runtime.activeAgents = Math.max(0, runtime.activeAgents - 1);
-        runtime.dashboard.event("agent_end", { activeAgents: runtime.activeAgents });
+        runtime.dashboard.event("agent_end", {
+            activeAgents: runtime.activeAgents,
+        });
         if (runtime.activeAgents > 0) {
             runtime.setStatus(ctx, `mega-compact: ▶ ${runtime.activeAgents} agent${runtime.activeAgents === 1 ? "" : "s"}`);
         }
@@ -153,7 +183,7 @@ export function registerEventHandlers(pi, runtime, config) {
                 // DIAG (team-run relief): surface whether the agent is idle + over
                 // threshold at agent_end so we can see if a mid-run durable-trim trigger
                 // *should* have fired but didn't.
-                const overThreshold = (runtime.lastCtxTokens ?? 0) >= config.thresholdTokens;
+                const overThreshold = (runtime.lastCtxTokens ?? 0) >= runtime.effectiveThreshold;
                 runtime.diagAgentEndIdle++;
                 runtime.logger.info("agent-end-idle", {
                     sessionId: runtime.rt.sessionId,
@@ -163,7 +193,9 @@ export function registerEventHandlers(pi, runtime, config) {
                     ctxPct: runtime.lastCtxPercent,
                     ctxTokens: runtime.lastCtxTokens,
                     thresholdTokens: config.thresholdTokens,
-                    wouldNudge: idle && queued && now >= runtime.resumeNudgeUntil,
+                    wouldNudge: idle &&
+                        (queued || overThreshold) &&
+                        now >= runtime.resumeNudgeUntil,
                 });
                 // S16+S24: MID-RUN DURABLE TRIM. During a long team run (sub-agents),
                 // pi's native durable compaction only fires from _checkCompaction at
@@ -178,6 +210,18 @@ export function registerEventHandlers(pi, runtime, config) {
                 // pi would actually compact (piCompactWouldNoop skips the user-facing
                 // no-op throw), and debounced (one durable trim per 2s) to avoid
                 // thrashing the transcript while sub-agents keep settling.
+                //
+                // FIX "compacts but doesn't resume": the manual ctx.compact() path
+                // STOPS the agent loop (agent-session.js:1345). The old resume-nudge
+                // was gated on `queued`, so when a sub-agent settled with no
+                // *immediately* queued message, the trim fired but the nudge did not,
+                // and the (stopped) session hung. The trim still fires on
+                // `idle && overThreshold` — we intentionally do NOT add a `!queued`
+                // guard, because that would suppress mid-run relief exactly during
+                // team-run waves where queued is usually true and relief is needed
+                // most. Instead we DECOUPLE the nudge from `queued`: after a durable
+                // trim we ALWAYS nudge so the agent reliably restarts. Debounced 30s.
+                let didDurableTrim = false;
                 if (idle && overThreshold && now >= runtime.debounceUntil) {
                     if (!piCompactWouldNoop(ctx)) {
                         runtime.debounceUntil = now + 2000;
@@ -186,11 +230,18 @@ export function registerEventHandlers(pi, runtime, config) {
                             sessionId: runtime.rt.sessionId,
                             ctxTokens: runtime.lastCtxTokens,
                             thresholdTokens: config.thresholdTokens,
+                            queued,
                         });
                         ctx.compact({ customInstructions: undefined }); // guardrails-allow PREVENT-PI-004: local ctx.compact() — no network; agent settled so no in-flight abort
+                        didDurableTrim = true;
                     }
                 }
-                if (idle && queued && now >= runtime.resumeNudgeUntil) {
+                // Restart the agent after a mid-run durable trim (which stopped it), or
+                // when it settled idle with queued work. Decoupled from `queued` for the
+                // durable-trim case — see FIX note above. Debounced 30s; never blocks.
+                if (idle &&
+                    now >= runtime.resumeNudgeUntil &&
+                    (didDurableTrim || queued)) {
                     runtime.resumeNudgeUntil = now + 30_000;
                     pi.sendUserMessage("[mega-compact] continue from the compacted context above.");
                 }
@@ -255,14 +306,15 @@ export function registerEventHandlers(pi, runtime, config) {
             return;
         const messages = event.messages;
         const view = runtime.engineView(messages);
-        const currentTokens = usage?.tokens ?? estimateSessionTokens(view) ??
+        const currentTokens = usage?.tokens ??
+            estimateSessionTokens(view) ??
             Math.round((pct / 100) * (usage?.contextWindow ?? 0));
-        // FAST GATE: token-based (tier threshold), not percentage-based.
-        if (currentTokens < config.thresholdTokens) {
+        // FAST GATE: token-based (tier% of the window), not a static amount.
+        if (currentTokens < runtime.effectiveThreshold) {
             runtime.diagCtxFastGate++;
             return;
         }
-        const check = autoCompactCheck(currentTokens, config.thresholdTokens); // SERVER-STYLE CONFIRM (local)
+        const check = autoCompactCheck(currentTokens, runtime.effectiveThreshold); // SERVER-STYLE CONFIRM (local)
         if (!check.shouldCompact) {
             runtime.diagCtxNoCompact++;
             return;
@@ -277,7 +329,9 @@ export function registerEventHandlers(pi, runtime, config) {
         // Adaptive compression (Fix E): scale compression strength + keepFrom depth
         // with how close we are to the model context limit.
         const pressure = pressureFromPct(pct);
-        const ran = runCompact(pi, runtime, config, ctx, messages, { compressionPressure: pressure });
+        const ran = runCompact(pi, runtime, config, ctx, messages, {
+            compressionPressure: pressure,
+        });
         if (ran.skipped) {
             runtime.diagCtxRunSkipped++;
             return;
@@ -287,7 +341,9 @@ export function registerEventHandlers(pi, runtime, config) {
         // Read live from env (in addition to the load-time config) so the flag can be
         // toggled per-test without reloading the module; config.legacyDurableTrim is
         // the cached default. (Mirrors how piCompactWouldNoop re-reads its floor.)
-        const legacy = config.legacyDurableTrim || process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "true" || process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "1";
+        const legacy = config.legacyDurableTrim ||
+            process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "true" ||
+            process.env.MEGACOMPACT_LEGACY_DURABLE_TRIM === "1";
         if (legacy) {
             if (piCompactWouldNoop(ctx))
                 return;
@@ -305,7 +361,9 @@ export function registerEventHandlers(pi, runtime, config) {
         // without reloading the module.
         try {
             const anchorEnv = process.env.MEGACOMPACT_ANCHOR_USER_MESSAGES;
-            const anchorUserMessages = (anchorEnv != null && anchorEnv !== "" && Number.isFinite(Number(anchorEnv)))
+            const anchorUserMessages = anchorEnv != null &&
+                anchorEnv !== "" &&
+                Number.isFinite(Number(anchorEnv))
                 ? Number(anchorEnv)
                 : config.anchorUserMessages;
             const cut = computeLiveTrimCut(view, {
@@ -382,7 +440,7 @@ export function registerEventHandlers(pi, runtime, config) {
             return {}; // let pi run its own native compaction
         try {
             const result = driveNativeCompaction(event, runtime, config);
-            if (result) {
+            if (result && result.compaction.summary?.trim()) {
                 runtime.diagBeforeCompactSupplied++;
                 runtime.logger.info("native-compact", {
                     sessionId: runtime.rt.sessionId,
@@ -390,8 +448,30 @@ export function registerEventHandlers(pi, runtime, config) {
                     tokensBefore: result.compaction.tokensBefore,
                     summaryTokens: result.compaction.estimatedTokensAfter,
                 });
+                nudgeResume(pi, runtime);
                 return { compaction: result.compaction };
             }
+            // FIX "compacts but doesn't resume" + "Nothing to compact" regression:
+            // when we have nothing to summarize (anchor floor protects everything →
+            // messagesToSummarize empty) or our Trident/RAPTOR summary came back
+            // EMPTY, pi's OWN compact() throws "Nothing to compact (session too
+            // small)" and leaves the session stuck with no resume context. Instead
+            // of returning {} (which makes pi run its throwing compact()), supply a
+            // fallback compaction from prep.firstKeptEntryId with a minimal resume
+            // summary. This ALWAYS injects a compact summary so the session
+            // resumes, and never surfaces the "Nothing to compact" error to the user.
+            const fb = fallbackCompaction(event);
+            if (fb) {
+                runtime.diagBeforeCompactSupplied++;
+                runtime.logger.info("native-compact-fallback", {
+                    sessionId: runtime.rt.sessionId,
+                    firstKeptEntryId: fb.compaction.firstKeptEntryId,
+                    tokensBefore: fb.compaction.tokensBefore,
+                    reason: event.reason,
+                });
+                nudgeResume(pi, runtime);
+                return { compaction: fb.compaction };
+            }
         }
         catch (err) {
             runtime.logger.error("native-compact-failed", {
@@ -399,7 +479,51 @@ export function registerEventHandlers(pi, runtime, config) {
                 error: String(err instanceof Error ? err.message : err),
             });
         }
-        // Fall back to pi's own native compaction if we can't supply one.
+        // Absolute last resort: let pi run its own (may throw "Nothing to compact").
         return {};
     });
+    /**
+     * Build a minimal fallback compaction so pi never runs its throwing compact().
+     *
+     * Used when our Trident/RAPTOR summary is empty or there is nothing to
+     * summarize (the anchor floor protects every message). We still record a
+     * resume summary + truncate from prep.firstKeptEntryId so the session always
+     * gets a compact summary and resumes. Returns undefined only if pi handed us
+     * no preparation cut point at all.
+     */
+    function fallbackCompaction(event) {
+        const prep = event.preparation;
+        if (!prep?.firstKeptEntryId)
+            return undefined;
+        // When messagesToSummarize is empty the anchor floor protects everything,
+        // so firstKeptEntryId == current first entry and the trim is a no-op — but
+        // we still record a resume summary so the session has context after compaction.
+        const tokensBefore = prep.tokensBefore ?? 0;
+        const summary = `[mega-compact] context compacted at ${tokensBefore.toLocaleString()} tokens ` +
+            `(anchor floor active). Continue from the most recent messages above.`;
+        return {
+            compaction: {
+                summary,
+                firstKeptEntryId: prep.firstKeptEntryId,
+                tokensBefore,
+                estimatedTokensAfter: estimateBlockTokens(summary),
+            },
+        };
+    }
+    /**
+     * Debounced resume-nudge: restart the agent loop after a compaction (which
+     * may have stopped it). Idempotent — one nudge per 30s, never blocks.
+     */
+    function nudgeResume(pi, runtime) {
+        try {
+            const now = Date.now();
+            if (now >= runtime.resumeNudgeUntil) {
+                runtime.resumeNudgeUntil = now + 30_000;
+                pi.sendUserMessage("[mega-compact] continue from the compacted context above.");
+            }
+        }
+        catch {
+            /* non-fatal: a failed nudge never blocks */
+        }
+    }
 }

package/dist/extensions/mega-pipeline.js

@@ -8,13 +8,13 @@
  */
 import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import { compactSession } from "../src/engine.js";
-import { recallAndInline, recallAndInlineAsync, formatRecallBlock } from "../src/recall.js";
+import { recallAndInline, recallAndInlineAsync, formatRecallBlock, } from "../src/recall.js";
 import { normalizeSessionId } from "../src/store.js";
 import { estimateBlockTokens } from "../src/tokens.js";
 import { touchSession, logDaily } from "../src/store/sqlite.js";
 import { consolidateMemories } from "../src/memory.js";
-import { C, MARKER_TYPE, } from "./mega-runtime.js";
-import { resolveRepoRoot, preserveRecentForPressure } from "./mega-config.js";
+import { C, MARKER_TYPE } from "./mega-runtime.js";
+import { resolveRepoRoot, preserveRecentForPressure, } from "./mega-config.js";
 import { runRaptor } from "../src/dedup/raptor/index.js";
 import { loadDedupConfig } from "../src/config/dedup.js";
 import { upsertEmbedding as indexUpsertEmbedding } from "../src/store/vectorIndex.js";
@@ -104,18 +104,23 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
         ? result.originalTokenEstimate
         : Math.max(0, result.originalTokenEstimate - result.tokenEstimate);
     runtime.rt.tokensSaved += saved;
+    runtime.rt.lastCompactAt = Date.now();
     if (result.deduped)
         runtime.rt.dedupSkips++;
     // Grow the rolling "saved" goal so the progress bar always has a fresh
     // denominator (we don't want it pinned at 100% once we pass an old target).
     if (runtime.rt.tokensSaved > runtime.savedGoal)
-        runtime.savedGoal = Math.ceil((runtime.rt.tokensSaved * 1.25) / 10_000) * 10_000;
+        runtime.savedGoal =
+            Math.ceil((runtime.rt.tokensSaved * 1.25) / 10_000) * 10_000;
     // Live toolbar activity: what file/region just got compacted or deduped.
     // Rendered via the rotating ticker line (see snapshot); the ring buffer is
     // cycled one-per-repaint so the single line scrolls through recent files.
     const files = result.filesModified ?? [];
     const fileLabel = files.length
-        ? files.map((f) => f.split("/").pop() ?? f).slice(0, 2).join(", ")
+        ? files
+            .map((f) => f.split("/").pop() ?? f)
+            .slice(0, 2)
+            .join(", ")
         : result.regionHash.slice(0, 8);
     runtime.lastActivityAt = Date.now();
     // Explain-why line: surfaced while fresh. Pulls the dedup reason (which for
@@ -167,7 +172,10 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     // waiting for the next turn-cadence tick. Uses the shared runMemoryReview
     // helper (fire-and-forget; doCompact is sync). Best-effort + non-fatal. Only
     // fires above the `high` band so low-pressure compactions don't pay the cost.
-    if (!result.deduped && config.memoryAutoReview && runtime.pressureBand !== "low" && runtime.pressureBand !== "medium") {
+    if (!result.deduped &&
+        config.memoryAutoReview &&
+        runtime.pressureBand !== "low" &&
+        runtime.pressureBand !== "medium") {
         void runMemoryReview(runtime, view, "pressure");
     }
     // Sentinel marker: a non-LLM bookkeeping entry so subsequent triggers can
@@ -195,7 +203,9 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
                 // S25: stamp the tree with the newest checkpoint epoch so the
                 // freshness guard in raptorSearchHits can reject stale trees after a
                 // later compaction adds newer checkpoints.
-                const builtAt = all.length > 0 ? Math.max(...all.map((c) => c.timestamp)) : Date.now();
+                const builtAt = all.length > 0
+                    ? Math.max(...all.map((c) => c.timestamp))
+                    : Date.now();
                 runRaptor(leaves, {
                     stateDir: runtime.currentStateDir,
                     sessionId: sid,
@@ -313,7 +323,8 @@ export function piCompactWouldNoop(ctx) {
                 if (m.role !== "toolResult")
                     isCut = true;
                 const c = m.content;
-                const text = typeof c === "string" ? c
+                const text = typeof c === "string"
+                    ? c
                     : Array.isArray(c)
                         ? c.map((b) => b?.text ?? "").join(" ")
                         : "";
@@ -366,12 +377,22 @@ export function doRecall(runtime, config, ctx, query, source) {
         liveWindow,
         dedupSim: config.dedupSim,
     }, runtime.store);
-    runtime.dashboard.event("recall", { source, query: query.slice(0, 120), injected: result.toInject.length, empty: result.empty });
+    runtime.dashboard.event("recall", {
+        source,
+        query: query.slice(0, 120),
+        injected: result.toInject.length,
+        empty: result.empty,
+    });
     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;
+        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)`;
     }
@@ -394,9 +415,15 @@ export async function doRecallAsync(runtime, config, ctx, query, source, opts =
     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,
+        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;
@@ -405,13 +432,22 @@ export async function doRecallAsync(runtime, config, ctx, query, source, opts =
     // 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,
+            sessionId: sid,
+            query,
+            limit: config.autoInlineK,
+            source,
+            skipInjected: true,
+            recallMaxTokens: config.recallMaxTokens,
+            windowDedupe: config.windowDedupe,
+            liveWindow,
+            dedupSim: config.crossRepoCosine,
+            crossRepo: true,
             globalIndexDir: process.env.MEGACOMPACT_INDEX_DIR,
         }, runtime.store);
         runtime.dashboard.event("recall-crossrepo", {
-            source, query: query.slice(0, 120), injected: x.toInject.length,
+            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.