pi-tuck 1.0.19 → 1.0.20

package/CHANGELOG.md

@@ -3,6 +3,28 @@
 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.20] - 2026-11-09
+
+### Fixed
+
+- **pi-tuck cut earlier than native Pi when a model's reply cap is above Pi's reserve.** 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. pi-tuck now reserves Pi's `reserveTokens`, native's point. Once a reply on the current branch did not fit, it holds the larger
+  of the two for the rest of that branch: a reply stopped for length, or a request pi-ai classes as a context overflow. A transient error such as a
+  503 keeps native's room. This is read from the 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 today's behaviour.
+- Lowering `reserveTokens` now takes effect even when the model's `maxTokens` is larger, until a reply does not fit.
+
+### Release gates
+
+- **Shipped without a live gate, because its replay matches 1.0.19:** 13,946 requests on 29 recordings, 0 differ, 0 lost and 0 dead tasks, the same
+  17 clips. Every recording has the reply cap equal to the reserve, where nothing changes.
+- New stress cells with the reply cap above the reserve, at 81,920 and 16,384, on a provider that clips the reply at the window end and one that
+  refuses prompt plus cap over the window, plus one with a transient 503. On Pi 1.2.0 and 1.5.0, 1.0.19 refuses in the four cap cells. This version
+  takes one clipped or refused reply in each and recovers, with no lost work and no compaction loop; after the 503 it keeps native's room. The full
+  stress test (292 cells) has 3 findings on each Pi, all also found on 1.0.19, and no cell is worse. Tests (676) and CI.
+- Sessions that are open keep the build they started with until they are restarted.
+
 ## [1.0.19] - 2026-11-09
 
 ### Added

package/README.md

@@ -63,9 +63,9 @@ pi install npm:pi-tuck
 Then start a new Pi session. That is all. pi-tuck takes over Pi's compaction, both automatic and `/compact`. You change no setting.
 
 - Needs Pi 1.2.0 or later (tested on 1.2.0 and 1.4.0), on macOS or Linux. On an older Pi, pi-tuck stays off, Pi's own compaction runs, and pi-tuck says so once. Full features on macOS with Apple silicon; elsewhere, compaction and word recall.
