pi-mega-compact 0.4.20 → 0.4.23

package/dist/extensions/mega-events.js

@@ -9,9 +9,10 @@
 import { normalizeSessionId } from "../src/store.js";
 import { autoCompactCheck } from "../src/compact.js";
 import { estimateSessionTokens } from "../src/tokens.js";
-import { dropCompactedRange } from "../src/adapt.js";
 import { recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
 import { runCompact, doRecall } from "./mega-pipeline.js";
+import { driveNativeCompaction } from "./mega-compact-driver.js";
+import { pressureFromPct } from "./mega-config.js";
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi, runtime, config) {
     // ---- Session lifecycle (state reset points) -------------------------------
@@ -108,7 +109,15 @@ export function registerEventHandlers(pi, runtime, config) {
         runtime.dashboard.event("turn_end", { turnIndex: event.turnIndex });
         runtime.snapshot(ctx);
     });
-    // ---- Auto-trigger: fast-gate → confirm → Trident+persist → drop --------
+    // ---- Auto-trigger: own the decision, pi owns the durable write ----------
+    // OUR auto-trigger (over threshold + debounce): persist our Trident checkpoint,
+    // then start pi's compaction flow via ctx.compact(). That fires
+    // `session_before_compact`, where OUR handler returns our summary +
+    // firstKeptEntryId, and pi durably writes the trim to disk (appendCompaction).
+    // Result: auto-compact AND a durable trim — resume reloads the trimmed window,
+    // no full-reload + additive recall inflation (Fix B kills the token-growth bug).
+    // We do NOT drop messages here (that would be ephemeral; the read-only session
+    // manager can't trim disk, so the trim has to come through pi).
     pi.on("context", async (event, ctx) => {
         if (!config.auto)
             return;
@@ -123,13 +132,9 @@ export function registerEventHandlers(pi, runtime, config) {
             return;
         const messages = event.messages;
         const view = runtime.engineView(messages);
-        // Prefer the runtime's real token estimate; fall back to our heuristic
-        // (and to a percent-of-window proxy when tokens is unknown).
         const currentTokens = usage?.tokens ?? estimateSessionTokens(view) ??
             Math.round((pct / 100) * (usage?.contextWindow ?? 0));
         // FAST GATE: token-based (tier threshold), not percentage-based.
-        // A 20% gate on a 2M window = 400k, which is way above the 50k low-tier
-        // threshold. Gate on the actual token count instead.
         if (currentTokens < config.thresholdTokens)
             return;
         const check = autoCompactCheck(currentTokens, config.thresholdTokens); // SERVER-STYLE CONFIRM (local)
@@ -140,28 +145,45 @@ export function registerEventHandlers(pi, runtime, config) {
         if (now < runtime.debounceUntil)
             return;
         runtime.debounceUntil = now + 2000;
-        const ran = runCompact(pi, runtime, config, ctx, messages);
+        // 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 });
         if (ran.skipped)
             return;
-        // DROP the compacted range from the outgoing context, honoring the anchor
-        // floor + tool-pair boundary guards (PREVENT-PI-001/002).
-        const kept = dropCompactedRange(messages, ran.keepFrom, config.anchorUserMessages);
-        if (kept.length < messages.length) {
-            return { messages: kept };
-        }
+        // Start pi's compaction flow so our session_before_compact handler can
+        // supply the durable trim (pi writes it to disk). We never use pi's summary.
+        ctx.compact({ customInstructions: undefined });
     });
-    // ---- Cancel native compaction once we've persisted our own -------------
-    pi.on("session_before_compact", async (_event, ctx) => {
+    // ---- Supply a DURABLE trim to pi's native compaction (Fix B) ----------
+    // We run the Trident pipeline to produce a compressed summary, then return
+    // it as a CompactionResult. pi writes the summary into a compactionSummary
+    // entry AND truncates the on-disk transcript from firstKeptEntryId. This is
+    // the durable fix for "tokens grow on read": the trim survives resume, so
+    // there is no full-reload + additive recall inflation.
+    pi.on("session_before_compact", async (event, ctx) => {
         runtime.resetRuntime(ctx.sessionManager.getSessionId());
-        if (runtime.rt.persistedThisSession) {
-            // We already persisted a checkpoint for this session (via the context
-            // hook drop) — cancel pi's own compaction to avoid double-compacting.
-            // Our context-hook drop already trimmed the window.
-            return { cancel: true };
+        if (!config.auto)
+            return {}; // let pi run its own native compaction
+        try {
+            const result = driveNativeCompaction(event, runtime, config);
+            if (result) {
+                runtime.logger.info("native-compact", {
+                    sessionId: runtime.rt.sessionId,
+                    firstKeptEntryId: result.compaction.firstKeptEntryId,
+                    tokensBefore: result.compaction.tokensBefore,
+                    summaryTokens: result.compaction.estimatedTokensAfter,
+                });
+                return { compaction: result.compaction };
+            }
+        }
+        catch (err) {
+            runtime.logger.error("native-compact-failed", {
+                sessionId: runtime.rt.sessionId,
+                error: String(err instanceof Error ? err.message : err),
+            });
         }
-        // We haven't persisted yet this session: let pi run its native compaction.
-        // (Our auto-trigger only fires again past the threshold, and will then
-        // capture a checkpoint next time around.)
+        // Fall back to pi's own native compaction if we can't supply one.
         return {};
     });
 }

package/dist/extensions/mega-pipeline.js

@@ -6,12 +6,15 @@
  * the shared MegaRuntime (token accounting, ticker, status, events) and are
  * driven by the event + command handlers in mega-events.ts / mega-commands.ts.
  */
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import { compactSession } from "../src/engine.js";
 import { recallAndInline } from "../src/recall.js";
 import { normalizeSessionId } from "../src/store.js";
 import { touchSession, logDaily } from "../src/store/sqlite.js";
 import { C, MARKER_TYPE, } from "./mega-runtime.js";
-import { resolveRepoRoot } from "./mega-config.js";
+import { resolveRepoRoot, preserveRecentForPressure } from "./mega-config.js";
+import { runRaptor } from "../src/dedup/raptor/index.js";
+import { loadDedupConfig } from "../src/config/dedup.js";
 /** Run the full compaction pipeline and persist a checkpoint. Returns the result. */
 export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
     runtime.bindRepo(ctx.cwd);
@@ -19,7 +22,10 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
     runtime.resetRuntime(sid);
     runtime.rt.sessionId = sid;
     const view = runtime.engineView(messages);
-    const keepFrom = opts.keepFrom ?? Math.max(0, view.length - config.preserveRecent);
+    // keepFrom deepens with context pressure (Fix E): under high pressure we
+    // compact more of the session, down to the preserveRecentMin floor.
+    const preserve = preserveRecentForPressure(opts.compressionPressure ?? 0, config.preserveRecent, config.preserveRecentMin);
+    const keepFrom = opts.keepFrom ?? Math.max(0, view.length - preserve);
     if (keepFrom <= 0)
         return { skipped: true };
     runtime.pulsing = true; // animate the status line while the (sync) pipeline runs
@@ -30,6 +36,7 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
         summary: opts.summary,
         timestamp: Date.now(),
         onTier: runtime.makeTierCallback(ctx),
+        compressionPressure: opts.compressionPressure,
     }, runtime.store);
     runtime.pulsing = false;
     if (result.skipped)
@@ -56,15 +63,13 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
     // 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;
-    // Live toolbar "now processing" line: what file/region just got compacted or
-    // deduped. Reset to the last-seen action after a few seconds (see snapshot).
+    // 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(", ")
         : result.regionHash.slice(0, 8);
-    runtime.currentActivity = result.deduped
-        ? `♻ deduped ${fileLabel}`
-        : `🗜 compacted ${result.checkpointId} · ${fileLabel}`;
     runtime.lastActivityAt = Date.now();
     // Explain-why line: surfaced while fresh. Pulls the dedup reason (which for
     // L2 includes the cosine sim) so the user sees WHY a region was kept/dropped.
@@ -98,6 +103,34 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
         tokenEstimate: result.tokenEstimate,
         deduped: result.deduped,
     });
