pi-tuck 1.0.9 → 1.0.11

package/src/compaction.ts

@@ -5,10 +5,10 @@ import { exportSource } from "./source-export.js";
 import { isDeepStrictEqual } from "node:util";
 import { assertNativeToolRounds } from "./protocol.js";
 import { projectedMessages } from "./omissions.js";
-import { applyClips, clipFor, type Clip } from "./clip.js";
+import { applyClips, clipBudgets, clipFor, type Clip } from "./clip.js";
 import { DEFAULT_CUT_AT, bandOf, chooseCut, conversationTokens, decideCut, gateCut, incomingEventTokens, incomingTokens, measurableConversationTokens, planningReserve, projectedConversationTokens, requestTokens, systemPart, validCutAt,
     type AgentMessage, type Messages, type Plan, type Target, type ToolShape } from "./budget.js";
-import { isContextOverflow } from "@earendil-works/pi-ai";
+import { isContextOverflow, type ToolResultMessage } from "@earendil-works/pi-ai";
 import { convertToLlm, SessionManager, SettingsManager, type ExtensionAPI, type ExtensionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { Check } from "typebox/value";
@@ -54,6 +54,11 @@ class CapacityError extends Refusal {}
 export const refusalNotice = (message: string, factor: number): string =>
     message + "; shorten the input, use a model with a larger window, or lower Pi's compaction.reserveTokens, then retry." +
     (factor >= 1.5 ? ` This provider has counted up to ${factor.toFixed(1)}x the input pi-tuck estimates; through a router such as OpenRouter, a different upstream may count less.` : "");
+/** What the operator hears when the provider refuses a request pi-tuck admitted as over its window: the bound that reply puts on the counting, and
+ * what pi-tuck did with it. A bound pi-tuck cannot carry (above the ceiling) says so rather than implying the next request is planned at it. */
+export const overflowNotice = (contextWindow: number, bound: number, learned: boolean): string =>
+    `pi-tuck: the provider refused this request as over its ${contextWindow}-token window, so the input counted at least ${bound.toFixed(2)}x what pi-tuck estimated` +
+    (learned ? "; the next request is planned at that." : "; too far out to be a low estimate, so the factor is unchanged.");
 /** The most a seed or an overflow raise may set the calibration factor to. A paired reply's own ratio is not bounded by it. */
 export const CALIBRATION_CEILING = 1.5;
 /** How many recent paired replies (and overflow bounds, and the seed while it is among them) the calibration factor is the maximum of. */
@@ -232,16 +237,27 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             !isDeepStrictEqual(convertToLlm(paired.messages), paired.snapshot)) return;
         // The provider refused this exact request for exceeding the window: its true count was at least window + 1, a lower bound on the ratio. A
         // bound above the ceiling says the estimate is not merely low, so it is not learned: the overflow ends the attempt as it does without it.
-        if (overflow) { const candidate = (ctx.model.contextWindow + 1) / paired.tokens; if (candidate <= CALIBRATION_CEILING) learn(candidate); return; }
+        // Either way the operator hears it from pi-tuck. The estimate is what admitted the request, and a turn that ended in the provider's error
+        // with no word from pi-tuck read as a hang: every other refusal says why, and this is the path that skipped it.
+        if (overflow) {
+            const bound = (ctx.model.contextWindow + 1) / paired.tokens;
+            const learned = bound <= CALIBRATION_CEILING;
+            ctx.ui.notify(overflowNotice(ctx.model.contextWindow, bound, learned), "warning");
+            if (learned) learn(bound);
+            return;
+        }
         const usage = message.usage;
         if (!usage) return;
         const counts = [usage.input, usage.cacheRead, usage.cacheWrite];
         if (!counts.every(n => Number.isSafeInteger(n) && n >= 0)) return;
         const input = counts.reduce((a, b) => a + b, 0), ratio = input / paired.tokens;
-        if (input > 0 && Number.isSafeInteger(input) && Number.isFinite(ratio)) learn(ratio);
+        // A request that was answered cannot have held more than the model's window, so a report above it describes something that never happened.
+        // Learning from one sets the factor for the requests after it: a 60,000-token cache read reported in a 32,768-token window made a
+        // 6,000-token prompt refuse. The overflow branch above learns from a refusal, where the count is a lower bound, and the ceiling is unchanged.
+        if (input > 0 && input <= ctx.model.contextWindow && Number.isSafeInteger(input) && Number.isFinite(ratio)) learn(ratio);
     });
     pi.on("agent_start", () => { admittedRun = true; pending = undefined; phase = "idle"; });
-    pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetFailure(); clips.clear(); });
+    pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetFailure(); clips.clear(); promptCut = undefined; });
 	const active = () => options.active?.() ?? true;
 	const settingsFor = () => options.settings ?? SettingsManager.inMemory(pi.getSettings());
 	// The standalone default reserves the model's catalogue maximum output: a transport may omit the output cap, and then only that
