pi-tuck 1.0.22 → 1.0.24

package/CHANGELOG.md

@@ -3,6 +3,67 @@
 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.24] - 2026-11-10
+
+### Fixed
+
+- **A prompt's cut could reach a run it was not planned for.** pi-tuck plans a prompt's cut when the prompt arrives. When another extension
+  handled that prompt, no run started, and the plan waited for the next run:
+  - **A run started by a custom message** carried a cut sized for the prompt that never ran: deeper than needed.
+  - **After a move in the session tree (`/tree`),** the plan was applied on the new branch. Its kept entry was not on that branch, so the request
+    lost the custom message that started the run, even on a branch that needed no cut.
+
+  Now a run started by a custom message plans afresh, and a move in the tree drops any waiting plan.
+
+### Added
+
+- Lifecycle tests: a handled prompt, then a custom-message run, and the same with a move in the tree first.
+
+### Release gates
+
+- **Shipped without a live gate, because its replay matches 1.0.23:** 13,946 requests on 29 recordings, read per request, 0 differ beyond the
+  base's own run-to-run noise; clips 17 → 17; 0 lost and 0 dead tasks.
+- **Stress, 310 cells:** findings the same as 1.0.23, cell for cell. Tests (715) and CI.
+
+## [1.0.23] - 2026-11-10
+
+### Fixed
+
+- **Near the new refusal line, replies were cut to a few hundred tokens (1.0.22).** Pi sets each request's reply cap to the window less its own
+  estimate of the request less a 4,096-token safety margin. 1.0.22 left only its reply floor and did not count that margin. pi-tuck now:
+  - reads Pi's margin from Pi itself;
+  - sends a request above the room only if Pi's own cap still leaves the reply floor;
+  - never draws the line below the room, where 1.0.21 also sends.
+
+  The floor is the larger of the branch's largest reply and 3,584 tokens, capped at the model's own reply cap. After a reply stopped for length or
+  refused for context overflow, it is the reserve.
+- **`tuck_search` said semantic recall was still indexing when it was fully indexed.** After the session grew, the next index plan could still be
+  preparing when a search ran. The search now ranks the plan its history grew from, as long as nothing in it changed, and says which entries are
+  still being indexed.
+- **`tuck_search` in the turn after a prompt's cut ranked nothing ("nothing is out of view").** The cut reaches the requests at once but the session
+  only at the turn's end. Search now uses the pending cut.
+- **A keyword-search timeout on a very long history failed the whole `tuck_search`.** The keyword half now reports `keyword_timeout`, and semantic
+  results still answer. The timeout message names the history's size, not a pattern.
+
+### Added
+
+- The settings stress test builds every request through pi-ai's real request path, so Pi's own reply cap is tested. A large-session stress test
+  searches an ~85 MB session that grows while the next index plan prepares.
+
+### Release gates
+
+- **Shipped without a live gate, because its replay matches 1.0.22:** 13,946 requests on 29 recordings, read per request. One recording's 13
+  differing requests matched exactly in two more runs of each build. 0 lost and 0 dead tasks.
+- **Stress on Pi 1.2.0 and 1.5.0, 310 cells, through pi-ai's request path:**
+  - no cell answers fewer than 1.0.21;
+  - replies cut off below the floor 11 → 0;
+  - native-parity findings all inside its four exceptions;
+  - the 85 MB test passes.
+
+  Tests (712) and CI.
+- **The 1.0.22 floor patch's Tier 1 gate runs on this version instead,** because its pilot found the reply-cap defect fixed here.
+- Sessions that are open keep the build they started with until they are restarted.
+
 ## [1.0.22] - 2026-11-10
 
 ### 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), and says once when it is set up. 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.21`.
-- To pin a version, add it: `pi install npm:pi-tuck@1.0.21`.
+- Prefer GitHub? `pi install git:github.com/galyavin/pi-tuck@v1.0.23`.
+- To pin a version, add it: `pi install npm:pi-tuck@1.0.23`.
 
 ## Uninstall
 
