pi-tuck 1.0.24 → 1.0.26

package/dist/src/request-capacity.js

@@ -1,13 +1,51 @@
 import { isContextOverflow, normalizeContext } from '@earendil-works/pi-ai';
 import { parseRecords, splitSummary } from './tuck/core/transcript.js';
+/** Pi's own request arithmetic: its reply clamp and the estimator behind it, as the running Pi has them.
+ * An installed extension cannot import these subpaths by name: Pi's extension loader aliases only pi-ai's root, compat, models, oauth and
+ * providers/all, and an installed package has no node_modules of its own. So resolve them first by name (tests, the eval harness, a dev
+ * checkout), then from the running Pi's own install, beside its executable. If neither works (an SDK host), there is none, and callers
+ * keep their fallbacks. */
+export async function loadPiRequestMath() {
+    try {
+        const [simple, estimate] = await Promise.all([import('@earendil-works/pi-ai/api/simple-options'), import('@earendil-works/pi-ai/utils/estimate')]);
+        return { clampMaxTokensToContext: simple.clampMaxTokensToContext, estimateContextTokens: estimate.estimateContextTokens };
+    }
+    catch { /* not resolvable by name: an installed extension */ }
+    try {
+        // pi-ai's exports map these subpaths for `import` only (./api/* -> ./dist/api/*.js), so find the package beside Pi's executable and
+        // import the files that map names.
+        const [{ existsSync, realpathSync }, { dirname, join }, { pathToFileURL }] = await Promise.all([import('node:fs'), import('node:path'), import('node:url')]);
+        const entry = process.argv[1];
+        if (!entry)
+            return undefined;
+        let dir = dirname(realpathSync(entry)), root;
+        for (let up = 0; up < 12 && !root; up++, dir = dirname(dir)) {
+            const candidate = join(dir, 'node_modules', '@earendil-works', 'pi-ai');
+            if (existsSync(join(candidate, 'dist', 'api', 'simple-options.js')))
+                root = candidate;
+            if (dirname(dir) === dir)
+                break;
+        }
+        if (!root)
+            return undefined;
+        const [simple, estimate] = await Promise.all([
+            import(pathToFileURL(join(root, 'dist', 'api', 'simple-options.js')).href),
+            import(pathToFileURL(join(root, 'dist', 'utils', 'estimate.js')).href)
+        ]);
+        if (typeof simple.clampMaxTokensToContext !== 'function' || typeof estimate.estimateContextTokens !== 'function')
+            return undefined;
+        return { clampMaxTokensToContext: simple.clampMaxTokensToContext, estimateContextTokens: estimate.estimateContextTokens };
+    }
+    catch {
+        return undefined;
+    }
+}
 /** 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.
+ * Without Pi's request arithmetic, fall back to Pi 1.2–1.5's documented 4,096-token allowance.
  */
-export async function piContextSafetyMargin() {
+export async function piContextSafetyMargin(math) {
     try {
-        const [{ clampMaxTokensToContext }, { estimateContextTokens }] = await Promise.all([
-            import('@earendil-works/pi-ai/api/simple-options'), import('@earendil-works/pi-ai/utils/estimate'),
-        ]);
+        const { clampMaxTokensToContext, estimateContextTokens } = math ?? await loadPiRequestMath() ?? (() => { throw new Error('No Pi request math'); })();
         const window = 1_000_000, context = normalizeContext({ messages: [] });
         const margin = window - estimateContextTokens(context).tokens - clampMaxTokensToContext({ contextWindow: window, maxTokens: window }, context, window);
         if (!Number.isSafeInteger(margin) || margin < 0 || margin >= window)
@@ -20,20 +58,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.24",
+  "version": "1.0.26",
   "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 = "c3eefa3bb76e52635b1e8394a025d3ffd6a056fc5636ed9b35f89dfddc1a322a";
+export const BUILD_ID = "e95edde95c614d01e1cbf6489134676fac0c1bbf6aa57ef639ffac1e7e105041";