pi-tuck 1.0.9 → 1.0.10

package/CHANGELOG.md

@@ -3,6 +3,38 @@
 All notable changes to pi-tuck. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow
 [Semantic Versioning](https://semver.org/).
 
+## [1.0.10] - 2026-11-01
+
+### Fixed
+
+- A session no longer stays stuck when Pi's `compaction.keepRecentTokens` covers the whole conversation (the 1.0.8 and 1.0.9 known issue,
+  at Pi's defaults on small windows). The cut a prompt needs is now pi-tuck's own: it is planned when the prompt arrives, as at a tool
+  boundary, every request of that run carries it, and the run's first boundary saves it. Pi's cut finder, which keeps the last
+  keepRecentTokens and then has nothing to cut, is no longer asked. A run that ends before a boundary drops the cut, and the next prompt
+  decides afresh.
+
+### Changed
+
+- A prompt's cut no longer goes through Pi's `session_before_compact`, so another extension's veto there no longer stops it. It never
+  stopped a cut between tool rounds either. Pi's own threshold and overflow cuts, and `/compact`, still ask other extensions as before.
+
+### Known issue
+
+- When the previous summary alone fills the room and a large prompt arrives, the prompt is dropped: a cut cannot yet shrink a summary on its
+  own. 1.0.10 drops it with no message, where 1.0.9 refused it with one ("Already compacted"). The next prompt runs normally. Seen once, on a
+  25,160-character prompt at a 32k window. A fix is planned for 1.0.11.
+
+### Release gates
+
+- Passed: tests; replay of the exact build on 29 recordings (no dead task, no refused request, every oversize result clipped and read
+  back); the Pi-defaults rerun on chain t06, which lost 28 of 30 tasks on 1.0.8: 0 dead tasks and 0 stuck sessions
+  ([`benchmark/RESULTS-DEFAULTS-1010.md`](benchmark/RESULTS-DEFAULTS-1010.md)). Two of its tasks sat on a first request the local server never
+  answered, ran to the 30-minute cap and recorded no token; they are read as server stalls, and a strict no-token count would not meet the bar.
+  One task was refused mid-run: its round carried 9,020 tokens of reasoning, so the next request was about 17,801 against the 16,384-token room.
+- **Failed as registered:** the paired 32k gate against 1.0.9 (chains t01 and t02, 60 tasks). No task was lost in either arm, but 1.0.10
+  resolved 49 tasks against 50, so "resolved no lower" failed by one task (−1.7 points, one-sided 95% lower bound −8.3;
+  [`benchmark/RESULTS-V110.md`](benchmark/RESULTS-V110.md)). The user approved shipping as an exception because of the small-window defect.
+
 ## [1.0.9] - 2026-11-01
 
 ### Changed
@@ -18,6 +50,18 @@ All notable changes to pi-tuck. The format follows [Keep a Changelog](https://ke
 - `tuck_search` takes a result back as returned: each entry of `priorResults` is a source's `sourceSha` and `read`, unchanged. It asked for
   `start` and `end`, which no result carried.
 
+### Known issue
+
+- Affects 1.0.8 and 1.0.9. At a small window, Pi's default `compaction.keepRecentTokens` (20,000) can exceed pi-tuck's input room (the window
+  less the larger of `compaction.reserveTokens` and the model's maximum output; 16,384 at a 32k window with the default reserve). After a
+  run that is stopped (Esc, or a time limit) with the context above the room, every later prompt can be refused with "The request needs a cut
+  and Pi has none to make (Nothing to compact (session too small))", and the session stays stuck. Workaround until 1.0.10: set
+  `"compaction": {"keepRecentTokens": N}` in Pi's `settings.json` (or `compaction.modelOverrides["provider/model"].keepRecentTokens` for one
+  model), with N well below the room. Windows of 128k and up are not affected at the defaults. 1.0.10 is planned to fix this: pi-tuck will
+  make prompt-time cuts itself. Evidence: in one check at these defaults (1.0.8, 32k window, one session of 30 tasks, one model), 28 tasks
+  were lost ([`benchmark/RESULTS-DEFAULTS.md`](benchmark/RESULTS-DEFAULTS.md)); it shows that the failure occurs, not how often.
+
+## [1.0.8] - 2026-11-01
 
 ### Fixed
 

package/README.md

@@ -57,8 +57,8 @@ Then start a new Pi session. That is all. pi-tuck takes over Pi's compaction, bo
 
 - Needs Pi 1.2.0 or later (tested on 1.2.0 and 1.4.0), on macOS or Linux. On an older Pi, pi-tuck stays off, Pi's own compaction runs, and pi-tuck says so once. Full features on macOS with Apple silicon; elsewhere, compaction and word recall.
 - On macOS with Apple silicon, the first session also downloads a local search model in the background (about 390 MB, once). Until it is ready, search works by keyword. See [Semantic search](#semantic-search).
-- Prefer GitHub? `pi install git:github.com/galyavin/pi-tuck@v1.0.9`.
-- To pin a version, add it: `pi install npm:pi-tuck@1.0.9`.
+- Prefer GitHub? `pi install git:github.com/galyavin/pi-tuck@v1.0.10`.
+- To pin a version, add it: `pi install npm:pi-tuck@1.0.10`.
 
 ## How it works
 
@@ -105,6 +105,7 @@ Known limits today:
 
 - pi-tuck's summary does not explain why things happened. It holds the words that were said, not a model's reading of them. The agent must look things up. Each look-up costs a tool call.
 - Small windows: an upstream that spends far more context on tool schemas than others (some OpenRouter upstreams do) can leave a small input room too little space, and pi-tuck then refuses to cut rather than overflow. This is what made 1.0.1 refuse at a 32k window with Pi's default 16,384 reserve. Since 1.0.4 the notice says when the provider is counting far above pi-tuck's estimate. In 1.0.4, after an oversize tool result or a "Nothing to compact" error from Pi, a session could keep refusing later prompts. 1.0.5 fixes both. Since 1.0.8, a fresh tool result too large for the room is clipped (its head and tail, with a `tuck_recall` locator to the rest) instead of refusing the run. Pin a different upstream, lower the reserve, or use a larger window; see [Small windows](#small-windows).
+- Small window, after a stopped run (1.0.8 and 1.0.9): Pi's default `compaction.keepRecentTokens` (20,000) can exceed pi-tuck's input room, which is the window less the larger of `compaction.reserveTokens` and the model's maximum output. At a 32k window with the default 16,384 reserve the room is 16,384. After a run that is stopped (Esc, or a time limit) with the context above the room, every later prompt can be refused with "The request needs a cut and Pi has none to make (Nothing to compact (session too small))", and the session stays stuck. In one check at these defaults (pi-tuck 1.0.8, 32k window, one session of 30 tasks, one local model), 28 tasks were lost, tasks 3 to 30; it shows that the failure occurs, not how often ([`benchmark/RESULTS-DEFAULTS.md`](benchmark/RESULTS-DEFAULTS.md)). Workaround until 1.0.10: set `"compaction": { "keepRecentTokens": N }` in Pi's `settings.json`, with N well below the room; the 32k benchmark used 3,333 (see [Small windows](#small-windows)). Windows of 128k and up are not affected at the defaults, since the room there is far above 20,000 tokens. 1.0.10 is planned to fix this: pi-tuck will make prompt-time cuts itself.
 - Semantic search (`tuck_search`) needs a Mac with Metal (Apple silicon). Elsewhere, compaction and `tuck_recall`'s word search work, there is no `tuck_search`, and nothing is downloaded.
 
 ## Benchmarks
@@ -113,8 +114,9 @@ Each row says what was measured, under which conditions, and where the data is.
 
 | What | Result | Conditions | Source |
 |---|---|---|---|
-| Tasks resolved, 32k window | Pi's built-in compaction 94 of 150; pi-tuck 120 of 150 (+17.3 points, 95% lower bound +10.7); observation masking 117 of 150 (pi-tuck +2.0, lower bound −2.7: no difference shown). Turns per task: 9.4 (built-in), 24.0 (pi-tuck), 11.9 (masking). Tokens per session: 6.10 M, 6.39 M, 7.02 M. Spend per arm for the five sessions: $0.87, $0.55, $0.94 | pi-tuck 1.0.5 (commit `aa30824`, the 1.0.5 code; 1.0.6 and 1.0.7 are not measured). DeepSeek V4.1 Flash pinned to one upstream, window 32,768, reserve 16,384, 5 chains of 30 SWE-bench Verified tasks, paired by task, one-sided bootstrap over tasks. **Limits:** only pi-tuck is held to the 16,384-token room (the built-in sent a request over it in 97 of 150 tasks, masking in 73, so the window is nominal for them). The difference by chain is +10.0, −3.3, +50.0, +16.7 and +13.3 points; leaving out chain t03 it is +9.2. The bootstrap resamples tasks, not chains. The pi-tuck arm ran at a different time from the others. One model, one window. pi-tuck refused to cut mid-run in 5 tasks, where one fresh tool result was larger than the room; they count as unresolved. In the same setup pi-tuck 1.0.3 resolved 72 of 150, with 52 tasks lost because an earlier refusal carried forward; 1.0.5 fixes that | [`benchmark/RESULTS-32K-ACCEPT.md`](benchmark/RESULTS-32K-ACCEPT.md) |
-| The 1.0.8 candidate against 1.0.7, 32k window | 0 dead tasks in both arms. Resolved 46 of 60 in both (+0.0 points, 95% lower bound −6.7). No mid-run refusal in either arm. Turns per task 25.37 (1.0.7) and 26.10 (1.0.8) | Pre-registered gate, passed as registered. pi-tuck `a2e7d1a` (the tool-result clip and the cut at the end of a run, on 1.0.6) against 1.0.7. Released 1.0.8 adds 1.0.7's Metal-only recall to that build. DeepSeek V4.1 Flash pinned to one upstream, window 32,768, reserve 16,384, chains t01 and t02, 60 paired tasks, both arms run together. One model, one window, one run per arm; 60 tasks cannot show a difference smaller than the bound. The run shows that the change introduced no refusal; no refusal occurred in the 1.0.7 arm for the clip to prevent | [`benchmark/RESULTS-V108.md`](benchmark/RESULTS-V108.md) |
+| Pi's default compaction settings, 32k window | 28 of 30 tasks lost (tasks 3 to 30, each refused at its prompt); 1 resolved. Fails the pre-registered bar of 0 lost tasks | pi-tuck 1.0.8 (`86935e9`), `mac-studio/main`, window 32,768, output cap 16,384, `reserveTokens` 16,384 and `keepRecentTokens` 20,000 (larger than the room), one session of chain t06. One session, one model, one build: it shows that the failure occurs at these settings, not how often. Not comparable with other rows | [`benchmark/RESULTS-DEFAULTS.md`](benchmark/RESULTS-DEFAULTS.md) |
+| Tasks resolved, 32k window | Pi's built-in compaction 94 of 150; pi-tuck 120 of 150 (+17.3 points, 95% lower bound +10.7); observation masking 117 of 150 (pi-tuck +2.0, lower bound −2.7: no difference shown). Turns per task: 9.4 (built-in), 24.0 (pi-tuck), 11.9 (masking). Tokens per session: 6.10 M, 6.39 M, 7.02 M. Spend per arm for the five sessions: $0.87, $0.55, $0.94 | pi-tuck 1.0.5 (commit `aa30824`, the 1.0.5 code; 1.0.6 and 1.0.7 are not measured). DeepSeek V4.1 Flash pinned to one upstream, window 32,768, reserve 16,384, 5 chains of 30 SWE-bench Verified tasks, paired by task, one-sided bootstrap over tasks. **Limits:** only pi-tuck is held to the 16,384-token room (the built-in sent a request over it in 97 of 150 tasks, masking in 73, so the window is nominal for them). The difference by chain is +10.0, −3.3, +50.0, +16.7 and +13.3 points; leaving out chain t03 it is +9.2. The bootstrap resamples tasks, not chains. The pi-tuck arm ran at a different time from the others. One model, one window. pi-tuck refused to cut mid-run in 5 tasks, where one fresh tool result was larger than the room; they count as unresolved. In the same setup pi-tuck 1.0.3 resolved 72 of 150, with 52 dead tasks (tasks refused at their prompt after an earlier failure). In the pi-tuck arm of this row there was 1 dead task (t03 task 24: refused at its prompt with "Nothing to compact"; the next task ran normally), so this build missed the pre-registered acceptance bar of zero dead tasks by one task (the other part of the bar, no loss against 1.0.3 by more than 3 points, was met) | [`benchmark/RESULTS-32K-ACCEPT.md`](benchmark/RESULTS-32K-ACCEPT.md) |
+| The 1.0.8 candidate against 1.0.7, 32k window | 0 dead tasks in both arms. Resolved 46 of 60 in both (+0.0 points, 95% lower bound −6.7). No mid-run refusal in either arm. Turns per task 25.37 (1.0.7) and 26.10 (1.0.8) | Pre-registered gate, passed as registered. pi-tuck `a2e7d1a` (the tool-result clip and the cut at the end of a run, on 1.0.6) against 1.0.7. Released 1.0.8 is that build merged with 1.0.7's Metal-only recall; its replay requests are reported byte-identical to the gated build on 29 recordings (stated in the source file, not re-run for this README). DeepSeek V4.1 Flash pinned to one upstream, window 32,768, reserve 16,384, chains t01 and t02, 60 paired tasks, both arms run together. One model, one window, one run per arm; 60 tasks cannot show a difference smaller than the bound. The run shows that the change introduced no refusal; no refusal occurred in the 1.0.7 arm for the clip to prevent | [`benchmark/RESULTS-V108.md`](benchmark/RESULTS-V108.md) |
 | Cut time, live | pi-tuck median 0.087 s (90th percentile 0.205 s); Pi's built-in median 268.8 s (90th percentile 421.6 s). Context carried after a cut, median: 27,751 against 29,241 tokens | **Interim.** pi-tuck 1.0.1, Pi 1.4.0, SWE-bench Verified chains of 30 tasks, 131,072-token window, reply reserve 32,768, local model `mac-studio/main` writing Pi's summaries. 27 cuts per arm, 5 chains. The built-in time depends on that model and on server load. pi-tuck's time is an upper bound read from the session file | [`benchmark/RESULTS-INTERIM.md`](benchmark/RESULTS-INTERIM.md) section 1 |
 | Cut time, paired replay | pi-tuck median 0.062 s (range 0.005 to 0.48 s); local-model summarizer 193.4 s (77.3 to 413.3 s); frontier summarizer 96.1 s (39.1 to 267.8 s; measured on the retired model `openai/gpt-6-astra`; feeds no test). Context carried after a cut, median: 28,006 (pi-tuck), 26,424 (local), 25,555 (frontier) tokens | **Interim.** The same recorded sessions cut at the same positions. pi-tuck: 10 recordings, 52 cuts. Summarizers: 6 recordings, 28 and 29 cuts. pi-tuck's time leaves out the background search index | [`benchmark/RESULTS-INTERIM.md`](benchmark/RESULTS-INTERIM.md) section 2 |
 | Billed input, cutting at 60% of the room instead of 100% | −17.9% at 128k, −14.0% at 32k with automatic prompt caching; −17.0% and −9.6% with explicit cache breakpoints. Cuts go from 6 to 12 (128k) and from 84 to 157 (32k); none frees under a tenth of the room | Simulated billing, not provider bills. Prompt caching priced. Build `1bda64b` (the default shipped in 1.0.3). 5 recorded live sessions. 128k = 131,072 window, reserve 32,768. 32k = 32,768 window, reserve 16,384 | [`rnd/replay32/RESULT-lean.md`](rnd/replay32/RESULT-lean.md) |
@@ -154,6 +156,14 @@ pi-tuck keeps room for the model's reply: the larger of the model's output limit
 
 The reserve is the larger of `reserveTokens` and the model's `maxTokens`, so lowering `reserveTokens` alone does nothing when `models.json` sets a larger `maxTokens` for that model. Lower both, and keep `maxTokens` above your largest expected reply.
 
+If a session gets stuck after a stopped run (see Known limits), set `keepRecentTokens` well below the room, in `~/.pi/agent/settings.json` for all models, or for one model:
+
+```json
+{ "compaction": { "modelOverrides": { "my-provider/my-model": { "keepRecentTokens": 3333 } } } }
+```
+
+3,333 is the value the 32k benchmark used: the main run's 20,000 of a 98,304 room, scaled to a 16,384 room (`benchmark/PREREG-32K.md`).
+
 If you reach the model through OpenRouter, you can also pin one upstream, so that every request is served by the same one. Put this in `models.json` in Pi's agent folder, and name the upstream you want:
 
 ```json

package/dist/src/build-id.d.ts

@@ -1 +1 @@
-export declare const BUILD_ID = "c4e6e6034a54ff7a893ee62484e54cf471964be3435aa587af8a288dcbf41314";
+export declare const BUILD_ID = "3c4da6131a995651dda4f51db08a27e509958ef5a18dcfc14a264b07c04663aa";

package/dist/src/build-id.js

@@ -1 +1 @@
-export const BUILD_ID = "c4e6e6034a54ff7a893ee62484e54cf471964be3435aa587af8a288dcbf41314";
+export const BUILD_ID = "3c4da6131a995651dda4f51db08a27e509958ef5a18dcfc14a264b07c04663aa";

package/dist/src/compaction.js

@@ -270,7 +270,7 @@ export async function installCompaction(pi, options = {}) {
             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 +312,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
@@ -327,6 +326,7 @@ export async function installCompaction(pi, options = {}) {
             failure = error instanceof Error ? error : new Error(String(error));
         pendingBoundaryCommit = false;
         pending = undefined;
+        promptCut = undefined;
         try {
             options.fail?.(error);
         }
@@ -429,9 +429,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 +448,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 +468,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 +501,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 +525,40 @@ 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);
+                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary, newPrompt: true }, 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";
@@ -646,12 +644,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 +674,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 +702,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 +728,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/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 = "3c4da6131a995651dda4f51db08a27e509958ef5a18dcfc14a264b07c04663aa";
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "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 = "3c4da6131a995651dda4f51db08a27e509958ef5a18dcfc14a264b07c04663aa";

package/src/compaction.ts

@@ -241,7 +241,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         if (input > 0 && 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 +284,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
@@ -298,6 +300,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 		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"); }
             finally { ctx.abort(); }
@@ -370,9 +373,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 +391,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 +410,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 +434,57 @@ 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);
+                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary, newPrompt: true }, 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";
@@ -549,26 +556,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 +621,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 {