pi-tuck 1.0.15 → 1.0.17

package/CHANGELOG.md

@@ -3,6 +3,68 @@
 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.17] - 2026-11-08
+
+### Fixed
+
+- **A host that patches a large section into the system prompt could get a refusal a cut would fit (1.0.0 to 1.0.16).** pi-tuck plans a prompt's cut when
+  the prompt arrives, before other extensions change the system prompt. A host engine that adds a section of thousands of tokens for one turn, as an
+  orchestrator does for its stand-off, could push that turn's first request over the room, and the final guard refused it. The guard now reduces first:
+  when the run's first request is over the room and no cut is planned, it plans the prompt's cut there, against the system prompt as finally sent, and
+  refuses only if that cut does not fit either. It works whatever order the extensions load in.
+
+### Added
+
+- Stress cells for a host that patches an 8k then 24k system section, at 65,536 and 81,920, registered before and after pi-tuck, with the section arriving
+  on a stand-off or on the first step turn after one and removed at the next stand-off. 1.0.16 refuses in the four cells at 81,920; 1.0.17 in none.
+
+### Changed
+
+- When queued input alone exceeds the room, the refusal names it as incoming input that cannot fit, instead of complete context. It still fails closed
+  with no cut.
+
+### Release gates
+
+- Replay matches 1.0.16: 0 of 13,946 requests differ on 29 recordings, 0 lost or dead tasks. Shipped without a live gate as a replay-matching patch.
+  Tests; CI; the stress test, with no cell worse than 1.0.16.
+
+## [1.0.16] - 2026-11-08
+
+### Fixed
+
+- **A long session could lose the task it was working on (1.0.0 to 1.0.15).** A summary quoted only the session's first user turn, up to 12,000 characters, and the
+  newest one. Every other user turn competed in the shrunk dialogue, which in a long session clips user turns to a few words and drops the oldest. In a session
+  that runs task after task, the current task is an older turn followed by short steps, so it was clipped or dropped while a finished first task stayed whole,
+  and agents acted on a days-old task. Short sessions, and the SWE-bench chains behind our benchmarks, keep each task's prompt in the kept tail and never hit it.
+  A summary now quotes user turns from both ends: first the opening of every recent answered turn, then the first prompt's opening (up to 2,000 characters),
+  then more of the newest turns, then the rest of the first prompt. A turn that does not fit keeps its opening and a locator to the rest. The budget is 15% of
+  the room and never less than 12,000 characters. When room is tight the quotes shrink step by step: the extensions first, then the openings, then the first
+  prompt alone as before. A turn pi-tuck refused and that never got a reply is not quoted.
+
+### Added
+
+- The settings stress test checks that the first prompt and the newest 8 answered prompts keep their openings through every cut, with cells for a run of
+  tasks at 32,768, tasks followed by long steps, and a long spec followed by 30 steering turns, at 32,768 and 81,920.
+
+### Known issues
+
+- At very small free room (a few thousand tokens or less), quotes give way and an older prompt can still lose its opening: 40 findings in 32 stress cells,
+  against 447 in 168 cells on 1.0.15. One sampled cell, with about 1,000 tokens free, loses a short middle prompt that 1.0.15 kept.
+- The known issues listed under 1.0.13 still apply.
+
+### Cost
+
+On replay of 17 real single-task sessions, cut rate and cost are unchanged: 7.0 cuts per 100 requests at 131,072 for both builds, and 9.3 at 81,920 (838 cuts
+against 837); billed tokens and request time within 0.1%. Those sessions have a median of one prompt, so the new quotes rarely apply there; their cost in a
+session of hundreds of turns is not measured.
+
+### Release gates
+
+- **Shipped without a live gate, as a fix for lost work.** Replay differs from 1.0.15, because summaries now quote more: 11,860 of 13,946 requests on 29
+  recordings, with 0 dead tasks, 0 refused requests and every clip read back (7 clips, where 1.0.15 had 28: summaries changed where cuts land). Tests; CI;
+  the stress test on Pi 1.2.0 and the newest Pi.
+- The 32k regression bench makes 74 cuts in 480 rounds, up from 67: sessions with a short first prompt now quote their newest turns too.
+
 ## [1.0.15] - 2026-11-08
 
 ### Fixed

package/README.md

