pi-mega-compact 0.21.9 → 0.21.11

package/dist/src/extractive.js

@@ -8,12 +8,14 @@
  * Deterministic: same messages → same output, every time.
  */
 import { estimateBlockTokens } from "./tokens.js";
+import { CURRENT_WORK_PATH_RE, isInterestingPath, isPlaceholderRequest, isSkeletonSummary, buildSalvageDigest, collectKeyFiles, extractFilesModified, } from "./extractive-salvage.js";
 // ---- Limits ----------------------------------------------------------------
 const MAX_RECENT_USER = 3;
 const MAX_DECISIONS = 5;
-const MAX_FILES = 10;
 const MAX_PENDING = 5;
 const MAX_TOPIC_LINES = 12;
+/** Cap for the merged keyFiles ∪ filesModified "Key files" line (A2a). */
+const MAX_SUMMARY_FILES = 8;
 // ---- Truncation helper -----------------------------------------------------
 function truncate(s, maxLen) {
     if (s.length <= maxLen)
@@ -27,8 +29,22 @@ function truncate(s, maxLen) {
  * Captures: tools used, recent user requests, current work, key files,
  * pending work. Typically 12 lines / ~500 tokens instead of ~70K.
  */
-function buildTopicSummary(messages, tools, recentUser, currentWork, keyFiles, pending) {
+function buildTopicSummary(messages, tools, recentUser, currentWork, keyFiles, pending, filesModified, decisions) {
     const lines = [];
+    // A2a: files captured from write/edit tool inputs are extracted
+    // extension-agnostically but never reached the summary. Fold them in so work
+    // outside the recency window (and outside the path regex) is still reported.
+    // Drop an absolute path when a kept relative path already names the SAME file.
+    // Only MULTI-COMPONENT relative paths fold ("engine/mesh.go" absorbs
+    // "/proj/engine/mesh.go"); a bare basename ("mesh.go") is never folded into an
+    // absolute path, since "/proj/other/x/mesh.go" may be a genuinely different
+    // file (QA lens 1 finding: the naive endsWith dropped different directories).
+    const combined = [...keyFiles, ...filesModified];
+    const allFiles = [...new Set(combined)].filter((p) => {
+        if (!p.startsWith("/"))
+            return true;
+        return !combined.some((r) => r !== p && !r.startsWith("/") && r.includes("/") && p.endsWith("/" + r));
+    }).slice(0, MAX_SUMMARY_FILES);
     // Scope line
     const users = messages.filter((m) => m.role === "user");
     const assistants = messages.filter((m) => m.role === "assistant");
@@ -45,45 +61,59 @@ function buildTopicSummary(messages, tools, recentUser, currentWork, keyFiles, p
     // Current work
     if (currentWork)
         lines.push(`Current work: ${currentWork}`);
-    // Key files
-    if (keyFiles.length)
-        lines.push(`Key files: ${keyFiles.join(", ")}.`);
+    // Key files (keyFiles ∪ filesModified)
+    if (allFiles.length)
+        lines.push(`Key files: ${allFiles.join(", ")}.`);
     // Pending work
     if (pending.length) {
         lines.push("Pending work:");
         for (const p of pending)
             lines.push(`  • ${p}`);
     }
+    // A2c: a scope-line-only summary carries zero information and strands a
+    // resumed session. Salvage the tail of the conversation instead. The line cap
+    // is raised ONLY here: the salvage block is bounded at 5 lines + 1 header, and
+    // a skeleton by definition contributed just the 1 scope line, so the worst
+    // case is 7 lines — still well under the normal 12-line budget.
+    const skeleton = isSkeletonSummary({ recentUser, keyFiles: allFiles, currentWork, decisions, pending });
+    if (skeleton) {
+        const digest = buildSalvageDigest(messages);
+        if (digest.length) {
+            lines.push("Recent activity:");
+            for (const d of digest)
+                lines.push(`  • ${d}`);
+        }
+        return lines.join("\n");
+    }
     // Cap total length
     return lines.slice(0, MAX_TOPIC_LINES).join("\n");
 }
-// ---- File path extraction --------------------------------------------------
-const INTERESTING_EXT = new Set(["rs", "ts", "tsx", "js", "json", "md"]);
-const FILE_PATH_RE = /(?:^|\s)([^\s"`']+\.(rs|ts|tsx|js|json|md|py|sh|sql|toml|yaml|yml|css|html))\b/g;
-function extractFilePaths(text) {
-    const paths = [];
-    for (const m of text.matchAll(FILE_PATH_RE)) {
-        const filePath = m[1];
-        const ext = m[2];
-        const basename = filePath.split("/").pop() ?? filePath;
-        if (basename === "node_modules" || filePath.includes("node_modules/"))
-            continue;
-        if (INTERESTING_EXT.has(ext))
-            paths.push(filePath);
-    }
-    return paths;
-}
-// ---- Recent user requests (existing logic, kept) ---------------------------
+// ---- Recent user requests --------------------------------------------------
+/**
+ * A2b: skip content-free "resume"/"continue" turns and look further back to
+ * fill the quota, so a resumed session surfaces its real requests. Falls back
+ * to the placeholders when EVERY user turn is one (an honest "• resume" beats
+ * an empty section).
+ */
 function collectRecentUserRequests(messages, limit) {
-    const requests = [];
-    for (let i = messages.length - 1; i >= 0 && requests.length < limit; i--) {
-        if (messages[i].role === "user") {
-            let snippet = messages[i].text.split("\n").slice(0, 3).join(" ");
-            snippet = snippet.replace(/^.+\nProcessed\$?\s*/i, "").replace(/\n/g, " ");
-            requests.push(truncate(snippet, 200));
+    const substantive = [];
+    const placeholders = [];
+    for (let i = messages.length - 1; i >= 0 && substantive.length < limit; i--) {
+        if (messages[i].role !== "user")
+            continue;
+        let snippet = messages[i].text.split("\n").slice(0, 3).join(" ");
+        snippet = snippet.replace(/^.+\nProcessed\$?\s*/i, "").replace(/\n/g, " ");
+        const cleaned = truncate(snippet, 200);
+        if (!cleaned.trim())
+            continue;
+        if (isPlaceholderRequest(cleaned)) {
+            if (placeholders.length < limit)
+                placeholders.push(cleaned);
+            continue;
         }
+        substantive.push(cleaned);
     }
-    return requests.reverse();
+    return (substantive.length ? substantive : placeholders).reverse();
 }
 // ---- Pending work (existing logic, kept) -----------------------------------
 const PENDING_WORDS = ["todo", "next", "pending", "follow up", "remaining"];
@@ -106,8 +136,9 @@ function inferCurrentWork(messages) {
         const m = messages[i];
         if (m.role !== "assistant")
             continue;
-        const path = m.text.match(/(?:^|\s)([^\s"`':]+\.(rs|ts|tsx|js|json|md|py|toml|yaml|yml|sql))\b/m);
-        if (path) {
+        // A1: same language-agnostic policy as extractFilePaths.
+        const path = m.text.match(CURRENT_WORK_PATH_RE);
+        if (path && isInterestingPath(path[1], path[2])) {
             const line = m.text.split("\n").slice(0, 2).join(" ");
             return truncate(line, 200);
         }
@@ -144,30 +175,6 @@ function extractDecisions(messages) {
     }
     return [...new Set(decisions)];
 }
-// ---- Files modified --------------------------------------------------------
-function extractFilesModified(tools) {
-    const files = new Set();
-    for (const m of tools) {
-        if (!m.toolName)
-            continue;
-        const name = m.toolName.toLowerCase();
-        if (name === "write" || name === "edit" || name === "notebookedit") {
-            // Extract file path from input payload
-            const input = m.input ?? m.text;
-            const pathMatch = input.match(/["']?(\/[^\s"']+\.\w+)["']?/);
-            if (pathMatch)
-                files.add(pathMatch[1]);
-        }
-        if (name === "bash") {
-            const cmd = m.input ?? m.text;
-            if (cmd.includes("git add") || cmd.includes("git commit") || cmd.includes("git diff")) {
-                for (const p of extractFilePaths(cmd))
-                    files.add(p);
-            }
-        }
-    }
-    return [...files].slice(0, MAX_FILES);
-}
 // ---- Public API ------------------------------------------------------------
 /**
  * Deterministic extractive summary. Same messages → same output, every time.
@@ -192,23 +199,7 @@ export function extractiveSummarize(messages) {
     const pending = inferPendingWork(safe);
     const keyDecisions = extractDecisions(safe);
     const filesModified = extractFilesModified(toolMsgs);
-    const topicSummary = buildTopicSummary(safe, tools, recentUser, currentWork, keyFiles, pending);
+    const topicSummary = buildTopicSummary(safe, tools, recentUser, currentWork, keyFiles, pending, filesModified, keyDecisions);
     const tokenEstimate = estimateBlockTokens(topicSummary);
     return { topicSummary, keyDecisions, nextSteps: pending, filesModified, tokenEstimate };
 }
-// ---- Key files (existing logic from compact.ts, moved here) ----------------
-const MAX_KEY_FILES = 5;
-const FRESHNESS_WINDOW = 10;
-function collectKeyFiles(messages) {
-    const recent = messages.slice(-FRESHNESS_WINDOW);
-    const pathFreq = new Map();
-    for (const m of recent) {
-        for (const p of extractFilePaths(m.text)) {
-            pathFreq.set(p, (pathFreq.get(p) ?? 0) + 1);
-        }
-    }
-    return [...pathFreq.entries()]
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, MAX_KEY_FILES)
-        .map(([p]) => p);
-}

package/dist/src/vector-cortex/dedup-attr/rollup.js

@@ -49,6 +49,11 @@ export function computeDedupTierRollup(events, windowMs, now) {
         const ts = Date.parse(ev.ts);
         if (Number.isNaN(ts) || ts < windowStart || ts > windowEnd)
             continue;
+        // "skipped" (degenerate-match guard declined a collapse) is a decision, but
+        // NOT a tier catch — it is attributed to no tier below. Excluding it from the
+        // denominator keeps l0Share + l1Share + l2Share summing to 1 over the window.
+        if (ev.status === "skipped")
+            continue;
         total += 1;
         switch (ev.tier) {
             case "L0":

package/dist/src/vectorStore/add-degenerate.js

@@ -0,0 +1,25 @@
+import { shouldSkipDegenerateMatch } from "../dedup/degenerate.js";
+/**
+ * Build the decliner for one add() cascade.
+ *
+ * Returns a predicate the L1/L2 call sites use as a one-line guard. When it
+ * returns true it has ALREADY recorded the declined decision (monitoring event +
+ * `skipped` audit line + the live `onTier` detail), so the caller only has to
+ * fall through. When the umbrella flag is off it always returns false and emits
+ * nothing — byte-identical to the pre-guard cascade.
+ */
+export function degenerateDecliner(args) {
+    const { store, input, contentHash, cfg, audit, t0 } = args;
+    const candidate = { ...input, contentHash };
+    return (tier, matched, similarity) => {
+        if (!shouldSkipDegenerateMatch(matched, candidate, cfg))
+            return false;
+        // Reported as `mark_only`: a tier matched but policy declined to collapse —
+        // exactly the existing MARK_ONLY shape, with a distinct reason string so the
+        // dashboard can tell a guard decline from an operator-configured MARK_ONLY.
+        store.record(tier, "mark_only", "degenerateGuard", Date.now() - t0, similarity, matched.checkpointId);
+        audit.skipped(tier, matched.checkpointId, "degenerateGuard", similarity);
+        input.onTier?.({ tier, status: "passed", detail: "degenerateGuard" });
+        return true;
+    };
+}

package/dist/src/vectorStore/add.js

@@ -27,6 +27,7 @@ import { lshBands } from "../dedup/l1-lsh.js";
 import { openBloom, saveBloom } from "../store/bloom.js";
 import { listCheckpoints, nextCheckpointId, upsertCheckpoint, loadSessionState, saveSessionState, upsertMinhashSignature, insertLshBuckets, addTokensSaved, bumpDedupStats, } from "../store/sqlite.js";
 import { computeRegionHash } from "./hash.js";
+import { degenerateDecliner } from "./add-degenerate.js";
 import { runL0Tier, computeSummaryHash } from "./add-l0.js";
 import { findL1Duplicate } from "./add-l1.js";
 import { dedupAuditRecorder } from "./dedup-audit.js";
@@ -67,8 +68,22 @@ export function addCheckpoint(store, input) {
     // Tracks whether a tier matched while in MARK_ONLY (record-but-don't-collapse),
     // and which tier.
     let markOnly = null;
-    // L0 exact-match tier (contentHash / regionHash / summaryHash) — see add-l0.ts.
+    // Content digest for this candidate (also consumed by the L0 tier below).
     const digest = computeContentDigest(input.regionText);
+    // Degenerate-match guard (incident 2026-08-19): declines a fuzzy-tier collapse
+    // onto a content-free skeleton when the incoming region is richer, so the
+    // skeleton stops absorbing every future compaction. Returns true (having
+    // already recorded the decision) ⇒ the caller treats the match as a non-match.
+    // Flag-off ⇒ always false ⇒ byte-identical predecessor. See add-degenerate.ts.
+    const declineDegenerate = degenerateDecliner({
+        store,
+        input,
+        contentHash: digest.contentHash,
+        cfg,
+        audit,
+        t0,
+    });
+    // L0 exact-match tier (contentHash / regionHash / summaryHash) — see add-l0.ts.
     const bloom = openBloom(store.stateDir);
     const summaryHash = computeSummaryHash(input.topicSummary);
     const l0 = runL0Tier({
@@ -94,7 +109,10 @@ export function addCheckpoint(store, input) {
     onTier?.({ tier: "L1", status: "scanning" });
     if (cfg.L1_ENABLED) {
         const l1 = findL1Duplicate(store, sessionId, input.regionText, all);
-        if (l1 && !cfg.MARK_ONLY_L1) {
+        // Guard first: a declined match must not collapse and must not be recorded
+        // as a MARK_ONLY hit either — it is a non-match for the rest of the cascade.
+        const l1Declined = l1 !== undefined && declineDegenerate("L1", l1);
+        if (l1 && !l1Declined && !cfg.MARK_ONLY_L1) {
             l1.timestamp = input.timestamp;
             upsertCheckpoint(l1, store.stateDir);
             bumpDedupStats(true, store.stateDir);
@@ -105,7 +123,7 @@ export function addCheckpoint(store, input) {
             onTier?.({ tier: "L1", status: "deduped", detail: "l1MinHash" });
             return r;
         }
-        if (l1 && cfg.MARK_ONLY_L1)
+        if (l1 && !l1Declined && cfg.MARK_ONLY_L1)
             markOnly = "L1";
     }
     onTier?.({ tier: "L1", status: "passed" });
@@ -131,7 +149,12 @@ export function addCheckpoint(store, input) {
             const sim = cosineSimilarity(embedding, cp.embedding);
             return sim > best.sim ? { checkpoint: cp, sim } : best;
         }, { checkpoint: all[0], sim: -1 });
-        if (!timedOut && nearest.sim >= simThreshold) {
+        // A declined match falls through to the "store a fresh checkpoint" path; the
+        // guard already audited the decision, so the near-miss emit below is skipped.
+        const l2Declined = !timedOut &&
+            nearest.sim >= simThreshold &&
+            declineDegenerate("L2", nearest.checkpoint, nearest.sim);
+        if (!timedOut && !l2Declined && nearest.sim >= simThreshold) {
             if (!cfg.MARK_ONLY_L2) {
                 // Near-identical — update timestamp on existing checkpoint
                 nearest.checkpoint.timestamp = input.timestamp;
@@ -164,7 +187,7 @@ export function addCheckpoint(store, input) {
         // Near-miss: how close did we come to collapsing? Only emitted when the
         // scan actually completed and scored a candidate — a timed-out scan has no
         // honest best to report.
-        if (!timedOut && nearest.sim >= 0) {
+        if (!timedOut && !l2Declined && nearest.sim >= 0) {
             audit.passed("L2", nearest.checkpoint.checkpointId, nearest.sim);
         }
     }

package/dist/src/vectorStore/dedup-audit.js

@@ -69,6 +69,14 @@ export function dedupAuditRecorder(ctx, scope) {
             matchedEntry,
             similarity,
         }),
+        skipped: (tier, matchedEntry, dedupReason, similarity) => emitDedupAudit(ctx, {
+            ...base,
+            tier,
+            status: "skipped",
+            matchedEntry,
+            dedupReason,
+            ...(similarity === undefined ? {} : { similarity }),
+        }),
         stored: (storedEntry, dedupReason, tokenEstimate) => emitDedupAudit(ctx, {
             ...base,
             tier: "new",

package/dist/vector-cortex/dedup-attr/rollup.js

@@ -49,6 +49,11 @@ export function computeDedupTierRollup(events, windowMs, now) {
         const ts = Date.parse(ev.ts);
         if (Number.isNaN(ts) || ts < windowStart || ts > windowEnd)
             continue;
+        // "skipped" (degenerate-match guard declined a collapse) is a decision, but
+        // NOT a tier catch — it is attributed to no tier below. Excluding it from the
+        // denominator keeps l0Share + l1Share + l2Share summing to 1 over the window.
+        if (ev.status === "skipped")
+            continue;
         total += 1;
         switch (ev.tier) {
             case "L0":

package/dist/vectorStore/dedup-audit.js

@@ -69,6 +69,14 @@ export function dedupAuditRecorder(ctx, scope) {
             matchedEntry,
             similarity,
         }),
+        skipped: (tier, matchedEntry, dedupReason, similarity) => emitDedupAudit(ctx, {
+            ...base,
+            tier,
+            status: "skipped",
+            matchedEntry,
+            dedupReason,
+            ...(similarity === undefined ? {} : { similarity }),
+        }),
         stored: (storedEntry, dedupReason, tokenEstimate) => emitDedupAudit(ctx, {
             ...base,
             tier: "new",

package/extensions/dashboard-server/routes-dedup-attribution.ts

@@ -59,7 +59,17 @@ function parseAuditLine(line: string): DedupAuditEvent | null {
   const tier = obj.tier;
   const status = obj.status;
   if (tier !== "L0" && tier !== "L1" && tier !== "L2" && tier !== "new") return null;
-  if (status !== "deduped" && status !== "passed" && status !== "stored") return null;
+  // "skipped" = a tier matched but the degenerate-match guard declined to
+  // collapse. Accepted so the line is not silently dropped from the tail; the
+  // rollup below counts only deduped/passed, so tier catch-share math is
+  // unchanged by its presence.
+  if (
+    status !== "deduped" &&
+    status !== "passed" &&
+    status !== "stored" &&
+    status !== "skipped"
+  )
+    return null;
   // sessionId is never read by the rollup; a parsed line may omit richer fields.
   return { type: "dedup_audit", ts: obj.ts, tier, status, sessionId: "" };
 }

package/extensions/dashboard-server/routes-rag-settings-helpers.ts

@@ -228,6 +228,12 @@ export const SETTINGS: ReadonlyArray<SettingGroup> = [
 			boolDirect("MEGACOMPACT_MARK_ONLY_L1", "Mark Only L1", "L1 runs but does not collapse", false),
 			boolDirect("MEGACOMPACT_MARK_ONLY_L2", "Mark Only L2", "L2 runs but does not collapse", false),
 			boolDirect("MEGACOMPACT_MINILM", "MiniLM Embedder", "Use MiniLM instead of trigram", false),
+			boolDirect(
+				"MEGACOMPACT_DEDUP_DEGENERATE_GUARD",
+				"Degenerate Match Guard",
+				"Decline an L1/L2 collapse when the MATCHED stored checkpoint is a content-free skeleton (a ~30-40 token structural summary) and the incoming region is richer. Without this, one degenerate checkpoint absorbs every later compaction forever and the store can never heal. OFF = byte-identical pre-guard cascade. Calibrated by the two Degenerate floors under Dedup Thresholds.",
+				true,
+			),
 			boolDirect(
 				"MEGACOMPACT_DEDUP_AUDIT",
 				"Dedup Audit Trail",
@@ -242,6 +248,8 @@ export const SETTINGS: ReadonlyArray<SettingGroup> = [
 			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_DEDUP_DEGEN_MIN_TOKENS", "Degenerate Min Tokens", "Absolute token floor below which a stored summary counts as a degenerate skeleton (Degenerate Match Guard)", 48, 0, 10000, "tokens"),
+			num("MEGACOMPACT_DEDUP_DEGEN_MIN_PCT", "Degenerate Min Percent", "Relative floor as a fraction of the summary's original region size; a summary under max(min-tokens, pct x original) is degenerate", 0.005, 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),

package/extensions/mega-events/context-handler/headroom.ts

@@ -16,9 +16,56 @@
  * Pure functions, no runtime dependency — trivially unit-testable headlessly.
  */
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import { estimateBlockTokens, estimateMessageTokens } from "../../../src/tokens.js";
+import { estimateBlockTokens } from "../../../src/tokens.js";
 import { messageContentText } from "./messageText.js";
 
+/**
+ * Full-surface AgentMessage token estimate for BUDGET arithmetic (tail cap).
+ *
+ * convertToLlm (pi dist/core/messages.js) ships assistant/toolResult messages
+ * VERBATIM — every content block goes over the wire: text, thinking, toolCall
+ * (name + full `arguments` JSON), toolResult output, role wrappers. The text
+ * extractor (messageContentText) is lossy-on-purpose for analytics, and using
+ * it here made a GLM-4.7-style assistant message with ~11.6k bytes of toolCall
+ * arguments register as ~77 tokens — a 30k-token tail passed an 11.9k budget,
+ * the model overflowed, and pi's one-shot compact-and-retry failed
+ * ("Context overflow recovery failed", 2026-08-20 incident).
+ *
+ * Counts every byte the provider actually receives. Still a heuristic (len/4
+ * + 1 per block, like estimateBlockTokens) — just no longer lossy. Never
+ * throws: unknown block shapes fall back to their JSON serialization length,
+ * and a non-array/string content is counted as its serialization.
+ */
+export function estimateAgentMessageBudgetTokens(m: AgentMessage): number {
+	try {
+		const c = (m as { content?: unknown }).content;
+		let bytes = 0;
+		if (typeof c === "string") {
+			bytes += c.length;
+		} else if (Array.isArray(c)) {
+			for (const b of c) {
+				if (b == null || typeof b !== "object") continue;
+				const o = b as Record<string, unknown>;
+				if (typeof o.text === "string") bytes += o.text.length;
+				if (typeof o.thinking === "string") bytes += o.thinking.length;
+				if (typeof o.name === "string") bytes += o.name.length;
+				if (o.arguments != null) bytes += JSON.stringify(o.arguments).length;
+				if (typeof o.output === "string") bytes += o.output.length;
+				// Per-block envelope overhead (role/type markers), matching the
+				// len/4+1 block accounting in estimateBlockTokens.
+				bytes += 4;
+			}
+		} else if (c != null) {
+			bytes += JSON.stringify(c).length;
+		}
+		return estimateBlockTokens(" ".repeat(Math.max(0, bytes)));
+	} catch {
+		// non-fatal: fall back to the legacy text-only estimate rather than
+		// disable the cap on a pathological message.
+		return estimateBlockTokens(messageContentText(m));
+	}
+}
+
 /**
  * The model's declared maxTokens is only trusted as the output budget when it
  * is plausible. models.json carries sentinel junk for some entries (1e9,
@@ -143,7 +190,7 @@ export function applyTailCap(opts: {
 		tailTokens +=
 			msgTokens != null
 				? Math.max(0, msgTokens[i])
-				: estimateMessageTokens({ text: messageContentText(recentRaw[i]) });
+				: estimateAgentMessageBudgetTokens(recentRaw[i]);
 		if (tailTokens > budget) {
 			// Keep from i+1 onward; never drop below the FINAL message.
 			start = Math.min(i + 1, recentRaw.length - 1);
@@ -181,7 +228,7 @@ export function recapReplayedTail(opts: {
 }): { recent: AgentMessage[]; dropped: number } {
 	return applyTailCap({
 		recentRaw: opts.recentRaw,
-		summaryTokens: estimateBlockTokens(messageContentText(opts.summaryAgentMsg)),
+		summaryTokens: estimateAgentMessageBudgetTokens(opts.summaryAgentMsg),
 		ctxWindow: opts.ctxWindow,
 		maxOutputTokens: opts.maxOutputTokens,
 		outputReservePct: opts.outputReservePct,

package/extensions/mega-events/context-handler/liveTrim.ts

@@ -170,8 +170,12 @@ export function buildLiveTrimView(
 			// (rt.lastCheckpointId) instead of ran.result.checkpointId, which is
 			// dedup-volatile: on a re-compact that dedups onto a DIFFERENT existing
 			// checkpoint, result.checkpointId is the matched id (engine.ts:188) while
-			// lastCheckpointId is only updated on a genuinely new checkpoint
-			// (compact.ts:100-104). Keying on result.checkpointId would make
+			// lastCheckpointId was, pre-C1, only updated on a genuinely new checkpoint.
+			// C1 (v0.21.10) now stamps lastCheckpointId on the dedup path too (see
+			// compact/run.ts) — it means "the checkpoint backing this epoch" — so this
+			// key and the D.2/D.3 comparison agree in both directions and the `??`
+			// fallbacks below are now only for the truly-no-checkpoint edge case.
+			// Keying on result.checkpointId directly would still make
 			// trimCache.checkpointId != rt.lastCheckpointId forever after that
 			// dedup fire, disabling replay for the rest of the epoch (the
 			// alternating cache-miss that 0.8.6 meant to fix). Prefer the stable

package/extensions/mega-events/context-handler.ts

@@ -219,8 +219,14 @@ export function registerContextHandler(
 
 		// Debounce so we don't fire on every context event past threshold.
 		// (Replay already returned above — only fresh compacts reach this point.)
+		// C2 (v0.21.10): EXEMPT headroom-triggered fires, matching the thrash-guard
+		// exemption above. pi's own overflow recovery (400 → compact → immediate
+		// retry) re-fires a context event <2s after our last fire; debouncing it
+		// returned the RAW untrimmed view, so input + output reserve still blew the
+		// window → 400 → "recovery failed after one compact-and-retry attempt".
+		// An overflowed session is unrecoverable; a re-fire is merely wasteful.
 		const now = Date.now();
-		if (now < runtime.debounceUntil) {
+		if (now < runtime.debounceUntil && !gate.headroomExceeded) {
 			runtime.diagCtxDebounce++;
 			return tailResult() ?? undefined;
 		}

package/extensions/mega-pipeline/compact/run.ts

@@ -109,10 +109,20 @@ function doCompact(
 	runtime.pulsing = false;
 
 	if (result.skipped) return { skipped: true };
-	if (!result.deduped) {
-		runtime.rt.persistedThisSession = true;
-		runtime.rt.lastCheckpointId = result.checkpointId;
-	}
+	// C1 (v0.21.10): lastCheckpointId tracks "the checkpoint backing this epoch",
+	// so it is stamped on BOTH paths — a matched-dedup checkpoint backs this epoch
+	// just as much as a freshly created one. Previously the dedup path left it
+	// undefined, so a runtime session whose every compaction deduped (common after
+	// a process restart, when checkpoints persist but `rt` is rebuilt) never set it
+	// → liveTrim's trimCache fell back to result.checkpointId (the matched id) →
+	// `trimCache.checkpointId === rt.lastCheckpointId` was `"chkpt_001" !== undefined`
+	// → the D.2/D.3 replay NEVER matched and the full pipeline re-ran on every
+	// context event (liveTrimReplays: 0, "comp lag warn"). A later fire matching a
+	// DIFFERENT checkpoint now changes the key once (one cache regeneration), then
+	// replays stabilise. `persistedThisSession` keeps its narrower meaning ("we
+	// wrote NEW state this session") and stays gated on !deduped.
+	if (!result.deduped) runtime.rt.persistedThisSession = true;
+	runtime.rt.lastCheckpointId = result.checkpointId;
 	runtime.rt.lastCompactedFrom = result.compactedFrom;
 	runtime.rt.lastCompactedTokens = result.tokenEstimate;
 	runtime.rt.dedupAttempts++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.21.9",
+  "version": "0.21.11",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",

package/src/config/dedup.ts

@@ -66,6 +66,18 @@ export interface DedupConfigShape {
   L2_COSINE_CODE: number | null;
   L2_COSINE_PROSE: number | null;
   L1_JACCARD: number; // MinHash/LSH near-dup verification
+  /**
+   * Degenerate-match guard (incident 2026-08-19). ON declines an L1/L2 collapse
+   * when the MATCHED stored checkpoint is a content-free skeleton and the
+   * incoming candidate is richer, so a degenerate checkpoint can no longer
+   * absorb every future compaction forever. OFF is byte-identical to the
+   * pre-guard cascade. See src/dedup/degenerate.ts.
+   */
+  DEDUP_DEGENERATE_GUARD: boolean;
+  /** Absolute token floor under which a stored summary counts as degenerate. */
+  DEDUP_DEGEN_MIN_TOKENS: number;
+  /** Relative floor as a fraction of the summary's original region size. */
+  DEDUP_DEGEN_MIN_PCT: number;
   DEDUP_SIM: number; // legacy content-similarity fallback
   MMR_LAMBDA: number; // retrieval diversity
   SEMDEDUP_COSINE: number; // offline SemDeDup pair threshold
@@ -123,6 +135,9 @@ export function loadDedupConfig(): DedupConfigShape {
     L2_COSINE_CODE: envNumOrNull("MEGACOMPACT_L2_THRESHOLD_CODE"),
     L2_COSINE_PROSE: envNumOrNull("MEGACOMPACT_L2_THRESHOLD_PROSE"),
     L1_JACCARD: envNum("MEGACOMPACT_L1_JACCARD", 0.8),
+    DEDUP_DEGENERATE_GUARD: envBool("MEGACOMPACT_DEDUP_DEGENERATE_GUARD", true),
+    DEDUP_DEGEN_MIN_TOKENS: envNum("MEGACOMPACT_DEDUP_DEGEN_MIN_TOKENS", 48),
+    DEDUP_DEGEN_MIN_PCT: envNum("MEGACOMPACT_DEDUP_DEGEN_MIN_PCT", 0.005),
     DEDUP_SIM: envNum("MEGACOMPACT_DEDUP_SIM", 0.9),
     MMR_LAMBDA: envNum("MEGACOMPACT_MMR_LAMBDA", 0.5),
     SEMDEDUP_COSINE: envNum("MEGACOMPACT_SEMDEDUP_COSINE", 0.95),