pi-tuck 1.0.20 → 1.0.22

package/CHANGELOG.md

@@ -3,6 +3,69 @@
 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.22] - 2026-11-10
+
+### Fixed
+
+- **pi-tuck refused requests that fit the window, and could strand a session (1.0.0 to 1.0.21).** 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:
+  - the floor is the larger of the biggest reply seen on the branch and 4,096 tokens, capped at the reserve;
+  - after a reply stopped for length or a context-overflow refusal, the floor is the full reserve, as in 1.0.20;
+  - everything pi-tuck does before refusing (cut to the band, cut to the room, a smaller summary, clipping a fresh result) is unchanged and still
+    comes first;
+  - a session that never reaches the room sends the same requests as 1.0.21.
+- **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, instead of sending part of it. In-run cuts now keep the run's starting prompt whole
+  beside a later steering message.
+
+### Added
+
+- **Each pi-tuck refusal, and each request sent above the room, leaves one session entry:** type `custom`, `customType` `pi-tuck-capacity`, with
+  `data` `{kind: "refusal" | "above-room", reason, estimatedTokens, room, hardLine, buildId}`. It is never sent to the model, and never appears in
+  summaries or recall.
+- **A native-parity check in the settings stress test,** computed from Pi's own `shouldCompact` and compaction settings for the Pi version under
+  test. It fails a cell where pi-tuck refuses a request native Pi would send, or forces a cut below native's compaction point. Four refusals are
+  allowed:
+  - past the window;
+  - after a reply that did not fit;
+  - when the whole starting prompt cannot fit;
+  - when sending would leave the reply less than the floor.
+
+### Known cost
+
+- **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. That beats a stranded session.
+
+### Release gates
+
+- **Shipped before its Tier 1 live gate, under the stranded-session rule;** the gate runs right after release, and a fail rolls back to 1.0.21.
+- **Replay matches 1.0.21,** read per request on 29 recordings: every differing request also differs between two runs of 1.0.21. 0 lost and 0 dead
+  tasks, the same 17 clips.
+- **Stress on Pi 1.2.0 and 1.5.0,** 298 cells: answered 1,309 → 1,356, refused 360 → 313, stranded sessions 3 → 0, native-parity findings 53 → 0. The
+  old fresh-room finding passes. Tests (696) and CI.
+- Sessions that are open keep the build they started with until they are restarted.
+
+## [1.0.21] - 2026-11-09
+
+### Fixed
+
+- **Semantic recall never started in `pi -p` (1.0.0 to 1.0.20).** pi-tuck skipped semantic recall whenever Pi ran with no UI, to keep a one-shot
+  run from starting the first-time download. That also skipped a runtime that was already installed. So jobs run with `pi -p` searched by keyword
+  only, while `tuck_search` said semantic recall was being set up. With no UI, an installed runtime now starts as it does in an interactive session.
+  Without one, pi-tuck says it is not set up and starts no download. RPC mode, which has a UI, was not affected.
+- **An off or failing semantic recall, or a bad settings file, is no longer silent in `pi -p`.** Pi shows no notices there, so pi-tuck writes each
+  such message once per session to stderr, never into the model's context.
+
+### Release gates
+
+- **Shipped without a live gate, because its replay matches 1.0.20.** Replay does not load the changed file (`index.ts`). In the replay, 43 requests
+  of one recording (live-s08-A) differed once. Three more runs of that recording on each build were identical, so it was noise under machine load.
+  0 lost and 0 dead tasks, the same 17 clips. Tests and CI; the settings stress test, none worse than 1.0.20.
+- Checked in real Pi 1.4.0: with `pi -p` and no runtime, one stderr line; with an installed runtime, semantic recall starts.
+- Sessions that are open keep the build they started with until they are restarted.
+
 ## [1.0.20] - 2026-11-09
 
 ### 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.19`.