@@ -284,8 +300,10 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     const isNoWork = (message: string | undefined) => ["Already compacted", "Nothing to compact (session too small)"].includes(message?.replace(/^Compaction failed: /, "") ?? "");
     // A missing model is configuration, not capacity.
     const missingModel = () => new Error("No context model for the request budget");
-    // Scoped to one awaited initial-prompt cut; never a persisted controller. It carries that decision's snapshot.
-    let pendingCut: { mandatory: number; before: number; host: number; opportunistic: boolean; proposed: boolean } | undefined;
+    // A prompt's cut, until its run saves it at its first boundary: every request of that run carries it (the context hook). A run that ends
+    // before a boundary drops it, and the next prompt decides afresh.
+    type CutEntry = { type: "compaction"; summary: string; firstKeptEntryId: string; tokensBefore: number; details?: unknown };
+    let promptCut: CutEntry | undefined;
     let failure: Error | undefined;
     let pendingBoundaryCommit = false;
     // Fresh tool results the room cannot hold, by call id: each request of the run carries the clip in their place; the session keeps them
@@ -293,13 +311,18 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     const clips = new Map<string, Clip>();
 	const fail = (error: unknown, ctx: ExtensionContext) => {
 		recorder.stop("native-attempt-failed");
-        const notify = !failure && error instanceof CapacityError;
+        // Every refusal says why, once per attempt: a capacity error with what the user can change, a cut Pi failed to commit with what that
+        // means for the session, anything else as it is (an attempt that ended with no word looked like a hang).
+        const notify = !failure;
 		// A CommitFault stays whatever fails after it.
 		if (!(failure instanceof CommitFault)) failure = error instanceof Error ? error : new Error(String(error));
         pendingBoundaryCommit = false;
         pending = undefined;
+        promptCut = undefined;
 		try { options.fail?.(error); } finally {
-            try { if (notify) ctx.ui.notify(refusalNotice(failure.message, factor), "error"); }
+            try { if (notify) ctx.ui.notify(failure instanceof CapacityError ? refusalNotice(failure.message, factor) : failure instanceof CommitFault
+                ? `pi-tuck: ${failure.message}; the session holds a cut its file may lack, so start a new session.`
+                : `pi-tuck could not plan this request (${failure.message}); the next prompt is planned afresh.`, "error"); }
             finally { ctx.abort(); }
         }
 	};
@@ -370,9 +393,15 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 		try {
 			if (!active()) return { cancel: true };
 			if (event.signal.aborted || ctx.signal?.aborted) { recorder.stop("cut-cancelled"); return { cancel: true }; }
-            // Pi also labels the awaited idle incoming preflight "manual".
-            const incoming = pendingCut;
-            const operatorManual = event.reason === "manual" && !(incoming && !admittedRun);
+            // Pi checks its own threshold after a prompt's input and before the run starts: the prompt's cut, planned with the prompt counted,
+            // is the answer, and it is saved before the first request.
+            if (promptCut && !admittedRun && event.reason === "threshold") {
+                access();
+                const { type: _, ...compaction } = promptCut;
+                promptCut = undefined;
+                return { compaction };
+            }
+            const operatorManual = event.reason === "manual";
             if (operatorManual && !admittedRun) forgetFailure();
 			access();
 			if (event.customInstructions?.trim()) {
@@ -382,19 +411,18 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 			}
             const { response, room, band } = limits(ctx);
             const retain = operatorManual || admittedRun;
-            // The incoming-prompt preflight brings its own snapshot. Any other cut (operator manual, Pi's threshold or overflow
-            // recovery) charges what the request must carry whatever is cut: the system part and the host input.
+            // A cut Pi asks for (an operator's /compact, Pi's threshold or overflow recovery) charges what the request must carry whatever is
+            // cut: the system part and the host input. A prompt's cut is pi-tuck's own and never comes here.
             const saved = ctx.sessionManager.buildSessionProjection().messages;
-            const host = incoming ? incoming.host : hostTokens(ctx);
-            const mandatory = incoming ? incoming.mandatory
-                : systemPart(ctx.getSystemPrompt(), toolShapes(pi.getActiveTools()), saved, ctx.getSystemPrompt()) + host;
-            const before = incoming ? incoming.before : plannerMeasureFor(ctx)(saved);
+            const host = hostTokens(ctx);
+            const mandatory = systemPart(ctx.getSystemPrompt(), toolShapes(pi.getActiveTools()), saved, ctx.getSystemPrompt()) + host;
+            const before = plannerMeasureFor(ctx)(saved);
             // Pi's own usage threshold (reason "threshold") counts the last reply's output tokens, reasoning included, plus the messages after
             // it: a basis this compactor does not plan on. It may ask for a cut on a request that fits. This compactor cuts only where its own
             // trigger would: nothing below the band, an opportunistic cut inside it, a due cut at or above the room. A refusal is a plain
             // cancel (Pi reports it as aborted), never a failure.
             let thresholdOpportunistic = false;
-            if (!incoming && event.reason === "threshold") {
+            if (event.reason === "threshold") {
                 const gate = gateCut({ total: before + mandatory, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx) });
                 if (gate.kind !== "plan") return { cancel: true };
                 thresholdOpportunistic = gate.opportunistic;
@@ -402,19 +430,18 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             // Pi checks old history before appending a new idle prompt. During an active run/manual cut the latest admitted input stays protected.
             const decision = chooseCut({
                 before, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx),
-                opportunistic: incoming?.opportunistic ?? thresholdOpportunistic,
-                unreduced: incoming ? "Incoming Pi preflight compaction did not reduce context within the estimated request budget"
-                    : "Compaction did not reduce context within the estimated request budget",
+                opportunistic: thresholdOpportunistic,
+                unreduced: "Compaction did not reduce context within the estimated request budget",
                 plan: (target): Plan<{ compaction: NonNullable<ReturnType<typeof tuckDraft>["compaction"]>; reserve: number }> => {
                     const reserve = planReserve(target, room, mandatory, ctx);
-                    // Every cut asked while no run is admitted (a prompt's preflight, an operator's cut, Pi's own cut before a run a custom message
-                    // starts) is planned for a run that has not begun: the session has moved on from any run that ended. A retry is inside its run.
-                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual, Boolean(incoming) || operatorManual || !admittedRun);
+                    // Every cut asked while no run is admitted (an operator's cut) is planned for a run that has not begun: the session has moved on
+                    // from any run that ended. A retry is inside its run.
+                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual, operatorManual || !admittedRun);
                     return draft.compaction ? { draft: true, after: draft.after, mode: draft.mode, compaction: draft.compaction, reserve }
                         : { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
                 },
             });