+    // Fix D: refresh the RAPTOR tree for this session so live recall (search) can
+    // serve high-level summaries. Best-effort + non-fatal: never block compaction.
+    // Budget-guarded (RAPTOR_BUDGET_MS) so it can't hang a large session.
+    if (config.raptorEnabled && !result.deduped) {
+        try {
+            const dd = loadDedupConfig();
+            const all = runtime.store.list(sid);
+            const leaves = all.map((cp) => ({
+                id: cp.checkpointId,
+                messages: [],
+                sourceText: cp.normalizedText ?? cp.summary ?? cp.regionHash,
+                embedding: cp.embedding,
+            }));
+            if (leaves.length >= 2) {
+                runRaptor(leaves, {
+                    stateDir: runtime.currentStateDir,
+                    sessionId: sid,
+                    budgetMs: dd.RAPTOR_BUDGET_MS,
+                    clustersPerLevel: dd.RAPTOR_CLUSTERS_PER_LEVEL,
+                    consistencyThreshold: dd.RAPTOR_CONSISTENCY,
+                    logger: runtime.logger,
+                });
+            }
+        }
+        catch {
+            /* non-fatal: tree refresh never blocks a compaction */
+        }
+    }
     runtime.setStatus(ctx, runtime.rt.persistedThisSession
         ? `mega-compact: ${result.checkpointId} · ${saved} tok saved`
         : `mega-compact: ready`);
