@sema-ai/core 1.275.1

package/dist/core/auto-compaction.js

@@ -0,0 +1,495 @@
+import { DEFAULT_CHARS_PER_TOKEN, DEFAULT_COMPACTION_SETTINGS, compact, computeFileLists, estimateContextTokens, estimateTokens, prepareCompaction, shouldCompact, } from "../internal/harness.js";
+import { EDIT_FRACTION } from "./context-edit.js";
+import { brainToRuntime } from "./runtime.js";
+/**
+ * Default summarization focus, applied when a task does not provide `compaction.instructions`.
+ * Addresses the common fidelity failure where summaries drop specific facts.
+ */
+export const DEFAULT_COMPACTION_INSTRUCTIONS = "Preserve verbatim every code, identifier, name, number, file path, error message, credential " +
+    "reference, and explicit user instruction or decision mentioned anywhere in the conversation. " +
+    "When in doubt, keep the specific detail rather than generalizing it.";
+// Fallback reserve fraction used ONLY when the configured reserve is pathological for the window.
+const FALLBACK_RESERVE_FRACTION = 0.15;
+/**
+ * SEMA-ONLY (trim-seam defense, no CC analogue) — stale-anchor freshness margin: a usage anchor is
+ * trusted only while the anchored estimate stays within `structural × margin + overhead` of the
+ * current message list. 2 covers the worst measured structural under-count (charsPerToken=3 vs a
+ * measured ~2.18 true ratio ⇒ ≤ ~1.4x) plus reasoning-block accounting slop, while still catching
+ * the live deception band (anchored estimates 2.9x–18x over the real context — docs/TOKEN-ESTIMATE-
+ * CALIBRATION-LIVE-2026-07-09.md §3/§4).
+ */
+export const STALE_ANCHOR_STRUCTURAL_MARGIN = 2;
+/**
+ * Repair compaction settings that are PATHOLOGICAL for the model's context window — without touching
+ * self-consistent explicit configuration (a deliberately large `reserveTokens` is a legitimate
+ * "compact early" knob, e.g. for long-run testing).
+ *
+ * DEFAULT_COMPACTION_SETTINGS (reserve 16384 / keepRecent 20000) are tuned for ≥100K windows; on a
+ * small window W they break in two compounding ways (found via LONGRUN-1's 12K declared window):
+ *   1. threshold = W - reserve ≤ 0 → `shouldCompact` fires at EVERY turn boundary;
+ *   2. keepRecent ≥ threshold → even a successful compaction leaves the kept tail at/over the
+ *      threshold; worse, `findCutPoint` with keepRecent ≥ the whole history falls back to the
+ *      EARLIEST valid cut point, summarizing a sliver of the head. Together: one real LLM summary
+ *      call per boundary, forever (thrash + cost explosion).
+ *   3. (design/64 §26.4 fix 2 — the prefix-cache "death band") threshold ABOVE the clearStale point
+ *      (`EDIT_FRACTION` = 0.7W): between 0.7W and the threshold, every request advances the
+ *      tool-result clearing frontier → breaks the prefix cache at the frontier → ~0.7W re-prefilled
+ *      PER REQUEST (at a 262K window with the default reserve that band is ~40 turns × ~183K tokens
+ *      per compaction cycle). Verified on the real vLLM gateway (search [87]-[89]: post-compaction
+ *      collapse + steady-state block reuse + stable-stub frontier mechanics).
+ * Repairs: (1) → reserve falls back to 15% of the window; (3) → threshold is clamped to ≤ 0.7W
+ * (compaction always fires before clearStale can engage — summarize-then-never-clear beats
+ * clear-then-summarize on both cache reuse AND fidelity); (2) → keepRecent drops to half the
+ * (post-clamp) threshold. (3) applies to explicit settings too: `editAt` is not user-configurable,
+ * so a threshold above it can never express consistent intent — compacting at 0.7W is strictly
+ * better for that caller (content is summarized, not stub-cleared). Settings already satisfying all
+ * three pass through unchanged (same object).
+ */
+export function sanitizeCompactionSettings(settings, contextWindow) {
+    if (!contextWindow || !Number.isFinite(contextWindow) || contextWindow <= 0) {
+        return settings;
+    }
+    let reserveTokens = settings.reserveTokens;
+    if (contextWindow - reserveTokens <= 0) {
+        reserveTokens = Math.ceil(contextWindow * FALLBACK_RESERVE_FRACTION); // pathology 1: threshold ≤ 0
+    }
+    const editAt = Math.floor(contextWindow * EDIT_FRACTION);
+    if (contextWindow - reserveTokens > editAt) {
+        reserveTokens = contextWindow - editAt; // pathology 3: threshold above clearStale = death band
+    }
+    const threshold = contextWindow - reserveTokens;
+    let keepRecentTokens = settings.keepRecentTokens;
+    if (keepRecentTokens >= threshold) {
+        keepRecentTokens = Math.max(1, Math.floor(threshold / 2)); // pathology 2: kept tail alone re-triggers
+    }
+    if (reserveTokens === settings.reserveTokens && keepRecentTokens === settings.keepRecentTokens) {
+        return settings;
+    }
+    return { ...settings, reserveTokens, keepRecentTokens };
+}
+/**
+ * Compact the session in place when context usage exceeds the threshold.
+ *
+ * Two call sites, same policy: the within-task `turn_boundary` hook (design/64 §25 (A) — after the
+ * session flush, before the next request's context rebuild) and `finish()` at task end. The caller
+ * must ensure no session write is in flight (both sites are between model requests, post-flush).
+ *
+ * THROWS (council §26.6 #6 contract note): a summarization failure — including a summary that came
+ * back EMPTY after the analysis-block strip (a real LLM call was burned, history left untouched) —
+ * is thrown, not swallowed; callers are expected to catch, count it toward the §17.4 breaker, and
+ * surface it via onError. A legitimate nothing-to-compact (under threshold/floor, no cut point)
+ * returns `{compacted:false}` quietly.
+ * Honors an optional cheaper `compactionModel` without mutating the harness's active model.
+ * Zero-config: uses DEFAULT_COMPACTION_SETTINGS unless overridden; settings pathological for the
+ * model's window are repaired via {@link sanitizeCompactionSettings}.
+ */
+export async function maybeCompact(opts) {
+    const compactStartAt = Date.now();
+    const rawSettings = opts.settings ?? DEFAULT_COMPACTION_SETTINGS;
+    if (!rawSettings.enabled) {
+        return { compacted: false, disabled: true }; // MF-18 修①: distinguishable from a structural no-op
+    }
+    const ctx = await opts.session.buildContext();
+    // design/123 D2: structural coefficient of the model whose window bounds this budget (the one
+    // that runs the next turn) — every structural quantity in this function lives in that coordinate.
+    const cpt = opts.model.charsPerToken ?? DEFAULT_CHARS_PER_TOKEN;
+    const est = estimateContextTokens(ctx.messages, cpt);
+    const overhead = opts.overheadTokens ?? 0;
+    // SEMA-ONLY stale-anchor freshness gate (trim-seam derived; no CC analogue — CC has no request-layer
+    // trim, so its anchors cannot outlive the context they measured). Live anchor: docs/TOKEN-ESTIMATE-
+    // CALIBRATION-LIVE-2026-07-09.md §4 — after a cache-break + trim collapse the real context was 2888
+    // tokens while the anchored estimate extrapolated est=52925 (18x) from a stale ~44k pre-collapse
+    // usage anchor; 21/23 live compactions (91%) fired prematurely on such over-estimates (est/real
+    // 2.9x–18x). The D1 strip (buildSessionContext) only retires anchors replayed across a COMPACTION
+    // boundary; an anchor whose surrounding context collapsed via trim/cache-break survives the scan
+    // (the compaction.ts stale-anchor note warned exactly this, but the gate had no invalidity check).
+    // Freshness invariant: a usage anchor bills the request that PRODUCED it — that request can only
+    // have contained what the current message list still holds (structural), plus the fixed prompt
+    // overhead. When the anchored estimate exceeds that ceiling with margin (structural under-counts
+    // by ≤ ~1.4x on real tokenizers: charsPerToken=3 vs measured ~2.18 — same doc §2), the context the
+    // anchor described no longer exists ⇒ the anchor is stale ⇒ fall back to the pure structural
+    // estimate (+ overhead), which is what the next request can actually contain.
+    const structuralTokens = ctx.messages.reduce((sum, m) => sum + estimateTokens(m, cpt), 0);
+    const anchorStale = est.usageTokens > 0 && est.tokens > structuralTokens * STALE_ANCHOR_STRUCTURAL_MARGIN + overhead;
+    // Anchor-less fallback (and the stale-anchor fallback) count messages only — add the fixed prompt
+    // overhead so the threshold comparison is like-for-like (see `overheadTokens`). Anchored (fresh):
+    // the overhead is already billed in.
+    const tokens = anchorStale || est.usageTokens === 0 ? structuralTokens + overhead : est.tokens;
+    const window = opts.model.contextTokens ?? opts.model.contextWindow;
+    // Small-window sanity: repair settings that are pathological for this window (threshold ≤ 0 /
+    // keepRecent ≥ threshold) so compaction neither always-triggers nor thrashes; self-consistent
+    // explicit settings pass through unchanged (see sanitizeCompactionSettings).
+    const settings = sanitizeCompactionSettings(rawSettings, window);
+    // `force` (manual /compact) bypasses the auto-threshold + anti-thrash floor; it still falls through to
+    // prepareCompaction, which returns `{compacted:false}` if there is no valid cut point (nothing to compact).
+    // design/123 D4 (r5): `forceUnderThreshold` (trim pressure) forces exactly when the NATURAL gate would
+    // not fire — est < max(threshold, minTokens-floor). See the option doc for the two regimes it rescues.
+    const wantsCompact = shouldCompact(tokens, window, settings);
+    const naturalTrigger = wantsCompact && tokens >= (opts.minTokens ?? 0);
+    const force = opts.force || (opts.forceUnderThreshold === true && !naturalTrigger);
+    if (!force && !naturalTrigger) {
+        // service [398] C3: over the threshold but UNDER the anti-thrash floor — compaction WANTED to
+        // fire and was suppressed. The success-only onCompaction path never fires here, so without this
+        // signal a run drifts into the request-trim / prefix-cache-collapse band with zero telemetry.
+        if (wantsCompact) {
+            return { compacted: false, suppressedByFloor: { estTokens: tokens, floor: opts.minTokens ?? 0 } };
+        }
+        return { compacted: false };
+    }
+    const branch = await opts.session.getBranch();
+    const prep = prepareCompaction(branch, settings, cpt);
+    if (!prep.ok) {
+        throw prep.error;
+    }
+    if (!prep.value) {
+        return { compacted: false };
+    }
+    // design/134 §3.2 (R3 LOW): preCompact fires HERE — after the trigger gate AND a confirmed valid
+    // cut point (never a "would not have compacted anyway" invocation, so every preCompact pairs with
+    // a compaction that actually proceeds unless the callback itself blocks), and before the
+    // provider/summary call. Swallow a throwing callback on EVERY path (R3 MED: an observer bug must
+    // not surface as a compaction failure — the caller's breaker / PTL recovery must be unaffected).
+    const trigger = opts.trigger ?? "auto";
+    let hookInstructions;
+    if (opts.preCompact) {
+        let pre;
+        try {
+            pre =
+                (await opts.preCompact({
+                    trigger,
+                    ...(opts.customInstructions !== undefined ? { customInstructions: opts.customInstructions } : {}),
+                })) ?? undefined;
+        }
+        catch {
+            // treated as no-block/no-instructions; tracing is the caller wrapper's job (it has the sink)
+        }
+        if (pre?.block !== undefined && pre.block !== "") {
+            // "forced" (PTL recovery / trim pressure) is not optional: ignore the block (the caller's
+            // wrapper traces the ignore) and proceed. auto/manual: skip this compaction — a deliberate
+            // decision, not a failure (`blocked:true` tells the caller apart from a structural no-op).
+            if (trigger !== "forced") {
+                return { compacted: false, blocked: true };
+            }
+        }
+        if (pre?.additionalInstructions) {
+            hookInstructions = pre.additionalInstructions;
+        }
+    }
+    // CC mergeHookInstructions shape: the hook's instructions EXTEND the configured ones (append,
+    // never replace) — a deployment's fidelity defaults survive a hook that only adds a focus.
+    const effectiveInstructions = hookInstructions
+        ? opts.customInstructions
+            ? `${opts.customInstructions}\n\n${hookInstructions}`
+            : hookInstructions
+        : opts.customInstructions;
+    // design/84 Seam C — provider reuse (data-gated; thin seam only, no provider implemented in core).
+    // Reuse guard (c): once the caller has reused the provider's summary `maxConsecutiveProviderReuse`
+    // times IN A ROW, bypass the provider for THIS one boundary so a real summary is forced (bounds drift
+    // from indefinite reuse). Default cap = 3 (CC parity); only the consult is bypassed — the rest of the
+    // path (LLM summarize) is unchanged. With no provider at all this whole block is dead and behavior is
+    // byte-for-byte the current path.
+    const maxReuse = opts.maxConsecutiveProviderReuse ?? 3;
+    const forceRealSummary = (opts.consecutiveProviderReuse ?? 0) >= maxReuse;
+    let providerSummary;
+    // Split-turn fidelity guard (HARDENER MAJOR): on a SPLIT turn the boundary carries `turnPrefixMessages`
+    // (turnStartIndex..firstKeptEntryIndex) that the LLM path summarizes and folds into the summary as
+    // "**Turn Context (split turn):**" (compaction.ts). The provider path only sees `messagesToSummarize`
+    // (the history BEFORE the split turn) and uses its return verbatim as the WHOLE summary, with
+    // firstKeptEntryId = the suffix start — so the turn-prefix work would be dropped from history AND never
+    // captured by the provider. Bypass the provider for any split-turn boundary so the prefix-preserving
+    // LLM path always runs. (Option (a) from the finding: the minimal safe seam.)
+    if (opts.summaryProvider && !forceRealSummary && !prep.value.isSplitTurn) {
+        // Provider sees the same boundary inputs the LLM path would. `modifiedFiles` is the recency-ordered
+        // list derived from the prepared file ops (same source the working-file attachments use below).
+        const providerModifiedFiles = computeFileLists(prep.value.fileOps).modifiedFilesByRecency;
+        try {
+            const raw = await opts.summaryProvider({
+                messagesToSummarize: prep.value.messagesToSummarize,
+                previousSummary: prep.value.previousSummary,
+                modifiedFiles: providerModifiedFiles,
+            });
+            // Reuse guard (a) — over the empty-summary guard: a null/undefined/empty/whitespace-only provider
+            // result is NOT a reuse hit, it FALLS BACK to the LLM path (treated exactly as if no provider). This
+            // reuses the same "never persist an empty summary" invariant the LLM path enforces below.
+            const trimmed = typeof raw === "string" ? raw.trim() : "";
+            if (trimmed) {
+                providerSummary = trimmed;
+            }
+        }
+        catch {
+            // Provider failure guard (HARDENER MAJOR): the summaryProvider is an OPTIMIZATION. A throw/rejection
+            // must DEGRADE to the existing LLM `generateSummary` path (treated exactly as a miss), never abort
+            // compaction. Without this, the rejection would propagate to the caller's catch, trip the §17.4
+            // breaker, skip compaction, and — after MAX_CONSECUTIVE_COMPACTION_FAILURES throws — disable
+            // within-task compaction entirely (strictly worse than having no provider). providerSummary stays
+            // undefined → LLM fallback.
+        }
+    }
+    let summary;
+    let firstKeptEntryId;
+    let summaryTokensBefore;
+    let details;
+    const reused = providerSummary !== undefined;
+    if (providerSummary !== undefined) {
+        // Provider hit: skip the LLM `generateSummary` call entirely; reuse the provided summary verbatim.
+        // firstKeptEntryId / tokensBefore come from the prepared boundary (the same values compact() would
+        // have returned). details (modifiedFiles) derived from prep.value.fileOps for parity with the LLM
+        // path's persisted CompactionDetails (so working-file attachments + downstream consumers are unchanged).
+        summary = providerSummary;
+        firstKeptEntryId = prep.value.firstKeptEntryId;
+        summaryTokensBefore = prep.value.tokensBefore;
+        details = computeFileLists(prep.value.fileOps);
+    }
+    else {
+        const summaryModel = opts.compactionModel ?? opts.model;
+        const auth = await opts.getApiKeyAndHeaders?.(summaryModel);
+        const runtime = brainToRuntime(opts.brain);
+        const res = await compact(prep.value, summaryModel, auth?.apiKey, auth?.headers, effectiveInstructions, opts.signal, opts.thinking, undefined, runtime, undefined, opts.onInputTruncated);
+        if (!res.ok) {
+            throw res.error;
+        }
+        // design/66 D #1: the summarization prompt asks the model to think first inside an <analysis>...</analysis>
+        // scratch block (improves coverage), which must be stripped before the summary is persisted/injected. The
+        // strip is idempotent and safe if the model didn't emit the block (no-op). Paired blocks only — an
+        // unterminated tag is left intact rather than swallowing the whole summary.
+        summary = (res.value.summary ?? "").replace(/<analysis>[\s\S]*?<\/analysis>\s*/gi, "").trim();
+        // Never replace real history with an empty/whitespace summary (a flaky gateway turn, output that was
+        // ONLY an analysis block, or a thinking-enabled model whose reasoning consumed the whole output
+        // budget). This is a FAILED attempt, not a no-op: it burned a real summary LLM call and left the
+        // session over-threshold, so it would silently repeat at every boundary. THROW so the caller's
+        // breaker (§17.4) counts it and `onError(phase:"compaction")` surfaces it — a probe that watched
+        // only `compacted` events once mistook exactly this silence for "compaction never triggered"
+        // (design/64 §26.7 / search [88]'s light arm).
+        if (!summary) {
+            throw new Error("compaction produced an empty summary (reasoning may have consumed the output budget; history left untouched)");
+        }
+        // Oversized guard (design/118 follow-up, codex review): the reasoning floor lets the summary call's
+        // OUTPUT budget exceed the reserve-derived cap, so a summary SIGNIFICANTLY larger than the entire
+        // pre-compaction context (a model hallucinating/expanding instead of summarizing at full floor budget)
+        // must never REPLACE that history — pure fact-loss with negative token gain. Throw so the §17.4
+        // breaker counts it (same contract as the empty-summary guard above). Threshold 1.5×, NOT 1×: a
+        // merely-ineffective summary (≈ the original size) is the §25.2 regrowth-floor's job — it LANDS once
+        // and the freed-aware floor spaces out further attempts (pinned by the anti-thrash test); throwing
+        // there would bypass the floor and burn a call per boundary until the breaker.
+        // design/123 D2 (应改): the summary lives in the TASK model's context, so compare in that
+        // model's structural coordinate (tokensBefore is already cpt-based via prepareCompaction).
+        if (Math.ceil(summary.length / cpt) > res.value.tokensBefore * 1.5) {
+            throw new Error(`compaction produced an oversized summary (≈${Math.ceil(summary.length / cpt)} tokens vs ` +
+                `${res.value.tokensBefore} before compaction; history left untouched)`);
+        }
+        firstKeptEntryId = res.value.firstKeptEntryId;
+        summaryTokensBefore = res.value.tokensBefore;
+        details = res.value.details;
+    }
+    // Working-file attachments (see MaybeCompactOptions.workingFileAttachments): append bounded
+    // CURRENT contents of the files the summarized region modified. Best-effort per file — a reader
+    // failure (deleted/renamed/remote hiccup) skips that file and must never fail a successful
+    // compaction. Appended INTO the summary text so it lives inside the same compaction entry
+    // (renders inside the <summary> framing; clearly labeled as a fresh on-disk snapshot).
+    let summaryWithAttachments = summary;
+    const attachedFiles = [];
+    const att = opts.workingFileAttachments;
+    // Selection set (CC 198 parity, blackboard 2026-07-03): most recently READ files when the caller
+    // tracks reads (CC's post-compact restore reads readFileState by timestamp — wider than the
+    // modified set, includes consulted reference files); else fall back to modified-by-recency
+    // (design/71 P2-①; alphabetical modifiedFiles remains the last fallback for old persisted details).
+    const recentlyRead = att?.recentlyReadFiles?.() ?? [];
+    const candidateFiles = recentlyRead.length > 0 ? recentlyRead : (details?.modifiedFilesByRecency ?? details?.modifiedFiles);
+    if (att && Array.isArray(candidateFiles) && candidateFiles.length > 0) {
+        const maxFiles = Math.max(1, att.maxFiles ?? 3);
+        const perFileCap = Math.max(200, att.maxCharsPerFile ?? 16_000);
+        // Total budget self-scales to the window (~15% of it, chars ≈ tokens×charsPerToken — design/123
+        // D2) so a small window is never drowned in attachments regardless of the per-file caps.
+        let remaining = Math.min(maxFiles * perFileCap, Math.floor(window * 0.15) * cpt);
+        const blocks = [];
+        for (const path of candidateFiles.slice(0, maxFiles)) {
+            if (remaining <= 0)
+                break;
+            let content = null;
+            try {
+                content = await att.readFile(path);
+            }
+            catch {
+                content = null;
+            }
+            if (content === null)
+                continue;
+            const cap = Math.min(perFileCap, remaining);
+            const wasClipped = content.length > cap;
+            const clipped = wasClipped
+                ? `${content.slice(0, cap)}\n[... ${content.length - cap} more characters truncated — read the file for the rest]`
+                : content;
+            remaining -= clipped.length;
+            blocks.push(`<working-file path="${path}">\n${clipped}\n</working-file>`);
+            // Structured record for the `compacted` wire event (blackboard ask ②: the shell renders CC's
+            // post-compact `Read {path} (…)` cards from this — it cannot parse <working-file> out of the summary).
+            attachedFiles.push({ path, chars: Math.min(content.length, cap), truncated: wasClipped });
+        }
+        if (blocks.length > 0) {
+            summaryWithAttachments +=
+                "\n\nCurrent on-disk contents of files touched in the summarized work (re-read at compaction time — trust these over any excerpts in the summary above):\n" +
+                    blocks.join("\n");
+        }
+    }
+    // §25.2 effectiveness measurement for the caller's anti-thrash floor: how much MESSAGE mass the
+    // compaction actually freed, in structural (char-heuristic) units. Deliberately NOT the usage-based
+    // estimate — post-compaction, the kept tail's last assistant usage still reflects the PRE-compaction
+    // request, so a usage-based "after" would overstate. A structural pre/post delta is truthful and
+    // translates ≈1:1 into the trigger estimate's units (any usage/system offset cancels in the delta).
+    let preChars = 0;
+    for (const m of ctx.messages)
+        preChars += estimateTokens(m, cpt);
+    await opts.session.appendCompaction(summaryWithAttachments, firstKeptEntryId, summaryTokensBefore, details, false);
+    let freedTokens = preChars; // failure default = "fully effective": the caller's floor stays low, never suppressing
+    // P-13: the §25.2 anti-thrash floor must live in the SAME coordinate as `triggerTokens` (estimate +
+    // anchor-less overhead). Reporting the post-compaction size DIRECTLY in that coordinate — rather than letting
+    // the caller subtract a chars/4 `freedTokens` delta from a possibly usage-anchored `triggerTokens` — stops
+    // the mixed-coordinate subtraction that inflated the floor (suppressing in-task compaction) on code-dense
+    // real models, where chars/4 underestimates the real freed tokens. `undefined` ⇒ caller keeps its legacy
+    // `triggerTokens − freedTokens` fallback.
+    let postTriggerTokens;
+    try {
+        const post = (await opts.session.buildContext()).messages;
+        let postChars = 0;
+        for (const m of post)
+            postChars += estimateTokens(m, cpt);
+        freedTokens = Math.max(0, preChars - postChars);
+        // STRUCTURAL, deliberately NOT estimateContextTokens(post): the kept tail's last assistant usage
+        // still reflects the PRE-compaction request (the same staleness :434 documents for freedTokens),
+        // so a usage-anchored "post size" ≈ the trigger point itself — and the caller's ×1.5 regrowth
+        // floor then lands at ~1.5× the PREVIOUS trigger. Each compaction ratchets the next trigger up
+        // ~50%; once the floor exceeds what the window can reach, within-task compaction is permanently
+        // suppressed and the run silently rides the request-layer trim (the §26.4 prefix-cache death
+        // band — measured live: 3 compactions at 12.4k/18.9k/28.4k on a 24k window, then 7 straight
+        // over-window turns with a cache collapse and no 4th compaction). The structural sum is the
+        // truthful post size; the caller's next-boundary trigger re-anchors on FRESH usage anyway.
+        postTriggerTokens = postChars + (opts.overheadTokens ?? 0);
+    }
+    catch {
+        /* keep the non-suppressing default — never fail a successful compaction on the measurement */
+    }
+    // design/84 Seam C observer (pure, no control-flow effect): fired only on a successful compaction.
+    // `reused` lets the caller advance/reset its consecutive-reuse counter for reuse guard (c), and
+    // `freedTokens` lets it apply reuse guard (b) — treat freed<ε as no-effective-compaction and NOT raise
+    // the anti-thrash floor (a reused summary that frees ~nothing must not suppress future real summaries).
+    // The floor/freed semantics live in the caller (runtask.ts §25.2); core just reports the measurements.
+    // Observer isolation (HARDENER MAJOR): the compaction has ALREADY succeeded (history mutated above). The
+    // observer is documented as control-flow-free, so a throw here MUST NOT escape — otherwise it would
+    // propagate to the caller's catch (runtask §17.4) and convert a SUCCESSFUL compaction into a counted
+    // breaker failure (and skip the caller's post-compaction bookkeeping: cacheBreakDetector reset + floor
+    // update). Swallow best-effort, exactly like the freedTokens measurement above.
+    try {
+        opts.onCompaction?.({
+            messagesCompacted: prep.value.messagesToSummarize.length,
+            freedTokens,
+            tokensBefore: summaryTokensBefore,
+            reused,
+        });
+    }
+    catch {
+        /* observer is a pure observer — never let it affect the return value or the caller's accounting */
+    }
+    // design/134: postCompact fires only after the compaction LANDED (appendCompaction above), with the
+    // post measurement already taken so `tokensAfter` rides along when available. `summary` is the
+    // conversation summary the compaction produced (CC compact_summary parity) — deliberately WITHOUT
+    // the working-file attachment blocks (those are a separate re-read mechanism, not summary content).
+    // Observe-only + swallowed throw: same isolation contract as the onCompaction observer above.
+    if (opts.postCompact) {
+        try {
+            await opts.postCompact({
+                trigger,
+                summary,
+                tokensBefore: summaryTokensBefore,
+                ...(postTriggerTokens !== undefined ? { tokensAfter: postTriggerTokens } : {}),
+            });
+        }
+        catch {
+            /* observe-only: a throwing postCompact must never fail a landed compaction */
+        }
+    }
+    // audit B-1: `triggerTokens` = the exact quantity the trigger gate compared (estimate + anchor-less
+    // overhead). The caller's §25.2 regrowth floor must live in THIS coordinate system, not in
+    // prepareCompaction's `tokensBefore` (which lacks the overhead term).
+    return {
+        compacted: true,
+        tokensBefore: summaryTokensBefore,
+        freedTokens,
+        triggerTokens: tokens,
+        postTriggerTokens,
+        firstKeptEntryId,
+        reused,
+        naturalTrigger,
+        durationMs: Date.now() - compactStartAt,
+        ...(postTriggerTokens !== undefined
+            ? { postOverThreshold: shouldCompact(postTriggerTokens, window, settings) }
+            : {}),
+        ...(attachedFiles.length > 0 ? { attachedFiles } : {}),
+    };
+}
+/**
+ * design/123 D4 (r5) — trim-force BACKOFF transition (pure; the run-scoped bit lives in the caller).
+ * Spiral protection replacing the §25.2 floor's role on the trim-force path: trim pressure re-arms
+ * every request while the transcript is oversized, so an unconditional force would burn a summary
+ * call at every boundary when summaries CANNOT shrink the context (the LONGRUN-1b incompressible
+ * shape). The invariant: trim-force is permitted only while the LATEST landed compaction proved it
+ * can bring the context back under the threshold (or no compaction has landed yet). Transitions,
+ * evaluated after each maybeCompact result:
+ *   1. no compaction landed → state unchanged (a structural no-op proves nothing either way);
+ *   2. a landed compaction with `postOverThreshold` → "压不动": BACKOFF ON — compaction demonstrably
+ *      cannot reach under-threshold, so forcing more of them only burns summary calls; the §25.2
+ *      floor policy takes back over (natural triggers are never gated by this bit);
+ *   3. a landed compaction that posted UNDER the threshold → summaries compress again: BACKOFF OFF
+ *      (this is how the natural floor-crossing compaction of design/123 D4's reset clause re-enables
+ *      the trim-force — its healthy landing posts under threshold);
+ *   4. post measurement unavailable → state unchanged (never flip on missing evidence);
+ *   5. (COMPACTION-LIVE-AUDIT D-1, evaluated BEFORE rule 3) a TRIM-FORCED landing with
+ *      `freedTokens ≤ 0` → negative-yield: BACKOFF ON. The trim layer deceives the usage-anchored
+ *      estimate down into the sawtooth trough (live: est 18807 on a ~55k session), the forced pass
+ *      finds little compressible history, and summary + working-file attachments make the transcript
+ *      LARGER (live: 18807→44609, 12679→35214). `freedTokens` is the structural pre/post delta
+ *      (clamped ≥0, so ≤0 means "freed nothing") — orthogonal to rule 2/3's threshold test, which
+ *      misses this shape because the bloated post (44609) can still sit UNDER the threshold (44800),
+ *      so rule 3 alone would re-enable the force and repeat the negative-yield pass every boundary.
+ *      SEMA-ONLY DEFENSE, not a CC port: CC's full compact keeps tail 0 and monotonically shrinks
+ *      (capture §A4), and CC has no request-layer trim, so this regime cannot exist there — it is a
+ *      derived interaction of our trim seam × keep-tail × attachment mass. Scoped to trim-forced
+ *      passes only (`trimForced`), so Seam C reused-summary landings (freed≈0 by design) on the
+ *      natural/manual paths never trip it. Release path unchanged: backoff gates only the FORCE, a
+ *      later natural landing that posts under threshold (rule 3, non-trim-forced) turns it back off.
+ */
+export function nextTrimForceBackoff(prev, comp, trimForced = false) {
+    // rule 5 guard: `trimForced` from the call site means "trim force was PERMITTED", not "this landing
+    // was trim-forced" — a landing that fired on the natural threshold (naturalTrigger) while trim
+    // pressure happened to be armed is NOT a trim-forced pass, and its negative yield must not back off
+    // the trim-force escape hatch (verify leg F3: armed + natural + freed<=0 mis-charged rule 5).
+    if (trimForced && comp.naturalTrigger !== true && comp.compacted && comp.freedTokens !== undefined && comp.freedTokens <= 0) {
+        return true; // rule 5: negative-yield trim-forced pass — back off immediately, don't wait for rule 2
+    }
+    if (!comp.compacted || comp.postOverThreshold === undefined) {
+        return prev;
+    }
+    return comp.postOverThreshold;
+}
+/** Fresh tracking state (no compaction seen yet). */
+export function createRapidRefillState() {
+    return { lastCompactionTurn: Number.NEGATIVE_INFINITY, count: 0 };
+}
+/**
+ * design/119 S3 (CC 2.1.198 rapid_refill_breaker, :229717/:476338): record that a compaction just
+ * happened at `turn` and report whether the thrash breaker should TRIP. A compaction landing within
+ * `minGapTurns` of the previous one is a "rapid refill"; `tripAt` consecutive rapid refills = the
+ * context is dominated by incompressible content and further compaction only burns summary calls.
+ * CC terminates the task; sema's caller (runtask) deviates conservatively — it opens the existing
+ * compaction breaker (no more compaction this task) and lets budget/PTL/turn limits end the run.
+ */
+export function recordCompactionAndCheckRapidRefill(state, turn, minGapTurns = 3, tripAt = 3) {
+    if (turn - state.lastCompactionTurn < minGapTurns) {
+        state.count += 1;
+    }
+    else {
+        state.count = 0;
+    }
+    state.lastCompactionTurn = turn;
+    return state.count >= tripAt;
+}
+//# sourceMappingURL=auto-compaction.js.map

package/dist/core/auto-compaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-compaction.js","sourceRoot":"","sources":["../../src/core/auto-compaction.ts"],"names":[],"mappings":"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"}