pi-mega-compact 0.21.9 → 0.21.11

package/dist/dedup/degenerate.js

@@ -0,0 +1,68 @@
+/**
+ * The effective token floor for a checkpoint: the larger of the absolute floor
+ * and `MIN_PCT × originalTokenEstimate`.
+ *
+ * A missing / zero / non-finite `originalTokenEstimate` contributes nothing, so
+ * the absolute floor applies alone — direct add() callers and pre-v0.4 rows that
+ * never recorded the original region size are judged on absolute size only,
+ * never accidentally deemed degenerate by a 0-valued percentage term.
+ */
+export function degenerateFloor(subject, tunables) {
+    const orig = subject.originalTokenEstimate;
+    const relative = typeof orig === "number" && Number.isFinite(orig) && orig > 0
+        ? orig * tunables.DEDUP_DEGEN_MIN_PCT
+        : 0;
+    return Math.max(tunables.DEDUP_DEGEN_MIN_TOKENS, relative);
+}
+/**
+ * Is this stored checkpoint a degenerate (content-free) summary?
+ *
+ * Calibration against the incident data:
+ *  - skeleton: tokenEstimate 34, original ≈19166 → 34 < max(48, 95.8) → TRUE
+ *  - normal:   tokenEstimate 2000, original 70000 → 2000 > max(48, 350) → FALSE
+ *
+ * The relative term is what makes this scale: a 34-token summary of a 900-token
+ * region is a legitimate 26× compression, while the same 34 tokens standing in
+ * for 19k is a skeleton.
+ */
+export function isDegenerateCheckpoint(subject, tunables) {
+    const tokens = subject.tokenEstimate ?? 0;
+    return tokens < degenerateFloor(subject, tunables);
+}
+/**
+ * Should an L1/L2 match be DECLINED because it would collapse richer incoming
+ * content onto a degenerate stored checkpoint?
+ *
+ * Returns true only when all four hold:
+ *   1. the umbrella flag is ON,
+ *   2. the matched (stored) checkpoint is degenerate,
+ *   3. the candidate is strictly richer than the match,
+ *   4. the candidate's content is not byte-identical to the match's.
+ *
+ * Condition 3 uses a strict `>`: equal-size skeletons collapsing is harmless and
+ * keeps the store from growing one row per compaction while the summarizer is
+ * broken. Only a genuine improvement is worth declining a collapse for.
+ *
+ * Condition 4 is a CORRECTNESS requirement, not a refinement. `context_chunks`
+ * carries a partial UNIQUE index on (session_id, content_hash) (schema/core.ts
+ * QA #1), so declining a match whose content hash already exists would fall
+ * through to an INSERT that throws — inside add(), which sits on the agent loop.
+ * It is also the semantically right call: identical bytes are the SAME region,
+ * so re-storing them adds no information and heals nothing. Only L0 may own the
+ * exact-match case; the guard exists for fuzzy matches on genuinely different
+ * text, which is exactly the incident's shape (each compaction produced a
+ * *similar but distinct* skeleton).
+ */
+export function shouldSkipDegenerateMatch(matched, candidate, tunables) {
+    if (!tunables.DEDUP_DEGENERATE_GUARD)
+        return false;
+    if (!isDegenerateCheckpoint(matched, tunables))
+        return false;
+    if ((candidate.tokenEstimate ?? 0) <= (matched.tokenEstimate ?? 0))
+        return false;
+    // Byte-identical content → not a healing opportunity (and would violate the
+    // UNIQUE index). Compared only when both hashes are known.
+    const a = candidate.contentHash;
+    const b = matched.contentHash;
+    return !(a !== undefined && b !== undefined && a === b);
+}

package/dist/extensions/dashboard-server/routes-dedup-attribution.js

@@ -50,7 +50,14 @@ function parseAuditLine(line) {
     const status = obj.status;
     if (tier !== "L0" && tier !== "L1" && tier !== "L2" && tier !== "new")
         return null;
-    if (status !== "deduped" && status !== "passed" && status !== "stored")
+    // "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/dist/extensions/dashboard-server/routes-rag-settings-helpers.js

@@ -85,6 +85,7 @@ export const SETTINGS = [
             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", "Append one events.log line per tier decision (which layer collapsed a region, onto what, at what similarity) to tune the thresholds below. Pure instrumentation — dedup behavior is identical either way.", true),
         ],
     },