-- To pin a version, add it: `pi install npm:pi-tuck@1.0.19`.
+- 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`.
 
 ## Uninstall
 
@@ -126,9 +126,11 @@ 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 window, after a stopped run (1.0.8 and 1.0.9 only; fixed in 1.0.10): Pi's default `compaction.keepRecentTokens` (20,000) can exceed pi-tuck's input room, which is the window less the larger of `compaction.reserveTokens` and the model's maximum output (16,384 at a 32k window with the default reserve). After a run that is stopped (Esc, or a time limit) with the context above the room, every later prompt could be refused with "The request needs a cut and Pi has none to make (Nothing to compact (session too small))", and the session stayed stuck. In one check at these defaults (pi-tuck 1.0.8, 32k window, one session of 30 tasks, one local model), 28 tasks were lost, tasks 3 to 30 ([`benchmark/RESULTS-DEFAULTS.md`](benchmark/RESULTS-DEFAULTS.md)). If you are on 1.0.8 or 1.0.9, upgrade to 1.0.10. In 1.0.10 the cut a prompt needs is pi-tuck's own, so `keepRecentTokens` no longer leaves it with nothing to cut. A rerun of the same check on the 1.0.10 candidate had no refusal and no stuck session. It had two caveats: two of its tasks had a first request the local server never answered, and 8 of its 30 tasks began without their prompt, which the refusal counter cannot see (fixed in 1.0.12; see Benchmarks and [`benchmark/RESULTS-DEFAULTS-1010.md`](benchmark/RESULTS-DEFAULTS-1010.md)). Windows of 128k and up were not affected at the defaults.
+- 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 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).
 - Since 1.0.18, on replay of 17 recordings, estimated request time against 1.0.13 is 2.2% higher quiet and 4.2% higher loaded at 81,920, and 1.1% and 1.9% lower at 131,072. Billed input moves the same way. At 81,920 each cut carries about 600 more tokens. Sessions that are open keep the build they started with until they are restarted ([`CHANGELOG.md`](CHANGELOG.md) 1.0.18).
@@ -184,13 +186,15 @@ A bad file is reported at session start, and pi-tuck uses the defaults.
 
 ### Small windows
 
-pi-tuck keeps room for the model's reply: the larger of the model's output limit and Pi's `compaction.reserveTokens` (default 16,384). It 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:
+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:
 
 ```json
 { "compaction": { "modelOverrides": { "my-provider/my-model": { "reserveTokens": 8192 } } } }
 ```
 
-The reserve is the larger of `reserveTokens` and the model's `maxTokens`, so lowering `reserveTokens` alone does nothing when `models.json` sets a larger `maxTokens` for that model. Lower both, and keep `maxTokens` above your largest expected reply.
+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.
 
 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:
 
@@ -210,7 +214,7 @@ The first time a session starts, pi-tuck downloads what it needs, once, about 39
 | llama.cpp release b11476 for macOS arm64 (12 MB) | github.com/ggml-org/llama.cpp |
 | CPython 3.13 (25 MB) and 16 Python packages for the tokenizer (9 MB) | github.com/astral-sh/python-build-standalone, pypi.org |
 
-Every file is pinned to a SHA-256 in [src/assets.ts](src/assets.ts) and checked before use. Everything goes to `~/.pi/agent/pi-tuck`; to remove it, delete that folder. Setup needs about 6.5 GB of free disk space while it runs, and uses 460 MB after. If it fails, for example offline, pi-tuck says so and tries again at the next session start. One-shot runs (`pi -p`) do not start the setup.
+Every file is pinned to a SHA-256 in [src/assets.ts](src/assets.ts) and checked before use. Everything goes to `~/.pi/agent/pi-tuck`; to remove it, delete that folder. Setup needs about 6.5 GB of free disk space while it runs, and uses 460 MB after. If it fails, for example offline, pi-tuck says so and tries again at the next session start. The first-time setup needs one interactive start: one-shot runs (`pi -p`) do not start the download. Since 1.0.21, a `pi -p` run starts semantic search when the runtime is already installed. If it is not installed, pi-tuck says so and starts no download. With no UI, an off or failing semantic recall, or a bad settings file, is written once per message per session to stderr, never into the model's context.
 
 Indexing starts in the background the first time a session uses `tuck_search`, and catches up after each compaction. Semantic search is off when Pi runs in a folder that contains Pi's agent folder, such as your home folder, because its own files live there. Open Pi in a project folder.
 

package/dist/index.js

@@ -1,10 +1,10 @@
 import { VERSION, getAgentDir } from "@earendil-works/pi-coding-agent";
-import { readFileSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { join, sep } from "node:path";
 import { installCompaction } from "./src/compaction.js";
 import { validCutAt } from "./src/budget.js";
 import { createSemanticRecall } from "./src/semantic-recall.js";
-import { defaultRoot } from "./src/assets.js";
+import { defaultRoot, runtimeConfigPath } from "./src/assets.js";
 import { ensureSemanticRuntime } from "./src/setup.js";
 export { installCompaction } from "./src/compaction.js";
 export { inspectIncident, readableIncident } from "./src/diagnostic-replay.js";
@@ -52,10 +52,25 @@ export default async function (pi) {
         return;
     let session = 0, said = "", setup, announced = false;
     // A context outlives its session (a setup can finish after /new); a notice to an ended session is dropped.
-    const say = (ctx, message, level) => { try {
-        ctx.ui.notify(message, level);
-    }
-    catch { /* ended */ } };
+    // With no UI (pi -p), Pi shows no notices, so a settings error or an off or failing semantic recall would go unsaid: write each to stderr
+    // instead, once per session. stderr is the operator's; it never enters the model's context.
+    const stderrSaid = new Set();
+    const say = (ctx, message, level) => {
+        if (!ctx.hasUI) {
+            if (!stderrSaid.has(message)) {
+                stderrSaid.add(message);
+                try {
+                    process.stderr.write(message + "\n");
+                }
+                catch { /* closed */ }
+            }
+            return;
+        }
+        try {
+            ctx.ui.notify(message, level);
+        }
+        catch { /* ended */ }
+    };
     const once = (ctx, message, level) => { if (said !== message) {
         said = message;
         say(ctx, message, level);
@@ -64,6 +79,7 @@ export default async function (pi) {
     pi.on("session_start", (_event, ctx) => {
         const current = ++session;
         off = false;
+        stderrSaid.clear();
         if (settings.error)
             once(ctx, `pi-tuck: ${settings.error}; using the defaults.`, "warning");
         if (!appleSilicon)
@@ -72,10 +88,15 @@ export default async function (pi) {
         // agent folder, such as the home folder.
         if (within(real(getAgentDir()), real(ctx.cwd)))
             return once(ctx, "pi-tuck: semantic recall is off here because Pi's agent folder is inside this folder; open Pi in a project folder to use it.", "info");
-        if (!ctx.hasUI)
-            return; // a one-shot run (pi -p) would end before a first-time setup could
+        // A run with no UI (pi -p, RPC, JSON) uses a runtime that is already installed: that needs no download. It does not start a first-time
+        // setup, which would outlast a one-shot run, and it says why, so tuck_search and /tuck name the real state.
+        const installed = existsSync(runtimeConfigPath(defaultRoot()));
+        if (!ctx.hasUI && !installed) {
+            semanticRecall.refuse("Semantic recall is not set up yet; start Pi once in an interactive session to set it up. Word recall works meanwhile");
+            return say(ctx, "pi-tuck: semantic recall is not set up yet; start Pi once in an interactive session to set it up. Word recall works.", "warning");
+        }
         if (!semanticRecall.status().configured)
-            semanticRecall.refuse("Semantic recall is being set up; word recall works meanwhile");
+            semanticRecall.refuse(installed ? "Semantic recall is starting; word recall works meanwhile" : "Semantic recall is being set up; word recall works meanwhile");
         setup ??= ensureSemanticRuntime(defaultRoot(), message => { announced = true; say(ctx, message, "info"); });
         setup.then(async () => {
             if (current !== session || off)

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

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

package/dist/src/build-id.js

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

package/dist/src/compaction.d.ts

@@ -32,15 +32,26 @@ export interface CompactionOptions {
     onSemanticSetting?: (enabled: boolean) => Promise<unknown>;
     semanticStatus?: () => unknown;
     diagnostics?: RecorderOptions;
+    /** Optional read-only observation of actual corrected budget checks; no request content. */
+    observeBudget?: (measurement: {
+        rawTokens: number;
+        tokens: number;
+        factor: number;
+        response: number;
+        room: number;
+        hardLine?: number;
+        context: ExtensionContext;
+    }) => void;
     /** Optional estimated complete-input ceiling, separate from physical output reservation.
      * The host owns final serialization/transport counting; this is not an exact wire-token cap. */
     activeInputTokens?: number | ((ctx: ExtensionContext) => number);
     /** An explicit cut point: a fraction of the input room, above 0 and at most 1. A cut is triggered at, and preferably planned to, the band,
-     * which is the room less 2% of it, or this fraction of the room when that is lower; a lower value cuts earlier and leaves less. The exact room
-     * stays the limit of every throw, fault and the complete-context guard. If omitted, the band adapts to the last cut. */
+     * which is the room less 2% of it, or this fraction of the room when that is lower; a lower value cuts earlier and leaves less. The room
+     * 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 uses Pi's reserveTokens until a length stop or a context-overflow refusal on the current branch, then also holds the catalogue maximum.
+     * Standalone cuts against Pi's reserveTokens, then admits up to the window less max(8192, 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;

package/dist/src/compaction.js

@@ -1,3 +1,6 @@
+import { textOf } from "./tuck/core/content.js";
+import { branchReplyFloor, carriesPrompt } 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";
 import { createHash } from "node:crypto";
@@ -216,6 +219,10 @@ export async function installCompaction(pi, options = {}) {
         } });
     // Pi's native start/settled events bracket the run and its post-turn cuts.
     let admittedRun = false;
+    let runPrompt;
+    const protectedPrompt = (ctx) => runPrompt ? ctx.sessionManager.getBranch().findLast(entry => entry.type === "message" && entry.message.role === "user" && textOf(entry.message.content).includes(runPrompt))?.id : undefined;
+    const promptRefusal = () => new Refusal("Prompt check failed: the whole starting prompt cannot fit after cutting to the band and room, shrinking the summary and clipping fresh results. Shorten the prompt or choose a model with a larger context window, then retry");
+    let estimatedTokens = 0;
     // One serial request, one accounting identity; observations never certify new content. A new identity (the first request after a session
     // start, or a model switch) starts with the window its branch's newest receipt recorded for that identity, else that receipt's factor, else the model's measured undercount or 1 (`seedWindow`).
     let identity = "", factor = 1, ratios = [];
@@ -235,6 +242,10 @@ export async function installCompaction(pi, options = {}) {
     const learn = (value) => { ratios.push(value); if (ratios.length > CALIBRATION_WINDOW)
         ratios.shift(); factor = Math.max(1, ...ratios); };
     const corrected = (tokens, ctx) => { identityFor(ctx); return Math.ceil(tokens * factor); };
+    const observeBudget = (rawTokens, ctx) => {
+        if (options.observeBudget)
+            options.observeBudget({ rawTokens, tokens: corrected(rawTokens, ctx), factor, ...limits(ctx), context: ctx });
+    };
     // The cut planner's raw reserve for the target limit, on the same factor as every other consumer.
     const planReserve = (target, room, band, mandatory, ctx) => {
         identityFor(ctx);
@@ -287,7 +298,7 @@ export async function installCompaction(pi, options = {}) {
             learn(ratio);
     });
     pi.on("agent_start", () => { admittedRun = true; pending = undefined; phase = "idle"; });
-    pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetFailure(); clips.clear(); promptCut = undefined; });
+    pi.on("agent_settled", () => { admittedRun = false; runPrompt = undefined; pending = undefined; phase = "idle"; forgetFailure(); clips.clear(); promptCut = undefined; });
     const active = () => options.active?.() ?? true;
     const settingsFor = () => options.settings ?? SettingsManager.inMemory(pi.getSettings());
     // The one reserve decision; every consumer takes its room from limits. Standalone starts at Pi's native cut point. Once a reply did
@@ -311,10 +322,12 @@ export async function installCompaction(pi, options = {}) {
             throw new Error("Invalid active-input token ceiling");
         return Math.min((ctx.model?.contextWindow ?? 0) - response, ceiling ?? Infinity);
     };
-    // Every throw, fault and complete-context guard uses the exact room.
+    // 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);
-        return { response, room };
+        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 decisionBand = (ctx, room, system) => {
         const last = ctx.sessionManager.getBranch().findLast(entry => entry.type === "compaction");
@@ -349,12 +362,22 @@ export async function installCompaction(pi, options = {}) {
     // Where the branch ended when the prompt's cut was planned: the prompt is the entry Pi appends there. A cut that keeps nothing of the conversation
     // before it names no entry to keep from, and read as it stands that drops the prompt too, so the model never sees it.
     let promptCutAt = 0;
-    const keptFrom = (cut, ctx) => cut.firstKeptEntryId || ctx.sessionManager.getBranch()[promptCutAt]?.id || "";
+    const keptFrom = (cut, ctx) => cut.firstKeptEntryId ||
+        ctx.sessionManager.getBranch().slice(promptCutAt).find(entry => entry.type !== "custom" || entry.customType !== "pi-tuck-capacity")?.id || "";
     let failure;
+    let refusalReceipted = false;
     let pendingBoundaryCommit = false;
     // Fresh tool results the room cannot hold, by call id: each request of the run carries the clip in their place; the session keeps them
     // whole. A clip ends with its run like any failure would: the next run plans from the session as it is, where the result is no longer fresh.
     const clips = new Map();
+    const receipt = (kind, reason, ctx) => {
+        let room = null, hardLine = null;
+        try {
+            ({ room, hardLine } = limits(ctx));
+        }
+        catch { /* Invalid configuration has no usable capacity. Preserve its original failure. */ }
+        pi.appendEntry("pi-tuck-capacity", { kind, reason, estimatedTokens, room, hardLine, buildId: BUILD_ID });
+    };
     const fail = (error, ctx) => {
         recorder.stop("native-attempt-failed");
         // Every refusal says why, once per attempt: a capacity error with what the user can change, a cut Pi failed to commit with what that
@@ -367,6 +390,10 @@ export async function installCompaction(pi, options = {}) {
         pending = undefined;
         promptCut = undefined;
         try {
+            if (!refusalReceipted) {
+                refusalReceipted = true;
+                receipt("refusal", failure.message, ctx);
+            }
             options.fail?.(error);
         }
         finally {
@@ -383,7 +410,7 @@ export async function installCompaction(pi, options = {}) {
     };
     // The one place a failure is dropped: when its attempt has settled, when a prompt arrives, and when the operator asks for a cut. A run that no
     // input started (a custom message) has only the first of these. No failure but a CommitFault outlives its attempt.
-    const forgetFailure = () => { if (!(failure instanceof CommitFault))
+    const forgetFailure = () => { refusalReceipted = false; if (!(failure instanceof CommitFault))
         failure = undefined; };
     const access = () => {
         if (failure)
@@ -497,6 +524,7 @@ export async function installCompaction(pi, options = {}) {
             const system = requestSystemPart(ctx.getSystemPrompt(), pi.getActiveTools(), saved, ctx.getSystemPrompt());
             const mandatory = system + host, band = decisionBand(ctx, room, system);
             const before = plannerMeasureFor(ctx)(saved);
+            observeBudget(before + mandatory, ctx);
             // Pi's own usage threshold (reason "threshold") counts the last reply's output tokens, reasoning included, plus the messages after
             // it: a basis this compactor does not plan on. It may ask for a cut on a request that fits. This compactor cuts only where its own
             // trigger would: nothing below the band, an opportunistic cut inside it, a due cut at or above the room. A refusal is a plain
@@ -509,19 +537,27 @@ export async function installCompaction(pi, options = {}) {
                 thresholdOpportunistic = gate.opportunistic;
             }
             // Pi checks old history before appending a new idle prompt. During an active run/manual cut the latest admitted input stays protected.
-            const decision = chooseCut({
-                before, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined,
+            const decide = (targetRoom = room, targetBand = band) => chooseCut({
+                before, mandatory, room: targetRoom, band: targetBand, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined,
                 opportunistic: thresholdOpportunistic,
                 unreduced: "Compaction did not reduce context within the estimated request budget",
                 plan: (target) => {
-                    const reserve = planReserve(target, room, band, mandatory, ctx);
+                    const reserve = planReserve(target, targetRoom, targetBand, mandatory, ctx);
                     // Every cut asked while no run is admitted (an operator's cut) is planned for a run that has not begun: the session has moved on
                     // from any run that ended. A retry is inside its run.
-                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual, operatorManual || !admittedRun);
+                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual, operatorManual || !admittedRun, admittedRun ? protectedPrompt(ctx) : undefined);
                     return draft.compaction ? { draft: true, after: draft.after, mode: draft.mode, compaction: draft.compaction, reserve }
                         : { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
                 },
             });
+            estimatedTokens = corrected(before + mandatory, ctx);
+            let decision = decide();
+            const { hardLine } = limits(ctx);
+            if (!operatorManual && hardLine > room && decision.kind === "fault") {
+                if (fits(before + mandatory, hardLine, ctx))
+                    return { cancel: true };
+                decision = decide(hardLine, hardLine);
+            }
             if (decision.kind === "cut") {
                 return { compaction: captureDraft(decision.plan.compaction, ctx, decision.plan.reserve, event.reason, event.preparation.tokensBefore, retain, operatorManual, event.preparation.previousSummary, { response, host, mandatory, target: decision.target, margin: room - band }) };
             }
@@ -530,6 +566,8 @@ export async function installCompaction(pi, options = {}) {
                 return { cancel: true };
             recorder.stop("no-cut");
             ctx.ui.notify(decision.message, "warning");
+            if (operatorManual)
+                receipt("refusal", decision.message, ctx);
             if (!operatorManual)
                 fail(new (decision.capacity ? CapacityError : Refusal)(decision.message), ctx);
             return { cancel: true };
@@ -544,7 +582,7 @@ export async function installCompaction(pi, options = {}) {
         }
     });
     pi.on("session_before_tree", (event) => event.preparation.userWantsSummary ? { cancel: true } : undefined);
-    pi.on("session_start", () => { clips.clear(); promptCut = undefined; recorder.stop("session-transition"); proposalId = undefined; failure = undefined; admittedRun = false; pendingBoundaryCommit = false; identity = ""; factor = 1; pending = undefined; phase = "idle"; });
+    pi.on("session_start", () => { clips.clear(); promptCut = undefined; recorder.stop("session-transition"); proposalId = undefined; failure = undefined; refusalReceipted = false; admittedRun = false; runPrompt = undefined; estimatedTokens = 0; pendingBoundaryCommit = false; identity = ""; factor = 1; pending = undefined; phase = "idle"; });
     const historyToolsEnabled = (ctx) => Boolean(promptCut) || hasTuckCut(ctx.sessionManager.getBranch());
     const syncHistoryTools = (ctx) => { if (active())
         applyHistoryTools(pi, historyToolsEnabled(ctx)); };
@@ -585,22 +623,24 @@ export async function installCompaction(pi, options = {}) {
         const band = decisionBand(ctx, room, system);
         const host = hostSnapshot ?? hostTokens(ctx), measure = measureFor(ctx), before = measure(saved);
         const incoming = incomingPart + system, mandatory = incoming + host;
-        if (!fits(incoming, room, ctx))
+        observeBudget(before + mandatory, ctx);
+        estimatedTokens = corrected(before + mandatory, ctx);
+        if (!fits(incoming, limits(ctx).hardLine, ctx))
             throw new CapacityError("Incoming Pi prompt and response reserve cannot fit the estimated request budget");
         // A cut removes only conversation. If the mandatory request, host input included, does not fit by itself, no cut can
         // help: leave it to the complete-context guard, which fails closed.
         const gate = gateCut({ total: before + mandatory, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx) });
-        if (gate.kind !== "plan")
+        if (gate.kind === "none")
             return;
         const previousSummary = saved.find(message => message.role === "compactionSummary")?.summary;
-        const decision = chooseCut({
-            before, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined, opportunistic: gate.opportunistic,
+        const decide = (targetRoom, targetBand, opportunistic) => chooseCut({
+            before, mandatory, room: targetRoom, band: targetBand, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined, opportunistic,
             unreduced: "Incoming prompt compaction did not reduce context within the estimated request budget",
             plan: (target) => {
-                const reserve = planReserve(target, room, band, mandatory, ctx);
+                const reserve = planReserve(target, targetRoom, targetBand, mandatory, ctx);
                 // Only a due cut re-renders a summary that sits alone in the session: inside the band a cut is opportunistic, and a smaller summary
                 // there buys nothing the request needed and costs history the next recall would have found.
-                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary, newPrompt: true, reRenderSummary: !gate.opportunistic }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, false);
+                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary, newPrompt: true, reRenderSummary: !opportunistic }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, false);
                 if (!draft.compaction)
                     return { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
                 const messages = withCut(ctx, { type: "compaction", ...draft.compaction, tokensBefore: before });
@@ -608,6 +648,15 @@ export async function installCompaction(pi, options = {}) {
                 return { draft: true, after: measure(messages), mode: draft.mode, compaction: draft.compaction, reserve };
             },
         });
+        let decision = gate.kind === "plan" ? decide(room, band, gate.opportunistic) : { kind: "defer" };
+        const { hardLine } = limits(ctx);
+        if (hardLine > room && (decision.kind === "defer" || decision.kind === "fault")) {
+            if (fits(before + mandatory, hardLine, ctx))
+                return;
+            decision = fits(mandatory, hardLine, ctx) ? decide(hardLine, hardLine, false) : { kind: "defer" };
+        }
+        if (decision.kind === "defer")
+            return;
         // An opportunistic cut inside the band that cannot reach it is no fault: the request goes to the guard.
         if (decision.kind === "none")
             return;
@@ -619,6 +668,7 @@ export async function installCompaction(pi, options = {}) {
     pi.on("before_agent_start", async (event, ctx) => {
         const prompted = phase === "decided";
         phase = "starting";
+        runPrompt = event.messageType === "custom" ? undefined : event.prompt;
         try {
             syncHistoryTools(ctx);
             if (prompted)
@@ -706,20 +756,25 @@ export async function installCompaction(pi, options = {}) {
         // request besides the fresh results. Reset per decision, so a retry sizes itself against the cut it is retrying, not an earlier attempt's.
         let previews = [];
         let floorKept;
-        const decide = () => {
+        let wholePromptFloor;
+        const protectedId = reason === "tool-loop" ? protectedPrompt(ctx) : undefined;
+        const decide = (targetRoom = room, targetBand = band) => {
             previews = [];
             floorKept = undefined;
+            wholePromptFloor = undefined;
             const before = measure(saved);
-            const gate = gateCut({ total: before + mandatory, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx) });
+            const gate = gateCut({ total: before + mandatory, mandatory, room: targetRoom, band: targetBand, fits: (tokens, limit) => fits(tokens, limit, ctx) });
             if (gate.kind !== "plan")
                 return gate;
             return chooseCut({
-                opportunistic: gate.opportunistic, mandatory, before, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined,
+                opportunistic: gate.opportunistic, mandatory, before, room: targetRoom, band: targetBand, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined,
                 unreduced: "Tool-loop preflight compaction did not reduce context within the estimated request budget",
                 plan: (target) => {
-                    const reserve = planReserve(target, room, band, mandatory, ctx);
-                    const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: densityTokens ?? before, previousSummary }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, true);
+                    const reserve = planReserve(target, targetRoom, targetBand, mandatory, ctx);
+                    const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: densityTokens ?? before, previousSummary, protectedPromptEntryId: protectedId }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, true);
                     if (!draft.compaction) {
+                        if (protectedId && draft.floorMessages)
+                            wholePromptFloor = measure(draft.floorMessages) + mandatory;
                         // The planner's own floor, so a clip's second budget is measured against what the smallest cut really keeps.
                         if (draft.floorMessages && event.toolResults) {
                             const fresh = new Set(event.toolResults.map(result => result.toolCallId));
@@ -747,18 +802,20 @@ export async function installCompaction(pi, options = {}) {
         // clipBudgets states the budgets tried and why they are counted in the estimate's units; `kept` is measured from the previews this decision
         // built, so the second budget is the cut's own floor and not a new formula. When nothing is clipped or the decision still faults, the
         // refusal stands.
-        if (decision.kind === "fault" && event.toolResults) {
+        const tryClips = (clipRoom, targetBand) => {
+            if (decision.kind !== "fault" || !event.toolResults)
+                return;
             const branch = ctx.sessionManager.getBranch();
             const entryIdOf = (toolCallId) => branch.findLast(entry => entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolCallId === toolCallId)?.id;
             const fresh = new Set(event.toolResults.map(result => result.toolCallId));
             const kept = previews.length ? Math.max(...previews.map(preview => measure(preview.filter(message => !(message.role === "toolResult" && fresh.has(message.toolCallId)))))) : floorKept;
-            for (const budget of clipBudgets(room, factor, mandatory, kept)) {
+            for (const budget of clipBudgets(clipRoom, factor, mandatory, kept)) {
                 const round = clipFor(event.toolResults, entryIdOf, budget);
                 if (!round.length)
                     continue;
                 for (const clip of round)
                     clips.set(clip.toolCallId, clip);
-                const clippedDecision = decide();
+                const clippedDecision = decide(clipRoom, targetBand);
                 if (clippedDecision.kind === "fault")
                     for (const clip of round)
                         clips.delete(clip.toolCallId);
@@ -767,10 +824,23 @@ export async function installCompaction(pi, options = {}) {
                     break;
                 }
             }
-        }
+        };
+        tryClips(room, band);
         const before = measure(saved);
-        if (decision.kind === "fault" && reason === "tool-loop")
+        observeBudget(before + mandatory, ctx);
+        estimatedTokens = corrected(before + mandatory, ctx);
+        const { hardLine } = limits(ctx);
+        if (hardLine > room && (decision.kind === "defer" || decision.kind === "fault")) {
+            if (fits(before + mandatory, hardLine, ctx))
+                return;
+            decision = decide(hardLine, hardLine);
+            tryClips(hardLine, hardLine);
+        }
+        if (decision.kind === "fault" && reason === "tool-loop") {
+            if (wholePromptFloor !== undefined && !fits(wholePromptFloor, hardLine, ctx))
+                throw promptRefusal();
             throw new (decision.capacity ? CapacityError : Refusal)(decision.message);
+        }
         if (decision.kind !== "cut")
             return;
         const compaction = captureDraft(decision.plan.compaction, ctx, decision.plan.reserve, reason, before, true, false, previousSummary, { response, host, mandatory, target: decision.target, margin: room - band });
@@ -905,8 +975,15 @@ export async function installCompaction(pi, options = {}) {
             const messages = historyToolsEnabled(ctx) ? historyToolDeclarations(event.messages, toolShapes(pi.getActiveTools()), true) : event.messages;
             const system = requestSystemPart(ctx.getSystemPrompt(), pi.getActiveTools(), messages, ctx.getSystemPrompt());
             const tokens = system + conversationTokens(messages);
-            if (!fits(tokens, limits(ctx).room, ctx))
+            observeBudget(tokens, ctx);
+            estimatedTokens = corrected(tokens, ctx);
+            const { room, hardLine } = 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");
+            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/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 = "27846aedbe111110535eeed5998c572182cd15de0efede0fe4df1571166a838e";
+export declare const DIAGNOSTIC_BUILD = "37e955d83a1e9237381f09fad8cd2aad1f2c6489ddbe51c58af227dbb46ddf3c";
 export interface Receipt {
     id: string;
     build: string;

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

@@ -0,0 +1,6 @@
+import type { SessionEntry } from '@earendil-works/pi-coding-agent';
+import type { Messages } from './budget.js';
+/** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
+export declare function branchReplyFloor(branch: readonly SessionEntry[], reserve: 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

@@ -0,0 +1,32 @@
+import { isContextOverflow } from '@earendil-works/pi-ai';
+import { parseRecords, splitSummary } from './tuck/core/transcript.js';
+/** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
+export function branchReplyFloor(branch, reserve) {
+    let largest = 4_096;
+    for (const entry of branch) {
+        if (entry.type !== 'message' || entry.message.role !== 'assistant')
+            continue;
+        const message = entry.message;
+        if (message.stopReason === 'length' || message.stopReason === 'error' && isContextOverflow(message))
+            return reserve;
+        const output = message.usage?.output;
+        if (typeof output === 'number' && Number.isFinite(output) && output > largest)
+            largest = output;
+    }
+    return Math.min(reserve, Math.ceil(largest));
+}
+/** 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)
+        return true;
+    return messages.some(message => {
+        if (message.role === 'user') {
+            const text = typeof message.content === 'string' ? message.content : message.content.flatMap(block => block.type === 'text' ? [block.text] : []).join('\n');
+            return text.includes(prompt);
+        }
+        if (message.role !== 'compactionSummary')
+            return false;
+        const split = splitSummary(message.summary);
+        return split !== null && split !== undefined && parseRecords(split.body, split.version).some(record => record.kind === 'excerpt' && record.role === 'user' && record.text.includes(prompt));
+    });
+}

package/dist/src/tuck.d.ts

@@ -74,7 +74,7 @@ export interface Tuck {
 import { compileDialogue } from "./tuck/core/summarize.js";
 export declare const tuck: Tuck;
 /** Uses pi-tuck's own cut, calibrated maximum tail and dialogue compiler; Pi owns persistence and continuation. */
-export declare function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean, operatorManual?: boolean, newPrompt?: boolean): Draft;
+export declare function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean, operatorManual?: boolean, newPrompt?: boolean, protectedPromptEntryId?: string): Draft;
 /** Shared compiler observes canonical branch and current token estimate; no native preparation utility. */
 /** `newPrompt`: the cut is planned for a run that has not begun (a prompt Pi has not appended yet, an operator's manual cut, Pi's own cut before
  * a run a custom message starts); the session has moved on from an ended run.
@@ -86,6 +86,7 @@ export declare function tuckObservedDraft(tuck: Tuck, input: {
     operatorManual?: boolean;
     newPrompt?: boolean;
     reRenderSummary?: boolean;
+    protectedPromptEntryId?: string;
 }, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy?: RecallPolicy, retainCurrentInput?: boolean): Draft;
 /** Numeric references use the original session index, then intersect with readable current-branch entries. */
 export declare function tuckRecall(tuck: Tuck, entries: readonly SessionEntry[], branch: readonly SessionEntry[], input: RecallOptions & {

package/dist/src/tuck.js

@@ -19,8 +19,8 @@ import { prepareKeywordQuery } from "./tuck/core/keyword-query.js";
 import { searchEntriesDetailed } from "./tuck/core/search-entries.js";
 export const tuck = { buildOwnCut, applyTailBudget, calibrateCharsPerToken, buildGlobalIndexById, compileDialogue, prepareKeywordQuery, searchEntriesDetailed };
 /** Uses pi-tuck's own cut, calibrated maximum tail and dialogue compiler; Pi owns persistence and continuation. */
-export function tuckDraft(tuck, event, ctx, reserveTokens, measure, policy = {}, retainCurrentInput = true, operatorManual = false, newPrompt = false) {
-    return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual, newPrompt }, ctx, reserveTokens, measure, policy, retainCurrentInput);
+export function tuckDraft(tuck, event, ctx, reserveTokens, measure, policy = {}, retainCurrentInput = true, operatorManual = false, newPrompt = false, protectedPromptEntryId) {
+    return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual, newPrompt, protectedPromptEntryId }, ctx, reserveTokens, measure, policy, retainCurrentInput);
 }
 /** Shared compiler observes canonical branch and current token estimate; no native preparation utility. */
 /** `newPrompt`: the cut is planned for a run that has not begun (a prompt Pi has not appended yet, an operator's manual cut, Pi's own cut before
@@ -115,6 +115,9 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
     const current = entries[userPosition];
     const userContent = current?.type === "message" && current.message.role === "user" ? current.message.content : undefined;
     const textOnly = isTextOnly(userContent);
+    // Steering can become the latest user source while the run still owns its original prompt.
+    const startingPosition = entries.findIndex(entry => entry.id === input.protectedPromptEntryId && entry.type === "message" && entry.message.role === "user");
+    const starting = entries[startingPosition];
     // Anchor the actual first source only; a native omission never promotes a later prompt.
     const firstUser = branch.find(entry => entry.type === "message" && entry.message.role === "user");
     const firstUserPosition = entries.findIndex(entry => entry.id === firstUser?.id && entry.type === "message");
@@ -277,8 +280,10 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
             };
             if (userPosition >= 0 && userPosition < boundary && textOnly)
                 add(current, Infinity);
+            if (startingPosition >= 0 && startingPosition < boundary && starting?.id !== current?.id)
+                add(starting, Infinity);
             for (const entry of anchors)
-                if (entry.id !== current?.id && positions.get(entry.id) < boundary)
+                if (entry.id !== current?.id && entry.id !== starting?.id && positions.get(entry.id) < boundary)
                     add(entry, length);
             const omissions = [];
             for (const role of ["user", "assistant", "toolResult"]) {

package/index.ts

@@ -1,10 +1,10 @@
 import { VERSION, getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { readFileSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { join, sep } from "node:path";
 import { installCompaction } from "./src/compaction";
 import { validCutAt } from "./src/budget";
 import { createSemanticRecall } from "./src/semantic-recall";
-import { defaultRoot } from "./src/assets";
+import { defaultRoot, runtimeConfigPath } from "./src/assets";
 import { ensureSemanticRuntime } from "./src/setup";
 
 export type { CompactionOptions } from "./src/compaction";
@@ -49,12 +49,19 @@ export default async function (pi: ExtensionAPI) {
 	if (settings.semanticRecall === false) return;
 	let session = 0, said = "", setup: Promise<unknown> | undefined, announced = false;
 	// A context outlives its session (a setup can finish after /new); a notice to an ended session is dropped.
-	const say = (ctx: ExtensionContext, message: string, level: "info" | "warning") => { try { ctx.ui.notify(message, level); } catch { /* ended */ } };
+	// With no UI (pi -p), Pi shows no notices, so a settings error or an off or failing semantic recall would go unsaid: write each to stderr
+	// instead, once per session. stderr is the operator's; it never enters the model's context.
+	const stderrSaid = new Set<string>();
+	const say = (ctx: ExtensionContext, message: string, level: "info" | "warning") => {
+		if (!ctx.hasUI) { if (!stderrSaid.has(message)) { stderrSaid.add(message); try { process.stderr.write(message + "\n"); } catch { /* closed */ } } return; }
+		try { ctx.ui.notify(message, level); } catch { /* ended */ }
+	};
 	const once = (ctx: ExtensionContext, message: string, level: "info" | "warning") => { if (said !== message) { said = message; say(ctx, message, level); } };
 	pi.on("session_shutdown", () => { session++; });
 	pi.on("session_start", (_event, ctx) => {
 		const current = ++session;
 		off = false;
+		stderrSaid.clear();
 		if (settings.error) once(ctx, `pi-tuck: ${settings.error}; using the defaults.`, "warning");
 		if (!appleSilicon)
 			return once(ctx, "pi-tuck: semantic recall needs macOS on Apple silicon; compaction and word recall work.", "info");
@@ -62,8 +69,15 @@ export default async function (pi: ExtensionAPI) {
 		// agent folder, such as the home folder.
 		if (within(real(getAgentDir()), real(ctx.cwd)))
 			return once(ctx, "pi-tuck: semantic recall is off here because Pi's agent folder is inside this folder; open Pi in a project folder to use it.", "info");
-		if (!ctx.hasUI) return; // a one-shot run (pi -p) would end before a first-time setup could
-		if (!semanticRecall.status().configured) semanticRecall.refuse("Semantic recall is being set up; word recall works meanwhile");
+		// A run with no UI (pi -p, RPC, JSON) uses a runtime that is already installed: that needs no download. It does not start a first-time
+		// setup, which would outlast a one-shot run, and it says why, so tuck_search and /tuck name the real state.
+		const installed = existsSync(runtimeConfigPath(defaultRoot()));
+		if (!ctx.hasUI && !installed) {
+			semanticRecall.refuse("Semantic recall is not set up yet; start Pi once in an interactive session to set it up. Word recall works meanwhile");
+			return say(ctx, "pi-tuck: semantic recall is not set up yet; start Pi once in an interactive session to set it up. Word recall works.", "warning");
+		}
+		if (!semanticRecall.status().configured)
+			semanticRecall.refuse(installed ? "Semantic recall is starting; word recall works meanwhile" : "Semantic recall is being set up; word recall works meanwhile");
 		setup ??= ensureSemanticRuntime(defaultRoot(), message => { announced = true; say(ctx, message, "info"); });
 		setup.then(async () => {
 			if (current !== session || off) return;

package/package.json

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

package/src/compaction.ts

@@ -1,3 +1,6 @@
+import { textOf } from "./tuck/core/content.js";
+import { branchReplyFloor, carriesPrompt } 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";
 import { createHash } from "node:crypto";
@@ -102,15 +105,18 @@ export interface CompactionOptions {
  onSemanticSetting?: (enabled: boolean) => Promise<unknown>;
  semanticStatus?: () => unknown;
  diagnostics?: RecorderOptions;
+ /** Optional read-only observation of actual corrected budget checks; no request content. */
+ observeBudget?: (measurement: { rawTokens: number; tokens: number; factor: number; response: number; room: number; hardLine?: number; context: ExtensionContext }) => void;
 	/** Optional estimated complete-input ceiling, separate from physical output reservation.
 	 * The host owns final serialization/transport counting; this is not an exact wire-token cap. */
 	activeInputTokens?: number | ((ctx: ExtensionContext) => number);
 	/** An explicit cut point: a fraction of the input room, above 0 and at most 1. A cut is triggered at, and preferably planned to, the band,
-	 * which is the room less 2% of it, or this fraction of the room when that is lower; a lower value cuts earlier and leaves less. The exact room
-	 * stays the limit of every throw, fault and the complete-context guard. If omitted, the band adapts to the last cut. */
+	 * which is the room less 2% of it, or this fraction of the room when that is lower; a lower value cuts earlier and leaves less. The room
+	 * 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 uses Pi's reserveTokens until a length stop or a context-overflow refusal on the current branch, then also holds the catalogue maximum.
+	 * Standalone cuts against Pi's reserveTokens, then admits up to the window less max(8192, 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 };
 	/** The exact messages the host's `context` hook adds to every final request beyond the saved conversation (for example a role
@@ -208,6 +214,11 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     } });
     // Pi's native start/settled events bracket the run and its post-turn cuts.
     let admittedRun = false;
+    let runPrompt: string | undefined;
+    const protectedPrompt = (ctx: ExtensionContext) => runPrompt ? ctx.sessionManager.getBranch().findLast(entry =>
+        entry.type === "message" && entry.message.role === "user" && textOf(entry.message.content).includes(runPrompt!))?.id : undefined;
+    const promptRefusal = () => new Refusal("Prompt check failed: the whole starting prompt cannot fit after cutting to the band and room, shrinking the summary and clipping fresh results. Shorten the prompt or choose a model with a larger context window, then retry");
+    let estimatedTokens = 0;
     // One serial request, one accounting identity; observations never certify new content. A new identity (the first request after a session
     // start, or a model switch) starts with the window its branch's newest receipt recorded for that identity, else that receipt's factor, else the model's measured undercount or 1 (`seedWindow`).
     let identity = "", factor = 1, ratios: number[] = [];
@@ -221,6 +232,9 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     // The factor is max(1, the last CALIBRATION_WINDOW paired ratios, overflow bounds and seed): it rises at once and a stale high ratio ages out.
     const learn = (value: number) => { ratios.push(value); if (ratios.length > CALIBRATION_WINDOW) ratios.shift(); factor = Math.max(1, ...ratios); };
     const corrected = (tokens: number, ctx: ExtensionContext) => { identityFor(ctx); return Math.ceil(tokens * factor); };
+    const observeBudget = (rawTokens: number, ctx: ExtensionContext) => {
+        if (options.observeBudget) options.observeBudget({ rawTokens, tokens: corrected(rawTokens, ctx), factor, ...limits(ctx), context: ctx });
+    };
     // The cut planner's raw reserve for the target limit, on the same factor as every other consumer.
     const planReserve = (target: Target, room: number, band: number, mandatory: number, ctx: ExtensionContext) => {
         identityFor(ctx);
@@ -263,7 +277,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         if (input > 0 && input <= ctx.model.contextWindow && Number.isSafeInteger(input) && Number.isFinite(ratio)) learn(ratio);
     });
     pi.on("agent_start", () => { admittedRun = true; pending = undefined; phase = "idle"; });
-    pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetFailure(); clips.clear(); promptCut = undefined; });
+    pi.on("agent_settled", () => { admittedRun = false; runPrompt = undefined; pending = undefined; phase = "idle"; forgetFailure(); clips.clear(); promptCut = undefined; });
 	const active = () => options.active?.() ?? true;
 	const settingsFor = () => options.settings ?? SettingsManager.inMemory(pi.getSettings());
 	// The one reserve decision; every consumer takes its room from limits. Standalone starts at Pi's native cut point. Once a reply did
@@ -288,10 +302,12 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             throw new Error("Invalid active-input token ceiling");
         return Math.min((ctx.model?.contextWindow ?? 0) - response, ceiling ?? Infinity);
     };
-    // Every throw, fault and complete-context guard uses the exact room.
+    // 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);
-        return { response, room };
+        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 decisionBand = (ctx: ExtensionContext, room: number, system: number) => {
         const last = ctx.sessionManager.getBranch().findLast(entry => entry.type === "compaction");
@@ -331,12 +347,19 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     // Where the branch ended when the prompt's cut was planned: the prompt is the entry Pi appends there. A cut that keeps nothing of the conversation
     // before it names no entry to keep from, and read as it stands that drops the prompt too, so the model never sees it.
     let promptCutAt = 0;
-    const keptFrom = (cut: CutEntry, ctx: ExtensionContext) => cut.firstKeptEntryId || ctx.sessionManager.getBranch()[promptCutAt]?.id || "";
+    const keptFrom = (cut: CutEntry, ctx: ExtensionContext) => cut.firstKeptEntryId ||
+        ctx.sessionManager.getBranch().slice(promptCutAt).find(entry => entry.type !== "custom" || entry.customType !== "pi-tuck-capacity")?.id || "";
     let failure: Error | undefined;
+    let refusalReceipted = false;
     let pendingBoundaryCommit = false;
     // Fresh tool results the room cannot hold, by call id: each request of the run carries the clip in their place; the session keeps them
     // whole. A clip ends with its run like any failure would: the next run plans from the session as it is, where the result is no longer fresh.
     const clips = new Map<string, Clip>();
+    const receipt = (kind: "refusal" | "above-room", reason: string, ctx: ExtensionContext) => {
+        let room: number | null = null, hardLine: number | null = null;
+        try { ({ room, hardLine } = limits(ctx)); } catch { /* Invalid configuration has no usable capacity. Preserve its original failure. */ }
+        pi.appendEntry("pi-tuck-capacity", { kind, reason, estimatedTokens, room, hardLine, buildId: BUILD_ID });
+    };
 	const fail = (error: unknown, ctx: ExtensionContext) => {
 		recorder.stop("native-attempt-failed");
         // Every refusal says why, once per attempt: a capacity error with what the user can change, a cut Pi failed to commit with what that
@@ -347,7 +370,10 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         pendingBoundaryCommit = false;
         pending = undefined;
         promptCut = undefined;
-		try { options.fail?.(error); } finally {
+		try {
+            if (!refusalReceipted) { refusalReceipted = true; receipt("refusal", failure.message, ctx); }
+            options.fail?.(error);
+        } finally {
             try { if (notify) ctx.ui.notify(failure instanceof CapacityError ? refusalNotice(failure.message, factor) : failure instanceof CommitFault
                 ? `pi-tuck: ${failure.message}; the session holds a cut its file may lack, so start a new session.`
                 : `pi-tuck could not plan this request (${failure.message}); the next prompt is planned afresh.`, "error"); }
@@ -356,7 +382,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 	};
 	// The one place a failure is dropped: when its attempt has settled, when a prompt arrives, and when the operator asks for a cut. A run that no
 	// input started (a custom message) has only the first of these. No failure but a CommitFault outlives its attempt.
-	const forgetFailure = () => { if (!(failure instanceof CommitFault)) failure = undefined; };
+	const forgetFailure = () => { refusalReceipted = false; if (!(failure instanceof CommitFault)) failure = undefined; };
 	const access = () => {
 		if (failure) throw failure;
 		hostAccess();
@@ -444,6 +470,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             const system = requestSystemPart(ctx.getSystemPrompt(), pi.getActiveTools(), saved, ctx.getSystemPrompt());
             const mandatory = system + host, band = decisionBand(ctx, room, system);
             const before = plannerMeasureFor(ctx)(saved);
+            observeBudget(before + mandatory, ctx);
             // Pi's own usage threshold (reason "threshold") counts the last reply's output tokens, reasoning included, plus the messages after
             // it: a basis this compactor does not plan on. It may ask for a cut on a request that fits. This compactor cuts only where its own
             // trigger would: nothing below the band, an opportunistic cut inside it, a due cut at or above the room. A refusal is a plain
@@ -455,25 +482,33 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
                 thresholdOpportunistic = gate.opportunistic;
             }
             // Pi checks old history before appending a new idle prompt. During an active run/manual cut the latest admitted input stays protected.
-            const decision = chooseCut({
-                before, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined,
+            const decide = (targetRoom = room, targetBand = band) => chooseCut({
+                before, mandatory, room: targetRoom, band: targetBand, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined,
                 opportunistic: thresholdOpportunistic,
                 unreduced: "Compaction did not reduce context within the estimated request budget",
                 plan: (target): Plan<{ compaction: NonNullable<ReturnType<typeof tuckDraft>["compaction"]>; reserve: number }> => {
-                    const reserve = planReserve(target, room, band, mandatory, ctx);
+                    const reserve = planReserve(target, targetRoom, targetBand, mandatory, ctx);
                     // Every cut asked while no run is admitted (an operator's cut) is planned for a run that has not begun: the session has moved on
                     // from any run that ended. A retry is inside its run.
-                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual, operatorManual || !admittedRun);
+                    const draft = tuckDraft(tuck, event, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, retain, operatorManual, operatorManual || !admittedRun, admittedRun ? protectedPrompt(ctx) : undefined);
                     return draft.compaction ? { draft: true, after: draft.after, mode: draft.mode, compaction: draft.compaction, reserve }
                         : { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
                 },
             });
+            estimatedTokens = corrected(before + mandatory, ctx);
+            let decision = decide();
+            const { hardLine } = limits(ctx);
+            if (!operatorManual && hardLine > room && decision.kind === "fault") {
+                if (fits(before + mandatory, hardLine, ctx)) return { cancel: true };
+                decision = decide(hardLine, hardLine);
+            }
             if (decision.kind === "cut") { return { compaction: captureDraft(decision.plan.compaction, ctx, decision.plan.reserve, event.reason, event.preparation.tokensBefore,
                 retain, operatorManual, event.preparation.previousSummary, { response, host, mandatory, target: decision.target, margin: room - band }) }; }
             // An opportunistic cut inside the band that cannot reach it is no fault: the request goes to the guard.
             if (decision.kind === "none") return { cancel: true };
 			recorder.stop("no-cut");
             ctx.ui.notify(decision.message, "warning");
+            if (operatorManual) receipt("refusal", decision.message, ctx);
 			if (!operatorManual) fail(new (decision.capacity ? CapacityError : Refusal)(decision.message), ctx);
 			return { cancel: true };
 		} catch (error) {
@@ -481,7 +516,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
 		}
 	});
 	pi.on("session_before_tree", (event) => event.preparation.userWantsSummary ? { cancel: true } : undefined);
-    pi.on("session_start", () => { clips.clear(); promptCut = undefined; recorder.stop("session-transition"); proposalId = undefined; failure = undefined; admittedRun = false; pendingBoundaryCommit = false; identity = ""; factor = 1; pending = undefined; phase = "idle"; });
+    pi.on("session_start", () => { clips.clear(); promptCut = undefined; recorder.stop("session-transition"); proposalId = undefined; failure = undefined; refusalReceipted = false; admittedRun = false; runPrompt = undefined; estimatedTokens = 0; pendingBoundaryCommit = false; identity = ""; factor = 1; pending = undefined; phase = "idle"; });
     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));
@@ -516,27 +551,36 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         const band = decisionBand(ctx, room, system);
         const host = hostSnapshot ?? hostTokens(ctx), measure = measureFor(ctx), before = measure(saved);
         const incoming = incomingPart + system, mandatory = incoming + host;
-        if (!fits(incoming, room, ctx))
+        observeBudget(before + mandatory, ctx);
+        estimatedTokens = corrected(before + mandatory, ctx);
+        if (!fits(incoming, limits(ctx).hardLine, ctx))
             throw new CapacityError("Incoming Pi prompt and response reserve cannot fit the estimated request budget");
         // A cut removes only conversation. If the mandatory request, host input included, does not fit by itself, no cut can
         // help: leave it to the complete-context guard, which fails closed.
         const gate = gateCut({ total: before + mandatory, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx) });
-        if (gate.kind !== "plan") return;
+        if (gate.kind === "none") return;
         const previousSummary = saved.find(message => message.role === "compactionSummary")?.summary;
-        const decision = chooseCut({
-            before, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined, opportunistic: gate.opportunistic,
+        const decide = (targetRoom: number, targetBand: number, opportunistic: boolean) => chooseCut({
+            before, mandatory, room: targetRoom, band: targetBand, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined, opportunistic,
             unreduced: "Incoming prompt compaction did not reduce context within the estimated request budget",
             plan: (target): Plan<{ compaction: NonNullable<ReturnType<typeof tuckObservedDraft>["compaction"]>; reserve: number }> => {
-                const reserve = planReserve(target, room, band, mandatory, ctx);
+                const reserve = planReserve(target, targetRoom, targetBand, mandatory, ctx);
                 // Only a due cut re-renders a summary that sits alone in the session: inside the band a cut is opportunistic, and a smaller summary
                 // there buys nothing the request needed and costs history the next recall would have found.
-                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary, newPrompt: true, reRenderSummary: !gate.opportunistic }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, false);
+                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary, newPrompt: true, reRenderSummary: !opportunistic }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, false);
                 if (!draft.compaction) return { draft: false, capacityRejected: Boolean(draft.capacityRejected), reason: draft.unavailable };
                 const messages = withCut(ctx, { type: "compaction", ...draft.compaction, tokensBefore: before });
                 assertNativeToolRounds(messages);
                 return { draft: true, after: measure(messages), mode: draft.mode, compaction: draft.compaction, reserve };
             },
         });
+        let decision = gate.kind === "plan" ? decide(room, band, gate.opportunistic) : { kind: "defer" as const };
+        const { hardLine } = limits(ctx);
+        if (hardLine > room && (decision.kind === "defer" || decision.kind === "fault")) {
+            if (fits(before + mandatory, hardLine, ctx)) return;
+            decision = fits(mandatory, hardLine, ctx) ? decide(hardLine, hardLine, false) : { kind: "defer" };
+        }
+        if (decision.kind === "defer") return;
         // An opportunistic cut inside the band that cannot reach it is no fault: the request goes to the guard.
         if (decision.kind === "none") return;
         if (decision.kind === "fault") throw new (decision.capacity ? CapacityError : Refusal)(decision.message);
@@ -547,6 +591,7 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     pi.on("before_agent_start", async (event, ctx) => {
         const prompted = phase === "decided";
         phase = "starting";
+        runPrompt = event.messageType === "custom" ? undefined : event.prompt;
         try {
             syncHistoryTools(ctx);
             if (prompted) access(); // decided on input; a failure latched there still stops the run
@@ -622,19 +667,23 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         // request besides the fresh results. Reset per decision, so a retry sizes itself against the cut it is retrying, not an earlier attempt's.
         let previews: Messages[] = [];
         let floorKept: number | undefined;
-        const decide = () => {
+        let wholePromptFloor: number | undefined;
+        const protectedId = reason === "tool-loop" ? protectedPrompt(ctx) : undefined;
+        const decide = (targetRoom = room, targetBand = band) => {
             previews = [];
             floorKept = undefined;
+            wholePromptFloor = undefined;
             const before = measure(saved);
-            const gate = gateCut({ total: before + mandatory, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx) });
+            const gate = gateCut({ total: before + mandatory, mandatory, room: targetRoom, band: targetBand, fits: (tokens, limit) => fits(tokens, limit, ctx) });
             if (gate.kind !== "plan") return gate;
             return chooseCut({
-            opportunistic: gate.opportunistic, mandatory, before, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined,
+            opportunistic: gate.opportunistic, mandatory, before, room: targetRoom, band: targetBand, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined,
             unreduced: "Tool-loop preflight compaction did not reduce context within the estimated request budget",
             plan: (target): Plan<{ compaction: NonNullable<ReturnType<typeof tuckObservedDraft>["compaction"]>; reserve: number }> => {
-                const reserve = planReserve(target, room, band, mandatory, ctx);
-                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: densityTokens ?? before, previousSummary }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, true);
+                const reserve = planReserve(target, targetRoom, targetBand, mandatory, ctx);
+                const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: densityTokens ?? before, previousSummary, protectedPromptEntryId: protectedId }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, true);
                 if (!draft.compaction) {
+                    if (protectedId && draft.floorMessages) wholePromptFloor = measure(draft.floorMessages) + mandatory;
                     // The planner's own floor, so a clip's second budget is measured against what the smallest cut really keeps.
                     if (draft.floorMessages && event.toolResults) {
                         const fresh = new Set(event.toolResults.map(result => result.toolCallId));
@@ -662,23 +711,36 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         // clipBudgets states the budgets tried and why they are counted in the estimate's units; `kept` is measured from the previews this decision
         // built, so the second budget is the cut's own floor and not a new formula. When nothing is clipped or the decision still faults, the
         // refusal stands.
-        if (decision.kind === "fault" && event.toolResults) {
+        const tryClips = (clipRoom: number, targetBand: number) => {
+            if (decision.kind !== "fault" || !event.toolResults) return;
             const branch = ctx.sessionManager.getBranch();
             const entryIdOf = (toolCallId: string) => branch.findLast(entry => entry.type === "message" && entry.message.role === "toolResult" && entry.message.toolCallId === toolCallId)?.id;
             const fresh = new Set(event.toolResults.map(result => result.toolCallId));
             const kept = previews.length ? Math.max(...previews.map(preview => measure(preview.filter(message =>
                 !(message.role === "toolResult" && fresh.has((message as ToolResultMessage).toolCallId)))))) : floorKept;
-            for (const budget of clipBudgets(room, factor, mandatory, kept)) {
+            for (const budget of clipBudgets(clipRoom, factor, mandatory, kept)) {
                 const round = clipFor(event.toolResults, entryIdOf, budget);
                 if (!round.length) continue;
                 for (const clip of round) clips.set(clip.toolCallId, clip);
-                const clippedDecision = decide();
+                const clippedDecision = decide(clipRoom, targetBand);
                 if (clippedDecision.kind === "fault") for (const clip of round) clips.delete(clip.toolCallId);
                 else { decision = clippedDecision; break; }
             }
-        }
+        };
+        tryClips(room, band);
         const before = measure(saved);
-        if (decision.kind === "fault" && reason === "tool-loop") throw new (decision.capacity ? CapacityError : Refusal)(decision.message);
+        observeBudget(before + mandatory, ctx);
+        estimatedTokens = corrected(before + mandatory, ctx);
+        const { hardLine } = limits(ctx);
+        if (hardLine > room && (decision.kind === "defer" || decision.kind === "fault")) {
+            if (fits(before + mandatory, hardLine, ctx)) return;
+            decision = decide(hardLine, hardLine);
+            tryClips(hardLine, hardLine);
+        }
+        if (decision.kind === "fault" && reason === "tool-loop") {
+            if (wholePromptFloor !== undefined && !fits(wholePromptFloor, hardLine, ctx)) throw promptRefusal();
+            throw new (decision.capacity ? CapacityError : Refusal)(decision.message);
+        }
         if (decision.kind !== "cut") return;
         const compaction = captureDraft(decision.plan.compaction, ctx, decision.plan.reserve, reason, before, true, false, previousSummary,
             { response, host, mandatory, target: decision.target, margin: room - band });
@@ -785,8 +847,14 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             const messages = historyToolsEnabled(ctx) ? historyToolDeclarations(event.messages, toolShapes(pi.getActiveTools()), true) : event.messages;
             const system = requestSystemPart(ctx.getSystemPrompt(), pi.getActiveTools(), messages, ctx.getSystemPrompt());
             const tokens = system + conversationTokens(messages);
-			if (!fits(tokens, limits(ctx).room, ctx))
+            observeBudget(tokens, ctx);
+            estimatedTokens = corrected(tokens, ctx);
+            const { room, hardLine } = 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");
+            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();
                 // No system prompt or hidden assistant blocks; no provider payload/headers.

package/src/request-capacity.ts

@@ -0,0 +1,32 @@
+import { isContextOverflow } 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 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;
+    for (const entry of branch) {
+        if (entry.type !== 'message' || entry.message.role !== 'assistant') continue;
+        const message = entry.message;
+        if (message.stopReason === 'length' || message.stopReason === 'error' && isContextOverflow(message)) return reserve;
+        const output = message.usage?.output;
+        if (typeof output === 'number' && Number.isFinite(output) && output > largest) largest = output;
+    }
+    return Math.min(reserve, Math.ceil(largest));
+}
+
+/** 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;
+    return messages.some(message => {
+        if (message.role === 'user') {
+            const text = typeof message.content === 'string' ? message.content : message.content.flatMap(block => block.type === 'text' ? [block.text] : []).join('\n');
+            return text.includes(prompt);
+        }
+        if (message.role !== 'compactionSummary') return false;
+        const split = splitSummary(message.summary);
+        return split !== null && split !== undefined && parseRecords(split.body, split.version).some(record =>
+            record.kind === 'excerpt' && record.role === 'user' && record.text.includes(prompt));
+    });
+}

package/src/tuck.ts

@@ -52,14 +52,14 @@ import { prepareKeywordQuery } from "./tuck/core/keyword-query";
 import { searchEntriesDetailed } from "./tuck/core/search-entries";
 export const tuck: Tuck = { buildOwnCut, applyTailBudget, calibrateCharsPerToken, buildGlobalIndexById, compileDialogue, prepareKeywordQuery, searchEntriesDetailed };
 /** Uses pi-tuck's own cut, calibrated maximum tail and dialogue compiler; Pi owns persistence and continuation. */
-export function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true, operatorManual = false, newPrompt = false) {
- return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual, newPrompt }, ctx, reserveTokens, measure, policy, retainCurrentInput);
+export function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: ExtensionContext, reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true, operatorManual = false, newPrompt = false, protectedPromptEntryId?: string) {
+ return tuckObservedDraft(tuck, { branchEntries: event.branchEntries, tokensBefore: event.preparation.tokensBefore, previousSummary: event.preparation.previousSummary, operatorManual, newPrompt, protectedPromptEntryId }, ctx, reserveTokens, measure, policy, retainCurrentInput);
 }
 /** Shared compiler observes canonical branch and current token estimate; no native preparation utility. */
 /** `newPrompt`: the cut is planned for a run that has not begun (a prompt Pi has not appended yet, an operator's manual cut, Pi's own cut before
  * a run a custom message starts); the session has moved on from an ended run.
  * `reRenderSummary`: the cut is due, so its summary may be re-rendered smaller (see the `no_live_messages` branch below). */
-export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEntry[]; tokensBefore: number; previousSummary?: string; operatorManual?: boolean; newPrompt?: boolean; reRenderSummary?: boolean }, ctx: ExtensionContext,
+export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEntry[]; tokensBefore: number; previousSummary?: string; operatorManual?: boolean; newPrompt?: boolean; reRenderSummary?: boolean; protectedPromptEntryId?: string }, ctx: ExtensionContext,
  reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true): Draft {
  const { isHistorySource, readable } = createRecall(policy);
 	const projected = ctx.sessionManager.buildSessionProjection();
@@ -143,6 +143,9 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
     const current = entries[userPosition];
     const userContent = current?.type === "message" && current.message.role === "user" ? current.message.content : undefined;
     const textOnly = isTextOnly(userContent);
+    // Steering can become the latest user source while the run still owns its original prompt.
+    const startingPosition = entries.findIndex(entry => entry.id === input.protectedPromptEntryId && entry.type === "message" && entry.message.role === "user");
+    const starting = entries[startingPosition];
     // Anchor the actual first source only; a native omission never promotes a later prompt.
     const firstUser = branch.find(entry => entry.type === "message" && entry.message.role === "user");
     const firstUserPosition = entries.findIndex(entry => entry.id === firstUser?.id && entry.type === "message");
@@ -280,7 +283,8 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
                 if (index !== undefined && quoted.records.length) { selected.add(index); if (quoted.whole) whole.add(index); }
             };
             if (userPosition >= 0 && userPosition < boundary && textOnly) add(current!, Infinity);
-            for (const entry of anchors) if (entry.id !== current?.id && positions.get(entry.id)! < boundary) add(entry, length);
+            if (startingPosition >= 0 && startingPosition < boundary && starting?.id !== current?.id) add(starting!, Infinity);
+            for (const entry of anchors) if (entry.id !== current?.id && entry.id !== starting?.id && positions.get(entry.id)! < boundary) add(entry, length);
             const omissions: TranscriptRecord[] = [];
             for (const role of ["user", "assistant", "toolResult"] as const) {
                 const list = units[role], prefix = prefixes[role];