-            if (decision.kind === "cut") { if (incoming) incoming.proposed = true; return { compaction: captureDraft(decision.plan.compaction, ctx, decision.plan.reserve, event.reason, event.preparation.tokensBefore,
+            if (decision.kind === "cut") { return { compaction: captureDraft(decision.plan.compaction, ctx, decision.plan.reserve, event.reason, event.preparation.tokensBefore,
                 retain, operatorManual, event.preparation.previousSummary, { response, host, mandatory, target: decision.target, margin: room - band }) }; }
             // An opportunistic cut inside the band that cannot reach it is no fault: the request goes to the guard.
             if (decision.kind === "none") return { cancel: true };
@@ -427,57 +454,59 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 		}
 	});
 	pi.on("session_before_tree", (event) => event.preparation.userWantsSummary ? { cancel: true } : undefined);
-    pi.on("session_start", () => { clips.clear(); recorder.stop("session-transition"); proposalId = undefined; failure = undefined; admittedRun = false; pendingBoundaryCommit = false; identity = ""; factor = 1; pending = undefined; phase = "idle"; });
-    // The cut before a run. Pi 1.4 counts a run as started before before_agent_start, and ctx.compact() first aborts and waits for an
-    // idle session, so a cut asked for there would wait on its own run. A prompt's cut is therefore made on `input`, while the session
-    // is idle. before_agent_start decides only for a run no input started (one a custom message starts) and cuts only if the session is
-    // still idle (Pi 1.1); otherwise it declines an opportunistic cut and fails a needed one closed.
+    pi.on("session_start", () => { clips.clear(); promptCut = undefined; recorder.stop("session-transition"); proposalId = undefined; failure = undefined; admittedRun = false; pendingBoundaryCommit = false; identity = ""; factor = 1; pending = undefined; phase = "idle"; });
+    // The session as it will be once a cut that is not saved yet is saved, and its conversation as the next request carries it.
+    const cutSession = (ctx: ExtensionContext, cut: CutEntry) => {
+        const header = ctx.sessionManager.getHeader();
+        if (!header) throw new Error("Missing native session header for the prompt's cut");
+        const preview = SessionManager.inMemory(ctx.cwd, undefined, [header, ...ctx.sessionManager.getBranch()]);
+        preview.appendCompaction(cut.summary, cut.firstKeptEntryId, 0, cut.details, true);
+        return preview;
+    };
+    const withCut = (ctx: ExtensionContext, cut: CutEntry) => cutSession(ctx, cut).buildSessionProjection().messages;
+    // The cut before a run, decided on `input` while the session is idle; before_agent_start decides only for a run no input started (one a
+    // custom message starts). The cut is pi-tuck's own, planned as at a tool boundary. It is not Pi's: Pi's cut finder keeps the last
+    // keepRecentTokens, and where those are the whole conversation it has nothing to cut, so every later prompt was refused for good (t06 at
+    // Pi's defaults on a 32k window). Each request of the run carries the cut, and the run's first boundary saves it.
     const preflight = async (ctx: ExtensionContext, incomingPart: number, observedPrompt: string, tools: readonly string[]) => {
+        promptCut = undefined;
         if (!active()) return;
         access();
         if (!settingsFor().getCompactionSettings(ctx.model).enabled) return;
         if (!ctx.model) throw missingModel();
-        const { room, band } = limits(ctx);
-        // Public early view only: later handlers, image normalization and tool-loop growth remain the complete-context
-        // guard's responsibility. One snapshot per decision, taken again after the awaited cut.
-        const snapshot = () => {
-            const saved = ctx.sessionManager.buildSessionProjection().messages;
-            const system = systemPart(observedPrompt, toolShapes(tools), saved, ctx.getSystemPrompt());
-            const host = hostTokens(ctx);
-            const before = measureFor(ctx)(saved);
-            return { incoming: incomingPart + system, host, before, mandatory: incomingPart + system + host };
-        };
-        const first = snapshot(), total = first.before + first.mandatory;
-        if (!fits(first.incoming, room, ctx))
+        const { response, room, band } = limits(ctx);
+        // Public early view only: later handlers, image normalization and tool-loop growth remain the complete-context guard's responsibility.
+        const saved = ctx.sessionManager.buildSessionProjection().messages;
+        const system = systemPart(observedPrompt, toolShapes(tools), saved, ctx.getSystemPrompt());
+        const host = hostTokens(ctx), measure = measureFor(ctx), before = measure(saved);
+        const incoming = incomingPart + system, mandatory = incoming + host;
+        if (!fits(incoming, room, ctx))
             throw new CapacityError("Incoming Pi prompt and response reserve cannot fit the estimated request budget");
         // A cut removes only conversation. If the mandatory request, host input included, does not fit by itself, no cut can
         // help: leave it to the complete-context guard, which fails closed.
-        const gate = gateCut({ total, mandatory: first.mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx) });
+        const gate = gateCut({ total: before + mandatory, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx) });
         if (gate.kind !== "plan") return;
