pi-tuck 1.0.15 → 1.0.16

package/CHANGELOG.md

@@ -3,6 +3,43 @@
 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.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.15`.
+- To pin a version, add it: `pi install npm:pi-tuck@1.0.15`.
 
 ## How it works
 

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

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

package/dist/src/build-id.js

@@ -1 +1 @@
-export const BUILD_ID = "1d9078a4eb50994b388a27d690a6af0f62e45cb1f019f9ef337138e249ebab1a";
+export const BUILD_ID = "e695eee2b3e13753eb135cb61b69783a79d72ac4c1ce08f28304b98cca6b5a49";

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 = "e695eee2b3e13753eb135cb61b69783a79d72ac4c1ce08f28304b98cca6b5a49";
 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.16",
   "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 = "e695eee2b3e13753eb135cb61b69783a79d72ac4c1ce08f28304b98cca6b5a49";

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);
         }