@@ -94,6 +95,8 @@ export const SETTINGS = [
             num("MEGACOMPACT_L2_THRESHOLD", "L2 Cosine Threshold", "L2 semantic dedup firing point", 0.85, 0, 1),
             num("MEGACOMPACT_L1_JACCARD", "L1 Jaccard Threshold", "L1 MinHash near-dup threshold", 0.8, 0, 1),
             num("MEGACOMPACT_DEDUP_SIM", "Dedup Similarity", "Legacy content-similarity fallback", 0.9, 0, 1),
+            num("MEGACOMPACT_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/dist/extensions/mega-events/context-handler/headroom.js

@@ -1,5 +1,60 @@
-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) {
+    try {
+        const c = m.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;
+                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,
@@ -91,7 +146,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);
@@ -119,7 +174,7 @@ export function applyTailCap(opts) {
 export function recapReplayedTail(opts) {
     return applyTailCap({
         recentRaw: opts.recentRaw,
-        summaryTokens: estimateBlockTokens(messageContentText(opts.summaryAgentMsg)),
+        summaryTokens: estimateAgentMessageBudgetTokens(opts.summaryAgentMsg),
         ctxWindow: opts.ctxWindow,
         maxOutputTokens: opts.maxOutputTokens,
         outputReservePct: opts.outputReservePct,

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

@@ -115,8 +115,12 @@ export function buildLiveTrimView(runtime, config, ctx, opts) {
             // (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/dist/extensions/mega-events/context-handler.js

@@ -183,8 +183,14 @@ export function registerContextHandler(pi, runtime, config) {
         }
         // 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/dist/extensions/mega-pipeline/compact/run.js

@@ -71,10 +71,21 @@ function doCompact(view, keepFrom, opts, sid, config, pi, ctx, runtime) {
     runtime.pulsing = false;
     if (result.skipped)
         return { skipped: true };
-    if (!result.deduped) {
+    // 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.lastCheckpointId = result.checkpointId;
     runtime.rt.lastCompactedFrom = result.compactedFrom;
     runtime.rt.lastCompactedTokens = result.tokenEstimate;
     runtime.rt.dedupAttempts++;

package/dist/src/config/dedup.js

@@ -63,6 +63,9 @@ export function loadDedupConfig() {
         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),

package/dist/src/dedup/degenerate.js

@@ -0,0 +1,68 @@
+/**
+ * The effective token floor for a checkpoint: the larger of the absolute floor
+ * and `MIN_PCT × originalTokenEstimate`.
+ *
+ * A missing / zero / non-finite `originalTokenEstimate` contributes nothing, so
+ * the absolute floor applies alone — direct add() callers and pre-v0.4 rows that
+ * never recorded the original region size are judged on absolute size only,
+ * never accidentally deemed degenerate by a 0-valued percentage term.
+ */
+export function degenerateFloor(subject, tunables) {
+    const orig = subject.originalTokenEstimate;
+    const relative = typeof orig === "number" && Number.isFinite(orig) && orig > 0
+        ? orig * tunables.DEDUP_DEGEN_MIN_PCT
+        : 0;
+    return Math.max(tunables.DEDUP_DEGEN_MIN_TOKENS, relative);
+}
+/**
+ * Is this stored checkpoint a degenerate (content-free) summary?
+ *
+ * Calibration against the incident data:
+ *  - skeleton: tokenEstimate 34, original ≈19166 → 34 < max(48, 95.8) → TRUE
+ *  - normal:   tokenEstimate 2000, original 70000 → 2000 > max(48, 350) → FALSE
+ *
+ * The relative term is what makes this scale: a 34-token summary of a 900-token
+ * region is a legitimate 26× compression, while the same 34 tokens standing in
+ * for 19k is a skeleton.
+ */
+export function isDegenerateCheckpoint(subject, tunables) {
+    const tokens = subject.tokenEstimate ?? 0;
+    return tokens < degenerateFloor(subject, tunables);
+}
+/**
+ * Should an L1/L2 match be DECLINED because it would collapse richer incoming
+ * content onto a degenerate stored checkpoint?
+ *
+ * Returns true only when all four hold:
+ *   1. the umbrella flag is ON,
+ *   2. the matched (stored) checkpoint is degenerate,
+ *   3. the candidate is strictly richer than the match,
+ *   4. the candidate's content is not byte-identical to the match's.
+ *
+ * Condition 3 uses a strict `>`: equal-size skeletons collapsing is harmless and
+ * keeps the store from growing one row per compaction while the summarizer is
+ * broken. Only a genuine improvement is worth declining a collapse for.
+ *
+ * Condition 4 is a CORRECTNESS requirement, not a refinement. `context_chunks`
+ * carries a partial UNIQUE index on (session_id, content_hash) (schema/core.ts
+ * QA #1), so declining a match whose content hash already exists would fall
+ * through to an INSERT that throws — inside add(), which sits on the agent loop.
+ * It is also the semantically right call: identical bytes are the SAME region,
+ * so re-storing them adds no information and heals nothing. Only L0 may own the
+ * exact-match case; the guard exists for fuzzy matches on genuinely different
+ * text, which is exactly the incident's shape (each compaction produced a
+ * *similar but distinct* skeleton).
+ */
+export function shouldSkipDegenerateMatch(matched, candidate, tunables) {
+    if (!tunables.DEDUP_DEGENERATE_GUARD)
+        return false;
+    if (!isDegenerateCheckpoint(matched, tunables))
+        return false;
+    if ((candidate.tokenEstimate ?? 0) <= (matched.tokenEstimate ?? 0))
+        return false;
+    // Byte-identical content → not a healing opportunity (and would violate the
+    // UNIQUE index). Compared only when both hashes are known.
+    const a = candidate.contentHash;
+    const b = matched.contentHash;
+    return !(a !== undefined && b !== undefined && a === b);
+}

package/dist/src/extractive-salvage.js

@@ -0,0 +1,195 @@
+/**
+ * extractive-salvage.ts — file-path policy + skeleton salvage for extractive.ts.
+ *
+ * Extracted from extractive.ts (A1/A2 sprint) to keep that file under the
+ * 300-line src/ soft limit. Pure functions only — no I/O, no logging.
+ *
+ * DESIGN (A1): blocklist, not allowlist. The old `INTERESTING_EXT` allowlist
+ * (rs/ts/tsx/js/json/md) silently produced content-free summaries for every
+ * other language — a .go/.py/.c project got a 34-token skeleton. An allowlist
+ * has to be *right* about ~40 ecosystems to be useful and fails closed (drops
+ * real work) when it is wrong; a NOISE blocklist only has to be right about the
+ * small, stable set of binary/generated/asset extensions and fails open (an
+ * unknown extension is surfaced, which is the safe direction for a summary).
+ */
+// ---- File path policy ------------------------------------------------------
+/**
+ * Generic extension capture: any 1–6 char ALPHABETIC extension. Path
+ * character class is unchanged from the original FILE_PATH_RE so existing
+ * matching behaviour (quotes/backticks/whitespace as delimiters) is preserved.
+ * Alphabetic-only is deliberate: every real source/config extension is alpha
+ * (c..tsx, tsconfig.json), while an alphanumeric class matches version strings
+ * ("GLM-4.7", "v0.21.9", "Node 18.2") as "files" and spams Key files.
+ */
+export const FILE_PATH_RE = /(?:^|\s)([^\s"`']+\.([A-Za-z]{1,6}))\b/g;
+/** Same policy, single-match, for inferCurrentWork (also excludes ':'). */
+export const CURRENT_WORK_PATH_RE = /(?:^|\s)([^\s"`':]+\.([A-Za-z]{1,6}))\b/m;
+/**
+ * Binary / generated / asset / vendored extensions that carry no summary value.
+ * Deliberately small and stable. Note `md`, `json`, `toml`, `yaml`, `sql`, `css`
+ * and `html` are NOT noise — they are hand-edited source in most repos.
+ */
+export const NOISE_EXT = new Set([
+    // lockfiles & logs
+    "lock", "log", "sum",
+    // images & media
+    "png", "jpg", "jpeg", "gif", "webp", "svg", "ico", "bmp", "tiff",
+    "mp3", "mp4", "mov", "wav", "webm", "avi",
+    // fonts
+    "woff", "woff2", "ttf", "otf", "eot",
+    // archives & binaries
+    "zip", "gz", "tgz", "bz2", "xz", "7z", "rar", "tar",
+    "exe", "dll", "so", "dylib", "bin", "o", "a", "obj", "class", "pyc", "pyo",
+    "wasm", "node", "jar", "war", "deb", "rpm", "dmg", "iso", "img",
+    // generated / build artifacts
+    "map", "min", "lockb", "snap", "cache", "tmp", "temp", "swp", "bak", "orig",
+    // data blobs & databases
+    "pdf", "db", "sqlite", "sqlite3", "pack", "idx", "pem", "key", "crt",
+]);
+/** Directory fragments whose files are never "key files" for a summary. */
+const NOISE_DIR_RE = /(?:^|\/)(?:node_modules|\.git|dist|build|coverage|vendor|target|__pycache__|\.venv|venv)(?:\/|$)/;
+/**
+ * TLD-shaped extensions: `example.com`, `github.com`, `npm.cmd` are domains and
+ * launchers, not code. (QA lens 1 finding, 2026-08-19.) Conservative list only —
+ * no real source extension lives here (.go/.rs/.ts stay interesting).
+ */
+const TLD_EXT = new Set([
+    "com", "org", "net", "io", "gov", "edu", "biz", "info", "dev", "app",
+    "page", "xyz", "site", "online", "cloud", "me", "co", "us", "uk", "de",
+    "fr", "jp", "cn", "nl", "se", "eu", "int", "mil", "cmd",
+]);
+/** True when a matched path is worth surfacing in a summary. */
+export function isInterestingPath(filePath, ext) {
+    const lowerExt = ext.toLowerCase();
+    if (NOISE_EXT.has(lowerExt))
+        return false;
+    if (TLD_EXT.has(lowerExt))
+        return false; // bare domains, not code
+    if (/^(?:https?|ftp):\/\//i.test(filePath) || filePath.toLowerCase().startsWith("www."))
+        return false;
+    if (NOISE_DIR_RE.test(filePath))
+        return false;
+    // `app.min.js` / `bundle.min.css` style double extensions.
+    if (/\.min\.[A-Za-z0-9]{1,6}$/.test(filePath))
+        return false;
+    if (/\.map$/.test(filePath))
+        return false;
+    // Prose abbreviations ("e.g", "i.e", "U.S"): a single-char base with no slash
+    // and no digit is never a filename. ("a.c" is rare collateral; "q1.py" and
+    // "src/a.ts" survive — digit / slash both exempt.)
+    const base = filePath.slice(0, filePath.lastIndexOf("."));
+    if (!filePath.includes("/") && !/\d/.test(filePath) && base.length <= 1)
+        return false;
+    return true;
+}
+// ---- Path collection -------------------------------------------------------
+const MAX_KEY_FILES = 5;
+const MAX_FILES = 10;
+const FRESHNESS_WINDOW = 10;
+/** All interesting file paths mentioned in a blob of text. */
+export function extractFilePaths(text) {
+    const paths = [];
+    for (const m of text.matchAll(FILE_PATH_RE)) {
+        if (isInterestingPath(m[1], m[2]))
+            paths.push(m[1]);
+    }
+    return paths;
+}
+/** Most-mentioned paths within the recency window (behaviour unchanged). */
+export 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);
+}
+/** Paths written/edited by tools (extension-agnostic; behaviour unchanged). */
+export 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") {
+            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);
+}
+// ---- Placeholder user turns (A2b) ------------------------------------------
+/**
+ * Content-free user turns. Extremely common in resumed sessions; taking them
+ * verbatim as "User requests" is what produced the three "• resume" bullets.
+ */
+const PLACEHOLDER_RE = /^(?:resume|continue|go on|go ahead|proceed|next|yes|yeah|yep|y|ok|okay|k|sure|thanks|thank you|ty|done|please continue|carry on)\W*$/i;
+export function isPlaceholderRequest(text) {
+    return PLACEHOLDER_RE.test(text.trim());
+}
+// ---- Skeleton salvage (A2c) ------------------------------------------------
+const MAX_SALVAGE_LINES = 5;
+const SALVAGE_LINE_LEN = 120;
+/**
+ * A "skeleton" summary is the scope line and nothing else — no files, no current
+ * work, no decisions, no pending items, and no *substantive* user request. That
+ * is ~34 tokens of zero information and is what breaks a resumed session.
+ *
+ * NOTE: `recentUser` is treated as empty when it holds only placeholders. The
+ * incident summary DID have three "• resume" bullets, so a plain
+ * `recentUser.length === 0` test would never have fired on the very case this
+ * salvage exists for.
+ */
+export function isSkeletonSummary(parts) {
+    const hasRealRequest = parts.recentUser.some((r) => !isPlaceholderRequest(r));
+    return (!hasRealRequest &&
+        parts.keyFiles.length === 0 &&
+        !parts.currentWork &&
+        parts.decisions.length === 0 &&
+        parts.pending.length === 0);
+}
+/**
+ * Last-resort content: the first meaningful line of the most recent assistant
+ * and tool messages. Deterministic (pure scan, newest-first, then re-ordered
+ * oldest-first for reading). Returns [] when there is genuinely nothing.
+ */
+export function buildSalvageDigest(messages) {
+    const out = [];
+    const seen = new Set();
+    for (let i = messages.length - 1; i >= 0 && out.length < MAX_SALVAGE_LINES; i--) {
+        const m = messages[i];
+        if (m.role !== "assistant" && m.role !== "tool")
+            continue;
+        const raw = m.text || m.output || m.input || "";
+        const line = raw
+            .split("\n")
+            .map((l) => l.trim())
+            .find((l) => l.length > 0);
+        if (!line)
+            continue;
+        const label = m.role === "tool" ? `${m.toolName ?? "tool"}: ` : "";
+        const entry = truncateLine(`${label}${line}`, SALVAGE_LINE_LEN);
+        if (seen.has(entry))
+            continue;
+        seen.add(entry);
+        out.push(entry);
+    }
+    return out.reverse();
+}
+function truncateLine(s, maxLen) {
+    return s.length <= maxLen ? s : s.slice(0, maxLen - 1) + "…";
+}