pi-tuck 1.0.14 → 1.0.16

package/CHANGELOG.md

@@ -3,6 +3,53 @@
 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
+
+- `tuck_search` no longer fails a whole search over one bad `priorResults` entry. An entry that does not match the history, such as a made-up hash or an id that is not an entry's, is now ignored, and the notice says how many were. Before, the search returned "Invalid explicit prior source range", and the agent fell back to word search.
+
+### Release gates
+
+- **Shipped without a live gate, because its replay matches 1.0.14:** 13,946 requests on 29 recordings, 0 differ, 0 dead tasks, the same 28 clips. Tests; CI; the stress test on Pi 1.2.0 and the newest Pi, with the same 3 of 274 cells.
+
 ## [1.0.14] - 2026-11-07
 
 ### Changed

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.13`.
-- To pin a version, add it: `pi install npm:pi-tuck@1.0.13`.
+- 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 = "9457180f73cad9d9bde254328dad70dd2abe8400e373a68e06ad455b5b66f203";
+export declare const BUILD_ID = "e695eee2b3e13753eb135cb61b69783a79d72ac4c1ce08f28304b98cca6b5a49";

package/dist/src/build-id.js

@@ -1 +1 @@
-export const BUILD_ID = "9457180f73cad9d9bde254328dad70dd2abe8400e373a68e06ad455b5b66f203";
+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 = "9457180f73cad9d9bde254328dad70dd2abe8400e373a68e06ad455b5b66f203";
+export declare const DIAGNOSTIC_BUILD = "e695eee2b3e13753eb135cb61b69783a79d72ac4c1ce08f28304b98cca6b5a49";
 export interface Receipt {
     id: string;
     build: string;

package/dist/src/semantic-recall.js

@@ -917,13 +917,10 @@ export class SemanticRecallController {
             const finalSources = new Map(final.sources.map(source => [source.entry.id, source.sha]));
             if (snapshot.sources.some(source => finalSources.get(source.entry.id) !== source.sha))
                 throw new Error('Eligible source changed or access revoked before return');
-            for (const reference of prior) {
-                const source = snapshot.sources.find(s => s.entry.id === reference.entryId);
-                if (!Number.isSafeInteger(reference.start) || !Number.isSafeInteger(reference.end) || reference.start > reference.end || !source || reference.sourceSha !== source.sha || reference.end > source.sourceText.length)
-                    throw new Error('Invalid explicit prior source range');
-            }
-            const previous = [...prior, ...(words?.hits ?? []).map((hit) => ({ entryId: hit.entryId, start: hit.read.offset, end: hit.read.offset + hit.read.limit, sourceSha: snapshot.sources.find(s => s.entry.id === hit.entryId)?.sha }))];
-            return { status: 'ok', notice: 'Related original evidence, not current truth or proof that every qualification was found. Scores do not establish authority, event time or supersession. Sources preserve recorded time and original order.' + ` Semantic ranking covers ${covered.conversation.indexedCharacters} of ${covered.conversation.outOfViewCharacters} characters of earlier conversation and ${covered.toolResults.indexedCharacters} of ${covered.toolResults.outOfViewCharacters} characters of earlier tool output (newest first, back to ${covered.toolResults.oldestCoveredTime ?? covered.oldestCoveredTime ?? 'an unknown time'}); use tuck_recall for the rest.`, coverage: { ...this.status(), window: covered }, method: 'embedding', groups: this.assemble(ranked.map(hit => hit.unit), snapshot, previous) };
+            // What the caller already read only spares it a repeat. A reference that does not match this history spares nothing, and it must not fail the search.
+            const usable = prior.filter(reference => { const source = snapshot.sources.find(s => s.entry.id === reference.entryId); return Number.isSafeInteger(reference.start) && Number.isSafeInteger(reference.end) && reference.start <= reference.end && source !== undefined && reference.sourceSha === source.sha && reference.end <= source.sourceText.length; }), ignored = prior.length - usable.length;
+            const previous = [...usable, ...(words?.hits ?? []).map((hit) => ({ entryId: hit.entryId, start: hit.read.offset, end: hit.read.offset + hit.read.limit, sourceSha: snapshot.sources.find(s => s.entry.id === hit.entryId)?.sha }))];
+            return { status: 'ok', notice: 'Related original evidence, not current truth or proof that every qualification was found. Scores do not establish authority, event time or supersession. Sources preserve recorded time and original order.' + (ignored ? ` ${ignored} of the priorResults did not match this history and were ignored, so their text may appear again.` : '') + ` Semantic ranking covers ${covered.conversation.indexedCharacters} of ${covered.conversation.outOfViewCharacters} characters of earlier conversation and ${covered.toolResults.indexedCharacters} of ${covered.toolResults.outOfViewCharacters} characters of earlier tool output (newest first, back to ${covered.toolResults.oldestCoveredTime ?? covered.oldestCoveredTime ?? 'an unknown time'}); use tuck_recall for the rest.`, coverage: { ...this.status(), window: covered }, method: 'embedding', groups: this.assemble(ranked.map(hit => hit.unit), snapshot, previous) };
         }
         catch (error) {
             if (error instanceof Error && error.name === 'SemanticAccessError') {

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.14",
+  "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 = "9457180f73cad9d9bde254328dad70dd2abe8400e373a68e06ad455b5b66f203";
+export const BUILD_ID = "e695eee2b3e13753eb135cb61b69783a79d72ac4c1ce08f28304b98cca6b5a49";

package/src/semantic-recall.ts

@@ -362,7 +362,8 @@ export class SemanticRecallController {
   if(!snapshot.units.length)return{status:'no_matches',notice:'No eligible original source units in this snapshot.',coverage:this.status(),method:'embedding',groups:[]};
   try{const worker=await this.runtime(snapshot.project);this.recheck(provider,snapshot);const encoded=await worker.call('embed',{texts:[query],kind:'query'},signal);this.operations.queryEmbeddings++;this.recheck(provider,snapshot);const prefix=indexedPrefix(snapshot),stored=snapshot.units.slice(0,prefix),byKey=new Map(stored.map(u=>[u.key,u])),covered=windowCoverage(snapshot,prefix)!;let ranked:{unit:Unit;score:number}[]=[],observed=0;for(let offset=0;offset<stored.length;offset+=SCORE_CHUNK){this.recheck(provider,snapshot);const scored=await this.index('score',snapshot,{keys:stored.slice(offset,offset+SCORE_CHUNK).map(u=>u.key),query:encoded.vectors[0]}) as {ranked:{key:string;score:number}[];observed:number};observed+=scored.observed;ranked.push(...scored.ranked.map(row=>({unit:byKey.get(row.key)!,score:row.score})));ranked.sort((a,b)=>b.score-a.score);ranked=ranked.slice(0,24);if(signal?.aborted)throw abort();await yieldWork();}if(observed!==stored.length)throw new Error('Snapshot index coverage changed');
    if(signal?.aborted||queryGeneration!==this.generation||!this.enabled)throw abort();this.recheck(provider,snapshot);const final=provider();const finalSources=new Map(final.sources.map(source=>[source.entry.id,source.sha]));if(snapshot.sources.some(source=>finalSources.get(source.entry.id)!==source.sha))throw new Error('Eligible source changed or access revoked before return');
-   for(const reference of prior){const source=snapshot.sources.find(s=>s.entry.id===reference.entryId);if(!Number.isSafeInteger(reference.start)||!Number.isSafeInteger(reference.end)||reference.start>reference.end||!source||reference.sourceSha!==source.sha||reference.end>source.sourceText.length)throw new Error('Invalid explicit prior source range');}const previous=[...prior,...(words?.hits??[]).map((hit:any)=>({entryId:hit.entryId,start:hit.read.offset,end:hit.read.offset+hit.read.limit,sourceSha:snapshot.sources.find(s=>s.entry.id===hit.entryId)?.sha}))];return{status:'ok',notice:'Related original evidence, not current truth or proof that every qualification was found. Scores do not establish authority, event time or supersession. Sources preserve recorded time and original order.'+` Semantic ranking covers ${covered.conversation.indexedCharacters} of ${covered.conversation.outOfViewCharacters} characters of earlier conversation and ${covered.toolResults.indexedCharacters} of ${covered.toolResults.outOfViewCharacters} characters of earlier tool output (newest first, back to ${covered.toolResults.oldestCoveredTime??covered.oldestCoveredTime??'an unknown time'}); use tuck_recall for the rest.`,coverage:{...this.status(),window:covered},method:'embedding',groups:this.assemble(ranked.map(hit=>hit.unit),snapshot,previous)};
+   // What the caller already read only spares it a repeat. A reference that does not match this history spares nothing, and it must not fail the search.
+   const usable=prior.filter(reference=>{const source=snapshot.sources.find(s=>s.entry.id===reference.entryId);return Number.isSafeInteger(reference.start)&&Number.isSafeInteger(reference.end)&&reference.start<=reference.end&&source!==undefined&&reference.sourceSha===source.sha&&reference.end<=source.sourceText.length;}),ignored=prior.length-usable.length;const previous=[...usable,...(words?.hits??[]).map((hit:any)=>({entryId:hit.entryId,start:hit.read.offset,end:hit.read.offset+hit.read.limit,sourceSha:snapshot.sources.find(s=>s.entry.id===hit.entryId)?.sha}))];return{status:'ok',notice:'Related original evidence, not current truth or proof that every qualification was found. Scores do not establish authority, event time or supersession. Sources preserve recorded time and original order.'+(ignored?` ${ignored} of the priorResults did not match this history and were ignored, so their text may appear again.`:'')+` Semantic ranking covers ${covered.conversation.indexedCharacters} of ${covered.conversation.outOfViewCharacters} characters of earlier conversation and ${covered.toolResults.indexedCharacters} of ${covered.toolResults.outOfViewCharacters} characters of earlier tool output (newest first, back to ${covered.toolResults.oldestCoveredTime??covered.oldestCoveredTime??'an unknown time'}); use tuck_recall for the rest.`,coverage:{...this.status(),window:covered},method:'embedding',groups:this.assemble(ranked.map(hit=>hit.unit),snapshot,previous)};
   }catch(error){if(error instanceof Error&&error.name==='SemanticAccessError'){await this.revoked(error);throw error;}if(signal?.aborted||queryGeneration!==this.generation||error instanceof Error&&error.name==='AbortError'){await this.cancelled();throw abort();}this.heal(error);return{status:'unavailable',notice:'Local semantic search failed; ordinary recall remains available. '+(error instanceof Error?error.message:'failure'),coverage:this.status(),groups:[]};}
  }
  private assemble(units:Unit[],snapshot:Snapshot,previous:PriorResult[]):SemanticGroup[]{

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