pi-mega-compact 0.4.20 → 0.4.23

package/extensions/mega-events.ts

@@ -11,10 +11,10 @@ import type { ExtensionAPI, ExtensionContext, ContextEvent, SessionBeforeCompact
 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 { MegaRuntime, recentUserQuery, WIDGET_KEY } from "./mega-runtime.js";
 import { runCompact, doRecall } from "./mega-pipeline.js";
-import type { MegaConfig } from "./mega-config.js";
+import { driveNativeCompaction } from "./mega-compact-driver.js";
+import { pressureFromPct, type MegaConfig } from "./mega-config.js";
 
 /** Register all pi lifecycle event handlers. */
 export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, config: MegaConfig): void {
@@ -119,7 +119,15 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     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: ContextEvent, ctx: ExtensionContext) => {
     if (!config.auto) return;
     const usage = ctx.getContextUsage();
@@ -133,15 +141,11 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
 
     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)
@@ -152,29 +156,44 @@ export function registerEventHandlers(pi: ExtensionAPI, runtime: MegaRuntime, co
     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: SessionBeforeCompactEvent, ctx: ExtensionContext) => {
+  // ---- 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: SessionBeforeCompactEvent, ctx: ExtensionContext) => {
     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/extensions/mega-pipeline.ts

@@ -8,6 +8,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { compactSession } from "../src/engine.js";
 import { recallAndInline } from "../src/recall.js";
@@ -18,7 +19,9 @@ import {
   C,
   MARKER_TYPE,
 } from "./mega-runtime.js";
-import { resolveRepoRoot, type MegaConfig } from "./mega-config.js";
+import { resolveRepoRoot, preserveRecentForPressure, type MegaConfig } from "./mega-config.js";
+import { runRaptor } from "../src/dedup/raptor/index.js";
+import { loadDedupConfig } from "../src/config/dedup.js";
 
 export type RunCompactResult =
   | { skipped: true }
@@ -31,7 +34,7 @@ export function runCompact(
   config: MegaConfig,
   ctx: ExtensionContext,
   messages: AgentMessage[],
-  opts: { keepFrom?: number; summary?: string } = {},
+  opts: { keepFrom?: number; summary?: string; compressionPressure?: number } = {},
 ): RunCompactResult {
   runtime.bindRepo(ctx.cwd);
   const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
@@ -39,7 +42,14 @@ export function runCompact(
   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
@@ -51,6 +61,7 @@ export function runCompact(
       summary: opts.summary,
       timestamp: Date.now(),
       onTier: runtime.makeTierCallback(ctx),
+      compressionPressure: opts.compressionPressure,
     },
     runtime.store,
   );
@@ -78,15 +89,13 @@ export function runCompact(
   // 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.
@@ -124,6 +133,37 @@ export function runCompact(
     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
@@ -162,8 +202,22 @@ export function doRecall(
 ) {
   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 result = recallAndInline(
-    { sessionId: sid, query, limit: config.autoInlineK, source, skipInjected: true },
+    {
+      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 });
@@ -177,3 +231,26 @@ export function doRecall(
   }
   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: ExtensionContext): string[] {
+  try {
+    const entries = ctx.sessionManager.getEntries();
+    const texts: string[] = [];
+    for (const e of entries) {
+      for (const m of sessionEntryToContextMessages(e)) {
+        const c = (m as { content?: unknown }).content;
+        if (typeof c === "string") texts.push(c);
+        else if (Array.isArray(c)) texts.push(c.map((b: any) => b.text).join(" "));
+      }
+    }
+    return texts;
+  } catch {
+    return [];
+  }
+}

package/extensions/mega-runtime.ts

@@ -90,10 +90,7 @@ export class MegaRuntime {
   // on model_select + session_start; persisted to SQL so cost + the dashboard
   // can read it without a live ctx.
   currentModel: ModelSnapshot | undefined;
-  // 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: string | undefined;
+  // 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
@@ -269,25 +266,25 @@ 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) {
@@ -318,7 +315,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.4.20",
+  "version": "0.4.23",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-2-Clause",
@@ -20,7 +20,7 @@
     "trident"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22.13"
   },
   "files": [
     "dist",
@@ -45,19 +45,18 @@
     "test": "npm run build && node --test \"dist/src/**/*.test.js\" \"dist/extensions/**/*.test.js\"",
     "guardrails": "python3 scripts/regression_check.py --all || node scripts/guardrails-scan.mjs",
     "precommit": "bash .claude/hooks/pre-commit.sh",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postinstall": "npm rebuild @mongodb-js/zstd || true"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "openclaw": ">=0.1.0"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^20.0.0",
+    "@types/node": "^22.20.1",
     "typescript": "^5.4.0"
   },
   "dependencies": {
-    "@mongodb-js/zstd": "^7.0.0",
-    "better-sqlite3": "^12.11.1"
+    "@mongodb-js/zstd": "^7.0.0"
   }
 }

package/src/config/dedup.ts

@@ -66,7 +66,10 @@ export function loadDedupConfig(): DedupConfigShape {
     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/src/config.ts

@@ -13,3 +13,29 @@ export const STATE_DIR_DEFAULT = join(homedir(), ".pi", "agent", "extensions", "
 
 /** 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: number | null | undefined): number {
+  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: number,
+  preserveRecent: number,
+  preserveRecentMin: number,
+): number {
+  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/src/dedup/raptor/index.ts

@@ -89,10 +89,22 @@ export function recallRaptor(
   opts: { embedder?: Embedder; stateDir: string; k?: number; topM?: number },
 ): string[] {
   const embedder = opts.embedder ?? defaultEmbedder();
-  const nodes = listRaptorNodes(sessionId, opts.stateDir);
-  if (nodes.length === 0) return [];
-  // Rehydrate a minimal in-memory tree (parent links reconstructed from children).
-  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const tree = rehydrateRaptorTree(sessionId, opts.stateDir);
+  if (!tree) return [];
+  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: string,
+  stateDir: string,
+): RaptorTree | null {
+  const nodes = listRaptorNodes(sessionId, stateDir);
+  if (nodes.length === 0) return null;
   const tree: RaptorTree = {
     nodes: new Map(
       nodes.map((n) => [
@@ -109,10 +121,33 @@ export function recallRaptor(
         },
       ]),
     ),
-    rootId: nodes.reduce<typeof nodes[number] | null>((best, n) => (!best || n.level > (best?.level ?? -1) ? n : best), null)?.id ?? null,
+    rootId:
+      nodes.reduce<typeof nodes[number] | null>(
+        (best, n) => (!best || n.level > (best?.level ?? -1) ? n : best),
+        null,
+      )?.id ?? null,
     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: string,
+  stateDir: string,
+): string | undefined {
+  const nodes = listRaptorNodes(sessionId, stateDir);
+  if (nodes.length === 0) return undefined;
+  // Highest-level node = the root (covers all leaves).
+  const root = nodes.reduce<(typeof nodes)[number] | null>(
+    (best, n) => (!best || n.level > best.level ? n : best),
+    null,
+  );
+  return root?.summary || undefined;
 }

package/src/dedup/raptor/promote.test.ts

@@ -0,0 +1,82 @@
+/**
+ * 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";
+import type { EngineMessage } from "../../types.js";
+
+const baseTmp = mkdtempSync(join(tmpdir(), "mc-promote-"));
+let counter = 0;
+function raptorConfig() {
+  return { ...loadDedupConfig(), RAPTOR_ENABLED: true };
+}
+function msg(text: string, toolName?: string): EngineMessage {
+  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/src/engine.ts

@@ -38,6 +38,10 @@ export interface CompactInput {
   timestamp?: number;
   /** When true (default), use extractive summary instead of raw concatenation. */
   useExtractiveSummary?: boolean;
+  /** Context-window pressure (0–1): how close the session is to the model
+   *  limit. Drives adaptive compression strength in the stored checkpoint
+   *  (Fix E). 0/undefined = room to spare; 1 = at the limit. */
+  compressionPressure?: number;
   /** Sync progress callback fired by the store as each dedup tier is evaluated
    *  (L0→L1→L2→new). Lets the UI render a live "L0 ✓ → L1 ✓ → L2 0.91 → stored"
    *  progress line during compaction. Never awaited; must be side-effect-free-ish
@@ -174,6 +178,7 @@ export function compactSession(input: CompactInput, store: VectorStore = getDefa
     originalTokenEstimate,
     timestamp: input.timestamp ?? 0,
     onTier: input.onTier,
+    compressionPressure: input.compressionPressure,
   });
 
   return {

package/src/recall.test.ts

@@ -54,6 +54,50 @@ test("recallAndInline empty when store has nothing for query", () => {
   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 as any,
+  );
+  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 as any,
+  );
+  // 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 as any,
+  );
+  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 });
 });