-        if (!ctx.isIdle()) {
-            if (gate.opportunistic) return;
-            throw new CapacityError("The request needs a cut that Pi cannot make once the run has started");
-        }
-        const cut = pendingCut = { mandatory: first.mandatory, before: first.before, host: first.host, opportunistic: gate.opportunistic, proposed: false };
-        try {
-            // CompactOptions callbacks are Pi's supported terminal completion surface.
-            await new Promise<void>((resolve, reject) => ctx.compact({ onComplete: () => resolve(),
-                onError: error => {
-                    // An opportunistic cut is not needed to send the request, which is below the room: the guard decides. However it ends (the
-                    // planner declined it, Pi had nothing to compact, an earlier handler cancelled it) it is no fault, unless a failure is latched
-                    // or the compactor proposed a cut that then failed to commit (the session may hold what the file lacks).
-                    // A needed cut that Pi has nothing to make (no history older than its keepRecentTokens since the last cut) is a refusal of
-                    // this request, which ends with it: as a fault it stayed, and every later prompt of the session failed on it.
-                    if (cut.opportunistic && !failure && !cut.proposed) resolve();
-                    else if (!cut.proposed && isNoWork(error.message)) reject(new CapacityError(`The request needs a cut and Pi has none to make (${error.message})`));
-                    else reject(error.message === "Compaction cancelled" && failure instanceof Refusal ? failure : cut.proposed ? new CommitFault(error.message) : error);
-                } }));
-        } finally { pendingCut = undefined; }
-        access();
-        // The cut awaited: take the snapshot again. An opportunistic cut never throws; the request is not over the room, and the guard decides.
-        const next = snapshot(), after = next.before + next.mandatory, afterFits = fits(after, limits(ctx).room, ctx);
-        if (!cut.opportunistic && (after >= total || !afterFits))
-            throw new (afterFits ? Refusal : CapacityError)("Incoming Pi preflight compaction did not reduce context within the estimated request budget");
+        const previousSummary = saved.find(message => message.role === "compactionSummary")?.summary;
+        const decision = chooseCut({
+            before, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), opportunistic: gate.opportunistic,
+            unreduced: "Incoming prompt compaction did not reduce context within the estimated request budget",
+            plan: (target): Plan<{ compaction: NonNullable<ReturnType<typeof tuckObservedDraft>["compaction"]>; reserve: number }> => {
+                const reserve = planReserve(target, room, mandatory, ctx);
+                // Only a due cut re-renders a summary that sits alone in the session: inside the band a cut is opportunistic, and a smaller summary
+                // there buys nothing the request needed and costs history the next recall would have found.
+                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary, newPrompt: true, reRenderSummary: !gate.opportunistic }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, false);
+                if (!draft.compaction) return { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
+                const messages = withCut(ctx, { type: "compaction", ...draft.compaction, tokensBefore: before });
+                assertNativeToolRounds(messages);
+                return { draft: true, after: measure(messages), mode: draft.mode, compaction: draft.compaction, reserve };
+            },
+        });
+        // An opportunistic cut inside the band that cannot reach it is no fault: the request goes to the guard.
+        if (decision.kind === "none") return;
+        if (decision.kind === "fault") throw new (decision.capacity ? CapacityError : Refusal)(decision.message);
+        const compaction = captureDraft(decision.plan.compaction, ctx, decision.plan.reserve, "prompt", before, false, false, previousSummary,
+            { response, host, mandatory, target: decision.target, margin: room - band });
+        promptCut = { type: "compaction", summary: compaction.summary, firstKeptEntryId: compaction.firstKeptEntryId, tokensBefore: before, details: compaction.details };
     };
     pi.on("before_agent_start", async (event, ctx) => {
         const prompted = phase === "decided";
@@ -508,7 +537,13 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         const queued = event.context.pendingMessages.length ? conversationTokens(event.context.pendingMessages as Messages) : 0;
         const mandatory = system + host + queued;
         const previousSummary = saved.find(message => message.role === "compactionSummary")?.summary;
+        // The cut previews this decision has built, in the order it built them. The clip retry below measures them for what a cut leaves the
+        // request besides the fresh results. Reset per decision, so a retry sizes itself against the cut it is retrying, not an earlier attempt's.
+        let previews: Messages[] = [];
+        let floorKept: number | undefined;
         const decide = () => {
+            previews = [];
+            floorKept = undefined;
             const before = measure(saved);
             return decideCut({
             total: before + mandatory, mandatory, before, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx),
@@ -516,29 +551,46 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             plan: (target): Plan<{ compaction: NonNullable<ReturnType<typeof tuckObservedDraft>["compaction"]>; reserve: number }> => {
                 const reserve = planReserve(target, room, mandatory, ctx);
                 const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, true);
-                if (!draft.compaction) return { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
+                if (!draft.compaction) {
+                    // The planner's own floor, so a clip's second budget is measured against what the smallest cut really keeps.
+                    if (draft.floorMessages && event.toolResults) {
+                        const fresh = new Set(event.toolResults.map(result => result.toolCallId));
+                        const kept = measure(draft.floorMessages.filter(message =>
+                            !(message.role === "toolResult" && fresh.has((message as ToolResultMessage).toolCallId))));
+                        floorKept = Math.min(floorKept ?? kept, kept);
+                    }
+                    return { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
+                }
                 const header = ctx.sessionManager.getHeader();
                 if (!header) throw new Error("Missing native session header at tool-loop boundary");
                 const preview = SessionManager.inMemory(ctx.cwd, undefined, [header, ...ctx.sessionManager.getBranch()]);
                 preview.appendCompaction(draft.compaction.summary, draft.compaction.firstKeptEntryId, before, draft.compaction.details, true);
                 const messages = preview.buildSessionProjection().messages;
                 assertNativeToolRounds(messages);
+                previews.push(messages);
                 return { draft: true, after: measure(messages), mode: draft.mode, compaction: draft.compaction, reserve };
             },
             });
         };
         let decision = decide();
-        // Only a request that would be refused is clipped. A fresh result is kept whole by every cut (it has not reached the model yet), so
-        // a round larger than the room refuses the run. In their place the request carries the results' heads and tails, together at most
-        // half of what the room leaves the conversation, each with a tuck_recall locator to its rest. When even that is refused the refusal stands.
+        // Only a request that would be refused is clipped. A fresh result is kept whole by every cut (it has not reached the model yet), so a round
+        // larger than the room refuses the run; in its place the request carries the result's head and tail with a tuck_recall locator to the rest.
+        // clipBudgets states the budgets tried and why they are counted in the estimate's units; `kept` is measured from the previews this decision
+        // built, so the second budget is the cut's own floor and not a new formula. When nothing is clipped or the decision still faults, the
+        // refusal stands.
         if (decision.kind === "fault" && event.toolResults) {
             const branch = ctx.sessionManager.getBranch();
             const entryIdOf = (toolCallId: string) => branch.findLast(entry => entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolCallId === toolCallId)?.id;
-            const round = clipFor(event.toolResults, entryIdOf, Math.floor((room - mandatory) / 2));
-            if (round.length) {
+            const fresh = new Set(event.toolResults.map(result => result.toolCallId));
+            const kept = previews.length ? Math.min(...previews.map(preview => measure(preview.filter(message =>
+                !(message.role === "toolResult" && fresh.has((message as ToolResultMessage).toolCallId)))))) : floorKept;
+            for (const budget of clipBudgets(room, factor, mandatory, kept)) {
+                const round = clipFor(event.toolResults, entryIdOf, budget);
+                if (!round.length) continue;
                 for (const clip of round) clips.set(clip.toolCallId, clip);
                 const clippedDecision = decide();
-                if (clippedDecision.kind === "fault") for (const clip of round) clips.delete(clip.toolCallId); else decision = clippedDecision;
+                if (clippedDecision.kind === "fault") for (const clip of round) clips.delete(clip.toolCallId);
+                else { decision = clippedDecision; break; }
             }
         }
         const before = measure(saved);
@@ -549,26 +601,51 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         return { entries: [{ type: "compaction" as const, summary: compaction.summary,
             firstKeptEntryId: compaction.firstKeptEntryId, details: compaction.details }] };
     };
+    // A boundary's cut. The run's first boundary also saves the prompt's cut, after any entries an earlier handler proposed, and decides on
+    // the session as it is with that cut: a fresh result can still need a cut of its own there.
+    type Boundary = Parameters<typeof boundaryCut>[0];
+    const atBoundary = (event: Boundary, ctx: ExtensionContext, reason: "tool-loop" | "run-end", decide: boolean) => {
+        if (!promptCut) return decide ? boundaryCut(event, ctx, reason) : undefined;
+        const entry = promptCut;
+        promptCut = undefined;
+        const preview = cutSession(ctx, entry), view: ExtensionContext = Object.create(ctx, { sessionManager: { value: preview } });
+        const more = decide && !event.entries.length
+            ? boundaryCut({ ...event, context: { ...event.context, contextMessages: preview.buildSessionProjection().messages } }, view, reason) : undefined;
+        const { tokensBefore: _, ...saved } = entry;
+        // As for a cut Pi makes (session_compact): the history the cut leaves behind is indexed, once Pi has committed the entries.
+        setImmediate(() => { semantic.indexAtCut(semanticProvider(ctx)); });
+        return { entries: [...event.entries as CutEntry[], saved, ...(more?.entries ?? [])] };
+    };
     pi.on("turn_end", (event, ctx) => {
         try {
-            if (!active() || !admittedRun || event.outcome !== "completed" || ctx.signal?.aborted ||
-                !event.context.canContinue || !event.toolResults.length || !settingsFor().getCompactionSettings(ctx.model).enabled) return;
-            const result = boundaryCut(event, ctx, "tool-loop");
+            if (!active() || !admittedRun) return;
+            const decide = event.outcome === "completed" && !ctx.signal?.aborted && event.context.canContinue && event.toolResults.length > 0 &&
+                settingsFor().getCompactionSettings(ctx.model).enabled;
+            if (!promptCut && !decide) return;
+            const result = atBoundary(event, ctx, "tool-loop", decide);
             if (result) pendingBoundaryCommit = true;
             return result;
         } catch (error) { fail(error, ctx); }
     });
+    // A request of a run whose prompt's cut is not saved yet: the saved conversation in it, which other handlers may surround, is replaced by
+    // the conversation with the cut applied. Pi sends the saved system message apart from the request's messages, so neither side carries it
+    // here. A request that does not carry the saved conversation as it stands cannot take the cut.
+    const cutRequest = <M,>(messages: M[], ctx: ExtensionContext, cut: CutEntry): M[] => {
+        const conversation = (all: Messages) => all.filter(message => message.role !== "system") as unknown[];
+        const saved = conversation(ctx.sessionManager.buildSessionProjection().messages);
+        for (let at = 0; at + saved.length <= messages.length; at++)
+            if (saved.every((message, i) => isDeepStrictEqual(messages[at + i], message)))
+                return [...messages.slice(0, at), ...conversation(withCut(ctx, cut)) as M[], ...messages.slice(at + saved.length)];
+        throw new Error("The prompt's cut cannot be applied: the request does not carry the saved conversation");
+    };
     pi.on("context", (event, ctx) => {
         try {
             if (!active()) return;
             access();
-            return { messages: applyClips(projectedMessages(event.messages, ctx, options.recallPolicy), clips) };
+            return { messages: applyClips(projectedMessages(promptCut ? cutRequest(event.messages, ctx, promptCut) : event.messages, ctx, options.recallPolicy), clips) };
         } catch (error) { try { fail(error, ctx); } finally { return { messages: [] }; } }
     });
 	pi.on("session_compact_failed", (event, ctx) => {
-        // The end of an opportunistic cut that proposed nothing, however it came about, is no event for the recorder or for failure handling;
-        // a latched failure still is, and so is the failure of a cut the compactor proposed.
-        if (pendingCut?.opportunistic && !failure && !pendingCut.proposed) return;
         // This compactor's own refusal of a Pi threshold ask (the gate, or an opportunistic cut that cannot reach the band) reaches here as a
         // threshold compaction cancelled and not from an extension: no event for the recorder.
         if (event.reason === "threshold" && event.aborted && !event.fromExtension) return;
@@ -589,9 +666,10 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         }
         // Pi commits these entries before the run settles.
         try {
-            if (!active() || !admittedRun || event.outcome !== "completed" || ctx.signal?.aborted || failure ||
-                !settingsFor().getCompactionSettings(ctx.model).enabled) return;
-            return boundaryCut(event, ctx, "run-end");
+            if (!active() || !admittedRun || failure || !settingsFor().getCompactionSettings(ctx.model).enabled) return;
+            const decide = event.outcome === "completed" && !ctx.signal?.aborted;
+            if (promptCut ? event.outcome === "error" : !decide) return;
+            return atBoundary(event, ctx, "run-end", decide);
         } catch (error) { fail(error, ctx); }
     });
 	pi.on("context_with_system", (event, ctx) => {

package/src/diagnostics.ts

@@ -10,7 +10,7 @@ export const DIAGNOSTIC_BUILD = BUILD_ID;
 export interface Receipt { id: string; build: string; reason: string; selectedView: string; boundary: string; settings: { draftReservedTokens: number; contextWindow: number; responseReserveTokens?: number; hostInputTokens?: number; mandatoryInputTokens?: number; target?: 'band' | 'room'; triggerMarginTokens?: number; cutAt?: number; calibrationFactor?: number; calibrationWindow?: number[]; calibrationIdentity?: string; activeInputCeilingTokens?: number | null }; before: { value: number; unit: 'estimated-input-tokens'; scope: 'native-preparation' | 'public-conversation' }; after: { value: number | null; unit: 'estimated-input-tokens'; scope: 'draft-preview' }; }
 export function attachReceipt<T extends { details?: unknown; firstKeptEntryId: string; tokensBefore: number }>(draft: T, reason: string, reserveTokens: number, contextWindow: number, resolved: Partial<Receipt['settings']> = {}): T & { details: Record<string, unknown> & { diagnosticReceipt: Receipt } } {
  const details = draft.details && typeof draft.details === 'object' ? draft.details as Record<string, unknown> : {};
- const receipt: Receipt = { id: randomUUID(), build: DIAGNOSTIC_BUILD, reason, selectedView: typeof details.view === 'string' ? details.view : 'deterministic-selected-draft', boundary: draft.firstKeptEntryId, settings: { draftReservedTokens: reserveTokens, contextWindow, ...resolved }, before: { value: draft.tokensBefore, unit: 'estimated-input-tokens', scope: reason === 'tool-loop' || reason === 'run-end' ? 'public-conversation' : 'native-preparation' }, after: { value: typeof details.tokensAfter === 'number' ? details.tokensAfter : null, unit: 'estimated-input-tokens', scope: 'draft-preview' } };
+ const receipt: Receipt = { id: randomUUID(), build: DIAGNOSTIC_BUILD, reason, selectedView: typeof details.view === 'string' ? details.view : 'deterministic-selected-draft', boundary: draft.firstKeptEntryId, settings: { draftReservedTokens: reserveTokens, contextWindow, ...resolved }, before: { value: draft.tokensBefore, unit: 'estimated-input-tokens', scope: reason === 'tool-loop' || reason === 'run-end' || reason === 'prompt' ? 'public-conversation' : 'native-preparation' }, after: { value: typeof details.tokensAfter === 'number' ? details.tokensAfter : null, unit: 'estimated-input-tokens', scope: 'draft-preview' } };
  return { ...draft, details: { ...details, diagnosticReceipt: receipt } };
 }
 export function receiptId(entry: { details?: unknown }): string | undefined {

package/src/tuck.ts

@@ -18,7 +18,8 @@ export type Measure = (messages: AgentMessage[]) => number;
 /** The summary view that produced a draft: the whole pre-cut dialogue, or the same dialogue shrunk to the allowance. Both carry the file ledger. */
 export type DraftMode = "dialogue" | "shrunk";
 type Draft = { compaction: Pick<Extract<SessionEntry, { type: "compaction" }>, "summary" | "firstKeptEntryId" | "tokensBefore" | "details">; after: number; mode: DraftMode; unavailable?: never; capacityRejected?: never }
-    | { compaction?: never; mode?: never; unavailable: string; capacityRejected?: boolean };
+    // The actual floor projection lets the caller measure it without the fresh results it may clip.
+    | { compaction?: never; mode?: never; unavailable: string; capacityRejected?: boolean; floorMessages?: AgentMessage[] };
 interface SearchHit { index: number; role: string; summary: string }
 export interface RecallContinuation { query: string; throughEntryId: string; offset: number }
 /** Includes JSON escaping, hit metadata and continuation, not just excerpt text. */
@@ -63,8 +64,9 @@ export function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: Ext
 }
 /** Shared compiler observes canonical branch and current token estimate; no native preparation utility. */
 /** `newPrompt`: the cut is planned for a run that has not begun (a prompt Pi has not appended yet, an operator's manual cut, Pi's own cut before
- * a run a custom message starts); the session has moved on from an ended run. */
-export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEntry[]; tokensBefore: number; previousSummary?: string; operatorManual?: boolean; newPrompt?: boolean }, ctx: ExtensionContext,
+ * a run a custom message starts); the session has moved on from an ended run.
+ * `reRenderSummary`: the cut is due, so its summary may be re-rendered smaller (see the `no_live_messages` branch below). */
+export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEntry[]; tokensBefore: number; previousSummary?: string; operatorManual?: boolean; newPrompt?: boolean; reRenderSummary?: boolean }, ctx: ExtensionContext,
  reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true): Draft {
  const { isHistorySource, readable } = createRecall(policy);
 	const projected = ctx.sessionManager.buildSessionProjection();
@@ -92,6 +94,12 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
 	let cut = tuck.buildOwnCut(entries, 1);
 	if (cut.ok) cut = tuck.applyTailBudget(entries, cut, { charsPerToken, maxTokens,
         oversizedFactor: Math.min(OVERSIZED_TAIL_FACTOR, inputRoom / Math.max(1, maxTokens)) });
+    // Nothing since the last cut: its summary alone is the conversation, and only a cut that is due can re-render it. A summary is compiled from
+    // the original sources, so the cut takes the whole history again under this cut's allowance, and a summary that leaves the request no room is
+    // made smaller. Inside the band a cut is opportunistic, and re-rendering there shrinks the summary and costs history for nothing (replays
+    // s04-B task 13, s08-B task 23: a 13,008-token first request became 3,336), so an opportunistic cut refuses as it did before.
+    else if (input.reRenderSummary && cut.reason === "no_live_messages" && entries.some(entry => entry.type === "compaction"))
+        cut = { ok: true, messages: [], selectedIds: [], firstKeptEntryId: "", compactAll: true, keptUserTurns: 0, keepFallbackToCompactAll: false };
 	if (!cut.ok) return { unavailable: `pi-tuck cannot select a cut: ${cut.reason}` };
     // The latest call's trailing receipts have not reached a subsequent response.
     // A preferred tail size must not erase this first exposure when the whole
@@ -213,7 +221,8 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     const model = ctx.model;
     const floorAt = (keep: number) => {
         const ledger = [...actionRecords(actions, keep), ...ledgerRecords(items, keep)];
-        return { ledger, base: measure(preview(serializeTranscript([...mandatory, ...ledger]) + DIALOGUE_SUFFIX)) };
+        const messages = preview(serializeTranscript([...mandatory, ...ledger]) + DIALOGUE_SUFFIX);
+        return { ledger, messages, base: measure(messages) };
     };
     const fits = (base: number) => Boolean(model) && base + reserveTokens < model!.contextWindow && base < before;
     // When the whole floor cannot fit, the trail and the ledger keep only their headings and counts; only that can refuse the cut.
@@ -221,7 +230,7 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     if (!fits(floor.base) && (items.length || actions.length)) floor = floorAt(0);
     const { ledger, base } = floor;
     if (!model || !fits(base))
-        return { unavailable: "pi-tuck's mandatory context cannot fit or reduce the request budget", capacityRejected: Boolean(model && base + reserveTokens >= model.contextWindow) };
+        return { unavailable: "pi-tuck's mandatory context cannot fit or reduce the request budget", capacityRejected: Boolean(model && base + reserveTokens >= model.contextWindow), floorMessages: floor.messages };
     const maxBriefChars = historicalAllowance(model.contextWindow, reserveTokens, base, before);
     const compileInput = { messages, sourceIndices, sourceEntryIds: originalCut.selectedIds, sourceTimes: originalCut.selectedIds.map(id => resolveSourceTime(entryById.get(id)!)), receiptContext,
         ranking: { maxBriefChars, mandatorySourceIndices: new Set(mandatory.flatMap(r => r.sourceIndex === undefined ? [] : [r.sourceIndex])) },
@@ -259,7 +268,7 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     const { summary, after } = offer ?? assemble(tuck.compileShrunkDialogue(compileInput));
     // Draft reduction concerns conversation. Final request admission owns the effective system/tools.
     if (after + reserveTokens >= model.contextWindow || after >= before)
-        return { unavailable: "pi-tuck's draft does not reduce context within the request budget", capacityRejected: after + reserveTokens >= model.contextWindow };
+        return { unavailable: "pi-tuck's draft does not reduce context within the request budget", capacityRejected: after + reserveTokens >= model.contextWindow, floorMessages: floor.messages };
     const mode: DraftMode = offer ? "dialogue" : "shrunk";
 	return { compaction: { summary, firstKeptEntryId: cut.firstKeptEntryId, tokensBefore: input.tokensBefore, details: { ...details, tokensAfter: after, view: offer ? "complete-dialogue" : "shrunk-dialogue", mode } }, after, mode };
     };