pi-tuck 1.0.23 → 1.0.25

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

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

@@ -1,11 +1,15 @@
 import type { SessionEntry } from '@earendil-works/pi-coding-agent';
-import type { Messages } from './budget.js';
+import type { AgentMessage, Messages } from './budget.js';
 /** Read Pi's private safety allowance through its public clamp, rather than copying it.
  * Older/unavailable subpaths fall back to Pi 1.2–1.5's documented 4,096-token allowance.
  */
 export declare function piContextSafetyMargin(): Promise<number>;
 /** The smallest reply room a request above the room must leave after Pi's own clamp: above the user's p99 reply (3,270 tokens). */
 export declare const REPLY_FLOOR_MIN = 3584;
+/** A spent thinking budget that produced neither a visible answer nor work. Empty/text/tool replies keep the existing length recovery. */
+export declare const thinkingOnlyLength: (message: AgentMessage) => boolean;
+/** Thinking-only exhaustion uses the observed largest reply, not the full reserve. Every other failed length/overflow keeps its override. */
+export declare const needsFullReplyReserve: (message: AgentMessage) => boolean;
 /** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
 export declare function branchReplyFloor(branch: readonly SessionEntry[], reserve: number): number;
 /** Admission never promises more output than a model with a positive reply cap can produce. */

package/dist/src/request-capacity.js

@@ -20,20 +20,29 @@ export async function piContextSafetyMargin() {
 }
 /** The smallest reply room a request above the room must leave after Pi's own clamp: above the user's p99 reply (3,270 tokens). */
 export const REPLY_FLOOR_MIN = 3_584;
+/** A spent thinking budget that produced neither a visible answer nor work. Empty/text/tool replies keep the existing length recovery. */
+export const thinkingOnlyLength = (message) => message.role === 'assistant' && message.stopReason === 'length' &&
+    message.content.length > 0 && message.content.every(block => block.type === 'thinking');
+/** Thinking-only exhaustion uses the observed largest reply, not the full reserve. Every other failed length/overflow keeps its override. */
+export const needsFullReplyReserve = (message) => message.role === 'assistant' &&
+    (message.stopReason === 'length' && !thinkingOnlyLength(message) || message.stopReason === 'error' && isContextOverflow(message));
 /** Read the whole current branch, including replies before cuts. No session-local fallback flag. */
 export function branchReplyFloor(branch, reserve) {
-    let largest = REPLY_FLOOR_MIN;
+    let largest = REPLY_FLOOR_MIN, thinkingStop = false;
     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))
+        if (needsFullReplyReserve(message))
             return reserve;
+        thinkingStop ||= thinkingOnlyLength(message);
         const output = message.usage?.output;
         if (typeof output === 'number' && Number.isFinite(output) && output > largest)
             largest = output;
     }
-    return Math.min(reserve, Math.ceil(largest));
+    // Include the exhausted thinking reply itself, even across later cuts/restarts. Its observed output must fit again;
+    // requestReplyFloor applies the model cap. Ordinary branches retain their existing reserve cap.
+    return thinkingStop ? Math.ceil(largest) : Math.min(reserve, Math.ceil(largest));
 }
 /** Admission never promises more output than a model with a positive reply cap can produce. */
 export function requestReplyFloor(branch, reserve, maxTokens) {

package/dist/src/status.d.ts

@@ -9,6 +9,8 @@ export declare function statusText(input: {
         type: string;
         tokensBefore?: unknown;
         details?: unknown;
+        customType?: unknown;
+        data?: unknown;
     }[];
     cutAt: number | undefined;
     search: boolean;

package/dist/src/status.js

@@ -21,6 +21,8 @@ export function statusText(input) {
     const cutLine = ours.length === 0 ? "Cuts: none yet in this session. The recall tools appear after the first cut."
         : `Cuts: ${ours.length} by pi-tuck in this session` + (typeof before === "number" && typeof after === "number" ? `, the last from ${count(before)} to ${count(after)} tokens.` : ".");
     const native = cuts.length - ours.length;
+    const retries = input.branch.filter(entry => entry.type === "custom" && entry.customType === "pi-tuck-capacity" &&
+        entry.data?.kind === "retry").length;
     const searchLine = !input.search ? "Search: by keyword (search by meaning needs macOS on Apple silicon)."
         : input.semantic.state === "ready" || input.semantic.state === "waiting" ? "Search: by meaning and keyword."
             : input.semantic.state === "preparing" ? "Search: by meaning and keyword; indexing history in the background."
@@ -28,6 +30,7 @@ export function statusText(input) {
     return [
         `pi-tuck ${input.version} (the version this session loaded; restart Pi after an update).`,
         cutLine,
+        ...(retries ? [`Retries: ${retries} after thinking-only length stops in this session.`] : []),
         ...(native > 0 ? [`Pi's own compaction cut ${native} time${native === 1 ? "" : "s"} in this session.`] : []),
         input.cutAt === undefined ? "Cut point: adapts by itself." : `Cut point: fixed at cutAt ${input.cutAt} of the input room. Remove cutAt from pi-tuck.json to let it adapt.`,
         searchLine,

package/dist/src/tuck.d.ts

@@ -87,6 +87,7 @@ export declare function tuckObservedDraft(tuck: Tuck, input: {
     newPrompt?: boolean;
     reRenderSummary?: boolean;
     protectedPromptEntryId?: string;
+    deepest?: boolean;
 }, 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

@@ -311,6 +311,14 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
         };
         const calibrationHigh = highAt(floorBoundary, minimumOpeningLength);
         const floorSummary = render(calibrationHigh.rows), floorProjection = preview(floorSummary, floorBoundary);
+        // The last admission attempt and thinking-only retry share this exact floor: whole protected prompts, the smallest
+        // existing summary representation, and the required fresh/native suffix. No historical fill or room target spends reply space.
+        if (input.deepest) {
+            assertNativeToolRounds(floorProjection);
+            const after = measure(floorProjection);
+            return { compaction: { summary: floorSummary, firstKeptEntryId: entries[floorBoundary]?.id ?? "", tokensBefore: input.tokensBefore,
+                    details: { ...detailsAt(floorBoundary), tokensAfter: after, carriedTarget: after, view: "shrunk-dialogue", mode: "shrunk", deepest: true } }, after, mode: "shrunk" };
+        }
         const offset = measure(floorProjection) - nativeAt(floorBoundary) - summaryTokens(floorSummary.length);
         const price = (characters, boundary) => offset + nativeAt(boundary) + summaryTokens(characters);
         const listCache = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "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 = "37e6c0132f0638bca430bc165bef86ac4814e136c47e4672e06b086310a2de70";
+export const BUILD_ID = "48d3f777f203edb56b29154215540eb8245182237d18cdc50c6cbe704ea28e7e";