@@ -125,11 +125,15 @@ The plan: [`benchmark/PREREG.md`](benchmark/PREREG.md), [`benchmark/PREREG-32K.m
 Known limits today:
 
 - pi-tuck's summary does not explain why things happened. It holds the words that were said, not a model's reading of them. The agent must look things up. Each look-up costs a tool call.
-- Small windows: an upstream that spends far more context on tool schemas than others (some OpenRouter upstreams do) can leave a small input room too little space. 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 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 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 was 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 host that patches a large section into the system prompt could get a refusal that a cut would have fit (1.0.0 to 1.0.16; fixed in 1.0.17). 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 could push that turn's first request over the room, and the final guard refused it. Now the guard plans the cut against the system prompt as finally sent, and refuses only if that cut does not fit either ([`CHANGELOG.md`](CHANGELOG.md) 1.0.17).
 - Semantic recall never started in `pi -p` (1.0.0 to 1.0.20; fixed in 1.0.21). pi-tuck skipped semantic recall whenever Pi ran with no UI, to keep a one-shot run from starting the first-time download, and that also skipped a runtime that was already installed. Jobs run with `pi -p` searched by keyword only, while `tuck_search` said semantic recall was being set up. RPC mode was not affected ([`CHANGELOG.md`](CHANGELOG.md) 1.0.21).
+- pi-tuck refused requests that fit the window, and could strand a session (1.0.0 to 1.0.21; fixed in 1.0.22). It refused at the room, the window less the full reply reserve, where native Pi still sends. With Pi's defaults and a large setup, a session could be refused at every prompt. The final refusal now sits at the window less a reply floor ([`CHANGELOG.md`](CHANGELOG.md) 1.0.22).
+- Near the 1.0.22 refusal line, replies were cut to a few hundred tokens (1.0.22; fixed in 1.0.23). 1.0.22 left only its reply floor and did not count Pi's 4,096-token margin on the reply cap ([`CHANGELOG.md`](CHANGELOG.md) 1.0.23).
+- Cost of the 1.0.22 change: between the room and the window, the reply reserve no longer cushions a wrong count. At a cold start an undercount can reach the provider. A provider that errors is caught and learned from; a server that truncates silently truncates, as it does for native Pi. With a setup above the room, cuts are forced and frequent, each freeing little, which beats a stranded session ([`CHANGELOG.md`](CHANGELOG.md) 1.0.22).
+- Four `tuck_search` faults, fixed in 1.0.23: it said semantic recall was still indexing when the history was fully indexed; in the turn after a prompt's cut it ranked nothing ("nothing is out of view"); a keyword-search timeout on a very long history failed the whole search, where now the semantic results still answer; and the timeout message named a pattern instead of the history's size ([`CHANGELOG.md`](CHANGELOG.md) 1.0.23).
 - pi-tuck cut earlier than native Pi when a model's reply cap is above Pi's reserve (1.0.0 to 1.0.19; fixed in 1.0.20). It reserved the larger of Pi's `compaction.reserveTokens` and the model's `maxTokens`: with `maxTokens` 32,768 and a reserve of 16,384 on an 81,920 window, its room fell to 49,152 tokens, where native Pi compacts at 65,536 ([`CHANGELOG.md`](CHANGELOG.md) 1.0.20).
 - A summary could drop the task a session was working on (1.0.0 to 1.0.17; fixed in 1.0.18). Until 1.0.15 a summary quoted only the session's first user turn, up to 12,000 characters, and the newest one, so in a long session the current task, an older turn followed by short steps, was clipped or dropped while a finished first task stayed whole, and agents acted on a days-old task. 1.0.16 added more quotes. From 1.0.13 to 1.0.17, separate rules decided what a summary quoted and what the kept tail held, and the prompt that set the current task, or the first prompt, could lose its opening after a cut: the stress test found it 40 times in 32 cells on 1.0.16 and 1.0.17. Since 1.0.18 one ranked list fills a cut's room, and the stress test finds no lost opening in 287 cells. 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.18 ([`CHANGELOG.md`](CHANGELOG.md) 1.0.18).
 - pi-tuck 1.0.16 cost more in live chains than its notes first said. Against 1.0.13 at an 81,920 window, it took 1.48 times the turns on the tasks both resolved (95% interval 1.34 to 1.64), 74% more cuts and 1.66 times the tokens, with 56 of 60 tasks resolved against 55. Replay of single-task sessions cannot show this cost. 1.0.18 replaced its quote rules; in the 1.0.18 gate it took 22.27 turns per task against 29.35 for 1.0.16 and 20.22 for the 1.0.13 arm (different pairs of runs; reported, not claimed) ([`benchmark/RESULTS-V1016.md`](benchmark/RESULTS-V1016.md), [`CHANGELOG.md`](CHANGELOG.md) 1.0.18).
@@ -188,13 +192,9 @@ A bad file is reported at session start, and pi-tuck uses the defaults.
 
 pi-tuck keeps room for the model's reply. Since 1.0.20 that room is Pi's `compaction.reserveTokens` (default 16,384), the same as native Pi. It rises to the model's `maxTokens` for the rest of the branch only after a reply on that branch did not fit: a reply that stopped for length, or a request refused as a context overflow. A transient error such as a 503 keeps the native room. This is read from the current branch at each decision, so resume, fork and `/tree` follow the branch, and a new session starts at `reserveTokens` again. A host that passes its own reserve keeps its own. Before 1.0.20, pi-tuck always reserved the larger of the two, so with a large `maxTokens` it cut earlier than native Pi.
 
-pi-tuck refuses a request that cannot fit, rather than let the provider cut it off. It estimates the request's size, and it scales that estimate by the worst gap it has seen between its count and the provider's. In a small window, an upstream that spends far more context on tool schemas (some OpenRouter upstreams do) can leave too little room. pi-tuck then refuses to cut rather than overflow. Lower the reserve for that model in Pi's `settings.json`, or use a larger window. For example, to lower it to 8,192:
+Since 1.0.22, pi-tuck refuses a request only past a line near the window. Pi sets each request's reply cap to the window less its own estimate of the request less a 4,096-token safety margin, and since 1.0.23 pi-tuck reads that margin from Pi. A request above the room goes out only if Pi's own cap still leaves the reply floor. The floor is the larger of the biggest reply seen on the branch and 3,584 tokens, capped at the model's own reply cap. After a reply that stopped for length or was refused as a context overflow, the floor is the reserve. The line never sits below the room, where 1.0.21 also sends. Before it refuses, pi-tuck cuts to the band, cuts to the room, makes a smaller summary and clips a fresh tool result, in that order. A run's request always carries the whole prompt that started the run: if it cannot fit after every reduction, pi-tuck stops the run with a notice saying to shorten the prompt or use a larger window. Each refusal, and each request sent above the room, leaves one `pi-tuck-capacity` entry in the session; it is never sent to the model, and never appears in summaries or recall.
 
-```json
-{ "compaction": { "modelOverrides": { "my-provider/my-model": { "reserveTokens": 8192 } } } }
-```
-
-Lowering `reserveTokens` takes effect even when `models.json` sets a larger `maxTokens` for that model, until a reply on the branch does not fit. After that, the larger of the two applies for the rest of the branch, so lower both if needed, and keep `maxTokens` above your largest expected reply.
+pi-tuck estimates the request's size, and it scales that estimate by the worst gap it has seen between its count and the provider's. In a small window, an upstream that spends far more context on tool schemas (some OpenRouter upstreams do) can leave too little room. If a small window refuses, use a larger window, or pin one upstream as below.
 
 If you reach the model through OpenRouter, you can also pin one upstream, so that every request is served by the same one. Put this in `models.json` in Pi's agent folder, and name the upstream you want:
 

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

@@ -1 +1 @@
-export declare const BUILD_ID = "37e955d83a1e9237381f09fad8cd2aad1f2c6489ddbe51c58af227dbb46ddf3c";
+export declare const BUILD_ID = "c3eefa3bb76e52635b1e8394a025d3ffd6a056fc5636ed9b35f89dfddc1a322a";

package/dist/src/build-id.js

@@ -1 +1 @@
-export const BUILD_ID = "37e955d83a1e9237381f09fad8cd2aad1f2c6489ddbe51c58af227dbb46ddf3c";
+export const BUILD_ID = "c3eefa3bb76e52635b1e8394a025d3ffd6a056fc5636ed9b35f89dfddc1a322a";

package/dist/src/compaction.d.ts

@@ -50,7 +50,7 @@ export interface CompactionOptions {
      * owns cut targets; standalone final capacity admission uses the branch reply floor. If omitted, the band adapts to the last cut. */
     cutAt?: number;
     /** A host's response reserve: without `responseExact: true`, the catalogue maximum output stays its floor; with it, `response` is exact.
-     * Standalone cuts against Pi's reserveTokens, then admits up to the window less max(8192, largest branch output), capped at that reserve.
+     * Standalone cuts against Pi's reserveTokens, then admits up to the window less Pi's safety margin and max(3,584, largest branch output), capped at that reserve.
      * After a length stop or context overflow it holds the full reserve, also raised to the catalogue maximum.
      * Resume, fork and /tree follow that branch's history; a new session has no inherited fallback. */
     requestReserve?: (ctx: ExtensionContext) => {

package/dist/src/compaction.js

@@ -1,5 +1,5 @@
 import { textOf } from "./tuck/core/content.js";
-import { branchReplyFloor, carriesPrompt } from "./request-capacity.js";
+import { requestReplyFloor, carriesPrompt, piContextSafetyMargin } from "./request-capacity.js";
 import { BUILD_ID } from "./build-id.js";
 import { createSemanticRecall, budgetSemantic } from "./semantic-recall.js";
 import { DIAGNOSTIC_BUILD, IncidentRecorder, attachReceipt, permittedEntries, receiptId, findReceiptEntry } from "./diagnostics.js";
@@ -10,7 +10,7 @@ import { assertNativeToolRounds } from "./protocol.js";
 import { projectedMessages } from "./omissions.js";
 import { applyClips, clipBudgets, clipFor } from "./clip.js";
 import { DEFAULT_CUT_AT, bandOf, chooseCut, conversationTokens, gateCut, incomingEventTokens, incomingTokens, measurableConversationTokens, planningReserve, projectedConversationTokens, systemPart, validCutAt } from "./budget.js";
-import { getCurrentSystemMessage, isContextOverflow } from "@earendil-works/pi-ai";
+import { getCurrentSystemMessage, isContextOverflow, normalizeContext } from "@earendil-works/pi-ai";
 import { calculateContextTokens, convertToLlm, estimateTokens, shouldCompact, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { Check } from "typebox/value";
@@ -104,6 +104,9 @@ export function seedWindow(branch, key) {
     return initialWindow(key);
 }
 export async function installCompaction(pi, options = {}) {
+    const piMargin = options.requestReserve ? 0 : await piContextSafetyMargin();
+    const piClamp = options.requestReserve ? undefined : await import('@earendil-works/pi-ai/api/simple-options')
+        .then(module => module.clampMaxTokensToContext).catch(() => undefined);
     const cutAt = options.cutAt ?? DEFAULT_CUT_AT;
     if (!validCutAt(cutAt))
         throw new Error("Invalid cut point: cutAt must be a number above 0 and at most 1");
@@ -118,7 +121,8 @@ export async function installCompaction(pi, options = {}) {
     const semanticPending = new Set();
     // Semantic indexing outlives any one attempt, so it checks only that the host still grants access: a compactor failure, which ends with its
     // attempt, must not read as a revocation (that disables semantic recall and deletes its index for the rest of the session).
-    const semanticProvider = (ctx) => () => memoizedEligibleSources(ctx, options.recallPolicy, hostAccess);
+    // A prompt's cut reaches the requests at once but the session only at the end of the first turn: until then search sees the history as the model does.
+    const semanticProvider = (ctx) => () => memoizedEligibleSources(ctx, options.recallPolicy, hostAccess, promptCut ? promptCut.firstKeptEntryId || ctx.sessionManager.getBranch().findLast(e => e.type === "message" && e.message.role === "user")?.id : undefined);
     const recorder = new IncidentRecorder(options.diagnostics);
     let proposalId;
     const observe = (ctx) => recorder.measureInline(() => {
@@ -325,9 +329,9 @@ export async function installCompaction(pi, options = {}) {
     // Room still owns every existing cut/clip attempt. Only final capacity admission uses the hard line.
     const limits = (ctx) => {
         const { response } = requestReserve(ctx), room = inputRoom(response, ctx);
-        const floor = options.requestReserve ? response : branchReplyFloor(ctx.sessionManager.getBranch(), response);
-        const hardLine = Math.min((ctx.model?.contextWindow ?? 0) - floor, lastCeiling ?? Infinity);
-        return { response, room, hardLine };
+        const floor = options.requestReserve ? response : requestReplyFloor(ctx.sessionManager.getBranch(), response, ctx.model?.maxTokens);
+        const hardLine = Math.min(Math.max(room, (ctx.model?.contextWindow ?? 0) - piMargin - floor), lastCeiling ?? Infinity);
+        return { response, room, hardLine, replyFloor: floor };
     };
     const decisionBand = (ctx, room, system) => {
         const last = ctx.sessionManager.getBranch().findLast(entry => entry.type === "compaction");
@@ -477,7 +481,18 @@ export async function installCompaction(pi, options = {}) {
                 // Bind the actual independent lexical offer, including attribution derived
                 // from custom markers and receipts excluded from semantic indexing. Rebuild
                 // under current caller policy after await, when the session moved; never send this block to the encoder.
-                const wordOffer = () => tuckRecall(tuck, ctx.sessionManager.getEntries(), ctx.sessionManager.getBranch(), { query: input.query }, options.recallPolicy);
+                // Keyword search over a very long history can hit its time limit. That limit guards one call, not the semantic half: the agent still gets the
+                // semantic results, and is told the keyword half stopped (seen in the field on an 84.7 MB session, where the whole search failed instead).
+                const wordOffer = () => {
+                    try {
+                        return tuckRecall(tuck, ctx.sessionManager.getEntries(), ctx.sessionManager.getBranch(), { query: input.query }, options.recallPolicy);
+                    }
+                    catch (error) {
+                        if (error instanceof Error && error.message.startsWith("Search aborted:"))
+                            return { status: "keyword_timeout", notice: "Keyword search stopped at its time limit on this long history; the semantic results follow. For a keyword match, use more specific words or read an entry by index.", hits: [] };
+                        throw error;
+                    }
+                };
                 // The key is taken in the same synchronous step as the first lexical pass. After the await the second pass runs only if it moved (see eligibilityKey); a moved key alone invalidates nothing.
                 // The snapshot id check covers every in-contract change (any branch change moves the id); the key-gated second pass is defence in depth for out-of-contract callers.
                 const provider = semanticProvider(ctx), initialSnapshot = provider(), initialKey = eligibilityKey(ctx), words = wordOffer(), wordText = JSON.stringify(words);
@@ -587,7 +602,9 @@ export async function installCompaction(pi, options = {}) {
     const syncHistoryTools = (ctx) => { if (active())
         applyHistoryTools(pi, historyToolsEnabled(ctx)); };
     pi.on("session_start", (_event, ctx) => syncHistoryTools(ctx));
-    pi.on("session_tree", (_event, ctx) => syncHistoryTools(ctx));
+    // A plan decided on `input` is for the branch it was decided on: moving in the tree leaves it planned for another branch, whose kept entry
+    // may not be on this one.
+    pi.on("session_tree", (_event, ctx) => { promptCut = undefined; phase = "idle"; syncHistoryTools(ctx); });
     pi.on("session_compact", (_event, ctx) => { if (!admittedRun)
         syncHistoryTools(ctx); });
     pi.on("turn_start", (_event, ctx) => syncHistoryTools(ctx));
@@ -666,7 +683,9 @@ export async function installCompaction(pi, options = {}) {
         promptCut = { type: "compaction", summary: compaction.summary, firstKeptEntryId: compaction.firstKeptEntryId, tokensBefore: before, details: compaction.details };
     };
     pi.on("before_agent_start", async (event, ctx) => {
-        const prompted = phase === "decided";
+        // A decided plan is for the prompt `input` saw. A run that a custom message starts is not that run (another extension handled the
+        // input, so no run started for it): plan afresh.
+        const prompted = phase === "decided" && event.messageType !== "custom";
         phase = "starting";
         runPrompt = event.messageType === "custom" ? undefined : event.prompt;
         try {
@@ -977,11 +996,16 @@ export async function installCompaction(pi, options = {}) {
             const tokens = system + conversationTokens(messages);
             observeBudget(tokens, ctx);
             estimatedTokens = corrected(tokens, ctx);
-            const { room, hardLine } = limits(ctx);
+            const { room, hardLine, replyFloor } = limits(ctx);
             if (runPrompt !== undefined && !carriesPrompt(messages, runPrompt))
                 throw new Refusal("Prompt check failed: the request is missing the whole text of the prompt that started this run. Shorten the prompt or choose a model with a larger context window, then retry");
             if (!fits(tokens, hardLine, ctx))
                 throw new CapacityError("Complete Pi context and response reserve exceed the estimated request budget");
+            // Pi's request estimator and its compaction estimator need not agree. The hard line is
+            // necessary; above the room, also require the real request clamp to preserve the floor.
+            if (!options.requestReserve && estimatedTokens > room && piClamp &&
+                piClamp(ctx.model, normalizeContext({ messages: convertToLlm(messages) }), ctx.model.maxTokens) < replyFloor)
+                throw new CapacityError("Pi's request clamp leaves less than the reply floor");
             if (estimatedTokens > room)
                 receipt("above-room", "Request exceeds the room and fits the hard line", ctx);
             if (recorder.enabled && !recorder.waitingForCut)

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 = "37e955d83a1e9237381f09fad8cd2aad1f2c6489ddbe51c58af227dbb46ddf3c";
+export declare const DIAGNOSTIC_BUILD = "c3eefa3bb76e52635b1e8394a025d3ffd6a056fc5636ed9b35f89dfddc1a322a";
 export interface Receipt {
     id: string;
     build: string;

package/dist/src/eligibility-cache.d.ts

@@ -15,5 +15,5 @@ export declare const eligibilityKeyMoved: (ctx: Context, since: readonly unknown
  * the same `SemanticAccessError` that `semanticEligibleSources` raises (the mapping below is that function's first statement, verbatim).
  * The policy is trusted by identity, so it must not change after install: a policy object mutated in place (a type added to
  * `privateCustomTypes`) or a `readAttemptMarker` with hidden state is not noticed until the history changes. */
-export declare function memoizedEligibleSources(ctx: Context, policy: RecallPolicy | undefined, access: () => void): Snapshot;
+export declare function memoizedEligibleSources(ctx: Context, policy: RecallPolicy | undefined, access: () => void, pendingKeptId?: string): Snapshot;
 export {};

package/dist/src/eligibility-cache.js

@@ -16,18 +16,18 @@ export const eligibilityKeyMoved = (ctx, since) => !same(since, eligibilityKey(c
  * the same `SemanticAccessError` that `semanticEligibleSources` raises (the mapping below is that function's first statement, verbatim).
  * The policy is trusted by identity, so it must not change after install: a policy object mutated in place (a type added to
  * `privateCustomTypes`) or a `readAttemptMarker` with hidden state is not noticed until the history changes. */
-export function memoizedEligibleSources(ctx, policy, access) {
+export function memoizedEligibleSources(ctx, policy, access, pendingKeptId) {
     try {
         access();
     }
     catch (error) {
         throw Object.assign(new Error(error instanceof Error ? error.message : 'Source access denied'), { name: 'SemanticAccessError' });
     }
-    const key = eligibilityKey(ctx), held = cache.get(ctx.sessionManager);
+    const key = [...eligibilityKey(ctx), pendingKeptId ?? null], held = cache.get(ctx.sessionManager);
     if (held && held.policy === policy && same(held.key, key))
         return { ...held.stored, units: [], complete: false, indexed: new Set() };
     // Access was checked on the line above with nothing awaited in between, so the rebuild does not check it a second time.
-    const built = semanticEligibleSources(ctx, policy ?? {}, () => { });
+    const built = semanticEligibleSources(ctx, policy ?? {}, () => { }, pendingKeptId);
     cache.set(ctx.sessionManager, { policy, key, stored: { id: built.id, session: built.session, project: built.project, sources: built.sources, throughEntryId: built.throughEntryId, viewStart: built.viewStart } });
     return built;
 }

package/dist/src/request-capacity.d.ts

@@ -1,6 +1,14 @@
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
 import type { Messages } from './budget.js';
+/** Read Pi's private safety allowance through its public clamp, rather than copying it.
+ * Older/unavailable subpaths fall back to Pi 1.2–1.5's documented 4,096-token allowance.
+ */
+export declare function piContextSafetyMargin(): Promise<number>;
+/** The smallest reply room a request above the room must leave after Pi's own clamp: above the user's p99 reply (3,270 tokens). */
+export declare const REPLY_FLOOR_MIN = 3584;
 /** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
 export declare function branchReplyFloor(branch: readonly SessionEntry[], reserve: number): number;
+/** Admission never promises more output than a model with a positive reply cap can produce. */
+export declare function requestReplyFloor(branch: readonly SessionEntry[], reserve: number, maxTokens?: number): number;
 /** Check decoded text, including a whole verbatim user quote in our summary; never JSON-escaped substring matching. */
 export declare function carriesPrompt(messages: Messages, prompt: string): boolean;

package/dist/src/request-capacity.js

@@ -1,8 +1,28 @@
-import { isContextOverflow } from '@earendil-works/pi-ai';
+import { isContextOverflow, normalizeContext } from '@earendil-works/pi-ai';
 import { parseRecords, splitSummary } from './tuck/core/transcript.js';
+/** Read Pi's private safety allowance through its public clamp, rather than copying it.
+ * Older/unavailable subpaths fall back to Pi 1.2–1.5's documented 4,096-token allowance.
+ */
+export async function piContextSafetyMargin() {
+    try {
+        const [{ clampMaxTokensToContext }, { estimateContextTokens }] = await Promise.all([
+            import('@earendil-works/pi-ai/api/simple-options'), import('@earendil-works/pi-ai/utils/estimate'),
+        ]);
+        const window = 1_000_000, context = normalizeContext({ messages: [] });
+        const margin = window - estimateContextTokens(context).tokens - clampMaxTokensToContext({ contextWindow: window, maxTokens: window }, context, window);
+        if (!Number.isSafeInteger(margin) || margin < 0 || margin >= window)
+            throw new Error('Invalid Pi context margin');
+        return margin;
+    }
+    catch {
+        return 4_096;
+    }
+}
+/** The smallest reply room a request above the room must leave after Pi's own clamp: above the user's p99 reply (3,270 tokens). */
+export const REPLY_FLOOR_MIN = 3_584;
 /** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
 export function branchReplyFloor(branch, reserve) {
-    let largest = 4_096;
+    let largest = REPLY_FLOOR_MIN;
     for (const entry of branch) {
         if (entry.type !== 'message' || entry.message.role !== 'assistant')
             continue;
@@ -15,6 +35,11 @@ export function branchReplyFloor(branch, reserve) {
     }
     return Math.min(reserve, Math.ceil(largest));
 }
+/** Admission never promises more output than a model with a positive reply cap can produce. */
+export function requestReplyFloor(branch, reserve, maxTokens) {
+    const floor = branchReplyFloor(branch, reserve);
+    return maxTokens !== undefined && maxTokens > 0 ? Math.min(floor, maxTokens) : floor;
+}
 /** Check decoded text, including a whole verbatim user quote in our summary; never JSON-escaped substring matching. */
 export function carriesPrompt(messages, prompt) {
     if (!prompt.length)

package/dist/src/semantic-recall.d.ts

@@ -129,7 +129,9 @@ export declare function healDelayMs(attempts: number, integrity: boolean, delays
 export type SemanticState = 'disabled' | 'unavailable' | 'preparing' | 'ready' | 'waiting';
 /** Where the current view starts, as a branch position: the latest compaction entry's first kept entry. Earlier entries were compacted away. With no compaction, nothing is out of view. */
 export declare function viewStart(branch: SessionEntry[]): number;
-export declare function semanticEligibleSources(ctx: Pick<ExtensionContext, 'sessionManager' | 'cwd'>, policy: RecallPolicy, access: () => void): Snapshot;
+/** `pendingKeptId`: the first kept entry of a cut pi-tuck has applied to the requests but Pi has not yet saved (a prompt's cut is saved at the end of
+ * the first turn). Tools in that turn see the history as the model does: everything before that entry is out of view. */
+export declare function semanticEligibleSources(ctx: Pick<ExtensionContext, 'sessionManager' | 'cwd'>, policy: RecallPolicy, access: () => void, pendingKeptId?: string): Snapshot;
 export declare class SemanticRecallController {
     private readonly timing;
     private readonly ownerId;
@@ -294,6 +296,9 @@ export declare class SemanticRecallController {
     /** A plan for this snapshot that is fully indexed or, for a search, has all its out-of-view conversation indexed. The tool output behind it and the in-view tail are not worth waiting for: they keep indexing in the background and the coverage statement says how far they got.
     * With no out-of-view conversation (no cut) nothing waits: the search returns at once. Only a window whose out-of-view part is tool output alone still waits for the whole window. */
     private readyFor;
+    /** A search may rank a plan its own snapshot has grown from (every source in the plan still eligible, unchanged), as long as the session has not
+     * moved since the search took that snapshot; a move during the search still fails it. Indexing keeps the exact `recheck`. */
+    private recheckGrown;
     private recheck;
     private joinPreparation;
     search(query: string, provider: () => Snapshot, signal?: AbortSignal, prior?: PriorResult[], words?: any): Promise<SemanticPage>;

package/dist/src/semantic-recall.js

@@ -427,6 +427,15 @@ export function viewStart(branch) {
 }
 const TOOL_OUTPUT = new Set(['toolResult', 'bashExecution']);
 const isToolOutput = (source) => TOOL_OUTPUT.has(source.row.role);
+/** Whether `now` only grew from `plan`: the same session and project, and every source the plan ranks still eligible with the same hash. */
+function grownFrom(now, plan) {
+    if (now.session !== plan.session || now.project !== plan.project)
+        return false;
+    if (now.id === plan.id)
+        return true;
+    const shas = new Map(now.sources.map(source => [source.entry.id, source.sha]));
+    return plan.sources.every(source => shas.get(source.entry.id) === source.sha);
+}
 /** Sources in the order they are covered: out-of-view conversation (user messages, assistant text, tool-call names and arguments), then out-of-view tool output, then what is in view.
  * Each part is newest first, extending backward. */
 function windowOrder(snapshot) {
@@ -464,7 +473,9 @@ function windowCoverage(snapshot, prefix = indexedPrefix(snapshot)) {
     return { indexedCharacters, windowCharacters: window.windowCharacters, outOfViewCharacters: window.conversationOutOfView + window.toolOutOfView, eligibleCharacters: window.eligibleCharacters, oldestCoveredEntryId: oldest?.entry.id ?? null, oldestCoveredTime: time(oldest),
         conversation: { indexedCharacters: conversation, outOfViewCharacters: window.conversationOutOfView }, toolResults: { indexedCharacters: tools, outOfViewCharacters: window.toolOutOfView, oldestCoveredTime: time(oldestTool) } };
 }
-export function semanticEligibleSources(ctx, policy, access) {
+/** `pendingKeptId`: the first kept entry of a cut pi-tuck has applied to the requests but Pi has not yet saved (a prompt's cut is saved at the end of
+ * the first turn). Tools in that turn see the history as the model does: everything before that entry is out of view. */
+export function semanticEligibleSources(ctx, policy, access, pendingKeptId) {
     try {
         access();
     }
@@ -486,8 +497,9 @@ export function semanticEligibleSources(ctx, policy, access) {
     const orders = new Map(branch.map((entry, order) => [entry.id, order]));
     const sources = eligible.flatMap(entry => { const order = orders.get(entry.id); const row = recall.discoveryEntry(entry, attempts, links); if (!row)
         return []; const { sourceText: unusedText, ranges: unusedRanges, ...readable } = row; return [{ entry, row: readable, sourceText: row.sourceText, ranges: row.ranges, order, sha: hash({ entry, order, row: readable, ranges: row.ranges, index: indices.get(entry.id) }) }]; });
-    const session = ctx.sessionManager.getSessionId(), id = hash({ session, project: resolve(ctx.cwd), branch: branch.map(e => [e.id, e.parentId]), sources: sources.map(s => [s.entry.id, s.sha]) });
-    return { id, session, project: ctx.cwd, sources, units: [], complete: false, throughEntryId: sources.at(-1)?.entry.id ?? null, viewStart: viewStart(branch), indexed: new Set() };
+    const pending = pendingKeptId === undefined ? -1 : branch.findIndex(e => e.id === pendingKeptId), start = Math.max(viewStart(branch), pending);
+    const session = ctx.sessionManager.getSessionId(), id = hash({ session, project: resolve(ctx.cwd), branch: branch.map(e => [e.id, e.parentId]), sources: sources.map(s => [s.entry.id, s.sha]), ...(pending >= 0 ? { pendingKeptId } : {}) });
+    return { id, session, project: ctx.cwd, sources, units: [], complete: false, throughEntryId: sources.at(-1)?.entry.id ?? null, viewStart: start, indexed: new Set() };
 }
 export class SemanticRecallController {
     timing;
@@ -647,11 +659,19 @@ export class SemanticRecallController {
         return this.worker;
     }
     path(snapshot) { const directory = this.config.indexDirectory; outsideProject(snapshot.project, directory, 'index'); return join(directory, hash({ owner: this.ownerId, session: snapshot.session, project: resolve(snapshot.project) }) + '.sqlite'); }
-    async index(action, snapshot, extra = {}) { const path = this.path(snapshot), generation = this.generation, worker = await this.runtime(snapshot.project); if (!this.enabled || generation !== this.generation)
-        throw abort(); if (this.provider)
-        this.recheck(this.provider, snapshot); this.indexFiles.add(path); const result = await worker.call('index', { path, identity: this.identity, action, projectDirectory: snapshot.project, ...extra }); if (!this.enabled || generation !== this.generation)
-        throw abort(); if (this.provider)
-        this.recheck(this.provider, snapshot); return result; }
+    async index(action, snapshot, extra = {}, boundId) { const path = this.path(snapshot), generation = this.generation, worker = await this.runtime(snapshot.project); if (!this.enabled || generation !== this.generation)
+        throw abort(); if (this.provider) {
+        if (boundId !== undefined)
+            this.recheckGrown(this.provider, snapshot, boundId);
+        else
+            this.recheck(this.provider, snapshot);
+    } /* a search's scoring may read a plan its snapshot grew from */ /* a search's scoring may read a plan its snapshot grew from */ this.indexFiles.add(path); const result = await worker.call('index', { path, identity: this.identity, action, projectDirectory: snapshot.project, ...extra }); if (!this.enabled || generation !== this.generation)
+        throw abort(); if (this.provider) {
+        if (boundId !== undefined)
+            this.recheckGrown(this.provider, snapshot, boundId);
+        else
+            this.recheck(this.provider, snapshot);
+    } return result; }
     async prepare(provider, full = true) {
         if (!this.enabled)
             return;
@@ -801,6 +821,10 @@ export class SemanticRecallController {
     /** A plan for this snapshot that is fully indexed or, for a search, has all its out-of-view conversation indexed. The tool output behind it and the in-view tail are not worth waiting for: they keep indexing in the background and the coverage statement says how far they got.
     * With no out-of-view conversation (no cut) nothing waits: the search returns at once. Only a window whose out-of-view part is tool output alone still waits for the whole window. */
     readyFor(id, forSearch) { const plan = this.current; return Boolean(plan && plan.id === id && (plan.complete || (forSearch && plan.window !== undefined && plan.window.searchUnits > 0 && plan.units.slice(0, plan.window.searchUnits).every(unit => plan.indexed.has(unit.key))))); }
+    /** A search may rank a plan its own snapshot has grown from (every source in the plan still eligible, unchanged), as long as the session has not
+     * moved since the search took that snapshot; a move during the search still fails it. Indexing keeps the exact `recheck`. */
+    recheckGrown(provider, snapshot, boundId) { const now = provider(); if (now.id !== boundId || !grownFrom(now, snapshot))
+        throw new Error('Eligible branch or source changed before semantic admission'); }
     recheck(provider, snapshot) { const now = provider(); if (now.id !== snapshot.id || now.session !== snapshot.session || now.project !== snapshot.project)
         throw new Error('Eligible branch or source changed before semantic admission'); }
     async joinPreparation(deadline, signal) {
@@ -868,22 +892,25 @@ export class SemanticRecallController {
                 const prepared = !this.task || await this.joinPreparation(deadline, signal);
                 if (signal?.aborted || queryGeneration !== this.generation)
                     throw abort();
-                if (!prepared || performance.now() >= deadline)
-                    return incomplete();
-                this.error = null;
-                this.schedule(provider);
+                if (prepared && performance.now() < deadline) {
+                    this.error = null;
+                    this.schedule(provider);
+                    await this.waitForReady(Math.max(0, deadline - performance.now()), signal, bound.id, true);
+                }
             }
-            else if (!this.current.complete) {
-                this.error = null;
-                this.schedule(provider);
+            else {
+                if (!this.current.complete) {
+                    this.error = null;
+                    this.schedule(provider);
+                }
+                await this.waitForReady(Math.max(0, deadline - performance.now()), signal, bound.id, true);
             }
-            await this.waitForReady(Math.max(0, deadline - performance.now()), signal, bound.id, true);
             if (signal?.aborted || queryGeneration !== this.generation)
                 throw abort();
         }
         // Ranking needs a plan for the bound snapshot and an indexed prefix; the coverage statement describes exactly that prefix and nothing else is ranked, so a search that reaches its wait limit with part of the window indexed ranks that part. Only an empty prefix is `indexing_incomplete`.
-        const snapshot = this.current;
-        if (!snapshot || snapshot.id !== bound.id || (snapshot.units.length ? indexedPrefix(snapshot) === 0 : !snapshot.complete)) {
+        const snapshot = this.current, older = snapshot !== undefined && snapshot.id !== bound.id && grownFrom(bound, snapshot);
+        if (!snapshot || (snapshot.id !== bound.id && !older) || (snapshot.units.length ? indexedPrefix(snapshot) === 0 : !snapshot.complete)) {
             const failure = this.error ?? this.healReason;
             return failure && !CHURN.test(failure) ? unavailable() : incomplete();
         }
@@ -891,15 +918,15 @@ export class SemanticRecallController {
             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);
+            this.recheckGrown(provider, snapshot, bound.id);
             const encoded = await worker.call('embed', { texts: [query], kind: 'query' }, signal);
             this.operations.queryEmbeddings++;
-            this.recheck(provider, snapshot);
+            this.recheckGrown(provider, snapshot, bound.id);
             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 = [], 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] });
+                this.recheckGrown(provider, snapshot, bound.id);
+                const scored = await this.index('score', snapshot, { keys: stored.slice(offset, offset + SCORE_CHUNK).map(u => u.key), query: encoded.vectors[0] }, bound.id);
                 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);
@@ -912,7 +939,7 @@ export class SemanticRecallController {
                 throw new Error('Snapshot index coverage changed');
             if (signal?.aborted || queryGeneration !== this.generation || !this.enabled)
                 throw abort();
-            this.recheck(provider, snapshot);
+            this.recheckGrown(provider, snapshot, bound.id);
             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))
@@ -920,7 +947,7 @@ export class SemanticRecallController {
             // 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) };
+            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.` + (older ? ` This ranking covers the history through entry ${snapshot.throughEntryId}: later entries are still being indexed, so search them by keyword.` : ''), 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/core/search-entries.js

@@ -16,8 +16,8 @@ const startBudget = () => {
     const deadline = Date.now() + SEARCH_BUDGET_MS;
     return () => {
         if (Date.now() > deadline) {
-            throw new Error(`Search aborted: query exceeded ${SEARCH_BUDGET_MS}ms. Simplify the pattern — ` +
-                "nested quantifiers such as (a+)+ can make matching blow up.");
+            throw new Error(`Search aborted: query exceeded ${SEARCH_BUDGET_MS}ms on this history. ` +
+                "Use more specific words, or read an entry by index.");
         }
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "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 = "37e955d83a1e9237381f09fad8cd2aad1f2c6489ddbe51c58af227dbb46ddf3c";
+export const BUILD_ID = "c3eefa3bb76e52635b1e8394a025d3ffd6a056fc5636ed9b35f89dfddc1a322a";

package/src/compaction.ts

@@ -1,5 +1,5 @@
 import { textOf } from "./tuck/core/content.js";
-import { branchReplyFloor, carriesPrompt } from "./request-capacity.js";
+import { requestReplyFloor, carriesPrompt, piContextSafetyMargin } from "./request-capacity.js";
 import { BUILD_ID } from "./build-id.js";
 import { createSemanticRecall, budgetSemantic, type SemanticRecallController } from "./semantic-recall";
 import { DIAGNOSTIC_BUILD, IncidentRecorder, attachReceipt, permittedEntries, receiptId, findReceiptEntry, type Receipt, type RecorderOptions } from "./diagnostics.js";
@@ -11,7 +11,7 @@ import { projectedMessages } from "./omissions.js";
 import { applyClips, clipBudgets, clipFor, type Clip } from "./clip.js";
 import { DEFAULT_CUT_AT, bandOf, chooseCut, conversationTokens, gateCut, incomingEventTokens, incomingTokens, measurableConversationTokens, planningReserve, projectedConversationTokens, systemPart, validCutAt,
     type AgentMessage, type Messages, type Plan, type Target, type ToolShape } from "./budget.js";
-import { getCurrentSystemMessage, isContextOverflow, type ImageContent, type ToolResultMessage } from "@earendil-works/pi-ai";
+import { getCurrentSystemMessage, isContextOverflow, normalizeContext, type ImageContent, type ToolResultMessage } from "@earendil-works/pi-ai";
 import { calculateContextTokens, convertToLlm, estimateTokens, shouldCompact, SessionManager, SettingsManager, type ExtensionAPI, type ExtensionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { Check } from "typebox/value";
@@ -115,7 +115,7 @@ export interface CompactionOptions {
 	 * owns cut targets; standalone final capacity admission uses the branch reply floor. If omitted, the band adapts to the last cut. */
 	cutAt?: number;
 	/** A host's response reserve: without `responseExact: true`, the catalogue maximum output stays its floor; with it, `response` is exact.
-	 * Standalone cuts against Pi's reserveTokens, then admits up to the window less max(8192, largest branch output), capped at that reserve.
+	 * Standalone cuts against Pi's reserveTokens, then admits up to the window less Pi's safety margin and max(3,584, largest branch output), capped at that reserve.
 	 * After a length stop or context overflow it holds the full reserve, also raised to the catalogue maximum.
 	 * Resume, fork and /tree follow that branch's history; a new session has no inherited fallback. */
 	requestReserve?: (ctx: ExtensionContext) => { response: number; responseExact?: true };
@@ -133,6 +133,9 @@ export interface CompactionOptions {
 }
 
 export async function installCompaction(pi: ExtensionAPI, options: CompactionOptions = {}) {
+    const piMargin = options.requestReserve ? 0 : await piContextSafetyMargin();
+    const piClamp = options.requestReserve ? undefined : await import('@earendil-works/pi-ai/api/simple-options')
+        .then(module => module.clampMaxTokensToContext).catch(() => undefined);
     const cutAt = options.cutAt ?? DEFAULT_CUT_AT;
     if (!validCutAt(cutAt)) throw new Error("Invalid cut point: cutAt must be a number above 0 and at most 1");
     const semantic = options.semanticRecall ?? createSemanticRecall(), search = options.search ?? true;
@@ -145,7 +148,8 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     const semanticPending = new Set<Promise<unknown>>();
     // Semantic indexing outlives any one attempt, so it checks only that the host still grants access: a compactor failure, which ends with its
     // attempt, must not read as a revocation (that disables semantic recall and deletes its index for the rest of the session).
-    const semanticProvider = (ctx: ExtensionContext) => () => memoizedEligibleSources(ctx, options.recallPolicy, hostAccess);
+    // A prompt's cut reaches the requests at once but the session only at the end of the first turn: until then search sees the history as the model does.
+    const semanticProvider = (ctx: ExtensionContext) => () => memoizedEligibleSources(ctx, options.recallPolicy, hostAccess, promptCut ? promptCut.firstKeptEntryId || ctx.sessionManager.getBranch().findLast(e => e.type === "message" && e.message.role === "user")?.id : undefined);
     const recorder = new IncidentRecorder(options.diagnostics);
     let proposalId: string | undefined;
     const observe = (ctx: ExtensionContext) => recorder.measureInline(() => {
@@ -305,9 +309,9 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     // Room still owns every existing cut/clip attempt. Only final capacity admission uses the hard line.
     const limits = (ctx: ExtensionContext) => {
         const { response } = requestReserve(ctx), room = inputRoom(response, ctx);
-        const floor = options.requestReserve ? response : branchReplyFloor(ctx.sessionManager.getBranch(), response);
-        const hardLine = Math.min((ctx.model?.contextWindow ?? 0) - floor, lastCeiling ?? Infinity);
-        return { response, room, hardLine };
+        const floor = options.requestReserve ? response : requestReplyFloor(ctx.sessionManager.getBranch(), response, ctx.model?.maxTokens);
+        const hardLine = Math.min(Math.max(room, (ctx.model?.contextWindow ?? 0) - piMargin - floor), lastCeiling ?? Infinity);
+        return { response, room, hardLine, replyFloor: floor };
     };
     const decisionBand = (ctx: ExtensionContext, room: number, system: number) => {
         const last = ctx.sessionManager.getBranch().findLast(entry => entry.type === "compaction");
@@ -432,7 +436,10 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             // Bind the actual independent lexical offer, including attribution derived
             // from custom markers and receipts excluded from semantic indexing. Rebuild
             // under current caller policy after await, when the session moved; never send this block to the encoder.
-            const wordOffer=()=>tuckRecall(tuck,ctx.sessionManager.getEntries(),ctx.sessionManager.getBranch(),{query:input.query},options.recallPolicy);
+            // Keyword search over a very long history can hit its time limit. That limit guards one call, not the semantic half: the agent still gets the
+            // semantic results, and is told the keyword half stopped (seen in the field on an 84.7 MB session, where the whole search failed instead).
+            const wordOffer=()=>{try{return tuckRecall(tuck,ctx.sessionManager.getEntries(),ctx.sessionManager.getBranch(),{query:input.query},options.recallPolicy);}
+                catch(error){if(error instanceof Error&&error.message.startsWith("Search aborted:"))return{status:"keyword_timeout",notice:"Keyword search stopped at its time limit on this long history; the semantic results follow. For a keyword match, use more specific words or read an entry by index.",hits:[]};throw error;}};
             // The key is taken in the same synchronous step as the first lexical pass. After the await the second pass runs only if it moved (see eligibilityKey); a moved key alone invalidates nothing.
             // The snapshot id check covers every in-contract change (any branch change moves the id); the key-gated second pass is defence in depth for out-of-contract callers.
             const provider=semanticProvider(ctx),initialSnapshot=provider(),initialKey=eligibilityKey(ctx),words=wordOffer(),wordText=JSON.stringify(words);
@@ -520,7 +527,9 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     const historyToolsEnabled = (ctx: ExtensionContext) => Boolean(promptCut) || hasTuckCut(ctx.sessionManager.getBranch());
     const syncHistoryTools = (ctx: ExtensionContext) => { if (active()) applyHistoryTools(pi, historyToolsEnabled(ctx)); };
     pi.on("session_start", (_event, ctx) => syncHistoryTools(ctx));
-    pi.on("session_tree", (_event, ctx) => syncHistoryTools(ctx));
+    // A plan decided on `input` is for the branch it was decided on: moving in the tree leaves it planned for another branch, whose kept entry
+    // may not be on this one.
+    pi.on("session_tree", (_event, ctx) => { promptCut = undefined; phase = "idle"; syncHistoryTools(ctx); });
     pi.on("session_compact", (_event, ctx) => { if (!admittedRun) syncHistoryTools(ctx); });
     pi.on("turn_start", (_event, ctx) => syncHistoryTools(ctx));
     pi.on("agent_settled", (_event, ctx) => syncHistoryTools(ctx));
@@ -589,7 +598,9 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         promptCut = { type: "compaction", summary: compaction.summary, firstKeptEntryId: compaction.firstKeptEntryId, tokensBefore: before, details: compaction.details };
     };
     pi.on("before_agent_start", async (event, ctx) => {
-        const prompted = phase === "decided";
+        // A decided plan is for the prompt `input` saw. A run that a custom message starts is not that run (another extension handled the
+        // input, so no run started for it): plan afresh.
+        const prompted = phase === "decided" && event.messageType !== "custom";
         phase = "starting";
         runPrompt = event.messageType === "custom" ? undefined : event.prompt;
         try {
@@ -849,11 +860,16 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             const tokens = system + conversationTokens(messages);
             observeBudget(tokens, ctx);
             estimatedTokens = corrected(tokens, ctx);
-            const { room, hardLine } = limits(ctx);
+            const { room, hardLine, replyFloor } = limits(ctx);
             if (runPrompt !== undefined && !carriesPrompt(messages, runPrompt))
                 throw new Refusal("Prompt check failed: the request is missing the whole text of the prompt that started this run. Shorten the prompt or choose a model with a larger context window, then retry");
 			if (!fits(tokens, hardLine, ctx))
 				throw new CapacityError("Complete Pi context and response reserve exceed the estimated request budget");
+            // Pi's request estimator and its compaction estimator need not agree. The hard line is
+            // necessary; above the room, also require the real request clamp to preserve the floor.
+            if (!options.requestReserve && estimatedTokens > room && piClamp &&
+                piClamp(ctx.model, normalizeContext({ messages: convertToLlm(messages) }), ctx.model.maxTokens) < replyFloor)
+                throw new CapacityError("Pi's request clamp leaves less than the reply floor");
             if (estimatedTokens > room) receipt("above-room", "Request exceeds the room and fits the hard line", ctx);
             if (recorder.enabled && !recorder.waitingForCut) recorder.measureInline(() => {
                 recorder.request();

package/src/eligibility-cache.ts

@@ -32,12 +32,12 @@ export const eligibilityKeyMoved = (ctx: Context, since: readonly unknown[]) =>
  * the same `SemanticAccessError` that `semanticEligibleSources` raises (the mapping below is that function's first statement, verbatim).
  * The policy is trusted by identity, so it must not change after install: a policy object mutated in place (a type added to
  * `privateCustomTypes`) or a `readAttemptMarker` with hidden state is not noticed until the history changes. */
-export function memoizedEligibleSources(ctx: Context, policy: RecallPolicy | undefined, access: () => void): Snapshot {
+export function memoizedEligibleSources(ctx: Context, policy: RecallPolicy | undefined, access: () => void, pendingKeptId?: string): Snapshot {
 	try { access(); } catch (error) { throw Object.assign(new Error(error instanceof Error ? error.message : 'Source access denied'), { name: 'SemanticAccessError' }); }
-	const key = eligibilityKey(ctx), held = cache.get(ctx.sessionManager);
+	const key = [...eligibilityKey(ctx), pendingKeptId ?? null], held = cache.get(ctx.sessionManager);
 	if (held && held.policy === policy && same(held.key, key)) return { ...held.stored, units: [], complete: false, indexed: new Set() };
 	// Access was checked on the line above with nothing awaited in between, so the rebuild does not check it a second time.
-	const built = semanticEligibleSources(ctx, policy ?? {}, () => {});
+	const built = semanticEligibleSources(ctx, policy ?? {}, () => {}, pendingKeptId);
 	cache.set(ctx.sessionManager, { policy, key, stored: { id: built.id, session: built.session, project: built.project, sources: built.sources, throughEntryId: built.throughEntryId, viewStart: built.viewStart } });
 	return built;
 }

package/src/request-capacity.ts

@@ -1,11 +1,29 @@
-import { isContextOverflow } from '@earendil-works/pi-ai';
+import { isContextOverflow, normalizeContext } from '@earendil-works/pi-ai';
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
 import type { Messages } from './budget.js';
 import { parseRecords, splitSummary } from './tuck/core/transcript.js';
 
+/** Read Pi's private safety allowance through its public clamp, rather than copying it.
+ * Older/unavailable subpaths fall back to Pi 1.2–1.5's documented 4,096-token allowance.
+ */
+export async function piContextSafetyMargin(): Promise<number> {
+    try {
+        const [{ clampMaxTokensToContext }, { estimateContextTokens }] = await Promise.all([
+            import('@earendil-works/pi-ai/api/simple-options'), import('@earendil-works/pi-ai/utils/estimate'),
+        ]);
+        const window = 1_000_000, context = normalizeContext({ messages: [] });
+        const margin = window - estimateContextTokens(context).tokens - clampMaxTokensToContext({ contextWindow: window, maxTokens: window } as never, context, window);
+        if (!Number.isSafeInteger(margin) || margin < 0 || margin >= window) throw new Error('Invalid Pi context margin');
+        return margin;
+    } catch { return 4_096; }
+}
+
+/** The smallest reply room a request above the room must leave after Pi's own clamp: above the user's p99 reply (3,270 tokens). */
+export const REPLY_FLOOR_MIN = 3_584;
+
 /** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
 export function branchReplyFloor(branch: readonly SessionEntry[], reserve: number): number {
-    let largest = 4_096;
+    let largest = REPLY_FLOOR_MIN;
     for (const entry of branch) {
         if (entry.type !== 'message' || entry.message.role !== 'assistant') continue;
         const message = entry.message;
@@ -16,6 +34,12 @@ export function branchReplyFloor(branch: readonly SessionEntry[], reserve: numbe
     return Math.min(reserve, Math.ceil(largest));
 }
 
+/** Admission never promises more output than a model with a positive reply cap can produce. */
+export function requestReplyFloor(branch: readonly SessionEntry[], reserve: number, maxTokens?: number): number {
+    const floor = branchReplyFloor(branch, reserve);
+    return maxTokens !== undefined && maxTokens > 0 ? Math.min(floor, maxTokens) : floor;
+}
+
 /** Check decoded text, including a whole verbatim user quote in our summary; never JSON-escaped substring matching. */
 export function carriesPrompt(messages: Messages, prompt: string): boolean {
     if (!prompt.length) return true;

package/src/semantic-recall.ts

@@ -195,6 +195,11 @@ export function viewStart(branch:SessionEntry[]):number{
 }
 const TOOL_OUTPUT=new Set(['toolResult','bashExecution']);
 const isToolOutput=(source:Source)=>TOOL_OUTPUT.has(source.row.role);
+/** Whether `now` only grew from `plan`: the same session and project, and every source the plan ranks still eligible with the same hash. */
+function grownFrom(now:Snapshot,plan:Snapshot):boolean{
+ if(now.session!==plan.session||now.project!==plan.project)return false;if(now.id===plan.id)return true;
+ const shas=new Map(now.sources.map(source=>[source.entry.id,source.sha]));return plan.sources.every(source=>shas.get(source.entry.id)===source.sha);
+}
 /** Sources in the order they are covered: out-of-view conversation (user messages, assistant text, tool-call names and arguments), then out-of-view tool output, then what is in view.
  * Each part is newest first, extending backward. */
 function windowOrder(snapshot:Snapshot):Source[]{
@@ -216,7 +221,9 @@ function windowCoverage(snapshot:Snapshot,prefix=indexedPrefix(snapshot)){
  return{indexedCharacters,windowCharacters:window.windowCharacters,outOfViewCharacters:window.conversationOutOfView+window.toolOutOfView,eligibleCharacters:window.eligibleCharacters,oldestCoveredEntryId:oldest?.entry.id??null,oldestCoveredTime:time(oldest),
   conversation:{indexedCharacters:conversation,outOfViewCharacters:window.conversationOutOfView},toolResults:{indexedCharacters:tools,outOfViewCharacters:window.toolOutOfView,oldestCoveredTime:time(oldestTool)}};
 }
-export function semanticEligibleSources(ctx:Pick<ExtensionContext,'sessionManager'|'cwd'>,policy:RecallPolicy,access:()=>void):Snapshot {
+/** `pendingKeptId`: the first kept entry of a cut pi-tuck has applied to the requests but Pi has not yet saved (a prompt's cut is saved at the end of
+ * the first turn). Tools in that turn see the history as the model does: everything before that entry is out of view. */
+export function semanticEligibleSources(ctx:Pick<ExtensionContext,'sessionManager'|'cwd'>,policy:RecallPolicy,access:()=>void,pendingKeptId?:string):Snapshot {
  try{access();}catch(error){throw Object.assign(new Error(error instanceof Error?error.message:'Source access denied'),{name:'SemanticAccessError'});}const branch=ctx.sessionManager.getBranch(),all=ctx.sessionManager.getEntries();
  if(branch.some(e=>e.type==='context_edit'&&e.replacement!==null))throw new Error('Unsupported replacement context edit');
  const omitted=new Set(branch.flatMap(e=>e.type==='context_edit'?[e.targetId]:[]));
@@ -225,7 +232,8 @@ export function semanticEligibleSources(ctx:Pick<ExtensionContext,'sessionManage
  const eligible=branch.filter(e=>!omitted.has(e.id)&&ids.get(e.id)===1),recall=createRecall(policy),attempts=recall.recallAttempts(eligible),links=recall.producerReads(eligible),indices=buildGlobalIndexById(all);
  const orders=new Map(branch.map((entry,order)=>[entry.id,order]));
  const sources=eligible.flatMap(entry=>{const order=orders.get(entry.id)!;const row=recall.discoveryEntry(entry,attempts,links);if(!row)return[];const {sourceText:unusedText,ranges:unusedRanges,...readable}=row;return[{entry,row:readable,sourceText:row.sourceText,ranges:row.ranges,order,sha:hash({entry,order,row:readable,ranges:row.ranges,index:indices.get(entry.id)})}];});
- const session=ctx.sessionManager.getSessionId(),id=hash({session,project:resolve(ctx.cwd),branch:branch.map(e=>[e.id,e.parentId]),sources:sources.map(s=>[s.entry.id,s.sha])});return{id,session,project:ctx.cwd,sources,units:[],complete:false,throughEntryId:sources.at(-1)?.entry.id??null,viewStart:viewStart(branch),indexed:new Set()};
+ const pending=pendingKeptId===undefined?-1:branch.findIndex(e=>e.id===pendingKeptId),start=Math.max(viewStart(branch),pending);
+ const session=ctx.sessionManager.getSessionId(),id=hash({session,project:resolve(ctx.cwd),branch:branch.map(e=>[e.id,e.parentId]),sources:sources.map(s=>[s.entry.id,s.sha]),...(pending>=0?{pendingKeptId}:{})});return{id,session,project:ctx.cwd,sources,units:[],complete:false,throughEntryId:sources.at(-1)?.entry.id??null,viewStart:start,indexed:new Set()};
 }
 export class SemanticRecallController {
  private readonly ownerId=randomUUID();private readonly indexFiles=new Set<string>();private closing?:Promise<void>;private joiningSearches=0;private activeSearches=new Set<Promise<SemanticPage>>();private config?:SemanticRecallConfig;private worker?:LocalWorker;private identity='';private provider?:()=>Snapshot;private generation=0;private cleanupError:string|null=null;private dirty=false;private operations={preparationEmbeddings:0,queryEmbeddings:0};
@@ -267,7 +275,7 @@ export class SemanticRecallController {
  private async runtime(project:string){if(this.idling)await this.idling;if(!this.enabled)throw abort();outsideProject(project,this.config!.runtimeRoot,'runtime');outsideProject(project,scratchParent(this.config!),'scratch');outsideRuntime(this.config!.runtimeRoot,scratchParent(this.config!),'scratch');if(this.worker&&this.recycle){const old=this.worker;await old.close();if(this.worker===old){this.worker=undefined;this.identity='';this.recycle=false;}if(!this.enabled)throw abort();}
   if(!this.worker){const worker=new LocalWorker(this.config!,project,error=>{if(this.worker!==worker)return;this.cleanupError=error instanceof Error?error.message:'Semantic cleanup failed';this.error=this.cleanupError;this.enabled=false;this.generation++;},reason=>{if(this.worker===worker)this.heal(new WorkerFailure(reason));},{startMs:this.timing.startDeadlineMs??START_DEADLINE_MS,callMs:this.timing.callDeadlineMs??CALL_DEADLINE_MS,embedTextMs:this.timing.embedTextMs??EMBED_TEXT_MS});this.worker=worker;}if(!this.identity){const ready=await this.worker.call('ready');if(ready.dimensions!==768||ready.maxTokens!==8192||!ready.offline)throw new Error('Incompatible semantic model; EG2 768/8192 offline required');this.identity=hash({worker:ready.identity,chunk:'eg2-passage256-focused-disjoint-direct-v3'});}return this.worker;}
  private path(snapshot:Snapshot){const directory=this.config!.indexDirectory;outsideProject(snapshot.project,directory,'index');return join(directory,hash({owner:this.ownerId,session:snapshot.session,project:resolve(snapshot.project)})+'.sqlite');}
- private async index(action:string,snapshot:Snapshot,extra:object={}){const path=this.path(snapshot),generation=this.generation,worker=await this.runtime(snapshot.project);if(!this.enabled||generation!==this.generation)throw abort();if(this.provider)this.recheck(this.provider,snapshot);this.indexFiles.add(path);const result=await worker.call('index',{path,identity:this.identity,action,projectDirectory:snapshot.project,...extra});if(!this.enabled||generation!==this.generation)throw abort();if(this.provider)this.recheck(this.provider,snapshot);return result;}
+ private async index(action:string,snapshot:Snapshot,extra:object={},boundId?:string){const path=this.path(snapshot),generation=this.generation,worker=await this.runtime(snapshot.project);if(!this.enabled||generation!==this.generation)throw abort();if(this.provider){if(boundId!==undefined)this.recheckGrown(this.provider,snapshot,boundId);else this.recheck(this.provider,snapshot);} /* a search's scoring may read a plan its snapshot grew from */this.indexFiles.add(path);const result=await worker.call('index',{path,identity:this.identity,action,projectDirectory:snapshot.project,...extra});if(!this.enabled||generation!==this.generation)throw abort();if(this.provider){if(boundId!==undefined)this.recheckGrown(this.provider,snapshot,boundId);else this.recheck(this.provider,snapshot);}return result;}
  private async prepare(provider:()=>Snapshot,full=true){
   if(!this.enabled)return;
   const generation=this.generation,started=performance.now();let snapshot=provider();const prior=this.current;
@@ -333,6 +341,9 @@ export class SemanticRecallController {
  /** A plan for this snapshot that is fully indexed or, for a search, has all its out-of-view conversation indexed. The tool output behind it and the in-view tail are not worth waiting for: they keep indexing in the background and the coverage statement says how far they got.
  * With no out-of-view conversation (no cut) nothing waits: the search returns at once. Only a window whose out-of-view part is tool output alone still waits for the whole window. */
  private readyFor(id:string|undefined,forSearch:boolean){const plan=this.current;return Boolean(plan&&plan.id===id&&(plan.complete||(forSearch&&plan.window!==undefined&&plan.window.searchUnits>0&&plan.units.slice(0,plan.window.searchUnits).every(unit=>plan.indexed.has(unit.key)))));}
+ /** A search may rank a plan its own snapshot has grown from (every source in the plan still eligible, unchanged), as long as the session has not
+  * moved since the search took that snapshot; a move during the search still fails it. Indexing keeps the exact `recheck`. */
+ private recheckGrown(provider:()=>Snapshot,snapshot:Snapshot,boundId:string){const now=provider();if(now.id!==boundId||!grownFrom(now,snapshot))throw new Error('Eligible branch or source changed before semantic admission');}
  private recheck(provider:()=>Snapshot,snapshot:Snapshot){const now=provider();if(now.id!==snapshot.id||now.session!==snapshot.session||now.project!==snapshot.project)throw new Error('Eligible branch or source changed before semantic admission');}
  private async joinPreparation(deadline:number,signal?:AbortSignal){
   const task=this.task;if(!task)return true;let timer:ReturnType<typeof setTimeout>|undefined,onAbort:(()=>void)|undefined;
@@ -355,15 +366,15 @@ export class SemanticRecallController {
    if(!planned){this.error=null;this.schedule(provider);}
    if(!(this.current?.id===bound.id&&((this.current.complete&&!this.current.units.length)||(indexedPrefix(this.current)>0&&this.worker!==undefined&&!this.recycle&&!this.idling)))){if(page)return page;return{status:'indexing_incomplete',notice:'No semantic ranking performed: nothing is out of view, so the whole history is in your context.',coverage:this.status(),groups:[]};}
   }else{
-  if(this.current?.id!==bound.id){const prepared=!this.task||await this.joinPreparation(deadline,signal);if(signal?.aborted||queryGeneration!==this.generation)throw abort();if(!prepared||performance.now()>=deadline)return incomplete();this.error=null;this.schedule(provider);}else if(!this.current.complete){this.error=null;this.schedule(provider);}await this.waitForReady(Math.max(0,deadline-performance.now()),signal,bound.id,true);if(signal?.aborted||queryGeneration!==this.generation)throw abort();
+  if(this.current?.id!==bound.id){const prepared=!this.task||await this.joinPreparation(deadline,signal);if(signal?.aborted||queryGeneration!==this.generation)throw abort();if(prepared&&performance.now()<deadline){this.error=null;this.schedule(provider);await this.waitForReady(Math.max(0,deadline-performance.now()),signal,bound.id,true);}}else{if(!this.current.complete){this.error=null;this.schedule(provider);}await this.waitForReady(Math.max(0,deadline-performance.now()),signal,bound.id,true);}if(signal?.aborted||queryGeneration!==this.generation)throw abort();
   }
   // Ranking needs a plan for the bound snapshot and an indexed prefix; the coverage statement describes exactly that prefix and nothing else is ranked, so a search that reaches its wait limit with part of the window indexed ranks that part. Only an empty prefix is `indexing_incomplete`.
-  const snapshot=this.current;if(!snapshot||snapshot.id!==bound.id||(snapshot.units.length?indexedPrefix(snapshot)===0:!snapshot.complete)){const failure=this.error??this.healReason;return failure&&!CHURN.test(failure)?unavailable():incomplete();}
+  const snapshot=this.current,older=snapshot!==undefined&&snapshot.id!==bound.id&&grownFrom(bound,snapshot);if(!snapshot||(snapshot.id!==bound.id&&!older)||(snapshot.units.length?indexedPrefix(snapshot)===0:!snapshot.complete)){const failure=this.error??this.healReason;return failure&&!CHURN.test(failure)?unavailable():incomplete();}
   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');
+  try{const worker=await this.runtime(snapshot.project);this.recheckGrown(provider,snapshot,bound.id);const encoded=await worker.call('embed',{texts:[query],kind:'query'},signal);this.operations.queryEmbeddings++;this.recheckGrown(provider,snapshot,bound.id);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.recheckGrown(provider,snapshot,bound.id);const scored=await this.index('score',snapshot,{keys:stored.slice(offset,offset+SCORE_CHUNK).map(u=>u.key),query:encoded.vectors[0]},bound.id) 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.recheckGrown(provider,snapshot,bound.id);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');
    // 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)};
+   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.`+(older?` This ranking covers the history through entry ${snapshot.throughEntryId}: later entries are still being indexed, so search them by keyword.`:''),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/core/search-entries.ts

@@ -38,8 +38,8 @@ const startBudget = (): (() => void) => {
   return () => {
     if (Date.now() > deadline) {
       throw new Error(
-        `Search aborted: query exceeded ${SEARCH_BUDGET_MS}ms. Simplify the pattern — ` +
-        "nested quantifiers such as (a+)+ can make matching blow up.",
+        `Search aborted: query exceeded ${SEARCH_BUDGET_MS}ms on this history. ` +
+        "Use more specific words, or read an entry by index.",
       );
     }
   };