-- On macOS with Apple silicon, the first session also downloads a local search model in the background (about 390 MB, once). Until it is ready, search works by keyword. See [Semantic search](#semantic-search).
-- Prefer GitHub? `pi install git:github.com/galyavin/pi-tuck@v1.0.18`.
-- To pin a version, add it: `pi install npm:pi-tuck@1.0.18`.
+- 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`.
 
 ## Uninstall
 
@@ -102,10 +102,11 @@ pi-tuck's tools appear only after its first cut. Before that there is nothing ou
 
 | Command | Does |
 |---|---|
+| `/tuck` | Says in words what pi-tuck is doing in this session: the version this session loaded (an open session keeps it until Pi restarts), how many cuts pi-tuck made and the last one's size before and after, whether the cut point adapts or is fixed by `cutAt`, and how search works here. It is for you; the model sees nothing new. |
 | `/tuck-semantic on\|off\|status` | Turns semantic search on or off for this session, or shows its state. |
 | `/tuck-incident on\|next\|off\|status` | Records this session's compaction decisions to a file you can attach to a bug report. |
 
-`/compact` works as usual, but pi-tuck does not take custom summary instructions. Pi's own setting `"compaction": { "enabled": false }` turns compaction off.
+`/compact` works as usual. Text after it does not steer the summary, because pi-tuck builds the summary from the session itself: since 1.0.19 it cuts as plain `/compact` does and says the text was not used. Pi's own setting `"compaction": { "enabled": false }` turns compaction off.
 
 ## What is proven, and what is not
 

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

@@ -1 +1 @@
-export declare const BUILD_ID = "3bbefa84bf1600296d12131a405f9feaa8fb1ea26ca1a85f5292b40a0a57333f";
+export declare const BUILD_ID = "27846aedbe111110535eeed5998c572182cd15de0efede0fe4df1571166a838e";

package/dist/src/build-id.js

@@ -1 +1 @@
-export const BUILD_ID = "3bbefa84bf1600296d12131a405f9feaa8fb1ea26ca1a85f5292b40a0a57333f";
+export const BUILD_ID = "27846aedbe111110535eeed5998c572182cd15de0efede0fe4df1571166a838e";

package/dist/src/compaction.d.ts

@@ -39,9 +39,9 @@ export interface CompactionOptions {
      * 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. */
     cutAt?: number;
-    /** The response reserve: the input room is the context window less this. By default the room never exceeds the window less the model's
-     * catalogue maximum output, because a transport may omit the output cap and the reply can then grow to that maximum. A host that knows its
-     * transport's behavior declares an exact reserve with `responseExact: true`, and the room is then the window less `response` exactly. */
+    /** 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.
+     * Resume, fork and /tree follow that branch's history; a new session has no inherited fallback. */
     requestReserve?: (ctx: ExtensionContext) => {
         response: number;
         responseExact?: true;

package/dist/src/compaction.js

@@ -290,16 +290,18 @@ export async function installCompaction(pi, options = {}) {
     pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetFailure(); clips.clear(); promptCut = undefined; });
     const active = () => options.active?.() ?? true;
     const settingsFor = () => options.settings ?? SettingsManager.inMemory(pi.getSettings());
-    // The standalone default reserves the model's catalogue maximum output: a transport may omit the output cap, and then only that
-    // reserve keeps input plus any reply inside the window.
-    const reserveFor = (ctx) => Math.max(settingsFor().getCompactionSettings(ctx.model).reserveTokens, ctx.model?.maxTokens ?? 0);
-    // The one place the response reserve is decided; every consumer takes its room from here. A host that knows how its transport caps
-    // a reply declares an exact reserve (`responseExact: true`) and is held to it; without that flag the catalogue maximum is the floor.
+    // The one reserve decision; every consumer takes its room from limits. Standalone starts at Pi's native cut point. Once a reply did
+    // not fit (a length stop, or a refusal pi-ai classes as a context overflow), hold the catalogue maximum too. Other errors, such as a 503,
+    // keep native's room. Read the whole branch, including history before compactions, each time: no flag to persist or reset on resume,
+    // fork, /tree or a new session.
     const requestReserve = (ctx) => {
-        const budget = options.requestReserve?.(ctx) ?? { response: reserveFor(ctx) };
+        const host = options.requestReserve?.(ctx);
+        const budget = host ?? { response: settingsFor().getCompactionSettings(ctx.model).reserveTokens };
         if (!Number.isSafeInteger(budget.response) || budget.response < 0)
             throw new Error("Invalid host request reserve");
-        return { response: budget.responseExact === true ? budget.response : Math.max(budget.response, ctx.model?.maxTokens ?? 0) };
+        const floor = host ? host.responseExact !== true : ctx.sessionManager.getBranch().some(entry => entry.type === "message" && entry.message.role === "assistant" &&
+            (entry.message.stopReason === "length" || (entry.message.stopReason === "error" && isContextOverflow(entry.message))));
+        return { response: floor ? Math.max(budget.response, ctx.model?.maxTokens ?? 0) : budget.response };
     };
     const inputRoom = (response, ctx) => {
         const configured = options.activeInputTokens;

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 = "3bbefa84bf1600296d12131a405f9feaa8fb1ea26ca1a85f5292b40a0a57333f";
+export declare const DIAGNOSTIC_BUILD = "27846aedbe111110535eeed5998c572182cd15de0efede0fe4df1571166a838e";
 export interface Receipt {
     id: string;
     build: string;

package/package.json

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

package/src/compaction.ts

@@ -109,9 +109,9 @@ export interface CompactionOptions {
 	 * 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. */
 	cutAt?: number;
-	/** The response reserve: the input room is the context window less this. By default the room never exceeds the window less the model's
-	 * catalogue maximum output, because a transport may omit the output cap and the reply can then grow to that maximum. A host that knows its
-	 * transport's behavior declares an exact reserve with `responseExact: true`, and the room is then the window less `response` exactly. */
+	/** 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.
+	 * 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
 	 * view), in the form the hook injects them. Cut triggers, the cut planner and the post-cut checks count them with the same
@@ -266,17 +266,19 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     pi.on("agent_settled", () => { admittedRun = false; pending = undefined; phase = "idle"; forgetFailure(); clips.clear(); promptCut = undefined; });
 	const active = () => options.active?.() ?? true;
 	const settingsFor = () => options.settings ?? SettingsManager.inMemory(pi.getSettings());
-	// The standalone default reserves the model's catalogue maximum output: a transport may omit the output cap, and then only that
-	// reserve keeps input plus any reply inside the window.
-	const reserveFor = (ctx: ExtensionContext) => Math.max(
-		settingsFor().getCompactionSettings(ctx.model).reserveTokens, ctx.model?.maxTokens ?? 0);
-	// The one place the response reserve is decided; every consumer takes its room from here. A host that knows how its transport caps
-	// a reply declares an exact reserve (`responseExact: true`) and is held to it; without that flag the catalogue maximum is the floor.
+	// The one reserve decision; every consumer takes its room from limits. Standalone starts at Pi's native cut point. Once a reply did
+	// not fit (a length stop, or a refusal pi-ai classes as a context overflow), hold the catalogue maximum too. Other errors, such as a 503,
+	// keep native's room. Read the whole branch, including history before compactions, each time: no flag to persist or reset on resume,
+	// fork, /tree or a new session.
 	const requestReserve = (ctx: ExtensionContext) => {
-        const budget: { response: number; responseExact?: true } = options.requestReserve?.(ctx) ?? { response: reserveFor(ctx) };
+        const host = options.requestReserve?.(ctx);
+        const budget = host ?? { response: settingsFor().getCompactionSettings(ctx.model).reserveTokens };
         if (!Number.isSafeInteger(budget.response) || budget.response < 0)
             throw new Error("Invalid host request reserve");
-        return { response: budget.responseExact === true ? budget.response : Math.max(budget.response, ctx.model?.maxTokens ?? 0) };
+        const floor = host ? host.responseExact !== true : ctx.sessionManager.getBranch().some(entry =>
+            entry.type === "message" && entry.message.role === "assistant" &&
+            (entry.message.stopReason === "length" || (entry.message.stopReason === "error" && isContextOverflow(entry.message))));
+        return { response: floor ? Math.max(budget.response, ctx.model?.maxTokens ?? 0) : budget.response };
     };
     const inputRoom = (response: number, ctx: ExtensionContext) => {
         const configured = options.activeInputTokens;