pi-tuck 1.0.12 → 1.0.14

package/dist/src/tuck/core/normalize.js

@@ -52,7 +52,7 @@ const normalizeOne = (msg, msgIndex) => {
 };
 /**
  * Normalize messages to blocks. `sourceIndices`, when provided, supplies the
- * session-global `#N` index per input position (see src/core/global-indices.ts).
+ * session-global `#N` index per input position (see global-indices.ts).
  * A missing entry yields `sourceIndex: undefined`, which downstream renderers
  * display as no ref — never a window-relative number. Omitted entirely, the
  * legacy positional behavior is preserved (used by callers/tests that have no
@@ -65,7 +65,6 @@ export const normalize = (messages, sourceIndices, receiptContext, sourceEntryId
     if (sourceTimes && sourceTimes.length !== messages.length)
         throw new Error("Original times must align with compiler messages");
     const timeByIndex = Object.fromEntries((sourceIndices ?? messages.map((_, i) => i)).flatMap((index, i) => index === undefined || !sourceTimes ? [] : [[index, sourceTimes[i]]]));
-    const context = receiptContext ?? { messages, sourceIndices: sourceIndices ?? messages.map((_, i) => i) };
     const pairs = new Map();
     const group = (id) => {
         if (typeof id !== "string" || !id)
@@ -77,17 +76,16 @@ export const normalize = (messages, sourceIndices, receiptContext, sourceEntryId
         }
         return pair;
     };
-    context.messages.forEach((msg, order) => {
+    (receiptContext?.messages ?? messages).forEach((msg, order) => {
         if (msg.role === "assistant" && Array.isArray(msg.content))
             for (const part of msg.content) {
                 if (part.type === "toolCall")
-                    group(part.id).calls.push({ name: part.name, order, index: context.sourceIndices[order], args: part.arguments });
+                    group(part.id).calls.push({ name: part.name, order, args: part.arguments });
             }
         if (msg.role === "toolResult") {
             if (typeof msg.isError !== "boolean")
                 throw new Error("Tool receipt lacks a recorded error status");
-            group(msg.toolCallId).receipts.push({ name: msg.toolName,
-                order, index: context.sourceIndices[order], isError: msg.isError, content: msg.content });
+            group(msg.toolCallId).receipts.push({ name: msg.toolName, order });
         }
     });
     // A call paired with exactly one later receipt of the same tool has a recorded outcome. An export through recall keeps its outcome block.

package/dist/src/tuck/cut.js

@@ -34,47 +34,20 @@ const toLiveMessage = (entry) => {
     return null;
 };
 const collectLiveMessages = (branchEntries) => {
-    // Find the last compaction entry and its firstKeptEntryId
-    let lastCompactionIdx = -1;
-    let lastKeptId;
-    for (let i = branchEntries.length - 1; i >= 0; i--) {
-        if (branchEntries[i].type === "compaction") {
-            lastCompactionIdx = i;
-            lastKeptId = branchEntries[i].firstKeptEntryId;
-            break;
-        }
-    }
-    // Orphan recovery: triggers when lastKeptId is set to "" (sentinel from prior
-    // compact-all) OR set to an id that no longer exists in the branch. In both cases,
-    // start collecting from right after the last compaction entry.
-    const hasPriorCompaction = lastCompactionIdx >= 0;
-    const hasValidKeptId = !!lastKeptId && branchEntries.some((e) => e.id === lastKeptId);
-    const orphanRecovery = hasPriorCompaction && !hasValidKeptId;
-    // Collect live messages
+    const lastCompactionIdx = branchEntries.findLastIndex(e => e.type === "compaction");
+    const lastKeptId = branchEntries[lastCompactionIdx]?.firstKeptEntryId;
+    const kept = lastKeptId ? branchEntries.findIndex(e => e.id === lastKeptId) : -1;
+    // An empty compact-all sentinel or a missing anchor resumes after the last
+    // compaction. With no prior compaction, collection starts at the beginning.
+    const start = kept >= 0 ? kept : lastCompactionIdx + 1;
     const liveMessages = [];
-    if (orphanRecovery) {
-        for (let i = lastCompactionIdx + 1; i < branchEntries.length; i++) {
-            const e = branchEntries[i];
-            if (e.type === "compaction")
-                continue;
-            const m = toLiveMessage(e);
-            if (m)
-                liveMessages.push({ entry: e, message: m });
-        }
-    }
-    else {
-        let foundKept = !lastKeptId; // if no prior compaction, start collecting immediately
-        for (const e of branchEntries) {
-            if (!foundKept && e.id === lastKeptId)
-                foundKept = true;
-            if (!foundKept)
-                continue;
-            if (e.type === "compaction")
-                continue;
-            const m = toLiveMessage(e);
-            if (m)
-                liveMessages.push({ entry: e, message: m });
-        }
+    for (let i = start; i < branchEntries.length; i++) {
+        const e = branchEntries[i];
+        if (e.type === "compaction")
+            continue;
+        const m = toLiveMessage(e);
+        if (m)
+            liveMessages.push({ entry: e, message: m });
     }
     return liveMessages;
 };

package/dist/src/tuck.js

@@ -53,8 +53,8 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
     const chars = (calibration.ok ? calibration.messages.reduce((n, m) => n + estimateSourceMessageChars(m), 0) : 0)
         + (input.previousSummary?.length ?? 0);
     const { charsPerToken } = tuck.calibrateCharsPerToken(chars, input.tokensBefore);
-    // A preferred tail takes at most half the current input allowance, so a cut leaves room to grow: a tail that fills the room lands the
-    // request just under the band and the next round cuts again. Current/fresh-source floors below may still require an explicit rejection.
+    // The planner's reserve includes mandatory input (system, host and incoming prompt), so this is half of the target room *after* that
+    // fixed input, not half of the whole room. Current/fresh-source floors below may still require an explicit rejection.
     const inputRoom = Math.floor(Math.max(0, (ctx.model?.contextWindow ?? 0) - reserveTokens - 1) / 2);
     const maxTokens = Math.min(MAX_TAIL_TOKENS, inputRoom);
     // Keep the current user turn native; older conversation competes in the
@@ -71,6 +71,11 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
         cut = { ok: true, messages: [], selectedIds: [], firstKeptEntryId: "", compactAll: true, keptUserTurns: 0, keepFallbackToCompactAll: false };
     if (!cut.ok)
         return { unavailable: `pi-tuck cannot select a cut: ${cut.reason}` };
+    const cutBefore = (cut, boundary, prefix) => ({
+        ...cut, messages: prefix.messages, selectedIds: prefix.selectedIds,
+        firstKeptEntryId: entries[boundary]?.id ?? "", compactAll: boundary === entries.length, keepFallbackToCompactAll: false,
+        keptUserTurns: entries.slice(boundary).filter(entry => entry.type === "message" && entry.message.role === "user").length,
+    });
     // The latest call's trailing receipts have not reached a subsequent response.
     // A preferred tail size must not erase this first exposure when the whole
     // fresh round fits. Existing full-draft admission rejects an impossible round.
@@ -93,9 +98,7 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
             const prefix = tuck.buildOwnCut(entries.slice(0, lastResponse), 0);
             if (!prefix.ok)
                 return { unavailable: "No reducible history before the fresh tool round" };
-            cut = { ...cut, messages: prefix.messages, selectedIds: prefix.selectedIds,
-                firstKeptEntryId: response.id, compactAll: false, keepFallbackToCompactAll: false,
-                keptUserTurns: entries.slice(lastResponse).filter(entry => entry.type === "message" && entry.message.role === "user").length };
+            cut = cutBefore(cut, lastResponse, prefix);
         }
     }
     // Direct shell output after the last response has not reached the model.
@@ -108,9 +111,7 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
         const prefix = tuck.buildOwnCut(entries.slice(0, freshBash), 0);
         if (!prefix.ok)
             return { unavailable: "No reducible history before the fresh shell output" };
-        cut = { ...cut, messages: prefix.messages, selectedIds: prefix.selectedIds,
-            firstKeptEntryId: entries[freshBash].id, compactAll: false, keepFallbackToCompactAll: false,
-            keptUserTurns: entries.slice(freshBash).filter(entry => entry.type === "message" && entry.message.role === "user").length };
+        cut = cutBefore(cut, freshBash, prefix);
     }
     // Preserve the actual latest user source, never an inferred task/decision.
     // Explicit omission of it must not promote an earlier user source instead.
@@ -131,9 +132,7 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
         const prefix = tuck.buildOwnCut(entries.slice(0, userPosition), 0);
         if (!prefix.ok)
             return { unavailable: "No reducible history before the current user input" };
-        cut = { ...cut, messages: prefix.messages, selectedIds: prefix.selectedIds,
-            firstKeptEntryId: current.id, compactAll: false, keepFallbackToCompactAll: false,
-            keptUserTurns: entries.slice(userPosition).filter(entry => entry.type === "message" && entry.message.role === "user").length };
+        cut = cutBefore(cut, userPosition, prefix);
     }
     if (cut.messages.length !== cut.selectedIds.length || (!cut.compactAll && !entries.some((e) => e.id === cut.firstKeptEntryId)))
         throw new Error("pi-tuck returned an invalid source boundary");
@@ -272,10 +271,7 @@ export function tuckObservedDraft(tuck, input, ctx, reserveTokens, measure, poli
     const prefix = tuck.buildOwnCut(entries.slice(0, floorBoundary), 0);
     if (!prefix.ok)
         return preferred;
-    const retried = compileAtCut({ ...cut, budgetCut: undefined, messages: prefix.messages, selectedIds: prefix.selectedIds,
-        firstKeptEntryId: entries[floorBoundary]?.id ?? "", compactAll: floorBoundary === entries.length,
-        keepFallbackToCompactAll: false,
-        keptUserTurns: entries.slice(floorBoundary).filter(entry => entry.type === "message" && entry.message.role === "user").length });
+    const retried = compileAtCut({ ...cutBefore(cut, floorBoundary, prefix), budgetCut: undefined });
     return preferred.compaction && retried.mode !== "dialogue" ? preferred : retried;
 }
 /** Numeric references use the original session index, then intersect with readable current-branch entries. */

