pi-tuck 1.0.24 → 1.0.26

package/src/status.ts

@@ -15,7 +15,7 @@ export const LOADED_VERSION: string = (() => {
 export function statusText(input: {
     version: string;
     active: boolean;
-    branch: readonly { type: string; tokensBefore?: unknown; details?: unknown }[];
+    branch: readonly { type: string; tokensBefore?: unknown; details?: unknown; customType?: unknown; data?: unknown }[];
     cutAt: number | undefined;
     search: boolean;
     semantic: { state: SemanticState; lastError: string | null };
@@ -27,6 +27,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 as { kind?: unknown } | null | undefined)?.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."
@@ -34,6 +36,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/src/tuck.ts

@@ -59,7 +59,7 @@ export function tuckDraft(tuck: Tuck, event: SessionBeforeCompactEvent, ctx: Ext
 /** `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; protectedPromptEntryId?: string }, ctx: ExtensionContext,
+export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEntry[]; tokensBefore: number; previousSummary?: string; operatorManual?: boolean; newPrompt?: boolean; reRenderSummary?: boolean; protectedPromptEntryId?: string; deepest?: boolean }, ctx: ExtensionContext,
  reserveTokens: number, measure: Measure, policy: RecallPolicy = {}, retainCurrentInput = true): Draft {
  const { isHistorySource, readable } = createRecall(policy);
 	const projected = ctx.sessionManager.buildSessionProjection();
@@ -304,6 +304,14 @@ export function tuckObservedDraft(tuck: Tuck, input: { branchEntries: SessionEnt
         };
         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: number, boundary: number) => offset + nativeAt(boundary) + summaryTokens(characters);
         const listCache = new Map<number, { files: ReturnType<typeof ledgerItems>; actions: ReturnType<typeof actionItems>; records: TranscriptRecord[] }>();