pi-tuck 1.0.9 → 1.0.11

package/dist/src/compaction.js

@@ -5,7 +5,7 @@ import { exportSource } from "./source-export.js";
 import { isDeepStrictEqual } from "node:util";
 import { assertNativeToolRounds } from "./protocol.js";
 import { projectedMessages } from "./omissions.js";
-import { applyClips, clipFor } from "./clip.js";
+import { applyClips, clipBudgets, clipFor } from "./clip.js";
 import { DEFAULT_CUT_AT, bandOf, chooseCut, conversationTokens, decideCut, gateCut, incomingEventTokens, incomingTokens, measurableConversationTokens, planningReserve, projectedConversationTokens, requestTokens, systemPart, validCutAt } from "./budget.js";
 import { isContextOverflow } from "@earendil-works/pi-ai";
 import { convertToLlm, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
@@ -52,6 +52,10 @@ class CapacityError extends Refusal {
  * likely comes from that counting (an upstream behind a router can spend much more context on tool schemas), so the notice says so. */
 export const refusalNotice = (message, factor) => 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, bound, learned) => `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. */
@@ -253,10 +257,14 @@ export async function installCompaction(pi, options = {}) {
             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.
+        // 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 candidate = (ctx.model.contextWindow + 1) / paired.tokens;
-            if (candidate <= CALIBRATION_CEILING)
-                learn(candidate);
+            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;
@@ -266,11 +274,14 @@ export async function installCompaction(pi, options = {}) {
         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))
+        // 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
@@ -312,8 +323,7 @@ export async function installCompaction(pi, options = {}) {
     const isNoWork = (message) => ["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;
+    let promptCut;
     let failure;
     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
@@ -321,19 +331,24 @@ export async function installCompaction(pi, options = {}) {
     const clips = new Map();
     const fail = (error, ctx) => {
         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");
+                    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();
@@ -429,9 +444,15 @@ export async function installCompaction(pi, options = {}) {
                 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();
@@ -442,19 +463,18 @@ export async function installCompaction(pi, options = {}) {
             }
             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 };
@@ -463,21 +483,18 @@ export async function installCompaction(pi, options = {}) {
             // 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) => {
                     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, 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.
@@ -499,12 +516,23 @@ export async function installCompaction(pi, options = {}) {
         }
     });
     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, cut) => {
+        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, cut) => 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, incomingPart, observedPrompt, tools) => {
+        promptCut = undefined;
         if (!active())
             return;
         access();
@@ -512,55 +540,42 @@ export async function installCompaction(pi, options = {}) {
             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((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) => {
+                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";
@@ -597,7 +612,13 @@ export async function installCompaction(pi, options = {}) {
         const queued = event.context.pendingMessages.length ? conversationTokens(event.context.pendingMessages) : 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 = [];
+        let floorKept;
         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),
@@ -605,8 +626,15 @@ export async function installCompaction(pi, options = {}) {
                 plan: (target) => {
                     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)
+                    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.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");
@@ -614,27 +642,36 @@ export async function installCompaction(pi, options = {}) {
                     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) => 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.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
+                else {
                     decision = clippedDecision;
+                    break;
+                }
             }
         }
         const before = measure(saved);
@@ -646,12 +683,28 @@ export async function installCompaction(pi, options = {}) {
         return { entries: [{ type: "compaction", summary: compaction.summary,
                     firstKeptEntryId: compaction.firstKeptEntryId, details: compaction.details }] };
     };
+    const atBoundary = (event, ctx, reason, decide) => {
+        if (!promptCut)
+            return decide ? boundaryCut(event, ctx, reason) : undefined;
+        const entry = promptCut;
+        promptCut = undefined;
+        const preview = cutSession(ctx, entry), view = 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, 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)
+            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 = boundaryCut(event, ctx, "tool-loop");
+            const result = atBoundary(event, ctx, "tool-loop", decide);
             if (result)
                 pendingBoundaryCommit = true;
             return result;
@@ -660,12 +713,23 @@ export async function installCompaction(pi, options = {}) {
             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 = (messages, ctx, cut) => {
+        const conversation = (all) => all.filter(message => message.role !== "system");
+        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)), ...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 {
@@ -677,10 +741,6 @@ export async function installCompaction(pi, options = {}) {
         }
     });
     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)
@@ -707,10 +767,12 @@ export async function installCompaction(pi, options = {}) {
         }
         // Pi commits these entries before the run settles.
         try {
-            if (!active() || !admittedRun || event.outcome !== "completed" || ctx.signal?.aborted || failure ||
-                !settingsFor().getCompactionSettings(ctx.model).enabled)
+            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 boundaryCut(event, ctx, "run-end");
+            return atBoundary(event, ctx, "run-end", decide);
         }
         catch (error) {
             fail(error, ctx);

package/dist/src/diagnostic-replay.d.ts

@@ -24,6 +24,7 @@ export declare function inspectIncident(records: IncidentRecord[]): {
             mode?: never;
             unavailable: string;
             capacityRejected?: boolean;
+            floorMessages?: import("@earendil-works/pi-agent-core").AgentMessage[];
         };
         receiptId: string | null;
         matchesRecordedProposal: boolean | null;

package/dist/src/diagnostics.d.ts

@@ -1,6 +1,6 @@
 import { type RecallPolicy } from './recall.js';
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
-export declare const DIAGNOSTIC_BUILD = "c4e6e6034a54ff7a893ee62484e54cf471964be3435aa587af8a288dcbf41314";
+export declare const DIAGNOSTIC_BUILD = "828ac4821689607af006d54a41fd5960bb910bc65aa43adbd81c2f6aac25d180";
 export interface Receipt {
     id: string;
     build: string;

package/dist/src/diagnostics.js

@@ -8,7 +8,7 @@ import { createRecall } from './recall.js';
 export const DIAGNOSTIC_BUILD = BUILD_ID;
 export function attachReceipt(draft, reason, reserveTokens, contextWindow, resolved = {}) {
     const details = draft.details && typeof draft.details === 'object' ? draft.details : {};
-    const 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 = { 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) {

package/dist/src/tuck.d.ts

@@ -21,6 +21,7 @@ type Draft = {
     mode?: never;
     unavailable: string;
     capacityRejected?: boolean;
+    floorMessages?: AgentMessage[];
 };
 interface SearchHit {
     index: number;
@@ -84,13 +85,15 @@ export declare function historicalAllowance(window: number, reserve: number, bas
 export declare function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean, operatorManual?: boolean, newPrompt?: boolean): Draft;
 /** 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. */
+ * 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 declare 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?: boolean): Draft;
 /** Numeric references use the original session index, then intersect with readable current-branch entries. */
 export declare function tuckRecall(tuck: Tuck, entries: readonly SessionEntry[], branch: readonly SessionEntry[], input: RecallOptions & {

package/dist/src/tuck.js

@@ -31,7 +31,8 @@ export function tuckDraft(tuck, event, ctx, reserveTokens, measure, policy = {},
 }
 /** 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. */
+ * 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, input, ctx, reserveTokens, measure, policy = {}, retainCurrentInput = true) {
     const { isHistorySource, readable } = createRecall(policy);
     const projected = ctx.sessionManager.buildSessionProjection();
@@ -62,6 +63,12 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
     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.
@@ -196,7 +203,8 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
         const model = ctx.model;
         const floorAt = (keep) => {
             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) => 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.
@@ -205,7 +213,7 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
             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])) }, };
@@ -244,7 +252,7 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
         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 = 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 };
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Deterministic compaction for Pi with no model call, plus exact recall of earlier history. Search by meaning on Apple silicon.",
   "keywords": [
     "pi-package",

package/src/build-id.ts

@@ -1 +1 @@
-export const BUILD_ID = "c4e6e6034a54ff7a893ee62484e54cf471964be3435aa587af8a288dcbf41314";
+export const BUILD_ID = "828ac4821689607af006d54a41fd5960bb910bc65aa43adbd81c2f6aac25d180";

package/src/clip.ts

@@ -16,6 +16,19 @@ const clipped = (text: string, keep: number, entryId: string): ToolResultMessage
         `tuck_recall {"entryId":"${entryId}","offset":${head}}, up to ${MAX_RECALL_CHARACTERS} characters a call]\n` + text.slice(text.length - tail) }];
 };
 
+/** The budgets to offer a fresh round the room cannot hold whole, in the units the round and the mandatory input are counted in, tried in order.
+ * The room is the provider's, so it is divided by the factor the provider's counts have been running at - the same conversion the planner's own
+ * reserve makes (budget.ts) - before the input no cut can remove is taken out; counting the provider's room against an estimate asks the round for
+ * more than the room holds at a factor above 1. The first try is half of what that leaves. `kept` is what the smallest cut leaves the request
+ * besides the fresh results - the summary floor and its quote of the prompt - measured from the planner's own preview, not a new formula: a half
+ * cannot spend it, so the second try is the whole free room less it. Omit it when the planner bailed before building a preview, and only the half
+ * is tried. Nothing is offered when the mandatory input alone leaves no room. */
+export const clipBudgets = (room: number, factor: number, mandatory: number, kept?: number): number[] => {
+    const free = Math.floor(room / Math.max(1, factor)) - mandatory;
+    if (free <= 0) return [];
+    return [...new Set(kept === undefined ? [Math.floor(free / 2)] : [Math.floor(free / 2), free - kept - 1])].filter(budget => budget > 0);
+};
+
 /** The round's text results within `budget` tokens together: each result smaller than an equal share of what is left stays whole, and the
  * rest are clipped to that share, keeping the most head and tail characters that fit it. None when the round already fits, or when a share
  * cannot hold even the locator. A round of one result gets the whole budget. Deterministic: the same round and budget always clip the same way. */