package/index.ts

@@ -16,7 +16,7 @@ export { ensureSemanticRuntime } from "./src/setup";
 
 /** pi-tuck as a Pi extension: compaction and history recall always; semantic recall too, unless `pi-tuck.json` in Pi's agent folder
  * says `{"semanticRecall": false}`. Its runtime is set up in the background the first time a session starts. The same file's `"cutAt"`
- * (a number above 0 and at most 1) is the fraction of the input room a cut is triggered at, 1 by default. */
+ * (a number above 0 and at most 1) is the fraction of the input room a cut is triggered at, 0.6 by default. */
 /** The oldest Pi with every hook and API pi-tuck uses, and the oldest its tests pass on (Pi 1.2 added the custom message that starts a
  * run to before_agent_start, which the prompt's cut counts). */
 export const PI_FLOOR = "1.2.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-tuck",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "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/budget.ts

@@ -3,6 +3,7 @@ import { convertToLlm, estimateTokens, type BeforeAgentStartEvent, type Extensio
 import { measurableMessages, projectedMessages } from "./omissions.js";
 import type { RecallPolicy } from "./recall.js";
 import { isDiscardedResponse } from "./protocol.js";
+import { MAX_TAIL_TOKENS } from "./tuck/cut.js";
 
 /**
  * The one measure of the next request. The cut triggers, the cut planner (including the draft admission in tuck.ts), the post-cut
@@ -19,16 +20,16 @@ export const TRIGGER_MARGIN_FRACTION = 0.02;
 /** Whether `value` is a cut point: a fraction of the room above 0 and at most 1. */
 export const validCutAt = (value: unknown): value is number => typeof value === "number" && value > 0 && value <= 1;
 /**
- * The one owner of the band: the limit a cut is triggered at and preferably planned to. It is the room less the margin, or the cut point
- * `cutAt` (a fraction of the room) when that is lower. The exact room stays the limit of every throw, fault and the complete-context guard,
- * whatever the cut point. With `cutAt` 1 the band is the room less the margin alone.
+ * The one owner of the band: the limit a cut is triggered at and preferably planned to. An adaptive default may raise the cut point above
+ * 60% using the last cut's conversation size and current system size, both estimates, so they are converted to the room's units by the factor. Explicit cut points use the fraction alone. The margin caps both.
  */
-/** The default cut point: a cut once a request passes 60% of the room. Measured against 1 with paired replays (no answer loss) and billed
+/** The initial default cut point: 60% of the room before a usable previous cut. Measured against 1 with paired replays (no answer loss) and billed
  * input under automatic and explicit prompt caching (about 17% less at 128k, 10-14% at 32k). */
 export const DEFAULT_CUT_AT = 0.6;
-export const bandOf = (room: number, cutAt = 1): number => {
+export const bandOf = (room: number, cutAt = 1, adaptive?: { system: number; tokensAfter: number; factor: number }): number => {
 	const positive = Math.max(0, room);
-	return Math.min(room - Math.ceil(positive * TRIGGER_MARGIN_FRACTION), Math.floor(positive * cutAt));
+	const base = Math.floor(positive * cutAt);
+	return Math.min(room - Math.ceil(positive * TRIGGER_MARGIN_FRACTION), adaptive ? Math.max(base, Math.ceil((adaptive.system + adaptive.tokensAfter + MAX_TAIL_TOKENS / 2) * adaptive.factor)) : base);
 };
 
 /** The APIs whose request converter (pi-ai openai-responses-shared) sends each signed thinking block back as an input reasoning item. */
@@ -100,6 +101,8 @@ export type Decision<D extends object = {}> =
 	| { kind: "cut"; target: Target; plan: Extract<Plan<D>, { draft: true }> }
 	| { kind: "fault"; capacity: boolean; message: string };
 export interface CutInput<D extends object = {}> {
+	/** The band adapts by itself (no explicit cut point), so a cut that isn't due must also free a tenth of the room. */
+	usefulOnly?: boolean;
 	/** Saved conversation, measured by the planner's own function. */
 	before: number;
 	/** Input that no cut can remove: system part, host input, queued messages, or the incoming prompt. */
@@ -126,19 +129,22 @@ export type Verdict<D extends object = {}> = Exclude<Decision<D>, { kind: "defer
  * A lean band, one the cut point binds (`band < bandOf(room)`), is planned first and the room plan landing below it is not taken for that:
  * the room plan keeps a native tail of up to half the room, so it can land just under a band that far below the room, and the next round
  * would cut again, freeing little. The room is planned only where the rules above use it: to compare the mode, or when the band has no plan
- * and a cut is due. With the default cut point the band is never lean and the order and the decisions are those above.
+ * and a cut is due. An adaptive band can also reach the margin, in which case the room plan is tried first.
  * The margin adds no new decision fault. Exceptions thrown by `plan` are not caught here: they are faults, and they now surface at
  * boundaries inside the band too, where no planner ran before the margin.
  */
 export function chooseCut<D extends object = {}>(input: CutInput<D> & { opportunistic: boolean }): Verdict<D> {
 	const { before, mandatory, room, band, fits, plan, unreduced } = input;
 	const lands = (p: Plan<D>): p is Extract<Plan<D>, { draft: true }> => p.draft && p.after < before && fits(p.after + mandatory, band);
+	// A cut no one needs yet must be worth its summary: one that frees under a tenth of the room would trigger again within a round or two.
+	// Without this, a band at the cap takes the room plan on every round where free room is small. A due cut is not asked: it has to happen.
+	const worthwhile = (p: Extract<Plan<D>, { draft: true }>) => !input.usefulOnly || !input.opportunistic || !fits(10 * (before - p.after), room);
 	let roomPlan: Plan<D> | undefined;
 	const exact = () => roomPlan ??= plan("room");
-	if (band >= bandOf(room)) { const e = exact(); if (lands(e)) return { kind: "cut", target: "room", plan: e }; }
+	if (band >= bandOf(room)) { const e = exact(); if (lands(e) && worthwhile(e)) return { kind: "cut", target: "room", plan: e }; }
 	const preferred = plan("band");
 	if (input.opportunistic) {
-		if (!lands(preferred)) return { kind: "none" };
+		if (!lands(preferred) || !worthwhile(preferred)) return { kind: "none" };
 		const e = exact();
 		return e.draft && e.mode === preferred.mode ? { kind: "cut", target: "band", plan: preferred } : { kind: "none" };
 	}

package/src/build-id.ts

@@ -1 +1 @@
-export const BUILD_ID = "f637995e7992c76737b37ae27dee5bb6bf47e959fd0f9677c3ae4d0c7530442c";
+export const BUILD_ID = "9457180f73cad9d9bde254328dad70dd2abe8400e373a68e06ad455b5b66f203";

package/src/compaction.ts

@@ -103,9 +103,9 @@ export interface CompactionOptions {
 	/** 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);
-	/** The cut point: a fraction of the input room, above 0 and at most 1 (default 1). A cut is triggered at, and preferably planned to, the band,
+	/** 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. Anything else is rejected when the compactor is installed. */
+	 * 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
@@ -216,9 +216,9 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
     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); };
     // The cut planner's raw reserve for the target limit, on the same factor as every other consumer.
-    const planReserve = (target: Target, room: number, mandatory: number, ctx: ExtensionContext) => {
+    const planReserve = (target: Target, room: number, band: number, mandatory: number, ctx: ExtensionContext) => {
         identityFor(ctx);
-        return planningReserve(ctx.model?.contextWindow ?? 0, target === "band" ? bandOf(room, cutAt) : room, factor, mandatory);
+        return planningReserve(ctx.model?.contextWindow ?? 0, target === "band" ? band : room, factor, mandatory);
     };
     pi.on("message_end", (event, ctx) => {
         if (event.message.role !== "assistant") return;
@@ -280,10 +280,16 @@ 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);
     };
-    // The exact room, and the band a cut is triggered at (budget.ts, from this session's cutAt); every throw and every fault uses the exact room.
+    // Every throw, fault and complete-context guard uses the exact room.
     const limits = (ctx: ExtensionContext) => {
         const { response } = requestReserve(ctx), room = inputRoom(response, ctx);
-        return { response, room, band: bandOf(room, cutAt) };
+        return { response, room };
+    };
+    const decisionBand = (ctx: ExtensionContext, room: number, system: number) => {
+        const last = ctx.sessionManager.getBranch().findLast(entry => entry.type === "compaction");
+        const after = last?.type === "compaction" ? (last.details as { tokensAfter?: unknown } | undefined)?.tokensAfter : undefined;
+        return bandOf(room, cutAt, options.cutAt === undefined && typeof after === "number" && Number.isFinite(after) && after >= 0
+            ? { system, tokensAfter: after, factor } : undefined);
     };
     const fits = (tokens: number, limit: number, ctx: ExtensionContext) => corrected(tokens, ctx) < limit;
     // The saved conversation and a cut's quantities are counted by the one function the guard counts with (strict, as the context hook is).
@@ -413,13 +419,14 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
                 ctx.ui.notify("pi-tuck does not accept summarization instructions; use /compact without arguments.", "warning");
 				return { cancel: true };
 			}
-            const { response, room, band } = limits(ctx);
+            const { response, room } = limits(ctx);
             const retain = operatorManual || admittedRun;
             // A cut Pi asks for (an operator's /compact, Pi's threshold or overflow recovery) charges what the request must carry whatever is
             // cut: the system part and the host input. A prompt's cut is pi-tuck's own and never comes here.
             const saved = ctx.sessionManager.buildSessionProjection().messages;
             const host = hostTokens(ctx);
-            const mandatory = systemPart(ctx.getSystemPrompt(), toolShapes(pi.getActiveTools()), saved, ctx.getSystemPrompt()) + host;
+            const system = systemPart(ctx.getSystemPrompt(), toolShapes(pi.getActiveTools()), saved, ctx.getSystemPrompt());
+            const mandatory = system + host, band = decisionBand(ctx, room, system);
             const before = plannerMeasureFor(ctx)(saved);
             // 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
@@ -433,11 +440,11 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             }
             // 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),
+                before, mandatory, room, band, 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, mandatory, ctx);
+                    const reserve = planReserve(target, room, band, 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);
@@ -479,10 +486,11 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         access();
         if (!settingsFor().getCompactionSettings(ctx.model).enabled) return;
         if (!ctx.model) throw missingModel();
-        const { response, room, band } = limits(ctx);
+        const { response, room } = limits(ctx);
         // Public early view only: later handlers, image normalization and tool-loop growth remain the complete-context guard's responsibility.
         const saved = ctx.sessionManager.buildSessionProjection().messages;
         const system = systemPart(observedPrompt, toolShapes(tools), saved, ctx.getSystemPrompt());
+        const band = decisionBand(ctx, room, system);
         const host = hostTokens(ctx), measure = measureFor(ctx), before = measure(saved);
         const incoming = incomingPart + system, mandatory = incoming + host;
         if (!fits(incoming, room, ctx))
@@ -493,10 +501,10 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         if (gate.kind !== "plan") return;
         const previousSummary = saved.find(message => message.role === "compactionSummary")?.summary;
         const decision = chooseCut({
-            before, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), opportunistic: gate.opportunistic,
+            before, mandatory, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx), usefulOnly: options.cutAt === undefined, opportunistic: gate.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, mandatory, ctx);
+                const reserve = planReserve(target, room, band, 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);
@@ -532,12 +540,13 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
         if (event.entries.length || !isDeepStrictEqual(event.context.contextMessages,
             ctx.sessionManager.buildSessionProjection().messages)) return;
         if (!ctx.model) return;
-        const { response, room, band } = limits(ctx);
+        const { response, room } = limits(ctx);
         const measure = measureFor(ctx), saved = event.context.contextMessages;
         // One snapshot per decision. Messages queued for the next request (steering, follow-ups) are in that request but not in the
         // saved conversation. Pi's peek returns the steering queue, else the follow-up queue; a follow-up is not in the very next
         // request while tools still run, so it can be counted early: conservative, and nothing else would cut at that later boundary.
         const system = systemPart(ctx.getSystemPrompt(), toolShapes(pi.getActiveTools()), saved, ctx.getSystemPrompt());
+        const band = decisionBand(ctx, room, system);
         const host = hostTokens(ctx);
         const queued = event.context.pendingMessages.length ? conversationTokens(event.context.pendingMessages as Messages) : 0;
         const mandatory = system + host + queued;
@@ -551,10 +560,10 @@ export async function installCompaction(pi: ExtensionAPI, options: CompactionOpt
             floorKept = undefined;
             const before = measure(saved);
             return decideCut({
-            total: before + mandatory, mandatory, before, room, band, fits: (tokens, limit) => fits(tokens, limit, ctx),
+            total: before + mandatory, mandatory, before, room, band, 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, mandatory, ctx);
+                const reserve = planReserve(target, room, band, mandatory, ctx);
                 const draft = tuckObservedDraft(tuck, { branchEntries: ctx.sessionManager.getBranch(), tokensBefore: before, previousSummary }, ctx, reserve, plannerMeasureFor(ctx), options.recallPolicy, true);
                 if (!draft.compaction) {
                     // The planner's own floor, so a clip's second budget is measured against what the smallest cut really keeps.

package/src/omissions.ts

@@ -5,12 +5,12 @@ import { createRecall, type RecallPolicy } from './recall';
 /** Native branch edits supply exclusion; original global indices supply provenance. */
 export function omittedSourceIndices(entries: readonly SessionEntry[], branch: readonly SessionEntry[]): ReadonlySet<number> {
  const indices = buildGlobalIndexById(entries);
- const edits = new Map<string, boolean>();
+ const edits = new Set<string>();
  for (const entry of branch) if (entry.type === 'context_edit') {
   if (entry.replacement !== null) throw new Error('pi-tuck does not support replacement context edits');
-  edits.set(entry.targetId, true);
+  edits.add(entry.targetId);
  }
- return new Set([...edits].flatMap(([id, omitted]) => omitted && indices.has(id) ? [indices.get(id)!] : []));
+ return new Set([...edits].flatMap(id => indices.has(id) ? [indices.get(id)!] : []));
 }
 /** Preserve surviving record bytes/order, and the summary's format (a v1 summary stays v1). No text matching or semantic inference. */
 export function filterOmittedSummary(summary: string, omitted: ReadonlySet<number>): string {
@@ -49,22 +49,20 @@ export function filterCustomQuotes(summary: string, entries: readonly SessionEnt
 }
 type ProjectedMessages = ReturnType<ExtensionContext['sessionManager']['buildSessionProjection']>['messages'];
 /** The saved conversation as this compactor delivers it: native omissions and ineligible custom quotes removed from summaries. */
-export function projectedMessages(messages: ProjectedMessages, ctx: ExtensionContext, policy?: RecallPolicy): ProjectedMessages {
+function projectMessages(messages: ProjectedMessages, ctx: ExtensionContext, policy: RecallPolicy | undefined, allowForeign: boolean): ProjectedMessages {
  const entries = ctx.sessionManager.getEntries(), branch = ctx.sessionManager.getBranch();
  const omitted = omittedSourceIndices(entries, branch);
- return messages.map(message => message.role === 'compactionSummary'
+ return messages.map(message => message.role === 'compactionSummary' && (!allowForeign || splitSummary(message.summary) !== undefined)
   ? { ...message, summary: filterCustomQuotes(filterOmittedSummary(message.summary, omitted), entries, branch, policy) } : message);
 }
-/** Whether a compaction summary is in this compactor's own format. */
-const isTranscriptSummary = (summary: string) => splitSummary(summary) !== undefined;
+export function projectedMessages(messages: ProjectedMessages, ctx: ExtensionContext, policy?: RecallPolicy): ProjectedMessages {
+ return projectMessages(messages, ctx, policy, false);
+}
 /**
  * The same as `projectedMessages` for every summary in this compactor's format, and it never throws for any other: a summary of another
  * format (a Pi default summary, an empty draft) cannot be filtered and is left as it is. For counting a conversation that a cut is about
  * to replace, such as an operator's /compact on a session whose saved summary is foreign. The context hook and the triggers stay strict.
  */
 export function measurableMessages(messages: ProjectedMessages, ctx: ExtensionContext, policy?: RecallPolicy): ProjectedMessages {
- const entries = ctx.sessionManager.getEntries(), branch = ctx.sessionManager.getBranch();
- const omitted = omittedSourceIndices(entries, branch);
- return messages.map(message => message.role === 'compactionSummary' && isTranscriptSummary(message.summary)
-  ? { ...message, summary: filterCustomQuotes(filterOmittedSummary(message.summary, omitted), entries, branch, policy) } : message);
+ return projectMessages(messages, ctx, policy, true);
 }

package/src/semantic-recall.ts

@@ -21,12 +21,11 @@ function physicalPath(path:string):string {
   const next=dirname(parent);if(next===parent)throw error;parts.unshift(basename(parent));parent=next;
  }}
 }
+const inside=(base:string,target:string)=>{const rel=relative(base,target);return rel!=='..'&&!rel.startsWith('..'+sep)&&!isAbsolute(rel);};
 function outsideProject(project:string,path:string,kind:'configuration'|'index'|'runtime'|'scratch'){
- const inside=(base:string,target:string)=>{const rel=relative(base,target);return rel!=='..'&&!rel.startsWith('..'+sep)&&!isAbsolute(rel);};
  if(inside(resolve(project),resolve(path))||inside(physicalPath(project),physicalPath(path)))throw new Error('Semantic '+kind+' must be outside project');
 }
 function outsideRuntime(runtime:string,path:string,kind:'index'|'scratch'){
- const inside=(base:string,target:string)=>{const rel=relative(base,target);return rel!=='..'&&!rel.startsWith('..'+sep)&&!isAbsolute(rel);};
  if(inside(resolve(runtime),resolve(path))||inside(physicalPath(runtime),physicalPath(path)))throw new Error('Semantic '+kind+' must be outside immutable runtime');
 }
 function scratchParent(config:SemanticRecallConfig){return config.scratchDirectory??dirname(config.indexDirectory);}

package/src/tuck/core/global-indices.ts

@@ -1,7 +1,7 @@
 /**
  * Session-global message indices — the single definition of the `#N` index space.
  *
- * Recall (`src/core/load-messages.ts`) numbers every `type == "message"` entry
+ * Recall numbers every `type == "message"` entry
  * in session-file order, counting across compaction windows and abandoned
  * branches. Compaction summaries must emit the same numbers, but `normalize`
  * historically numbered the selected window from zero. This module owns the
@@ -15,41 +15,27 @@ export const isCountedMessageEntry = (entry: any): boolean =>
   entry?.type === "message" && entry.message != null;
 
 /**
- * Accumulates the id → global-index mapping one entry at a time so both the
- * in-memory array path and the streaming file path share one counting rule.
- *
- * Entries without a usable id are still counted (they occupy an index) but
- * produce no map entry. Duplicate ids are ambiguous — dropped fail-closed so
- * callers emit no ref instead of a wrong one.
+ * Map session entry ids to their global message index (position among counted
+ * message entries in array order, which matches session-file order). Entries
+ * without a usable id still occupy an index. Duplicate ids are dropped
+ * fail-closed so callers emit no ref instead of a wrong one.
  */
-const createGlobalIndexBuilder = () => {
+export const buildGlobalIndexById = (entries: readonly any[]): Map<string, number> => {
   const byId = new Map<string, number>();
   const ambiguous = new Set<string>();
   let messageIndex = 0;
-  return {
-    add(entry: any) {
-      if (!isCountedMessageEntry(entry)) return;
-      const id = entry?.id;
-      if (typeof id === "string" && id.length > 0) {
-        if (byId.has(id) || ambiguous.has(id)) {
-          byId.delete(id);
-          ambiguous.add(id);
-        } else {
-          byId.set(id, messageIndex);
-        }
+  for (const entry of entries) {
+    if (!isCountedMessageEntry(entry)) continue;
+    const id = entry?.id;
+    if (typeof id === "string" && id.length > 0) {
+      if (byId.has(id) || ambiguous.has(id)) {
+        byId.delete(id);
+        ambiguous.add(id);
+      } else {
+        byId.set(id, messageIndex);
       }
-      messageIndex++;
-    },
-    map: () => byId,
-  };
-};
-
-/**
- * Map session entry ids to their global message index (position among counted
- * message entries in array order, which matches session-file order).
- */
-export const buildGlobalIndexById = (entries: readonly any[]): Map<string, number> => {
-  const b = createGlobalIndexBuilder();
-  for (const entry of entries) b.add(entry);
-  return b.map();
+    }
+    messageIndex++;
+  }
+  return byId;
 };

package/src/tuck/core/normalize.ts

@@ -54,7 +54,7 @@ const normalizeOne = (msg: CompilerMessage, msgIndex: number | undefined): Norma
 
 /**
  * Normalize messages to blocks. `sourceIndices`, when provided, supplies the
- * session-global `#N` index per input position (see src/core/global-indices.ts).
+ * session-global `#N` index per input position (see global-indices.ts).
  * A missing entry yields `sourceIndex: undefined`, which downstream renderers
  * display as no ref — never a window-relative number. Omitted entirely, the
  * legacy positional behavior is preserved (used by callers/tests that have no
@@ -71,23 +71,21 @@ export const normalize = (
   if (sourceEntryIds && sourceEntryIds.length !== messages.length) throw new Error("Original entry IDs must align with compiler messages");
   if (sourceTimes && sourceTimes.length !== messages.length) throw new Error("Original times must align with compiler messages");
   const timeByIndex = Object.fromEntries((sourceIndices ?? messages.map((_, i) => i)).flatMap((index, i) => index === undefined || !sourceTimes ? [] : [[index, sourceTimes[i]]]));
-  const context = receiptContext ?? { messages, sourceIndices: sourceIndices ?? messages.map((_, i) => i) };
-  const pairs = new Map<string, { calls: { name: string; order: number; index: number | undefined; args: Record<string, unknown> }[];
-    receipts: { name: string; order: number; index: number | undefined; isError: boolean; content: Extract<CompilerMessage, { role: "toolResult" }>["content"] }[] }>();
+  const pairs = new Map<string, { calls: { name: string; order: number; args: Record<string, unknown> }[];
+    receipts: { name: string; order: number }[] }>();
   const group = (id: string) => {
     if (typeof id !== "string" || !id) throw new Error("Tool history lacks a recorded call identity");
     let pair = pairs.get(id);
     if (!pair) { pair = { calls: [], receipts: [] }; pairs.set(id, pair); }
     return pair;
   };
-  context.messages.forEach((msg, order) => {
+  (receiptContext?.messages ?? messages).forEach((msg, order) => {
     if (msg.role === "assistant" && Array.isArray(msg.content)) for (const part of msg.content) {
-      if (part.type === "toolCall") group(part.id).calls.push({ name: part.name, order, index: context.sourceIndices[order], args: part.arguments });
+      if (part.type === "toolCall") group(part.id).calls.push({ name: part.name, order, args: part.arguments });
     }
     if (msg.role === "toolResult") {
       if (typeof msg.isError !== "boolean") throw new Error("Tool receipt lacks a recorded error status");
-      group(msg.toolCallId).receipts.push({ name: msg.toolName,
-        order, index: context.sourceIndices[order], isError: msg.isError, content: msg.content });
+      group(msg.toolCallId).receipts.push({ name: msg.toolName, order });
     }
   });
   // A call paired with exactly one later receipt of the same tool has a recorded outcome. An export through recall keeps its outcome block.

package/src/tuck/cut.ts

@@ -55,42 +55,18 @@ export type OwnCutResult =
   | { ok: false; reason: OwnCutCancelReason };
 
 const collectLiveMessages = (branchEntries: any[]): EntryWithMessage[] => {
-  // Find the last compaction entry and its firstKeptEntryId
-  let lastCompactionIdx = -1;
-  let lastKeptId: string | undefined;
-  for (let i = branchEntries.length - 1; i >= 0; i--) {
-    if (branchEntries[i].type === "compaction") {
-      lastCompactionIdx = i;
-      lastKeptId = branchEntries[i].firstKeptEntryId;
-      break;
-    }
-  }
-
-  // Orphan recovery: triggers when lastKeptId is set to "" (sentinel from prior
-  // compact-all) OR set to an id that no longer exists in the branch. In both cases,
-  // start collecting from right after the last compaction entry.
-  const hasPriorCompaction = lastCompactionIdx >= 0;
-  const hasValidKeptId = !!lastKeptId && branchEntries.some((e: any) => e.id === lastKeptId);
-  const orphanRecovery = hasPriorCompaction && !hasValidKeptId;
-
-  // Collect live messages
+  const lastCompactionIdx = branchEntries.findLastIndex(e => e.type === "compaction");
+  const lastKeptId = branchEntries[lastCompactionIdx]?.firstKeptEntryId;
+  const kept = lastKeptId ? branchEntries.findIndex(e => e.id === lastKeptId) : -1;
+  // An empty compact-all sentinel or a missing anchor resumes after the last
+  // compaction. With no prior compaction, collection starts at the beginning.
+  const start = kept >= 0 ? kept : lastCompactionIdx + 1;
   const liveMessages: EntryWithMessage[] = [];
-  if (orphanRecovery) {
-    for (let i = lastCompactionIdx + 1; i < branchEntries.length; i++) {
-      const e = branchEntries[i];
-      if (e.type === "compaction") continue;
-      const m = toLiveMessage(e);
-      if (m) liveMessages.push({ entry: e, message: m });
-    }
-  } else {
-    let foundKept = !lastKeptId; // if no prior compaction, start collecting immediately
-    for (const e of branchEntries) {
-      if (!foundKept && e.id === lastKeptId) foundKept = true;
-      if (!foundKept) continue;
-      if (e.type === "compaction") continue;
-      const m = toLiveMessage(e);
-      if (m) liveMessages.push({ entry: e, message: m });
-    }
+  for (let i = start; i < branchEntries.length; i++) {
+    const e = branchEntries[i];
+    if (e.type === "compaction") continue;
+    const m = toLiveMessage(e);
+    if (m) liveMessages.push({ entry: e, message: m });
   }
   return liveMessages;
 };