@@ -64,8 +64,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.14`.
-- To pin a version, add it: `pi install npm:pi-tuck@1.0.14`.
+- Prefer GitHub? `pi install git:github.com/galyavin/pi-tuck@v1.0.16`.
+- To pin a version, add it: `pi install npm:pi-tuck@1.0.16`.
 
 ## How it works
 
@@ -74,7 +74,7 @@ When context fills up, pi-tuck replaces the older turns with one summary. The su
 - **The dialogue.** What you asked and what the agent answered, in order, word for word. If it is too long for the room, it shrinks: the oldest assistant text is clipped first, then older prompts. Clipped text says how to read it in full.
 - **The files.** Files the agent read, wrote or edited, newest first (up to 60), each with a pointer to read it back.
 - **The action trail.** The agent's other tool calls, such as shell commands, newest first (up to 30). The output is left out. A pointer leads to it.
-- **Your first prompt**, word for word (up to 12,000 characters).
+- **Your prompts, quoted from both ends** (1.0.16 and later): first the opening of every recent answered turn, then the first prompt's opening (up to 2,000 characters), then more of the newest turns, then the rest of the first prompt. A turn that does not fit keeps its opening and a locator to the rest. The budget is 15% of the room and never less than 12,000 characters. When room is tight, the quotes shrink step by step: the extensions first, then the openings, then the first prompt alone. Before 1.0.16 a summary quoted only the first prompt (up to 12,000 characters) and the newest turn; see Known limits.
 
 Tool output stays in the session file, not in the summary. Each summary ends with a short instruction to the agent: re-read a file before you edit it, look things up, and treat anything not shown as unknown.
 
@@ -114,8 +114,10 @@ Known limits today:
 - 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. pi-tuck then refuses to cut rather than overflow. This made 1.0.1 refuse at a 32k window with Pi's default 16,384 reserve. Version 1.0.4 added a notice that says when the provider counts 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 fixed both. Version 1.0.8 clips a fresh tool result that is too large for the room (its head and tail, with a `tuck_recall` locator to the rest) instead of refusing the run. If a small window still refuses, 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 only; fixed in 1.0.10): 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 (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 could be refused with "The request needs a cut and Pi has none to make (Nothing to compact (session too small))", and the session stayed 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 ([`benchmark/RESULTS-DEFAULTS.md`](benchmark/RESULTS-DEFAULTS.md)). If you are on 1.0.8 or 1.0.9, upgrade to 1.0.10. In 1.0.10 the cut a prompt needs is pi-tuck's own, so `keepRecentTokens` no longer leaves it with nothing to cut. A rerun of the same check on the 1.0.10 candidate had no refusal and no stuck session. It had two caveats: two of its tasks had a first request the local server never answered, and 8 of its 30 tasks began without their prompt, which the refusal counter cannot see (fixed in 1.0.12; see Benchmarks and [`benchmark/RESULTS-DEFAULTS-1010.md`](benchmark/RESULTS-DEFAULTS-1010.md)). Windows of 128k and up were not affected at the defaults.
 - A prompt could be lost, with no notice (1.0.10 and 1.0.11; fixed in 1.0.12). When a new prompt arrived over the cut point and pi-tuck's cut kept nothing of the conversation before it, which happens when everything since the last cut is one long turn, the prompt was dropped from the request and from the saved session. The model never saw it and usually went on with the previous task, so work you asked for could be lost, and could look answered. The next prompt ran normally. If you used 1.0.10 or 1.0.11 and a reply ignored what you had just asked, this is the likely cause. Upgrade to 1.0.12 ([`CHANGELOG.md`](CHANGELOG.md) 1.0.12).
+- A long session could lose the task it was working on (1.0.0 to 1.0.15; fixed in 1.0.16). A summary quoted only the session's first user turn, up to 12,000 characters, and the newest one. Every other user turn competed in the shrunk dialogue, which in a long session clips user turns to a few words and drops the oldest. In a session that runs task after task, the current task is an older turn followed by short steps, so it was clipped or dropped while a finished first task stayed whole, and agents acted on a days-old task. Short sessions, and the SWE-bench chains behind our benchmarks, keep each task's prompt in the kept tail and never hit it. Upgrade to 1.0.16 ([`CHANGELOG.md`](CHANGELOG.md) 1.0.16).
+- At very small free room (a few thousand tokens or less), the quotes give way and an older prompt can still lose its opening, in 1.0.16: 40 findings in 32 stress cells, against 447 in 168 cells on 1.0.15 ([`CHANGELOG.md`](CHANGELOG.md) 1.0.16).
 - The cut point adapts by itself since 1.0.13; before it, pi-tuck cut too often at small windows or with a large setup (1.0.11 and 1.0.12). The trade, from the changelog: on windows that cut too often, each request now carries more context. Cuts, re-processing and request time fall, and billed tokens rise on paid models. On replay of real sessions at an 81,920 window, cuts went from 22.3 to 9.3 per 100 requests, request time was about 16 to 20% lower, and billed tokens were 16 to 19% higher; at a 65,536 window billed tokens rose by as much as 35%. A very large setup at a small window, such as 40k at 65,536, still leaves too little free room for a good rhythm: cuts stay frequent and free little ([`CHANGELOG.md`](CHANGELOG.md) 1.0.13).
-- Still applying (1.0.11 to 1.0.13): a fresh assistant message larger than the free room is refused, and a short next prompt recovers (in an unattended `pi -p` run, a refusal ends the run). A reply that reports more than the window reads to Pi as a silent overflow; when nothing can be cut, pi-tuck refuses the next prompt, and the prompt after that runs. If a provider keeps rejecting requests in a wording Pi does not class as a context overflow, or with a bare HTTP 413, pi-tuck does not recover on its own: the session stays intact, and every prompt can fail until the request shrinks. Try `/compact` ([`CHANGELOG.md`](CHANGELOG.md) 1.0.13).
+- Still applying (1.0.11 to 1.0.16): a fresh assistant message larger than the free room is refused, and a short next prompt recovers (in an unattended `pi -p` run, a refusal ends the run). A reply that reports more than the window reads to Pi as a silent overflow; when nothing can be cut, pi-tuck refuses the next prompt, and the prompt after that runs. If a provider keeps rejecting requests in a wording Pi does not class as a context overflow, or with a bare HTTP 413, pi-tuck does not recover on its own: the session stays intact, and every prompt can fail until the request shrinks. Try `/compact` ([`CHANGELOG.md`](CHANGELOG.md) 1.0.13).
 - Other extensions (1.0.10): 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. Pi's own threshold and overflow cuts, and `/compact`, still ask other extensions as before.
 - 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.
 

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

@@ -1 +1 @@
-export declare const BUILD_ID = "1d9078a4eb50994b388a27d690a6af0f62e45cb1f019f9ef337138e249ebab1a";
+export declare const BUILD_ID = "27bb99fa3ca595dac73089d18c4c3506073c5d3e3f778ea572708f6e7a49ffc3";

package/dist/src/build-id.js

@@ -1 +1 @@
-export const BUILD_ID = "1d9078a4eb50994b388a27d690a6af0f62e45cb1f019f9ef337138e249ebab1a";
+export const BUILD_ID = "27bb99fa3ca595dac73089d18c4c3506073c5d3e3f778ea572708f6e7a49ffc3";

package/dist/src/compaction.js

@@ -542,7 +542,7 @@ export async function installCompaction(pi, options = {}) {
     // 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) => {
+    const preflight = (ctx, incomingPart, observedPrompt, tools) => {
         promptCut = undefined;
         promptCutAt = ctx.sessionManager.getBranch().length;
         if (!active())
@@ -807,22 +807,41 @@ export async function installCompaction(pi, options = {}) {
                 throw missingModel();
             // The complete request, counted after Pi's conversion (summary/custom/bash envelopes), with the effective system once.
             // Pi applies a forced prompt after this hook; the public prompt already observes it.
-            const tokens = requestTokens(event.messages, ctx.getSystemPrompt());
+            let messages = event.messages, tokens = requestTokens(messages, ctx.getSystemPrompt());
+            // The run's first request is over the room although the prompt's decision found it fit: something changed the request after that decision
+            // (another extension patching the system prompt in before_agent_start, whatever the load order). Reduce here rather than refuse: plan the
+            // prompt's cut against the request as it now is, carry it in memory, and save it at the first boundary, as any prompt's cut is saved.
+            if (!fits(tokens, limits(ctx).room, ctx) && !promptCut) {
+                const branch = ctx.sessionManager.getBranch(), last = branch.at(-1);
+                if (last?.type === "message" && last.message.role === "user") {
+                    const header = ctx.sessionManager.getHeader();
+                    const before = header && SessionManager.inMemory(ctx.cwd, undefined, [header, ...branch.slice(0, -1)]);
+                    if (before) {
+                        preflight(Object.create(ctx, { sessionManager: { value: before } }), incomingTokens(typeof last.message.content === "string" ? last.message.content : last.message.content.flatMap(b => b.type === "text" ? [b.text] : []).join("\n"), typeof last.message.content === "string" ? [] : last.message.content.filter((b) => b.type === "image")), ctx.getSystemPrompt(), pi.getActiveTools());
+                        if (promptCut) {
+                            messages = cutRequest(event.messages, ctx, promptCut);
+                            tokens = requestTokens(messages, ctx.getSystemPrompt());
+                        }
+                    }
+                }
+            }
             if (!fits(tokens, limits(ctx).room, ctx))
                 throw new CapacityError("Complete Pi context and response reserve exceed the estimated request budget");
             if (recorder.enabled && !recorder.waitingForCut)
                 recorder.measureInline(() => {
                     recorder.request();
                     // No system prompt or hidden assistant blocks; no provider payload/headers.
-                    const permitted = event.messages.filter(m => m.role !== "system" &&
+                    const permitted = messages.filter(m => m.role !== "system" &&
                         !(m.role === "assistant" && m.content.some(b => b.type === "thinking")) &&
                         !(m.role === "custom" && options.recallPolicy?.privateCustomTypes?.includes(m.customType)));
                     recorder.capture("prepared-request", "public-context-with-system-hook-before-later-transforms-not-wire", { messages: permitted, estimatedInputTokens: tokens }, permitted.length !== event.messages.length);
                 });
             if (tokens > 0 && Number.isSafeInteger(tokens))
                 pending = {
-                    identity: identityFor(ctx), tokens, messages: event.messages, snapshot: structuredClone(convertToLlm(event.messages)),
+                    identity: identityFor(ctx), tokens, messages, snapshot: structuredClone(convertToLlm(messages)),
                 };
+            if (messages !== event.messages)
+                return { messages };
         }
         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 = "1d9078a4eb50994b388a27d690a6af0f62e45cb1f019f9ef337138e249ebab1a";
+export declare const DIAGNOSTIC_BUILD = "27bb99fa3ca595dac73089d18c4c3506073c5d3e3f778ea572708f6e7a49ffc3";
 export interface Receipt {
     id: string;
     build: string;

package/dist/src/tuck.js

@@ -166,22 +166,75 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
                 receiptContext.messages.push(entry.message);
                 receiptContext.sourceIndices.push(indices.get(entry.id));
             }
-        const mandatory = [];
-        // The initiating prompt is quoted first, like the current input below: text only, since quoting cannot deliver other blocks.
+        // The newest user turns, newest first, then the initiating prompt, share one budget: in a session that runs task after task, the current task is
+        // an older user turn followed by short steps, and the dialogue clips user turns oldest first down to a few words, so quoting only the first prompt
+        // kept a finished task whole and lost the one being worked on. A turn that does not fit keeps its head and a locator; the first prompt gets what
+        // the newest turns leave, so a one-task session, whose later turns are short, still quotes it as before.
         const initiating = firstUserPosition >= 0 && firstUserPosition < boundary && entries[firstUserPosition].id !== protectedUser?.id ? entries[firstUserPosition] : undefined;
-        const initiatingContent = initiating?.type === "message" && initiating.message.role === "user" ? initiating.message.content : undefined;
-        if (initiating && isTextOnly(initiatingContent)) {
-            const text = textOf(initiatingContent), index = indices.get(initiating.id);
+        const quote = (entry, budget, label) => {
+            const content = entry.type === "message" && entry.message.role === "user" ? entry.message.content : undefined;
+            if (!isTextOnly(content))
+                return [];
+            const text = textOf(content), index = indices.get(entry.id);
             if (index === undefined)
-                throw new Error("Missing initiating user source index");
-            const quoted = head(text, MAX_TASK_CONTRACT_CHARACTERS), sourceTimes = [{ sourceIndex: index, ...resolveSourceTime(initiating) }];
-            if (text.trim()) {
-                mandatory.push({ kind: "excerpt", role: "user", sourceIndex: index, text: quoted, sourceTimes });
-                if (quoted.length < text.length)
-                    mandatory.push({ kind: "omission", role: "user", sourceIndex: index,
-                        reason: `Initiating prompt continues: characters ${quoted.length}-${text.length} omitted; read them with tuck_recall {"index":${index},"offset":${quoted.length}}`, sourceTimes });
+                throw new Error("Missing quoted user source index");
+            const quoted = head(text, budget), sourceTimes = [{ sourceIndex: index, ...resolveSourceTime(entry) }];
+            if (!text.trim() || !quoted.length)
+                return [];
+            return [{ kind: "excerpt", role: "user", sourceIndex: index, text: quoted, sourceTimes }, ...(quoted.length < text.length ? [{ kind: "omission", role: "user",
+                        sourceIndex: index, reason: `${label} continues: characters ${quoted.length}-${text.length} omitted; read them with tuck_recall {"index":${index},"offset":${quoted.length}}`, sourceTimes }] : [])];
+        };
+        // Both ends are anchored, in this order: the heads of the newest user turns (at most a quarter of the budget), the head of the first prompt (the
+        // goal of a long session), then extensions of the newest turns, then the rest of the first prompt. Heads come first so steps after a task can't
+        // use up the budget the task turn needs; the first prompt's head comes before any extension so steering turns can't use up the goal's.
+        const quotesFor = (budget, headSize, withFirst) => {
+            const turns = [];
+            // Only answered turns: a prompt that was refused and never got a reply was never taken up, and quoting it would spend the budget for nothing.
+            let answered = false;
+            for (let at = entries.length - 1; at >= 0; at--) {
+                const entry = entries[at];
+                if (entry.type === "message" && entry.message.role === "assistant") {
+                    answered = true;
+                    continue;
+                }
+                if (entry.type !== "message" || entry.message.role !== "user")
+                    continue;
+                const replied = answered;
+                answered = false;
+                if (at >= boundary || !replied || entry.id === protectedUser?.id || entry.id === firstUser?.id || !isTextOnly(entry.message.content))
+                    continue;
+                const text = textOf(entry.message.content);
+                if (text.trim())
+                    turns.push({ entry, text, take: 0 });
             }
-        }
+            // headSize 0 quotes the first prompt alone, as before any user turn was quoted: the last step before no quote at all.
+            if (headSize === 0)
+                turns.length = 0;
+            let left = budget, heads = Math.floor(budget / 4);
+            for (const turn of turns) {
+                if (heads <= 0)
+                    break;
+                turn.take = Math.min(turn.text.length, headSize, heads);
+                heads -= turn.take;
+                left -= turn.take;
+            }
+            const firstText = withFirst && initiating?.type === "message" && initiating.message.role === "user" && isTextOnly(initiating.message.content) ? textOf(initiating.message.content) : "";
+            let firstTake = Math.min(firstText.length, headSize ? Math.round(headSize * 20 / 3) : budget, Math.max(0, left));
+            left -= firstTake;
+            for (const turn of turns) {
+                if (left <= 0)
+                    break;
+                const more = Math.min(turn.text.length - turn.take, left);
+                turn.take += more;
+                left -= more;
+            }
+            firstTake += Math.min(firstText.length - firstTake, Math.max(0, left));
+            const records = turns.filter(turn => turn.take > 0).reverse().flatMap(turn => quote(turn.entry, turn.take, "User turn"));
+            if (firstTake > 0 && initiating)
+                records.unshift(...quote(initiating, firstTake, "Initiating prompt"));
+            return records;
+        };
+        const mandatory = [];
         if (protectedUser?.type === "message" && protectedUser.message.role === "user")
             mandatory.push({ kind: "excerpt", role: "user", sourceIndex: currentIndex, text: textOf(protectedUser.message.content), sourceTimes: [{ sourceIndex: currentIndex, ...resolveSourceTime(protectedUser) }] });
         // The file ledger and the action trail of the compacted history are mandatory, so they are charged in base like the quotes above.
@@ -200,22 +253,43 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
         };
         const before = measure(projected.messages);
         const model = ctx.model;
-        const floorAt = (keep) => {
+        const floorAt = (keep, choice) => {
             const ledger = [...actionRecords(actions, keep), ...ledgerRecords(items, keep)];
-            const messages = preview(serializeTranscript([...mandatory, ...ledger]) + DIALOGUE_SUFFIX);
-            return { ledger, messages, base: measure(messages) };
+            const messages = preview(serializeTranscript([...mandatory, ...quotesFor(choice.budget, choice.head, choice.first), ...ledger]) + DIALOGUE_SUFFIX);
+            return { ledger, messages, base: measure(messages), choice };
         };
         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.
-        let floor = floorAt(Math.max(items.length, actions.length));
-        if (!fits(floor.base) && (items.length || actions.length))
-            floor = floorAt(0);
+        // When room is tight the newest turns win over the first prompt, which in a long-running session is often a finished task. The floor gives way
+        // in this order: the trail and ledger to their headings, the extensions (the budget halved), then the heads, the first prompt's among them
+        // (300 characters, 2,000 for the first prompt; then 100 and 667), then everything but the first prompt (as before user turns were quoted),
+        // and only then every quote. Only a floor with no quote but the current input can refuse the cut.
+        // The budget grows with the room: 15% of it, at least the 12,000 characters a first prompt always had. A long-running session's task can be tens
+        // of thousands of characters, and the room is what can afford it.
+        const taskBudget = Math.max(MAX_TASK_CONTRACT_CHARACTERS, Math.floor(Math.max(0, (model?.contextWindow ?? 0) - reserveTokens) * charsPerToken * 0.15));
+        const budgets = [taskBudget, taskBudget / 2, taskBudget / 4, taskBudget / 8, 1500].map(Math.floor).filter((b, at, all) => b >= 1500 && all.indexOf(b) === at);
+        const choices = [{ head: 300, budgets }, { head: 100, budgets: [1500, 600] }]
+            .flatMap(({ head, budgets }) => budgets.map(budget => ({ budget, head, first: true }))).concat([{ budget: MAX_TASK_CONTRACT_CHARACTERS, head: 0, first: true }, { budget: 0, head: 0, first: false }]);
+        // When even the smallest floor cannot fit, no step of the ladder can: refuse at once instead of building every preview.
+        const smallest = floorAt(0, choices[choices.length - 1]);
+        let floor = smallest;
+        if (fits(smallest.base))
+            for (const choice of choices) {
+                floor = floorAt(Math.max(items.length, actions.length), choice);
+                if (fits(floor.base))
+                    break;
+                if (items.length || actions.length) {
+                    floor = floorAt(0, choice);
+                    if (fits(floor.base))
+                        break;
+                }
+            }
         const { ledger, base } = floor;
+        const kept = [...mandatory, ...quotesFor(floor.choice.budget, floor.choice.head, floor.choice.first)];
         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), 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])) }, };
+            ranking: { maxBriefChars, mandatorySourceIndices: new Set(kept.flatMap(r => r.sourceIndex === undefined ? [] : [r.sourceIndex])) }, };
         // Both views use the same parser, mandatory insertion, native preview and guard, and end with the same closing section.
         const assemble = (compiled) => {
             if (typeof compiled !== "string")
@@ -224,7 +298,7 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
             if (!split)
                 throw new Error("pi-tuck returned an invalid summary");
             const records = parseRecords(split.body, split.version);
-            for (const record of mandatory) {
+            for (const record of kept) {
                 const insertion = records.findIndex(row => row.sourceIndex !== undefined && row.sourceIndex > record.sourceIndex);
                 records.splice(insertion < 0 ? records.length : insertion, 0, record);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "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 = "1d9078a4eb50994b388a27d690a6af0f62e45cb1f019f9ef337138e249ebab1a";
+export const BUILD_ID = "27bb99fa3ca595dac73089d18c4c3506073c5d3e3f778ea572708f6e7a49ffc3";

package/src/compaction.ts

@@ -8,7 +8,7 @@ import { projectedMessages } from "./omissions.js";
 import { applyClips, clipBudgets, clipFor, type Clip } from "./clip.js";
 import { DEFAULT_CUT_AT, bandOf, chooseCut, conversationTokens, decideCut, gateCut, incomingEventTokens, incomingTokens, measurableConversationTokens, planningReserve, projectedConversationTokens, requestTokens, systemPart, validCutAt,
     type AgentMessage, type Messages, type Plan, type Target, type ToolShape } from "./budget.js";
-import { isContextOverflow, type ToolResultMessage } from "@earendil-works/pi-ai";
+import { isContextOverflow, type ImageContent, type ToolResultMessage } from "@earendil-works/pi-ai";
 import { convertToLlm, SessionManager, SettingsManager, type ExtensionAPI, type ExtensionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { Check } from "typebox/value";
@@ -479,7 +479,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     // 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[]) => {
+    const preflight = (ctx: ExtensionContext, incomingPart: number, observedPrompt: string, tools: readonly string[]) => {
         promptCut = undefined;
         promptCutAt = ctx.sessionManager.getBranch().length;
         if (!active()) return;
@@ -699,20 +699,35 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 			if (!ctx.model) throw missingModel();
 			// The complete request, counted after Pi's conversion (summary/custom/bash envelopes), with the effective system once.
 			// Pi applies a forced prompt after this hook; the public prompt already observes it.
-            const tokens = requestTokens(event.messages, ctx.getSystemPrompt());
+            let messages = event.messages, tokens = requestTokens(messages, ctx.getSystemPrompt());
+            // The run's first request is over the room although the prompt's decision found it fit: something changed the request after that decision
+            // (another extension patching the system prompt in before_agent_start, whatever the load order). Reduce here rather than refuse: plan the
+            // prompt's cut against the request as it now is, carry it in memory, and save it at the first boundary, as any prompt's cut is saved.
+            if (!fits(tokens, limits(ctx).room, ctx) && !promptCut) {
+                const branch = ctx.sessionManager.getBranch(), last = branch.at(-1);
+                if (last?.type === "message" && last.message.role === "user") {
+                    const header = ctx.sessionManager.getHeader();
+                    const before = header && SessionManager.inMemory(ctx.cwd, undefined, [header, ...branch.slice(0, -1)]);
+                    if (before) {
+                        preflight(Object.create(ctx, { sessionManager: { value: before } }), incomingTokens(typeof last.message.content === "string" ? last.message.content : last.message.content.flatMap(b => b.type === "text" ? [b.text] : []).join("\n"), typeof last.message.content === "string" ? [] : last.message.content.filter((b): b is ImageContent => b.type === "image")), ctx.getSystemPrompt(), pi.getActiveTools());
+                        if (promptCut) { messages = cutRequest(event.messages, ctx, promptCut); tokens = requestTokens(messages, ctx.getSystemPrompt()); }
+                    }
+                }
+            }
 			if (!fits(tokens, limits(ctx).room, ctx))
 				throw new CapacityError("Complete Pi context and response reserve exceed the estimated request budget");
             if (recorder.enabled && !recorder.waitingForCut) recorder.measureInline(() => {
                 recorder.request();
                 // No system prompt or hidden assistant blocks; no provider payload/headers.
-                const permitted = event.messages.filter(m => m.role !== "system" &&
+                const permitted = messages.filter(m => m.role !== "system" &&
                     !(m.role === "assistant" && m.content.some(b => b.type === "thinking")) &&
                     !(m.role === "custom" && options.recallPolicy?.privateCustomTypes?.includes(m.customType)));
                 recorder.capture("prepared-request", "public-context-with-system-hook-before-later-transforms-not-wire", { messages: permitted, estimatedInputTokens: tokens }, permitted.length !== event.messages.length);
             });
             if (tokens > 0 && Number.isSafeInteger(tokens)) pending = {
-                identity: identityFor(ctx), tokens, messages: event.messages, snapshot: structuredClone(convertToLlm(event.messages)),
+                identity: identityFor(ctx), tokens, messages, snapshot: structuredClone(convertToLlm(messages)),
             };
+            if (messages !== event.messages) return { messages };
 
 		} catch (error) { fail(error, ctx); }
 	});

package/src/tuck.ts

@@ -187,20 +187,52 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
 	for (const entry of entries) if (entry.type === "message") {
 		receiptContext.messages.push(entry.message); receiptContext.sourceIndices.push(indices.get(entry.id));
 	}
-    const mandatory: TranscriptRecord[] = [];
-    // The initiating prompt is quoted first, like the current input below: text only, since quoting cannot deliver other blocks.
+    // The newest user turns, newest first, then the initiating prompt, share one budget: in a session that runs task after task, the current task is
+    // an older user turn followed by short steps, and the dialogue clips user turns oldest first down to a few words, so quoting only the first prompt
+    // kept a finished task whole and lost the one being worked on. A turn that does not fit keeps its head and a locator; the first prompt gets what
+    // the newest turns leave, so a one-task session, whose later turns are short, still quotes it as before.
     const initiating = firstUserPosition >= 0 && firstUserPosition < boundary && entries[firstUserPosition]!.id !== protectedUser?.id ? entries[firstUserPosition] : undefined;
-    const initiatingContent = initiating?.type === "message" && initiating.message.role === "user" ? initiating.message.content : undefined;
-    if (initiating && isTextOnly(initiatingContent)) {
-        const text = textOf(initiatingContent!), index = indices.get(initiating.id);
-        if (index === undefined) throw new Error("Missing initiating user source index");
-        const quoted = head(text, MAX_TASK_CONTRACT_CHARACTERS), sourceTimes = [{ sourceIndex: index, ...resolveSourceTime(initiating) }];
-        if (text.trim()) {
-            mandatory.push({ kind: "excerpt", role: "user", sourceIndex: index, text: quoted, sourceTimes });
-            if (quoted.length < text.length) mandatory.push({ kind: "omission", role: "user", sourceIndex: index,
-                reason: `Initiating prompt continues: characters ${quoted.length}-${text.length} omitted; read them with tuck_recall {"index":${index},"offset":${quoted.length}}`, sourceTimes });
+    const quote = (entry: SessionEntry, budget: number, label: string): TranscriptRecord[] => {
+        const content = entry.type === "message" && entry.message.role === "user" ? entry.message.content : undefined;
+        if (!isTextOnly(content)) return [];
+        const text = textOf(content!), index = indices.get(entry.id);
+        if (index === undefined) throw new Error("Missing quoted user source index");
+        const quoted = head(text, budget), sourceTimes = [{ sourceIndex: index, ...resolveSourceTime(entry) }];
+        if (!text.trim() || !quoted.length) return [];
+        return [{ kind: "excerpt", role: "user", sourceIndex: index, text: quoted, sourceTimes }, ...(quoted.length < text.length ? [{ kind: "omission" as const, role: "user" as const,
+            sourceIndex: index, reason: `${label} continues: characters ${quoted.length}-${text.length} omitted; read them with tuck_recall {"index":${index},"offset":${quoted.length}}`, sourceTimes }] : [])];
+    };
+    // Both ends are anchored, in this order: the heads of the newest user turns (at most a quarter of the budget), the head of the first prompt (the
+    // goal of a long session), then extensions of the newest turns, then the rest of the first prompt. Heads come first so steps after a task can't
+    // use up the budget the task turn needs; the first prompt's head comes before any extension so steering turns can't use up the goal's.
+    const quotesFor = (budget: number, headSize: number, withFirst: boolean): TranscriptRecord[] => {
+        const turns: { entry: SessionEntry; text: string; take: number }[] = [];
+        // Only answered turns: a prompt that was refused and never got a reply was never taken up, and quoting it would spend the budget for nothing.
+        let answered = false;
+        for (let at = entries.length - 1; at >= 0; at--) {
+            const entry = entries[at]!;
+            if (entry.type === "message" && entry.message.role === "assistant") { answered = true; continue; }
+            if (entry.type !== "message" || entry.message.role !== "user") continue;
+            const replied = answered;
+            answered = false;
+            if (at >= boundary || !replied || entry.id === protectedUser?.id || entry.id === firstUser?.id || !isTextOnly(entry.message.content)) continue;
+            const text = textOf(entry.message.content);
+            if (text.trim()) turns.push({ entry, text, take: 0 });
         }
-    }
+        // headSize 0 quotes the first prompt alone, as before any user turn was quoted: the last step before no quote at all.
+        if (headSize === 0) turns.length = 0;
+        let left = budget, heads = Math.floor(budget / 4);
+        for (const turn of turns) { if (heads <= 0) break; turn.take = Math.min(turn.text.length, headSize, heads); heads -= turn.take; left -= turn.take; }
+        const firstText = withFirst && initiating?.type === "message" && initiating.message.role === "user" && isTextOnly(initiating.message.content) ? textOf(initiating.message.content) : "";
+        let firstTake = Math.min(firstText.length, headSize ? Math.round(headSize * 20 / 3) : budget, Math.max(0, left));
+        left -= firstTake;
+        for (const turn of turns) { if (left <= 0) break; const more = Math.min(turn.text.length - turn.take, left); turn.take += more; left -= more; }
+        firstTake += Math.min(firstText.length - firstTake, Math.max(0, left));
+        const records = turns.filter(turn => turn.take > 0).reverse().flatMap(turn => quote(turn.entry, turn.take, "User turn"));
+        if (firstTake > 0 && initiating) records.unshift(...quote(initiating, firstTake, "Initiating prompt"));
+        return records;
+    };
+    const mandatory: TranscriptRecord[] = [];
     if (protectedUser?.type === "message" && protectedUser.message.role === "user")
         mandatory.push({ kind: "excerpt", role: "user", sourceIndex: currentIndex, text: textOf(protectedUser.message.content), sourceTimes: [{ sourceIndex: currentIndex!, ...resolveSourceTime(protectedUser) }] });
     // The file ledger and the action trail of the compacted history are mandatory, so they are charged in base like the quotes above.
@@ -218,21 +250,37 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     };
     const before = measure(projected.messages);
     const model = ctx.model;
-    const floorAt = (keep: number) => {
+    const floorAt = (keep: number, choice: { budget: number; head: number; first: boolean }) => {
         const ledger = [...actionRecords(actions, keep), ...ledgerRecords(items, keep)];
-        const messages = preview(serializeTranscript([...mandatory, ...ledger]) + DIALOGUE_SUFFIX);
-        return { ledger, messages, base: measure(messages) };
+        const messages = preview(serializeTranscript([...mandatory, ...quotesFor(choice.budget, choice.head, choice.first), ...ledger]) + DIALOGUE_SUFFIX);
+        return { ledger, messages, base: measure(messages), choice };
     };
     const fits = (base: number) => Boolean(model) && base + reserveTokens < model!.contextWindow && base < before;
-    // When the whole floor cannot fit, the trail and the ledger keep only their headings and counts; only that can refuse the cut.
-    let floor = floorAt(Math.max(items.length, actions.length));
-    if (!fits(floor.base) && (items.length || actions.length)) floor = floorAt(0);
+    // When room is tight the newest turns win over the first prompt, which in a long-running session is often a finished task. The floor gives way
+    // in this order: the trail and ledger to their headings, the extensions (the budget halved), then the heads, the first prompt's among them
+    // (300 characters, 2,000 for the first prompt; then 100 and 667), then everything but the first prompt (as before user turns were quoted),
+    // and only then every quote. Only a floor with no quote but the current input can refuse the cut.
+    // The budget grows with the room: 15% of it, at least the 12,000 characters a first prompt always had. A long-running session's task can be tens
+    // of thousands of characters, and the room is what can afford it.
+    const taskBudget = Math.max(MAX_TASK_CONTRACT_CHARACTERS, Math.floor(Math.max(0, (model?.contextWindow ?? 0) - reserveTokens) * charsPerToken * 0.15));
+    const budgets = [taskBudget, taskBudget / 2, taskBudget / 4, taskBudget / 8, 1500].map(Math.floor).filter((b, at, all) => b >= 1500 && all.indexOf(b) === at);
+    const choices = [{ head: 300, budgets }, { head: 100, budgets: [1500, 600] }]
+        .flatMap(({ head, budgets }) => budgets.map(budget => ({ budget, head, first: true }))).concat([{ budget: MAX_TASK_CONTRACT_CHARACTERS, head: 0, first: true }, { budget: 0, head: 0, first: false }]);
+    // When even the smallest floor cannot fit, no step of the ladder can: refuse at once instead of building every preview.
+    const smallest = floorAt(0, choices[choices.length - 1]!);
+    let floor = smallest;
+    if (fits(smallest.base)) for (const choice of choices) {
+        floor = floorAt(Math.max(items.length, actions.length), choice);
+        if (fits(floor.base)) break;
+        if (items.length || actions.length) { floor = floorAt(0, choice); if (fits(floor.base)) break; }
+    }
     const { ledger, base } = floor;
+    const kept = [...mandatory, ...quotesFor(floor.choice.budget, floor.choice.head, floor.choice.first)];
     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), 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])) },
+        ranking: { maxBriefChars, mandatorySourceIndices: new Set(kept.flatMap(r => r.sourceIndex === undefined ? [] : [r.sourceIndex])) },
     };
     // Both views use the same parser, mandatory insertion, native preview and guard, and end with the same closing section.
     const assemble = (compiled: string) => {
@@ -240,7 +288,7 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
         const split = compiled ? splitSummary(compiled) : { body: "", version: 2 as const };
         if (!split) throw new Error("pi-tuck returned an invalid summary");
         const records = parseRecords(split.body, split.version);
-        for (const record of mandatory) {
+        for (const record of kept) {
             const insertion = records.findIndex(row => row.sourceIndex !== undefined && row.sourceIndex > record.sourceIndex!);
             records.splice(insertion < 0 ? records.length : insertion, 0, record);
         }