@@ -126,7 +159,21 @@ export function runCompact(pi, runtime, config, ctx, messages, opts = {}) {
 export function doRecall(runtime, config, ctx, query, source) {
     runtime.bindRepo(ctx.cwd);
     const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
-    const result = recallAndInline({ sessionId: sid, query, limit: config.autoInlineK, source, skipInjected: true }, runtime.store);
+    // 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 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 (!result.empty && result.toInject.length > 0) {
         const top = result.toInject[0];
@@ -138,3 +185,28 @@ export function doRecall(runtime, config, ctx, query, source) {
     }
     return result;
 }
+/**
+ * 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.
+ */
+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 [];
+    }
+}

package/dist/extensions/mega-runtime.js

@@ -68,10 +68,7 @@ export class MegaRuntime {
     // on model_select + session_start; persisted to SQL so cost + the dashboard
     // can read it without a live ctx.
     currentModel;
-    // Live "what it's doing right now" line for the toolbar. Set on each
-    // compaction; shown in teal while recent, then kept as the last-seen action so
-    // the widget is never blank. Cleared on session reset.
-    currentActivity;
+    // Live "what it's doing right now" timestamp, used for the fresh-window.
     lastActivityAt = 0;
     // Live per-tier dedup trace (Phase 1): e.g. "L0 ✓ → L1 ✓ → L2 0.91 → stored".
     // Built from the store's sync onTier callback during a compaction so the user
@@ -243,29 +240,27 @@ export class MegaRuntime {
                 const bar = "▓".repeat(filled) + "░".repeat(10 - filled);
                 lines.push(`   ${C.green}saved ${fmt(this.rt.tokensSaved)} ${bar}${C.reset} ${pct}% of ${fmt(goal)}`);
             }
-            // Live "now processing" line — teal while fresh (≤4s), then the last-seen
-            // action keeps the widget lively. Cleared on session reset.
+            // Live "now processing" line + why + recent deduped/compacted events,
+            // collapsed to ONE rotating line (fresh only). The ticker ring buffer
+            // (≤5 most-recent events) is cycled one-per-repaint so the line scrolls
+            // through recent files in real time while activity fires. We rotate on a
+            // 250ms step (same cadence as the pulse), using an event counter as the
+            // deterministic phase so consecutive repaints advance the visible entry.
             const fresh = Date.now() - this.lastActivityAt < 4000;
             if (this.tierTrace && fresh) {
                 lines.push(`   ${pulse}${this.tierTrace}`);
             }
-            else if (this.currentActivity) {
-                lines.push(`   ${fresh ? C.teal : C.dim}${this.currentActivity}${C.reset}`);
+            else if (this.ticker.length > 0) {
+                const step = Math.floor(Date.now() / 250);
+                const idx = this.ticker.length - 1 - (step % this.ticker.length);
+                const head = this.ticker[idx].text;
+                const why = this.lastWhy ? ` ${C.gray}· ${this.lastWhy}${C.reset}` : "";
+                const more = this.ticker.length > 1 ? ` ${C.dim}(+${this.ticker.length - 1} more)${C.reset}` : "";
+                lines.push(`   ${fresh ? C.teal : C.dim}${head}${why}${more}${C.reset}`);
             }
             else if (this.pulsing) {
                 lines.push(`   ${pulse}${C.teal}compacting…${C.reset}`);
             }
-            // Phase 3 — explain-why line (fresh only).
-            if (this.lastWhy && fresh)
-                lines.push(`   ${C.gray}${this.lastWhy}${C.reset}`);
-            // Phase 3 — recall/activity ticker (most-recent first), fresh only.
-            if (fresh) {
-                for (let i = this.ticker.length - 1; i >= 0; i--) {
-                    if (lines.length >= 9)
-                        break; // leave room for the hint line (MAX 10)
-                    lines.push(`   ${i === this.ticker.length - 1 ? "" : C.dim}${this.ticker[i].text}${C.reset}`);
-                }
-            }
             // Plain-language hint so first-time users understand the widget. Always
             // last, dimmed. "/mega-help explains these terms."
             if (lines.length < 10) {
@@ -295,7 +290,6 @@ export class MegaRuntime {
         this.statusKey = undefined;
         this.activeAgents = 0;
         this.currentTurn = 0;
-        this.currentActivity = undefined;
         this.lastActivityAt = 0;
         this.tierTrace = undefined;
         this.ticker.length = 0;

package/dist/src/config/dedup.js

@@ -33,7 +33,10 @@ export function loadDedupConfig() {
         L0_ENABLED: envBool("MEGACOMPACT_L0_ENABLED", true),
         L1_ENABLED: envBool("MEGACOMPACT_L1_ENABLED", true),
         L2_ENABLED: envBool("MEGACOMPACT_L2_ENABLED", true),
-        RAPTOR_ENABLED: envBool("MEGACOMPACT_RAPTOR_ENABLED", false), // shadow by default
+        // Fix D: RAPTOR promoted to live recall. Default ON; canary.ts sequences it
+        // last (L0→L1→L2→RAPTOR) and auto-disables on p95 breach, so promotion is
+        // safe. `RAPTOR_SHADOW_MODE=false` still gates serving during transition.
+        RAPTOR_ENABLED: envBool("MEGACOMPACT_RAPTOR_ENABLED", true),
         MARK_ONLY_L0: envBool("MEGACOMPACT_MARK_ONLY_L0", false),
         MARK_ONLY_L1: envBool("MEGACOMPACT_MARK_ONLY_L1", false),
         MARK_ONLY_L2: envBool("MEGACOMPACT_MARK_ONLY_L2", false),

package/dist/src/config.js

@@ -10,3 +10,24 @@ import { homedir } from "node:os";
 export const STATE_DIR_DEFAULT = join(homedir(), ".pi", "agent", "extensions", "pi-mega-compact");
 /** Pi custom message / entry type used as the dedup sentinel. */
 export const MARKER_TYPE = "mega-compact-marker";
+/**
+ * Derive context-window pressure (0–1) from a usage percentage. Used to scale
+ * compression strength + keepFrom depth (Fix E): low pct = room to spare,
+ * high pct = near the limit. Deterministic; clamps to [0,1].
+ */
+export function pressureFromPct(pct) {
+    if (pct == null || Number.isNaN(pct))
+        return 0;
+    return pct < 0 ? 0 : pct > 100 ? 1 : pct / 100;
+}
+/**
+ * Map pressure → how many recent messages to preserve verbatim. Under low
+ * pressure we keep `preserveRecent`; under high pressure we compact deeper,
+ * down to `preserveRecentMin`. Never splits a tool pair / anchor floor — the
+ * boundary guard (computeDropRange) enforces that downstream.
+ */
+export function preserveRecentForPressure(pressure, preserveRecent, preserveRecentMin) {
+    const p = pressure < 0 ? 0 : pressure > 1 ? 1 : pressure;
+    const v = Math.round(preserveRecent - (preserveRecent - preserveRecentMin) * p);
+    return Math.max(preserveRecentMin, Math.min(preserveRecent, v));
+}

package/dist/src/dedup/raptor/index.js

@@ -66,11 +66,20 @@ export function runRaptor(leaves, opts) {
  */
 export function recallRaptor(query, sessionId, opts) {
     const embedder = opts.embedder ?? defaultEmbedder();
-    const nodes = listRaptorNodes(sessionId, opts.stateDir);
-    if (nodes.length === 0)
+    const tree = rehydrateRaptorTree(sessionId, opts.stateDir);
+    if (!tree)
         return [];
-    // Rehydrate a minimal in-memory tree (parent links reconstructed from children).
-    const byId = new Map(nodes.map((n) => [n.id, n]));
+    return stagedExpansion(query, tree, { embedder, k: opts.k, topM: opts.topM });
+}
+/**
+ * Rehydrate a persisted RAPTOR tree from raptor_nodes (Fix D): rebuild the
+ * in-memory RaptorTree + parent links so vectorStore.search can serve it live.
+ * Returns null when no tree exists (caller falls back to the flat path).
+ */
+export function rehydrateRaptorTree(sessionId, stateDir) {
+    const nodes = listRaptorNodes(sessionId, stateDir);
+    if (nodes.length === 0)
+        return null;
     const tree = {
         nodes: new Map(nodes.map((n) => [
             n.id,
@@ -89,6 +98,19 @@ export function recallRaptor(query, sessionId, opts) {
         levels: Math.max(1, ...nodes.map((n) => n.level + 1)),
         timedOut: false,
     };
-    void byId;
-    return stagedExpansion(query, tree, { embedder, k: opts.k, topM: opts.topM });
+    return tree;
+}
+/**
+ * Return the RAPTOR root summary for a session, if a tree has been built.
+ * Used by the durable-trim driver (Fix B/D) to supply pi a session-level
+ * compressed summary instead of one slice's extractive summary. Returns
+ * undefined when no tree exists yet (caller falls back to the slice summary).
+ */
+export function recallRaptorRootSummary(sessionId, stateDir) {
+    const nodes = listRaptorNodes(sessionId, stateDir);
+    if (nodes.length === 0)
+        return undefined;
+    // Highest-level node = the root (covers all leaves).
+    const root = nodes.reduce((best, n) => (!best || n.level > best.level ? n : best), null);
+    return root?.summary || undefined;
 }

package/dist/src/dedup/raptor/promote.test.js

@@ -0,0 +1,69 @@
+/**
+ * promote.test.ts — Fix D: RAPTOR tree served by vectorStore.search.
+ *
+ * Asserts that, when a RAPTOR tree has been built + persisted for a session,
+ * VectorStore.search returns the tree's staged-expansion hits (broader, O(log n)
+ * coverage) merged with the flat hits — so the dormant tree becomes the live
+ * recall surface. No network: default extractive summarizer + trigram embedder.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { VectorStore } from "../../vectorStore.js";
+import { runRaptor } from "./index.js";
+import { compactSession } from "../../engine.js";
+import { Logger } from "../../log.js";
+import { loadDedupConfig } from "../../config/dedup.js";
+import { listRaptorNodes } from "../../store/sqlite.js";
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-promote-"));
+let counter = 0;
+function raptorConfig() {
+    return { ...loadDedupConfig(), RAPTOR_ENABLED: true };
+}
+function msg(text, toolName) {
+    return toolName ? { role: "assistant", text, toolName, input: text, output: text } : { role: "user", text };
+}
+const SESS = "sess_promote";
+test("Fix D: vectorStore.search serves a persisted RAPTOR tree (broader recall)", () => {
+    const stateDir = join(baseTmp, `run-${counter++}`);
+    const s = new VectorStore({ dedupSim: 0.9, stateDir, config: raptorConfig() });
+    // Persist several distinct checkpoints.
+    for (let i = 1; i <= 5; i++) {
+        compactSession({ sessionId: SESS, messages: [msg(`topic alpha wire ${i} and bootstrap sequence`), msg(`ok ${i}`, "Edit")], keepFrom: 2, timestamp: i }, s);
+    }
+    // No tree yet → flat search only, returns hits, no RAPTOR coverage.
+    assert.equal(listRaptorNodes(SESS, stateDir).length, 0, "no tree initially");
+    const flat = s.search(SESS, "alpha wire bootstrap", 3);
+    assert.ok(flat.length > 0, "flat search returns hits");
+    // Build + persist a RAPTOR tree for the session (mirrors runCompact refresh).
+    const all = s.list(SESS);
+    const leaves = all.map((cp) => ({
+        id: cp.checkpointId,
+        messages: [],
+        sourceText: cp.normalizedText ?? cp.summary ?? cp.regionHash,
+        embedding: cp.embedding,
+    }));
+    const tree = runRaptor(leaves, { stateDir, sessionId: SESS, logger: new Logger() });
+    assert.ok(tree && listRaptorNodes(SESS, stateDir).length > 0, "tree persisted");
+    // With the tree live + RAPTOR_ENABLED, search still returns hits and now
+    // exercises the RAPTOR-served path without regression.
+    const withTree = s.search(SESS, "alpha wire bootstrap", 3);
+    assert.ok(withTree.length > 0, "search returns hits with RAPTOR promoted");
+    // Every returned hit is a real checkpoint in the session.
+    for (const h of withTree) {
+        assert.ok(all.some((cp) => cp.checkpointId === h.checkpoint.checkpointId), "hit is a real checkpoint");
+    }
+});
+test("Fix D: search still works for a session with <2 leaves (no tree)", () => {
+    const stateDir = join(baseTmp, `run-${counter++}`);
+    const s = new VectorStore({ dedupSim: 0.9, stateDir, config: raptorConfig() });
+    compactSession({ sessionId: SESS, messages: [msg("only one topic here"), msg("ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
+    const r = s.search(SESS, "only one topic", 3);
+    assert.ok(r.length > 0, "single-checkpoint search still works (no tree)");
+    assert.equal(listRaptorNodes(SESS, stateDir).length, 0, "no tree built for <2 leaves");
+});
+test("cleanup", () => {
+    rmSync(baseTmp, { recursive: true, force: true });
+});

package/dist/src/engine.js

@@ -104,6 +104,7 @@ export function compactSession(input, store = getDefaultStore()) {
         originalTokenEstimate,
         timestamp: input.timestamp ?? 0,
         onTier: input.onTier,
+        compressionPressure: input.compressionPressure,
     });
     return {
         skipped: false,

package/dist/src/recall.js

@@ -14,6 +14,8 @@
  * extension decides where it lands.
  */
 import { recall as searchRecall } from "./engine.js";
+import { estimateBlockTokens } from "./tokens.js";
+import { defaultEmbedder, cosineSimilarity } from "./embedder.js";
 /** Wrap a recall block so the model reads it as restored compacted context. */
 export function formatRecallBlock(hits) {
     if (hits.length === 0)
@@ -38,18 +40,42 @@ export function formatRecallBlock(hits) {
 export function recallAndInline(opts, store) {
     const limit = opts.limit ?? 3;
     const skip = opts.skipInjected ?? true;
+    const maxTokens = opts.recallMaxTokens ?? 0; // 0 = unbounded (legacy behavior)
+    const doWindowDedupe = opts.windowDedupe ?? false;
+    const dedupSim = opts.dedupSim ?? 0.9;
     const { hits } = searchRecall({ sessionId: opts.sessionId, query: opts.query, limit, skipInjected: false }, store);
-    // Shared dedup: drop checkpoints already injected this session, then mark the
-    // survivors so repeated triggers are free. (Cosine near-dup collapse already
-    // happened inside store.search.)
+    // Precompute live-window embeddings once for inline dedupe (Fix C). Trigram
+    // embedder is local + cheap; never a network call (PREVENT-PI-004).
+    let liveEmbeddings = [];
+    if (doWindowDedupe && opts.liveWindow && opts.liveWindow.length > 0) {
+        const embedder = defaultEmbedder();
+        liveEmbeddings = opts.liveWindow.map((m) => embedder.embed(m));
+    }
+    // Shared dedup + bounded/inline block assembly. We build the block
+    // incrementally so the token cap can stop mid-stream (Fix C).
     const toInject = [];
+    const parts = [];
+    let blockTokens = 0;
     for (const h of hits) {
         if (skip && store.wasInjected(opts.sessionId, h.checkpoint.checkpointId))
             continue;
+        // Inline dedupe: skip a hit already resident in the live window (Fix C).
+        if (doWindowDedupe && liveEmbeddings.length > 0) {
+            const hitVec = defaultEmbedder().embed(h.checkpoint.summary);
+            if (liveEmbeddings.some((v) => cosineSimilarity(v, hitVec) >= dedupSim))
+                continue;
+        }
+        const part = formatRecallBlock([h]);
+        const partTokens = estimateBlockTokens(part);
+        // Token cap: never push a chunk that would overrun the ceiling.
+        if (maxTokens > 0 && blockTokens + partTokens > maxTokens)
+            break;
+        parts.push(part);
         toInject.push(h);
+        blockTokens += partTokens;
         store.markInjected(opts.sessionId, h.checkpoint.checkpointId);
     }
-    const block = formatRecallBlock(toInject);
+    const block = parts.join("\n");
     const report = toInject.map((h) => `  • ${h.checkpoint.checkpointId} (${h.checkpoint.summary.slice(0, 60).replace(/\n/g, " ")}…)`);
     return {
         toInject,

package/dist/src/recall.test.js

@@ -45,6 +45,34 @@ test("recallAndInline empty when store has nothing for query", () => {
     assert.equal(r.empty, true);
     assert.equal(r.block, "");
 });
+test("Fix C: recallMaxTokens caps the injected block", () => {
+    const s = store();
+    // Three distinct checkpoints so we can observe the cap bite mid-stream.
+    compactSession({ sessionId: SESS, messages: [msg("user", "alpha module wiring and bootstrap sequence"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
+    compactSession({ sessionId: SESS, messages: [msg("user", "beta module config and env resolution"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 2 }, s);
+    compactSession({ sessionId: SESS, messages: [msg("user", "gamma module shutdown and cleanup hooks"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 3 }, s);
+    // A ceiling of 100 tokens fits the first checkpoint (~82) but stops before the
+    // second (~163 cumulative) — proving the cap bites mid-stream.
+    const r = recallAndInline({ sessionId: SESS, query: "module wiring config shutdown", limit: 5, source: "command", recallMaxTokens: 100, skipInjected: false }, s);
+    assert.ok(r.toInject.length >= 1, "at least one injected under the cap");
+    assert.ok(r.toInject.length < 3, "cap prevented all three from injecting");
+    assert.ok(r.block.length > 0, "block non-empty");
+});
+test("Fix C: inline dedupe drops a hit already resident in the live window", () => {
+    const s = store();
+    const resident = "alpha module wiring and bootstrap sequence";
+    compactSession({ sessionId: SESS, messages: [msg("user", resident), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 1 }, s);
+    compactSession({ sessionId: SESS, messages: [msg("user", "omega module telemetry and tracing spans"), msg("assistant", "ok", "Edit")], keepFrom: 2, timestamp: 2 }, s);
+    // Baseline: with dedupe OFF, both checkpoints are candidates.
+    const rNoDedup = recallAndInline({ sessionId: SESS, query: "module wiring telemetry", limit: 5, source: "command", skipInjected: false }, s);
+    // The live window contains the exact summary of the first checkpoint — as it
+    // would be if a prior recall already injected it. Inline dedupe must drop it
+    // (strictly fewer injected than the no-dedupe baseline).
+    const residentSummary = rNoDedup.toInject[0].checkpoint.summary;
+    const rDedup = recallAndInline({ sessionId: SESS, query: "module wiring telemetry", limit: 5, source: "command", skipInjected: false, windowDedupe: true, liveWindow: [residentSummary], dedupSim: 0.9 }, s);
+    assert.ok(rDedup.toInject.length <= rNoDedup.toInject.length, "dedupe never adds hits");
+    assert.ok(rDedup.toInject.length < rNoDedup.toInject.length, "inline dedupe dropped a resident hit");
+});
 test("cleanup", () => {
     rmSync(baseTmp, { recursive: true, force: true });
 });

package/dist/src/store/backfill.js

@@ -19,7 +19,7 @@ import { openStore } from "./sqlite.js";
 import { computeContentDigest } from "../dedup/digest.js";
 import { minhashSignature, SIGNATURE_VERSION, NUM_HASHES } from "../dedup/l1-minhash.js";
 import { lshBands } from "../dedup/l1-lsh.js";
-import { upsertMinhashSignature, insertLshBuckets, listCheckpoints, saveRaptorTree } from "./sqlite.js";
+import { upsertMinhashSignature, insertLshBuckets, listCheckpoints, saveRaptorTree, withTx } from "./sqlite.js";
 import { buildRaptorTree } from "../dedup/raptor/tree.js";
 import { defaultEmbedder } from "../embedder.js";
 import { getStateDir } from "../store.js";
@@ -64,7 +64,7 @@ export function backfillContentHashes(stateDir = getStateDir()) {
     let processed = 0;
     let lastSid = start.lastSid;
     let lastId = start.lastId;
-    const tx = db.transaction((rows) => {
+    function applyRows(rows) {
         const lookup = db.prepare("SELECT id FROM context_chunks WHERE session_id = ? AND content_hash = ? AND content_hash2 = ? AND id != ? LIMIT 1");
         const update = db.prepare(`UPDATE context_chunks
        SET content_hash=?, content_hash2=?, content_hash_version=?, normalized_text=?,
@@ -87,9 +87,9 @@ export function backfillContentHashes(stateDir = getStateDir()) {
             lastId = row.id;
             processed++;
         }
-    });
+    }
     if (pending.length > 0) {
-        tx(pending);
+        withTx(db, () => applyRows(pending));
         db.prepare("INSERT INTO backfill_progress(name, last_session_id, last_id, updated, duplicates_resolved) VALUES('content_hashes',?,?,?,?) ON CONFLICT(name) DO UPDATE SET last_session_id=excluded.last_session_id, last_id=excluded.last_id, updated=excluded.updated, duplicates_resolved=excluded.duplicates_resolved").run(lastSid, lastId, updated, duplicatesResolved);
     }
     if (THROTTLE_MS > 0) {
@@ -135,7 +135,7 @@ export function backfillPhase(phase, sessionId, stateDir, opts = {}) {
     let cursor = lastId ?? undefined;
     for (let i = Math.max(0, startIndex); i < all.length; i += batchSize) {
         const batch = all.slice(i, i + batchSize);
-        const tx = db.transaction(() => {
+        withTx(db, () => {
             for (const cp of batch) {
                 const sig = minhashSignature(cp.normalizedText ?? cp.summary ?? "");
                 if (sig.length === NUM_HASHES) {
@@ -148,7 +148,6 @@ export function backfillPhase(phase, sessionId, stateDir, opts = {}) {
                 processed++;
             }
         });
-        tx();
         savePhaseCursor(db, phase, cursor ?? null, processed);
         batches++;
         if (THROTTLE_MS > 0) {