pi-zip 0.2.8 → 0.3.0-rc.2

package/src/run.ts

@@ -1,18 +1,20 @@
 // The per-session state machine behind index.ts: cold detection, the run plan (F8), the warm valve (F10), persistence at turn_end,
 // settle preparation and the away-timer for the summary (F12).
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { detectCold, lastMessageMs, lastPrompt, modelKey, resolveTtl, ttlFor } from "./cache.ts";
-import { describe, lawPrices, loadStats, pWarm, record, sample, statsPath, GAP_EDGES, type Entry } from "./learn.ts";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { detectCold, lastMessageMs, lastPrompt, modelKey, payloadRetention, refused, resolveTtl, ttlFor } from "./cache.ts";
+import { agentDir, curve, describe, lawPrices, loadStats, pWarm, record, sample, statsPath, GAP_EDGES, type Entry } from "./learn.ts";
 import { validateEdits, repairPayload } from "./guard.ts";
 import { fmtK, Stats, noticeDesc, noticeText, type NoticeAction, type NoticeData, type ZipControl } from "./notice.ts";
-import { applyPlanToMessages, buildBlocks, calibrate, countUserTurns, G0, planContext, reserveTokensFor, untouchedEst, type Block, type Calibration, type Cut, type FoldTarget, type Law, type PlanOpts, type PlanResult, type RunPlan } from "./plan.ts";
+import { applyPlanToMessages, buildBlocks, calibrate, countUserTurns, FOLD_HOLD, G0, keepRecentTokensFor, piCanCompact, planContext, rebaseFolds, reserveTokensFor, sizeOf, spliceNative, untouchedEst, UNIT, type Block, type Cut, type FoldTarget, type Law, type PlanOpts, type PlanResult, type RunPlan, type Scale, type SysInfo } from "./plan.ts";
 import { handleFor, PH_MARK, RECALL_TOOL } from "./placeholder.ts";
-import { recalledHandlesFromBranch } from "./recall.ts";
+import { branchOutputs, recalledHandlesFromBranch, resolveHandlesInBranch } from "./recall.ts";
+import { cleanupRecall, commandNamesRecall, fileRecallFor, materialize, parseRecallPath, recallRoot, recallRootShown, rewriteCommand, sidDir, type FileRecall } from "./recallfile.ts";
 import { buildCut } from "./summary.ts";
-import { type Any, PRODUCT, clamp, textOf, tok4, tokensOf } from "./util.ts";
-import { fmtLife, SPARK_GAPS, type CardData, type StateWord } from "./ui.ts";
+import { type Any, COLD_CUSTOM, COMMIT_CUSTOM, envInt, PRODUCT, textOf, tok4 } from "./util.ts";
+import { replayGrowth } from "./state.ts";
+import { fmtLife, type CardData, type ChartBin, type StateWord } from "./ui.ts";
 
 export const PLAN_CUSTOM = "pi-zip/plan";
 export const STATE_CUSTOM = "pi-zip/state";
@@ -21,6 +23,13 @@ const fmtAway = (s: number) => (s < 90 ? `${Math.round(s)} s` : s < 5400 ? `${Ma
 export const NOTICE_CUSTOM = "pi-zip/notice"; // a fold/summary notice kept in the transcript (rendered by index.ts, never sent to the model)
 export const UNUSED_SUMMARY_CUSTOM = "pi-zip/unused-summary"; // a background summary nobody adopted: its cost, so the session totals stay honest
 export const AWAY_FRACTION = 0.8; // the away-timer fires this far into the cache lifetime
+/** Pi's idle cache warmer decides before each refresh at 0.9 x TTL, at least 10 s before expiry (core/cache-warmer.js getCacheWarmingDelayMs);
+ *  undefined: a lifetime of 10 s or less, which Pi never warms. */
+export const warmingDelayMs = (ttlMs: number): number | undefined => (ttlMs <= 10_000 ? undefined : Math.max(1, Math.floor(Math.min(ttlMs * 0.9, ttlMs - 10_000))));
+/** How long after a due warming decision pi-zip concludes that none is coming (15 s at a 5-minute TTL). */
+const warmingMargin = (ttlMs: number): number => Math.max(1_000, Math.min(15_000, 0.05 * ttlMs));
+/** A refresh lands this soon after a "warm" decision (it is one tiny request): 10 s at a 5-minute TTL. */
+const warmCheckMs = (ttlMs: number): number => Math.min(10_000, ttlMs / 8);
 // Other context managers rewrite the view too (F14); two writers give unpredictable results, so we pause and keep only the Guard.
 const CONFLICT_RE = /billion-context|bc-pi|magic-context|smart-compact|hot-compact|context-prune|pi-vcc|context-mode|prefix-cache/i;
 
@@ -30,7 +39,7 @@ export function checkEdits(blocks: Block[], userTurns: number, folds: FoldTarget
 	const live = folds.filter((t) => byId.has(t.entryId));
 	const cutBlock = cut ? byId.get(cut.firstKeptEntryId) : undefined;
 	if (cut && !cutBlock) return `cut target ${cut.firstKeptEntryId} is not in the projection`;
-	return validateEdits(blocks, { folds: new Map(live.map((t) => [byId.get(t.entryId)!.idx, t.ph])), recover: new Map(live.map((t) => [byId.get(t.entryId)!.idx, t.recover])), cut: cutBlock ? cutBlock.idx : null }, userTurns);
+	return validateEdits(blocks, { folds: new Map(live.map((t) => [byId.get(t.entryId)!.idx, t.ph])), recover: new Map(live.map((t) => [byId.get(t.entryId)!.idx, t.recover])), cut: cutBlock ? cutBlock.idx : null, ahead: !!cut?.ahead }, userTurns);
 }
 
 /** A summary being prepared (or finished) while the user is away. It has its own AbortController: no run owns it. */
@@ -41,7 +50,7 @@ interface Bg {
 	controller: AbortController;
 }
 
-/** Resolves with the promise's value, or null as soon as the signal aborts (Esc cancels the waiting, not the work). */
+/** Resolves with the promise's value, or null as soon as the signal aborts (Esc: Pi cancels the prompt; the work goes on). */
 function waitFor<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T | null> {
 	return new Promise((resolve) => {
 		if (signal?.aborted) return resolve(null);
@@ -52,6 +61,23 @@ function waitFor<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T | null
 }
 
 const errText = (err: unknown) => (err instanceof Error ? (err.stack ?? err.message) : String(err));
+/** A compaction another extension supplied (through session_before_compact): not Pi's own summary, not pi-zip's. */
+const foreignCompaction = (e: Any): boolean => e?.type === "compaction" && !!e.fromHook && e.details?.by !== PRODUCT;
+
+/** pi-zip's own compaction takes milliseconds: the summary is done. Pi runs every extension's session_before_compact handler for it, so
+ *  one that is not finished by this deadline has another handler at work (writing its own summary, say): pi-zip cancels it then, so it
+ *  can never land during the run, and the draft path takes the summary. */
+const nativeDeadlineMs = () => envInt("NATIVE_MS", 2_000);
+/** A compaction slower than this (or half the deadline) had another handler at work too: the native path ends for the process, so its
+ *  work (a model call, say) is not paid for, and waited for, at every cold return. */
+const NATIVE_SLOW_MS = 250;
+
+/** The prompt Pi appends right after before_agent_start, as a projected entry without an id: the plan made before it counts its size. */
+function pendingPrompt(e: Any): Any | null {
+	if (typeof e?.prompt !== "string") return null;
+	const m = { role: "user", content: [{ type: "text", text: e.prompt }, ...(Array.isArray(e.images) ? e.images : [])], timestamp: Date.now() };
+	return { sourceEntry: { type: "message", message: m }, messages: [m] };
+}
 
 export class Zip implements ZipControl {
 	off = false;
@@ -65,6 +91,7 @@ export class Zip implements ZipControl {
 	private runEdits = false; // this run carries an edit plan that turn_end has yet to persist
 	private runPlan: RunPlan | null = null;
 	private lastReqMs = 0; // the real-time cache clock: newest request start or end
+	private reqMsBefore = 0; // the clock before the request in flight started: what a refused request gives back
 	private lastModelKey = ""; // provider/model of the newest request: a cache entry belongs to one model
 	private settleIds: string[] = []; // entries the settle plan folded: only used to label a plan as prepared
 	private bg: Bg | null = null;
@@ -91,37 +118,132 @@ export class Zip implements ZipControl {
 	private nextEdit: number | null = null; // the next request is the first to carry a new edit: its untouched prefix (real tokens)
 	private pending: { gapS: number; expect: number; edited: boolean; key: string } | null = null;
 	private justEdited = false; // the newest response answered a request that first carried an edit: the next request gets no warm edit
+	// pi-zip's own ctx.compact() in flight: the only compaction session_before_compact answers (compaction null = cancel a late ask)
+	private nativeAsk: { compaction: Any | null; answered: boolean; askedAt: number; until: number } | null = null;
+	// the native path ended for this process, and why: another extension took part in pi-zip's compaction (answered, cancelled or
+	// replaced it, or took its time), or Pi's compaction failed. Summaries then ride along with the first request (the draft path).
+	private nativeOff: string | null = null;
+	// this run's return went in through another extension's compaction (it answered pi-zip's): the run plan adds no summary on top of
+	// it (folds only, a summary only at Pi's compaction room), and the summary prepared for the context it replaced is discarded
+	private foreignRun = false;
+	// this run's away summary went in through Pi's compaction before the run: the projection just before it, for the run plan (I1)
+	private nativeRun: { key: string; cut: Cut; before: number; after: number; pre: Any[]; entryId: string } | null = null;
+	// the cache tier (PI_CACHE_RETENTION) of the current model's requests: the payload of its newest request when seen, else the
+	// provider-scoped env resolved once per run (research pi-tricks §3.1); null = nothing known, the process env decides (cache.ts)
+	private retention: { key: string; tier: "short" | "long"; src: "env" | "provider env" | "payload" } | null = null;
 
 	constructor(private pi: ExtensionAPI) {}
 
 	active = () => !this.off && !this.conflict;
 
-	/** zip_recall declared to the model? Checked at session start and before every run (index.ts); a `--tools` allowlist hides it. */
-	recallOk = true;
+	/** How the model gets a folded output back, checked at session start and before every run (index.ts): "tool" = zip_recall is declared;
+	 *  "file" = a `--tools` allowlist hides it but read, grep or bash is active (placeholders name a recall file, written on demand);
+	 *  "reread" = none of those either: only re-readable outputs fold. */
+	recallMode: "tool" | "file" | "reread" = "tool";
+	private recallTools = { read: false, grep: false, bash: false };
+	get recallOk(): boolean {
+		return this.recallMode === "tool";
+	}
 	/** index.ts registered the transcript renderer for NOTICE_CUSTOM (Pi versions without registerEntryRenderer fall back to a status line). */
 	entryRenderer = false;
 	private coldWhy = ""; // the expanded notice's "why now" for this run
 	private noticed = false; // a transcript notice was written in this process (the branch may not show it yet)
 	/** A summary was persisted since the last cold run start: later warm plans make none unless at the compaction room. */
 	summarizedWarm = false;
-	setRecallOk(ok: boolean, ctx?: Any) {
-		if (ok !== this.recallOk) this.ledger({ type: "recall_available", ok });
-		this.recallOk = ok;
-		if (!ok && ctx) this.stateLine(ctx, "reread-only", "a tool allowlist hides zip_recall · only re-readable outputs fold · allow zip_recall to fold more");
+	setRecallMode(mode: "tool" | "file" | "reread", tools: { read: boolean; grep: boolean; bash: boolean }, ctx?: Any) {
+		if (mode !== this.recallMode) this.ledger({ type: "recall_available", ok: mode === "tool", mode, ...tools });
+		this.recallMode = mode;
+		this.recallTools = tools;
+		if (!ctx) return;
+		if (mode === "file" && this.fileRecall(ctx)) this.stateLine(ctx, "on", `a tool allowlist hides zip_recall · zipped outputs are read back from files in ${recallRootShown()}`, true, "on:file");
+		else if (mode === "file") this.stateLine(ctx, "reread-only", "a tool allowlist hides zip_recall · only re-readable outputs fold · no session file (--no-session), so no recall copies are written either", true, "reread-only:no-session");
+		else if (mode !== "tool") this.stateLine(ctx, "reread-only", "a tool allowlist hides zip_recall · only re-readable outputs fold · allow zip_recall, read, grep or bash to fold more");
+	}
+	/** The recall files this session's placeholders name; undefined outside file mode, and without a session file (`--no-session`: the
+	 *  outputs are in no file, so none is written for them either): then only re-readable outputs fold. */
+	private fileRecall(ctx: Any): FileRecall | undefined {
+		if (this.recallMode !== "file") return undefined;
+		const sid = this.recallSid(ctx);
+		return sid ? fileRecallFor(sid, this.recallTools) : undefined;
+	}
+	/** The session id recall copies are written under: none without a session file (`pi --no-session` keeps the session in memory). */
+	private recallSid(ctx: Any): string {
+		try {
+			return typeof ctx?.sessionManager?.getSessionFile?.() === "string" ? this.sessionId(ctx) : "";
+		} catch {
+			return "";
+		}
+	}
+	private sessionId(ctx: Any): string {
+		try {
+			const sid = ctx?.sessionManager?.getSessionId?.();
+			return typeof sid === "string" ? sid : "";
+		} catch {
+			return "";
+		}
 	}
 
 	/** Folded tool outputs of the current branch by toolCallId -> handle (the transcript marks them). */
 	readonly foldedCalls = new Map<string, string>();
 	foldedHandle = (toolCallId: string): string | undefined => this.foldedCalls.get(toolCallId);
+	/** handle -> what was folded ("read src/learn.ts"), from the placeholders of this branch: the recall row names it. */
+	readonly labels = new Map<string, string>();
+	labelOf = (handle: string): string | undefined => this.labels.get(handle);
 	refreshFolded(ctx: Any) {
 		const branch = this.branch(ctx);
 		const byId = new Map(branch.map((e: Any) => [e?.id, e]));
 		this.foldedCalls.clear();
 		for (const e of branch) {
-			if (e?.type !== "context_edit" || !String(e?.replacement?.content?.[0]?.text ?? "").startsWith(PH_MARK)) continue;
+			const ph = String(e?.replacement?.content?.[0]?.text ?? "");
+			if (e?.type !== "context_edit" || !ph.startsWith(PH_MARK)) continue;
+			const h = handleFor(e.targetId);
+			// older placeholders wrote a read slice as "offset=1 limit=2000": show it the way Pi does ("path:1-2000")
+			const label = ph.slice(0, ph.indexOf("\n") >>> 0).split(" · ")[1]?.replace(/ offset=(\d+)(?: limit=(\d+))?$| limit=(\d+)$/, (_m, o, l, l2) => {
+				const st = o ? +o : 1, li = l ?? l2;
+				return `:${st}${li ? `-${st + +li - 1}` : ""}`;
+			});
+			if (label) this.labels.set(h, label);
 			const id = byId.get(e.targetId)?.message?.toolCallId;
-			if (typeof id === "string") this.foldedCalls.set(id, handleFor(e.targetId));
+			if (typeof id === "string") this.foldedCalls.set(id, h);
+		}
+	}
+
+	// ---- the real size of the request that carried a plan (notices, research pi-tricks §3.4) ---------------------------------------
+	private liveCtx: Any = null; // the newest handler context: its sessionManager resolves to the current session at call time
+	private realMemo = new Map<number, { real: number | undefined } | { n: number }>();
+	/** input + cacheRead + cacheWrite of the first assistant message stamped at or after reqTs (errors and aborts skipped): the request
+	 *  that carried the plan. undefined until that response exists (the notice keeps its estimate); 0 when it reports no usage. A user
+	 *  message stamped after reqTs before it ends the search for good: what follows answers a later run (a valve plan committed at a run's
+	 *  last turn_end, a plan whose request failed), so the estimate stays. The run's own prompt is stamped before reqTs (its millisecond at
+	 *  the latest). A found value is kept; a miss is looked at again only when the session has grown. */
+	realSizeAfter(reqTs: number): number | undefined {
+		const memo = this.realMemo.get(reqTs);
+		if (memo && "real" in memo) return memo.real;
+		let sm: Any = null, n = -1;
+		try {
+			sm = this.liveCtx?.sessionManager;
+			n = typeof sm?.getEntryCount === "function" ? sm.getEntryCount() : -1;
+		} catch {
+			return undefined;
+		}
+		if (memo && n >= 0 && memo.n === n) return undefined;
+		let branch: Any[] = [];
+		try {
+			branch = sm?.getBranch?.() ?? [];
+		} catch {}
+		for (const e of branch) {
+			const m = e?.type === "message" ? e.message : null;
+			if (m?.role === "user" && Number(m.timestamp) > reqTs) {
+				this.realMemo.set(reqTs, { real: undefined }); // a later prompt came first: no response can be this plan's any more
+				return undefined;
+			}
+			if (m?.role !== "assistant" || !(Number(m.timestamp) >= reqTs) || m.stopReason === "error" || m.stopReason === "aborted") continue;
+			const u = m.usage, real = u ? (Number(u.input) || 0) + (Number(u.cacheRead) || 0) + (Number(u.cacheWrite) || 0) : 0;
+			this.realMemo.set(reqTs, { real });
+			return real;
 		}
+		this.realMemo.set(reqTs, { n });
+		return undefined;
 	}
 
 	/** /zip output in the transcript (custom entry, never sent to the model). */
@@ -135,15 +257,15 @@ export class Zip implements ZipControl {
 		}
 	}
 
-	/** A state change as one transcript line ("▸ pi-zip  paused  …"); each word once per session unless always. */
-	stateLine(ctx: Any, word: StateWord, reason: string, once = true) {
+	/** A state change as one transcript line ("ƶ pi-zip  paused  …"); each word once per session unless always. */
+	stateLine(ctx: Any, word: StateWord, reason: string, once = true, key: string = word) {
 		const text = `${PRODUCT}  ${word}  ${reason}`;
 		if (ctx?.mode !== "tui" && word !== "paused") return; // print/json/rpc (sub-agents): no transcript to keep it in
-		if (once && (this.statesShown.has(word) || this.branch(ctx).some((e: Any) => e?.type === "custom" && e.customType === NOTICE_CUSTOM && e.data?.kind === "state" && e.data?.word === word))) return;
-		this.statesShown.add(word);
+		if (once && (this.statesShown.has(key) || this.branch(ctx).some((e: Any) => e?.type === "custom" && e.customType === NOTICE_CUSTOM && e.data?.kind === "state" && (e.data?.key ?? e.data?.word) === key))) return;
+		this.statesShown.add(key);
 		this.ledger({ type: "state", word, reason });
 		// a state is not tied to this turn's edits: append now, so it sits where it happened
-		if (!this.show(ctx, { v: 2, kind: "state", word, reason, text, before: 0, after: 0, desc: "" })) this.notify(ctx, text);
+		if (!this.show(ctx, { v: 2, kind: "state", word, reason, text, before: 0, after: 0, desc: "", ...(key !== word ? { key } : {}) })) this.notify(ctx, text);
 	}
 	private statesShown = new Set<string>();
 
@@ -158,8 +280,8 @@ export class Zip implements ZipControl {
 		} catch {
 			return;
 		}
-		const ttl = ttlFor(ctx.model ?? this.model);
-		this.stateLine(ctx, "on", `folds old tool output after the prompt cache expires (${fmtLife(ttl / 1000).slice(1)} here) · nothing to set up · /zip for status`);
+		const ttl = ttlFor(ctx.model ?? this.model, [], this.tier(ctx.model ?? this.model));
+		this.stateLine(ctx, "on", `old tool output gets zipped once the prompt cache expires (${fmtLife(ttl / 1000).slice(1)} here) · /zip`);
 	}
 
 	ledger(rec: Record<string, unknown>) {
@@ -207,25 +329,81 @@ export class Zip implements ZipControl {
 		}
 	}
 
-	private sysTokens(ctx: Any): number {
+	/** The system prompt and the declared tools from Pi's API: only used when the transcript records no system message (plan.ts calibrate). */
+	private sysInfo(ctx: Any): SysInfo {
+		let text = "", tools: Any[] = [];
+		try {
+			text = ctx?.getSystemPrompt?.() ?? "";
+		} catch {}
+		try {
+			const active = new Set(this.pi.getActiveTools?.() ?? []);
+			tools = (this.pi.getAllTools?.() ?? []).filter((t: Any) => active.has(t?.name));
+		} catch {}
+		return { text, tools };
+	}
+
+	/** The cache tier of `model`'s requests, when known (see `retention`). */
+	private tier(model?: Any): "short" | "long" | undefined {
+		const r = this.retention;
+		return r && r.key === modelKey(model ?? this.model) ? r.tier : undefined;
+	}
+	/** Once per run: PI_CACHE_RETENTION as Pi resolves it for this model's provider (the credential's env in auth.json first, then the
+	 *  process env). A tier read from this model's newest request payload is the truth about that request and stays. */
+	private async resolveRetention(ctx: Any): Promise<void> {
+		const key = modelKey(ctx?.model);
+		if (!key || (this.retention?.key === key && this.retention.src === "payload")) return;
+		let scoped: string | undefined;
+		try {
+			const r = await ctx?.modelRegistry?.getApiKeyAndHeaders?.(ctx.model);
+			const v = r?.env?.PI_CACHE_RETENTION;
+			if (typeof v === "string" && v) scoped = v;
+		} catch {}
+		const v = scoped ?? process.env.PI_CACHE_RETENTION;
+		const next = { key, tier: v === "long" ? ("long" as const) : ("short" as const), src: scoped ? ("provider env" as const) : ("env" as const) };
+		if (next.tier !== this.retention?.tier || next.key !== this.retention?.key || next.src !== this.retention?.src) this.ledger({ type: "retention", ...next });
+		this.retention = next;
+	}
+
+	/** The token scale (O, c) read from the branch: stateless, so a fresh process calibrates exactly like a long-lived one. */
+	scaleOf(ctx: Any, entries?: Any[]): Scale {
+		try {
+			return calibrate(entries ?? ((ctx.sessionManager.buildSessionProjection() as Any)?.entries ?? []), this.sysInfo(ctx), this.branch(ctx), ctx?.model ? modelKey(ctx.model) : undefined);
+		} catch {
+			return UNIT;
+		}
+	}
+
+	/** The token scale of model `key` ("provider/id"), read from the branch. */
+	private scaleAt(ctx: Any, entries: Any[] | undefined, key: string): Scale {
 		try {
-			return tok4(ctx.getSystemPrompt?.() ?? "");
+			return calibrate(entries ?? [], this.sysInfo(ctx), this.branch(ctx), key);
 		} catch {
-			return 0;
+			return UNIT;
 		}
 	}
 
-	/** Plan options with the token scale read from the branch (stateless: a fresh process calibrates exactly like a long-lived one). */
-	private opts(ctx: Any, pending: boolean, mode: "cold" | "warm", entries: Any[], pWarm = mode === "cold" ? 0 : 1): { o: PlanOpts; cal: Calibration } {
-		const sys = this.sysTokens(ctx);
-		const cal = calibrate(entries, sys);
-		return { cal, o: { mode, sys, k: cal.k, cwd: (ctx?.cwd as string) ?? process.cwd(), recalled: this.recalled, model: ctx?.model, promptPending: pending, rereadOnly: !this.recallOk, noSummary: mode === "warm" && this.summarizedWarm, reserve: this.reserve(ctx), steerIds: this.steerIds, law: this.law(ctx, pWarm), trace: [] } };
+	/** Plan options with the token scale read from the branch. */
+	private opts(ctx: Any, pending: boolean, mode: "cold" | "warm", entries: Any[], pWarm = mode === "cold" ? 0 : 1): { o: PlanOpts; cal: Scale } {
+		const cal = this.scaleOf(ctx, entries);
+		const fileRecall = this.fileRecall(ctx);
+		const rereadOnly = this.recallMode === "reread" || (this.recallMode === "file" && !fileRecall);
+		return { cal, o: { mode, scale: cal, cwd: (ctx?.cwd as string) ?? process.cwd(), recalled: this.recalled, model: ctx?.model, promptPending: pending, rereadOnly, ...(fileRecall ? { fileRecall } : {}), noSummary: mode === "warm" && this.summarizedWarm, ...(FOLD_HOLD && mode === "warm" ? this.holdOf(ctx) : {}), reserve: this.reserve(ctx), steerIds: this.steerIds, law: this.law(ctx, pWarm), trace: [] } };
+	}
+
+	/** The prompt of the session's last cold return: the first user message after the newest COLD_CUSTOM entry (none: nothing is held). */
+	private holdOf(ctx: Any): { hold?: { anchor: string } } {
+		const branch = this.branch(ctx);
+		let mark = -1;
+		branch.forEach((e: Any, i: number) => { if (e?.type === "custom" && e.customType === COLD_CUSTOM) mark = i; });
+		if (mark < 0) return {};
+		const at = branch.findIndex((e: Any, i: number) => i > mark && e?.type === "message" && e.message?.role === "user" && !this.steerIds.has(e.id));
+		return at < 0 ? {} : { hold: { anchor: branch[at].id } };
 	}
 
 	private law(ctx: Any, pWarm: number): Law {
 		const m = ctx?.model ?? this.model;
 		const ent = this.entKey === modelKey(m) ? this.ent : undefined;
-		return { pr: lawPrices(ent?.cls, resolveTtl(m, this.branch(ctx)).ms >= 3_600_000), g: this.g, pWarm };
+		return { pr: lawPrices(ent?.cls, resolveTtl(m, this.branch(ctx), this.tier(m)).ms >= 3_600_000), g: this.g, pWarm };
 	}
 	private entKey = "";
 	private loadEnt(key: string) {
@@ -242,6 +420,25 @@ export class Zip implements ZipControl {
 		});
 	}
 
+	/** Ledger only (research pi-tricks §3.5): entries another context manager wrote into this branch, each logged once: a context_edit
+	 *  that is neither pi-zip's placeholder nor Pi's own omission (null), or a compaction an extension other than pi-zip supplied.
+	 *  Nothing is decided from it. */
+	private foreignSeen = new Set<string>();
+	private logForeign(ctx: Any, where: string) {
+		if (!process.env.PI_ZIP_LEDGER || this.off) return; // the ledger is the only reader
+		for (const e of this.branch(ctx)) {
+			if (typeof e?.id !== "string" || this.foreignSeen.has(e.id)) continue;
+			let rec: Record<string, unknown> | null = null;
+			if (e.type === "context_edit" && e.replacement != null) {
+				const text = textOf(e.replacement.content);
+				if (!text.startsWith(PH_MARK)) rec = { kind: "context_edit", targetId: e.targetId ?? null, chars: text.length, head: text.slice(0, 60) };
+			} else if (foreignCompaction(e)) rec = { kind: "compaction", by: e.details?.by ?? null, firstKeptEntryId: e.firstKeptEntryId ?? null, chars: String(e.summary ?? "").length };
+			if (!rec) continue;
+			this.foreignSeen.add(e.id);
+			this.ledger({ type: "foreign_edit", where, id: e.id, ...rec });
+		}
+	}
+
 	private detectConflict(ctx: Any) {
 		let found: string | null = null;
 		try {
@@ -262,6 +459,7 @@ export class Zip implements ZipControl {
 
 	// ---- events ----------------------------------------------------------------------------------------------
 	sessionStart(ctx: Any) {
+		this.liveCtx = ctx;
 		const branch = this.branch(ctx);
 		for (let i = branch.length - 1; i >= 0; i--) {
 			const en = branch[i];
@@ -275,8 +473,138 @@ export class Zip implements ZipControl {
 		for (const h of recalledHandlesFromBranch(branch)) this.recalled.add(h);
 		this.model = ctx?.model;
 		this.ttlNoticed = false;
+		this.restoreState(branch);
 		this.detectConflict(ctx);
-		this.ledger({ type: "session_start", off: this.off, quiet: this.quiet, conflict: this.conflict });
+		let recallFilesRemoved = 0;
+		try {
+			recallFilesRemoved = cleanupRecall(); // recall copies older than 14 days (they can be written again from the session)
+		} catch {}
+		this.ledger({ type: "session_start", off: this.off, quiet: this.quiet, conflict: this.conflict, ...(recallFilesRemoved ? { recallFilesRemoved } : {}) });
+	}
+
+	/** A resumed (or restarted, reloaded, forked) process arms the away timer from the branch's last request, as `settle` would have after
+	 *  it (formal TRIAGE (a) 7): the summary for the next cold return is prepared while the user is away, not while they wait. Only when
+	 *  the session ended on a finished response (a run cut off mid-tool has no settle point) and the plan for it has a cut. Called after
+	 *  the recall mode is known (it decides which outputs fold, so which plan the return will make). */
+	resumeAway(ctx: Any) {
+		try {
+			const branch = this.branch(ctx);
+			if (!this.active() || !ctx?.hasUI || !ctx?.model) return;
+			const last = [...branch].reverse().find((en: Any) => en?.type === "message" && en.message);
+			const m = last?.message;
+			if (m?.role !== "assistant" || m.stopReason === "toolUse") return;
+			const entries = ((ctx.sessionManager.buildSessionProjection() as Any)?.entries ?? []) as Any[];
+			if (!entries.length) return;
+			this.loadEnt(modelKey(ctx.model));
+			const { o } = this.opts(ctx, true, "cold", entries);
+			const p = planContext(entries, o);
+			if (!p || p.cutIdx === null) return;
+			const at = lastMessageMs(branch);
+			const delayMs = this.scheduleSummary(p, ctx, at || undefined);
+			this.ledger({ type: "away_resumed", timerMs: delayMs, lastRequestMs: at });
+		} catch (err) {
+			this.ledger({ type: "error", where: "resume_away", error: errText(err) });
+		}
+	}
+
+	/** What a process that never left would know: growth g, "the newest response carried an edit" and "a summary was made in this warm
+	 *  stretch" are functions of the session, rebuilt from the branch (state.ts; a restart, a resume or a fork plans like the live process). */
+	private restoreState(branch: Any[]) {
+		try {
+			const r = replayGrowth(branch, G0);
+			this.g = r.g;
+			this.deltas = r.deltas;
+			this.justEdited = r.justEdited;
+			this.summarizedWarm = this.summarizedSince(branch);
+			if (branch.length) this.ledger({ type: "state_restored", g: Math.round(this.g), justEdited: this.justEdited, summarizedWarm: this.summarizedWarm });
+		} catch (err) {
+			this.ledger({ type: "error", where: "restore_state", error: errText(err) });
+		}
+	}
+
+	/** Is the newest pi-zip summary of the branch newer than the last cold return? (The live flag: set when a summary is persisted,
+	 *  cleared at a cold return.) Each user prompt after the summary is judged as `detectCold` judged it, from the branch before it. */
+	private summarizedSince(branch: Any[]): boolean {
+		let at = -1;
+		branch.forEach((e, i) => { if (e?.type === "compaction" && e.details?.by === PRODUCT) at = i; });
+		if (at < 0) return false;
+		let skip = branch[at].details?.via === "native"; // the prompt after a native summary is the very return that made it
+		const models = loadStats().models;
+		for (let i = at + 1; i < branch.length; i++) {
+			const m = branch[i]?.type === "message" ? branch[i].message : null;
+			if (m?.role !== "user" || this.steerIds.has(branch[i].id)) continue;
+			if (skip) { skip = false; continue; }
+			const a = branch.slice(i + 1).find((x: Any) => x?.type === "message" && x.message?.role === "assistant" && x.message.provider)?.message;
+			if (!a) continue; // a prompt nothing answered
+			const model = { provider: a.provider, id: a.model };
+			const ts = Number(m.timestamp) || Date.parse(branch[i].timestamp) || 0;
+			const ent = models[modelKey(model)];
+			if (detectCold(model, 0, branch.slice(0, i), ts, "", (g, prior) => pWarm(ent, g, prior), this.tier(model)).cold) return false;
+		}
+		return true;
+	}
+
+	// ---- recall through files (research pi-tricks §2) -----------------------------------------------------------------------
+	/** This machine's directory for this session's recall files. */
+	private localRecallDir(ctx: Any): string | null {
+		const sid = this.recallSid(ctx);
+		return sid ? join(recallRoot(), sidDir(sid)) : null;
+	}
+	/** Write the originals of these handles (from the current branch) if they are not on disk as they are: their local paths. */
+	private materializeHandles(ctx: Any, handles: string[]): Map<string, string> {
+		const sid = this.recallSid(ctx);
+		if (!sid || !handles.length) return new Map();
+		const { items } = resolveHandlesInBranch(this.branch(ctx), handles);
+		const found = items.filter((it): it is typeof it & { text: string } => it.text !== null);
+		const out = materialize(recallRoot(), sid, found.map((it) => ({ handle: it.handle, text: it.text })));
+		this.ledger({ type: "recall_file", handles: found.map((it) => it.handle), missing: handles.length - found.length, chars: found.reduce((a, it) => a + it.text.length, 0) });
+		return out;
+	}
+	/** Every output this session's model no longer sees in full (folded, or summarised away): what a grep, ls or find over the directory needs. */
+	private materializeAll(ctx: Any): string | null {
+		const sid = this.recallSid(ctx);
+		if (!sid) return null;
+		let visible = new Set<string>();
+		try {
+			const entries = ((ctx.sessionManager.buildSessionProjection() as Any)?.entries ?? []) as Any[];
+			visible = new Set(entries.filter((pe) => pe?.sourceEntry?.type === "message" && pe.messages?.[0]?.role === "toolResult" && !textOf(pe.messages[0].content).startsWith(PH_MARK)).map((pe) => pe.sourceEntry.id));
+		} catch {}
+		const zipped = branchOutputs(this.branch(ctx)).filter((o) => o.tool !== RECALL_TOOL && !visible.has(o.entryId));
+		materialize(recallRoot(), sid, zipped.map((o) => ({ handle: o.handle, text: o.text })));
+		this.ledger({ type: "recall_file", all: true, count: zipped.length, chars: zipped.reduce((a, o) => a + o.text.length, 0) });
+		return join(recallRoot(), sidDir(sid));
+	}
+	/**
+	 * tool_call: a built-in read, grep, find or ls whose path names a recall file (or this session's recall directory), or a bash command
+	 * that does, gets this machine's copy, written now from the current branch if it is not on disk yet. Any prefix is accepted (another
+	 * machine, another user, a forked session's id): the handle is resolved against the current branch. Never blocks a call.
+	 */
+	toolCall(e: Any, ctx: Any): undefined {
+		try {
+			const input = e?.input, name = e?.toolName;
+			if (!input || typeof input !== "object") return undefined;
+			if ((name === "read" || name === "grep" || name === "find" || name === "ls") && typeof input.path === "string") {
+				const ref = parseRecallPath(input.path);
+				if (!ref) return undefined;
+				if (ref.handle) {
+					const local = this.materializeHandles(ctx, [ref.handle]).get(ref.handle);
+					if (local) input.path = local;
+				} else if (name !== "read") {
+					const dir = this.materializeAll(ctx);
+					if (dir) input.path = dir;
+				}
+			} else if (name === "bash" && typeof input.command === "string" && commandNamesRecall(input.command)) {
+				const dir = this.localRecallDir(ctx);
+				if (!dir) return undefined;
+				const r = rewriteCommand(input.command, dir);
+				if (r.dir) this.materializeAll(ctx);
+				else this.materializeHandles(ctx, r.handles);
+				input.command = r.command;
+			}
+		} catch (err) {
+			this.ledger({ type: "error", where: "tool_call", error: errText(err) });
+		}
+		return undefined;
 	}
 
 	shutdown() {
@@ -285,7 +613,8 @@ export class Zip implements ZipControl {
 		this.bg = null;
 	}
 
-	beforeAgentStart(ctx: Any) {
+	async beforeAgentStart(ctx: Any, e?: Any): Promise<void> {
+		this.liveCtx = ctx;
 		this.cancelTimer(); // the user is back: nothing is started behind their back any more
 		this.model = ctx?.model;
 		this.cold = false;
@@ -293,10 +622,13 @@ export class Zip implements ZipControl {
 		this.runChecked = true;
 		this.runEdits = false;
 		this.runPlan = null;
+		this.nativeRun = null;
+		this.foreignRun = false;
 		this.settleIds = [];
 		this.bgWaitMs = 0;
 		this.wireLedgered = false;
 		this.runUserSeen = 0;
+		this.logForeign(ctx, "run");
 		if (!this.active()) return;
 		this.detectConflict(ctx);
 		if (!this.active()) return;
@@ -305,15 +637,21 @@ export class Zip implements ZipControl {
 		this.loadEnt(key);
 		this.branchLastMs = lastMessageMs(branch);
 		if (!this.prevKey) ({ key: this.prevKey, total: this.prevTotal } = lastPrompt(branch)); // fresh process: the session's newest response
-		const { cold, reason, ttl, pWarm: p, src, gapS, pastTtl } = detectCold(ctx.model, this.lastReqMs, branch, Date.now(), this.lastModelKey, (g, prior) => pWarm(this.ent, g, prior));
+		await this.resolveRetention(ctx);
+		const { cold, reason, ttl, pWarm: p, src, gapS, pastTtl } = detectCold(ctx.model, this.lastReqMs, branch, Date.now(), this.lastModelKey, (g, prior) => pWarm(this.ent, g, prior), this.tier(ctx.model));
 		this.cold = cold;
-		if (cold) this.summarizedWarm = false; // a cold return may summarise again
+		if (cold) {
+			this.summarizedWarm = false; // a cold return may summarise again
+			try {
+				this.pi.appendEntry(COLD_CUSTOM, {}); // right before the prompt: the session says where its last cold return was (plan.ts FOLD_HOLD)
+			} catch {}
+		}
 		this.pastTtl = pastTtl;
 		this.pWarm = p;
 		this.survSrc = src;
 		this.runChecked = false; // the first request decides (cold: the cold plan; warm: only above the cap, if the law fires)
 		this.coldReason = reason;
-		this.coldWhy = src === "model switch" ? "model switched: its cache starts empty, so this request rewrites it anyway" : cold && gapS !== null ? `cache cold (away ${fmtAway(gapS)}): this request rewrites it anyway, so editing is free` : "";
+		this.coldWhy = src === "model switch" ? "cache cold · model switched" : cold && gapS !== null ? `cache cold · away ${fmtAway(gapS)}` : ""; // the warm form says "cache warm · worth it at this size"
 		for (const h of recalledHandlesFromBranch(branch)) this.recalled.add(h);
 		for (let i = branch.length - 1; i >= 0; i--) {
 			const en = branch[i];
@@ -328,12 +666,164 @@ export class Zip implements ZipControl {
 			this.ttlNoticed = true; // once per session
 			if (!this.quiet) this.stateLine(ctx, "cache", ttl.note.replace(`${PRODUCT} · `, ""));
 		}
+		if (cold && this.bg?.done) {
+			try {
+				await this.nativeSummary(ctx, e);
+			} catch (err) {
+				const a = this.nativeAsk;
+				if (a && !a.answered) a.compaction = null; // a late ask of pi-zip's compaction is cancelled, never left to Pi's own summary
+				this.ledger({ type: "error", where: "native_summary", error: errText(err) });
+			}
+		}
+	}
+
+	/** session_before_compact: answers ONLY the compaction pi-zip itself asked for a moment ago (nativeAsk): its own summary and its own
+	 *  tokensBefore. Pi's threshold and overflow compactions, /compact and other extensions' compactions get undefined and run untouched.
+	 *  Once pi-zip has given up on its compaction (compaction null), a late ask of it is cancelled, never one with a live signal: that is
+	 *  another compaction (pi-zip's own was aborted). */
+	sessionBeforeCompact(e?: Any): Any {
+		const a = this.nativeAsk;
+		if (!a || a.answered || Date.now() > a.until) return undefined;
+		if (e?.reason !== undefined && e.reason !== "manual") return undefined; // ctx.compact() is a manual compaction
+		if (!a.compaction && e?.signal && e.signal.aborted !== true) return undefined;
+		a.answered = true;
+		a.askedAt = performance.now();
+		return a.compaction ? { compaction: a.compaction } : { cancel: true };
+	}
+
+	/** The native path ends for the rest of the process (logged once): from now on summaries ride along with the first request. */
+	private endNative(reason: string) {
+		if (this.nativeOff) return;
+		this.nativeOff = reason;
+		this.ledger({ type: "native_off", reason });
+	}
+
+	/** Why Pi's own compaction cannot take this summary now (null: it can). Each reason keeps today's path: the run plan carries the summary
+	 *  request-locally and turn_end persists it as a draft. */
+	private nativeGate(ctx: Any, branch: Any[], pre: Any[]): string | null {
+		if (this.nativeOff) return "off for this process";
+		if (typeof ctx?.compact !== "function") return "no ctx.compact";
+		if (typeof ctx?.abort !== "function") return "no ctx.abort"; // what cancels a compaction another handler holds up
+		// another extension supplies compactions in this session: its session_before_compact handler would run for pi-zip's too
+		if (branch.some(foreignCompaction)) return "another extension's compaction is in this branch";
+		let idle = false;
+		try {
+			idle = ctx.isIdle?.() === true; // compact() aborts whatever runs first: only ever called while Pi is idle (it is, here, in 1.1.0)
+		} catch {}
+		if (!idle) return "not idle";
+		if (branch[branch.length - 1]?.type === "compaction") return "already compacted";
+		let settings: Any;
+		try {
+			settings = this.pi.getSettings?.();
+		} catch {}
+		if (!piCanCompact(pre, keepRecentTokensFor(settings, ctx?.model))) return "nothing to compact";
+		return null;
+	}
+
+	/**
+	 * A summary prepared while the user was away goes into the session through Pi's own compaction, before the run (research pi-tricks
+	 * §1b, variant 1): ctx.compact() with session_before_compact answering pi-zip's summary and pi-zip's own tokensBefore (the notice's
+	 * "before", provider scale), so Pi's "[compaction] Compacted from N tokens" shows that number. It takes milliseconds: the summary is
+	 * done. The run plan is then made on the projection as it was before the compaction, so the run's first request carries the same
+	 * bytes as the draft path would have sent; any gate that fails keeps the draft path.
+	 * Pi runs every extension's session_before_compact handler for it (the last answer wins, a cancel stops it): unless pi-zip's own
+	 * entry is the one that went in, fast, the native path ends for the process (endNative). A compaction not finished by the deadline
+	 * is cancelled first, and a summary prepared for a context another extension's compaction has replaced is discarded, never adopted.
+	 */
+	private async nativeSummary(ctx: Any, e: Any): Promise<void> {
+		const b = this.bg;
+		if (!b?.done || !b.key) return;
+		const branch = this.branch(ctx);
+		const pre = ((ctx.sessionManager.buildSessionProjection() as Any)?.entries ?? []) as Any[];
+		const skip = (reason: string) => this.ledger({ type: "native_skip", reason });
+		// the plan the first request will make: the same one, with the prompt Pi is about to append
+		const pending = pendingPrompt(e);
+		const entries = pending ? [...pre, pending] : pre;
+		const { o } = this.opts(ctx, !pending, "cold", entries, this.pWarm);
+		o.pastTtl = this.pastTtl;
+		const p = planContext(entries, o);
+		if (!p || p.cutIdx === null || p.firstKeptEntryId !== b.key) return skip("the summary does not fit this plan");
+		const cut = b.done;
+		if (checkEdits(p.blocks, p.userTurns, p.folds, cut)) return skip("guard");
+		const gate = this.nativeGate(ctx, branch, pre);
+		if (gate) return skip(gate);
+		const before = Math.round(p.ctxTokens);
+		const compaction = { summary: cut.text, firstKeptEntryId: cut.firstKeptEntryId, tokensBefore: before, details: { by: PRODUCT, via: "native", trigger: cut.trigger }, usage: cut.usage };
+		const known = new Set(branch.map((en: Any) => en?.id));
+		const ask = { compaction: compaction as Any | null, answered: false, askedAt: 0, until: Infinity };
+		this.nativeAsk = ask;
+		const deadline = nativeDeadlineMs(), t0 = performance.now();
+		const res = await new Promise<{ ok: boolean; err?: string; late?: boolean }>((resolve) => {
+			let settled = false;
+			const finish = (r: { ok: boolean; err?: string; late?: boolean }) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				resolve(r);
+			};
+			const timer = setTimeout(() => {
+				if (!ask.answered) ask.compaction = null; // asked after this, pi-zip cancels: never Pi's own summary on pi-zip's behalf
+				ask.until = Date.now() + 60_000;
+				finish({ ok: false, late: true });
+			}, deadline);
+			timer.unref?.();
+			const done = (r: { ok: boolean; err?: string }) => {
+				if (this.nativeAsk === ask) this.nativeAsk = null; // pi-zip's compaction is over: nothing is answered for it any more
+				finish(r);
+			};
+			try {
+				ctx.compact({ onComplete: () => done({ ok: true }), onError: (err: Any) => done({ ok: false, err: err instanceof Error ? err.message : String(err) }) });
+			} catch (err) {
+				done({ ok: false, err: errText(err) });
+			}
+		});
+		const ms = Math.round(performance.now() - t0), askMs = ask.askedAt ? Math.round(ask.askedAt - t0) : null;
+		// what went in: compactions added since the call (pi-zip's is the one carrying its summary; Pi keeps the last handler's answer)
+		const added = this.branch(ctx).filter((en: Any) => en?.type === "compaction" && !known.has(en?.id));
+		const last = added[added.length - 1] ?? null;
+		const entry = last && last.summary === cut.text ? last : null;
+		// still pending at the deadline: cancel it now, before the run starts (Pi checks its abort signal right before it appends)
+		if (res.late && !last) {
+			try {
+				ctx.abort?.();
+			} catch {}
+		}
+		const off = entry
+			? added.length > 1 ? "another compaction went in as well" : res.late || ms > Math.min(NATIVE_SLOW_MS, deadline / 2) ? `Pi's compaction took ${ms} ms: another session_before_compact handler at work` : null
+			: last ? "another extension's compaction went in instead of pi-zip's"
+			: res.late ? (ask.answered ? `Pi's compaction was not done ${deadline} ms after pi-zip answered (cancelled)` : `another session_before_compact handler ran before pi-zip's (cancelled after ${deadline} ms)`)
+			: `Pi's compaction failed: ${res.err ?? "no compaction entry"}`;
+		if (off) this.endNative(off);
+		if (!entry?.id) {
+			this.ledger({ type: "native_fail", ms, askMs, answered: ask.answered, error: res.late ? "deadline" : (res.err ?? "no compaction entry"), foreign: !!last });
+			if (last) {
+				// another extension's compaction replaced the context this summary was written for: adopting it, or writing a new one on
+				// top of it, would summarise twice. It is this stretch's summary (summarizedWarm, as after a pi-zip summary).
+				this.discardBg();
+				this.foreignRun = true;
+				this.summarizedWarm = true;
+			}
+			return; // nothing went in: the draft path, the run plan adopts the prepared summary as before
+		}
+		this.bg = null; // adopted by Pi's compaction
+		this.summarizedWarm = true; // one summary per warm stretch, as for a draft (commit)
+		// the summary is in the session from now on, whatever the run does: book it here (commit() does not book it again)
+		const cutSaved = Math.round(p.scale.c * (cut.prefixTokens - cut.summaryTokens));
+		this.nativeRun = { key: b.key, cut, before, after: Math.round(p.ctxAfterFolds - cutSaved), pre, entryId: entry.id };
+		const s = this.stats;
+		s.summaries++;
+		s.summarizedTokens += cutSaved;
+		s.summaryUsd += cut.costUsd;
+		s.activeSaved += cutSaved;
+		s.writeSavedTokens += cutSaved;
+		this.ledger({ type: "summary", via: "native", trigger: cut.trigger, source: "settle", count: cut.count, tokensBefore: before, prefixTokens: Math.round(p.scale.c * cut.prefixTokens), summaryTokens: Math.round(p.scale.c * cut.summaryTokens), ms: cut.ms, compactMs: ms, askMs, waitedMs: 0, llmOk: cut.llmOk, llmError: cut.llmError, costUsd: cut.costUsd, ...this.usageOf(cut) });
 	}
 
 	private cancelTimer() {
 		this.timerGen++;
 		if (this.timer) clearTimeout(this.timer);
 		this.timer = null;
+		this.awayPlan = null;
 	}
 
 	/** A summary nobody adopted still cost money: abort it if it is still running, book it if it finished. */
@@ -364,20 +854,25 @@ export class Zip implements ZipControl {
 				this.ledger({ type: "error", where: "context/run_plan", error: errText(err) });
 			}
 		}
+		if (ctx?.signal?.aborted) return undefined; // Esc (Pi cancelled the prompt): this request never goes out, so nothing is applied or announced
 		if (this.runPlan && !this.runPlan.persisted) {
 			const out = applyPlanToMessages(e.messages, this.runPlan);
-			if (out) {
+			if (out || this.runPlan.native) { // a native summary is already in the request Pi built: it still goes out with this request
 				if (!this.runPlan.sent) this.nextEdit = this.runPlan.untouched ?? 0;
 				this.runPlan.sent = true;
-				this.runPlan.applied = out.applied;
-				return { messages: out.messages };
+				const applied = (this.runPlan.applied = out?.applied ?? this.runPlan.applied ?? new Set<string>());
+				if (!this.runPlan.noticed) { // say it where it happens: at the top of the turn, before the model answers
+					this.runPlan.noticed = true;
+					const live = this.runPlan.folds.filter((t) => applied.has(t.entryId));
+					this.noticeFor(ctx, this.runPlan, live, this.runPlan.cut ?? this.runPlan.native ?? null, this.runPlan.ctxBefore, 0);
+				}
+				return out ? { messages: out.messages } : undefined;
 			}
 		}
 		return undefined;
 	}
 
-	/** A prepared summary for this cut, or null. A summary still being written is waited for (only the remainder); Esc stops the waiting, not the work. */
-	/** While the user waits for a summary, Pi's working line says what for (and that Esc skips a prepared one). */
+	/** While the user waits for a summary, Pi's working line says what for. */
 	private async working<T>(ctx: Any, text: string, p: Promise<T>): Promise<T> {
 		const ui = ctx?.mode === "tui" ? ctx?.ui : null;
 		try {
@@ -392,6 +887,8 @@ export class Zip implements ZipControl {
 		}
 	}
 
+	/** A prepared summary for this cut, or null. A summary still being written is waited for (only the remainder). Esc there cancels the
+	 *  whole prompt (Pi 1.1.0 aborts the run, research pi-tricks §3.6): the waiting stops, the summary goes on for the next try. */
 	private async takeBg(key: string | null, signal?: AbortSignal, ctx?: Any): Promise<{ cut: Cut | null; adopted: boolean }> {
 		const b = this.bg;
 		if (!b || key === null || b.key !== key) {
@@ -399,7 +896,7 @@ export class Zip implements ZipControl {
 			return { cut: null, adopted: false };
 		}
 		const w0 = performance.now();
-		const cut = b.done ?? (await this.working(ctx, `${PRODUCT}: finishing the summary it started while you were away · Esc skips it`, waitFor(b.promise, signal)));
+		const cut = b.done ?? (await this.working(ctx, `${PRODUCT}: finishing the summary it started while you were away · Esc cancels this prompt`, waitFor(b.promise, signal)));
 		this.bgWaitMs = performance.now() - w0;
 		if (cut) {
 			this.bg = null;
@@ -413,17 +910,36 @@ export class Zip implements ZipControl {
 	/** ONE plan per edit run: computed at the first request (the new prompt is in the session), applied to every request until turn_end persists the same set. */
 	private async computeRunPlan(ctx: Any) {
 		const t0 = performance.now();
-		const entries = ((ctx.sessionManager.buildSessionProjection() as Any)?.entries ?? []) as Any[];
+		const now = ((ctx.sessionManager.buildSessionProjection() as Any)?.entries ?? []) as Any[];
+		// a summary that went in through Pi's compaction before the run (nativeSummary): plan on the projection as it was right before
+		// it, plus what came after, so folds, scale and placeholders are exactly what the draft path computes (the run's first request
+		// carries the same bytes); the request Pi builds already starts with the summary
+		const nat = this.nativeRun, foreign = this.foreignRun;
+		this.nativeRun = null;
+		this.foreignRun = false;
+		const spliced = nat ? spliceNative(nat.pre, now, nat.entryId) : null;
 		if (!this.cold && this.justEdited) { // no warm edit on the request right after an edited one (no back-to-back warm rewrites)
 			this.ledger({ type: "b2b_skip", where: "run" });
 			this.discardBg();
 			return;
 		}
-		const { o, cal } = this.opts(ctx, false, this.cold ? "cold" : "warm", entries, this.pWarm);
-		o.pastTtl = this.pastTtl;
-		const p = planContext(entries, o);
+		const plan = (entries: Any[]) => {
+			const { o, cal } = this.opts(ctx, false, this.cold ? "cold" : "warm", entries, this.pWarm);
+			o.pastTtl = this.pastTtl;
+			if (foreign) o.noSummary = true; // another extension's compaction just went in: folds only (a summary only at Pi's compaction room)
+			return { o, cal, p: planContext(entries, o) };
+		};
+		let { o, cal, p } = plan(spliced ?? now);
+		const onPre = !!nat && !!spliced && !!p && p.cutIdx !== null && p.firstKeptEntryId === nat.key;
+		if (nat && !onPre) {
+			// the summary is in the session, but this plan would not cut there (the prompt, or what came with it, changed the plan): plan on
+			// the session as it is now, with the summary at its head
+			this.ledger({ type: "native_mismatch", planned: p?.firstKeptEntryId ?? null, compacted: nat.key });
+			({ o, cal, p } = plan(now));
+		}
 		this.lawLedger("run", o);
-		if (!p) {
+		const native = nat?.cut ?? null;
+		if (!p && !native) {
 			this.discardBg(); // the law does not fire (warm below the cap or a rewrite that does not pay back; a likely-warm cold return): a prepared summary does not pay back
 			return;
 		}
@@ -431,35 +947,46 @@ export class Zip implements ZipControl {
 		const trigger = this.cold ? "cold" : "valve";
 		let folds: FoldTarget[] = p?.folds ?? [];
 		let cut: Cut | null = null;
-		let adopted = false;
-		if (p && p.cutIdx !== null) {
+		let adopted = !!native; // Pi's compaction took the prepared summary
+		if (!native && p && p.cutIdx !== null) {
 			const got = await this.takeBg(p.firstKeptEntryId, ctx.signal, ctx);
 			cut = got.cut;
 			adopted = got.adopted;
-		} else {
+		} else if (!native) {
 			this.discardBg();
 		}
 		const sameSet = this.settleIds.length === folds.length && this.settleIds.every((id) => folds.some((u) => u.entryId === id));
 		const source: RunPlan["source"] = !this.cold ? "valve" : adopted || (this.settleIds.length > 0 && sameSet) ? "settle" : "runstart";
 		const foldMs = performance.now() - t0;
-		if (!cut && p && p.cutIdx !== null && !ctx.signal?.aborted) cut = await this.working(ctx, `${PRODUCT}: writing a summary (folding alone cannot make the context small enough)`, buildCut(p, ctx)); // produced now, before the first request: the user waits
+		if (!cut && !native && p && p.cutIdx !== null && !ctx.signal?.aborted) cut = await this.working(ctx, `${PRODUCT}: writing a summary (folding alone cannot make the context small enough)`, buildCut(p, ctx)); // produced now, before the first request: the user waits
 		// a plan that cannot be persisted must never be sent: the request view would differ from what turn_end can write (I1)
 		if (p) {
-			const invalid = checkEdits(p.blocks, p.userTurns, folds, cut);
+			const invalid = checkEdits(p.blocks, p.userTurns, folds, cut ?? (onPre ? native : null));
 			if (invalid) {
-				this.ledger({ type: "guard_drop", where: "run_plan", reason: invalid, folds: folds.length, summary: !!cut });
-				if (cut && checkEdits(p.blocks, p.userTurns, folds, null) === null) cut = null;
+				this.ledger({ type: "guard_drop", where: "run_plan", reason: invalid, folds: folds.length, summary: !!(cut ?? native) });
+				if (native) folds = []; // the summary is in the session already: only the folds can be dropped
+				else if (cut && checkEdits(p.blocks, p.userTurns, folds, null) === null) cut = null;
 				else { folds = []; cut = null; }
 			}
 		}
-		const ctxAfter = cut ? (p?.ctxAfterFolds ?? 0) - cal.k * (cut.prefixTokens - cut.summaryTokens) : (p?.ctxAfterFolds ?? 0);
-		this.runPlan = { source, folds, cut, ctxBefore: p?.ctxTokens ?? 0, ctxAfter, ms: foldMs, k: cal.k, persisted: false, cutVisibleIdx: p?.cutVisibleIdx ?? -1, cutKeptFirstMsg: p?.cutKeptFirstMsg, untouched: p ? p.k * untouchedEst(p.blocks, folds, !!cut, o.sys) : 0 };
-		this.ledger({ type: "cold_plan", trigger, source, folds: folds.length, summary: !!cut, ...this.calOf(cal), ctxBefore: Math.round(this.runPlan.ctxBefore), ctxAfter: Math.round(ctxAfter), ms: Math.round(foldMs), ...(cut ? { summaryMs: cut.ms, llmOk: cut.llmOk, waitedMs: Math.round(adopted ? this.bgWaitMs : cut.ms), ...this.usageOf(cut) } : {}) });
+		const sum = cut ?? (onPre ? native : null); // a summary this plan's sizes do not count yet
+		let ctxBefore = p?.ctxTokens ?? 0;
+		let ctxAfter = (p?.ctxAfterFolds ?? 0) - (sum ? cal.c * (sum.prefixTokens - sum.summaryTokens) : 0);
+		if (nat) {
+			// the notice's "before" is the number Pi's [compaction] block shows (computed with the prompt before Pi appended it)
+			ctxAfter = p ? ctxAfter + (onPre ? nat.before - ctxBefore : 0) : nat.after;
+			ctxBefore = nat.before;
+		}
+		this.runPlan = {
+			source, folds: onPre ? rebaseFolds(folds, p!.cutVisibleIdx) : folds, cut, native: native ?? undefined, ctxBefore, ctxAfter, ms: foldMs, scale: cal, persisted: false,
+			waitMs: cut ? (adopted ? this.bgWaitMs : cut.ms) : 0, cutVisibleIdx: p?.cutVisibleIdx ?? -1, cutKeptFirstMsg: p?.cutKeptFirstMsg, untouched: p ? sizeOf(cal, untouchedEst(p.blocks, folds, !!(cut ?? native))) : sizeOf(cal, 0),
+		};
+		this.ledger({ type: "cold_plan", trigger, source, folds: folds.length, summary: !!(cut ?? native), ...(p?.ahead ? { ahead: true } : {}), ...(native ? { via: "native", onPre } : {}), ...this.calOf(cal), ctxBefore: Math.round(ctxBefore), ctxAfter: Math.round(ctxAfter), ms: Math.round(foldMs), ...(cut ? { summaryMs: cut.ms, llmOk: cut.llmOk, waitedMs: Math.round(adopted ? this.bgWaitMs : cut.ms), ...this.usageOf(cut) } : {}) });
 	}
 
-	/** Ledger form of a calibration; ctxBefore/ctxAfter next to it are already scaled (k x estimate). */
-	private calOf(cal: Calibration) {
-		return { k: Math.round(cal.k * 1000) / 1000, calReal: cal.real, calEst: Math.round(cal.est), calSource: cal.source };
+	/** Ledger form of a calibration; ctxBefore/ctxAfter next to it are already real (O + c x estimate). */
+	private calOf(cal: Scale) {
+		return { O: Math.round(cal.O), c: Math.round(cal.c * 1000) / 1000, oSource: cal.oSource, calReal: cal.real, calEst: Math.round(cal.est), calSource: cal.source };
 	}
 
 	private usageOf(cut: Cut) {
@@ -490,8 +1017,11 @@ export class Zip implements ZipControl {
 				}
 			} else {
 				this.discardBg();
+				// no cut now, but the timer still runs: if Pi's own compaction or another extension's edit rewrites the context while the user
+				// is away, the plan made then may have one (runAway plans again when the context changed since this settle)
+				scheduledMs = this.scheduleSummary(p, ctx);
 			}
-			this.ledger({ type: "settle_plan", folds: p.folds.length, summary: p.cutIdx !== null, timerMs: scheduledMs, ...this.calOf(cal), ctxBefore: Math.round(p.ctxTokens), ms: Math.round(performance.now() - t0) });
+			this.ledger({ type: "settle_plan", folds: p.folds.length, summary: p.cutIdx !== null, ...(p.ahead ? { ahead: true } : {}), timerMs: scheduledMs, ...this.calOf(cal), ctxBefore: Math.round(p.ctxTokens), ms: Math.round(performance.now() - t0) });
 			if (!p.folds.length && p.cutIdx === null) return undefined;
 			// ids only: placeholders and summary text are recomputed (they are pure functions of the session), never stored a second time
 			const data = { policy: PRODUCT, ts: Date.now(), targets: p.folds.map((t) => t.entryId), cutKey: p.firstKeptEntryId };
@@ -503,18 +1033,127 @@ export class Zip implements ZipControl {
 	}
 
 	/** Start the away-timer for a summary; returns the delay in ms. unref'd: it never keeps the process alive. */
-	private scheduleSummary(p: PlanResult, ctx: Any): number {
-		const ttl = ttlFor(ctx.model, this.branch(ctx));
-		const delay = Math.max(0, (this.lastReqMs || Date.now()) + AWAY_FRACTION * ttl - Date.now());
+	private scheduleSummary(p: PlanResult, ctx: Any, lastMs?: number): number {
+		const ttl = ttlFor(ctx.model, this.branch(ctx), this.tier(ctx.model));
+		const last = lastMs ?? (this.lastReqMs || Date.now());
+		this.awaySig = this.contextSig(ctx);
+		const warm = this.idleWarming() ? warmingDelayMs(ttl) : undefined;
+		if (warm !== undefined) {
+			// Pi keeps the cache warm between runs (cacheWarming "idle") and decides before each refresh, at its warming delay: a summary
+			// written now would be thrown away at a warm return, so it waits for Pi's decision (cacheWarmingDecision); should none come
+			// (Pi is not warming this request after all), it starts just after the decision was due
+			this.awayPlan = { p, ctx };
+			const delay = Math.max(0, last + warm + warmingMargin(ttl) - Date.now());
+			this.armAway(delay, () => this.startAway("no warming decision"));
+			return Math.round(delay);
+		}
+		const delay = Math.max(0, last + AWAY_FRACTION * ttl - Date.now());
+		this.armAway(delay, () => void this.runAway(p, ctx));
+		return Math.round(delay);
+	}
+
+	/** What the model would see of the branch, by its newest context entry: a message, edit, compaction or summary (our own bookkeeping
+	 *  entries and other extensions' custom entries change nothing). A different one at the timer than at settle means something
+	 *  rewrote the context in between (Pi's compaction, another extension's edit). */
+	private awaySig = "";
+	private contextSig(ctx: Any): string {
+		const branch = this.branch(ctx);
+		for (let i = branch.length - 1; i >= 0; i--) {
+			const t = branch[i]?.type;
+			if (t === "message" || t === "context_edit" || t === "compaction" || t === "branch_summary" || t === "custom_message") return `${t}:${branch[i].id}`;
+		}
+		return "";
+	}
+
+	/** One timer for the away summary (unref'd: it never keeps the process alive); a newer one, or the user's return, cancels it. */
+	private armAway(delayMs: number, fn: () => void) {
+		if (this.timer) clearTimeout(this.timer);
 		const gen = ++this.timerGen;
-		this.timer = setTimeout(() => void this.runAway(p, ctx, gen), delay);
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			if (gen === this.timerGen && this.active()) fn(); // else the user came back, or we were switched off
+		}, Math.max(0, delayMs));
 		this.timer.unref?.();
-		return Math.round(delay);
 	}
 
-	private async runAway(p: PlanResult, ctx: Any, gen: number) {
-		this.timer = null;
-		if (gen !== this.timerGen || !this.active()) return; // the user came back, or we were switched off
+	// ---- Pi's own idle cache warming (research pi-tricks §3.3): observed, never answered ----------------------------------------
+	private awayPlan: { p: PlanResult; ctx: Any } | null = null; // a summary waiting for Pi's warming decision
+	/** Does Pi refresh the cache between runs by itself? (settings cacheWarming "idle"; the default "streaming" warms only during a run)
+	 *  Pi reads it from the global settings only (settings-manager getCacheWarmingMode: warming costs money), so a project-level "idle"
+	 *  in the merged settings warms nothing: the global file decides; only when it cannot be read do the merged settings. */
+	private idleWarming(): boolean {
+		try {
+			if (this.pi.getSettings?.()?.cacheWarming !== "idle") return false;
+		} catch {
+			return false;
+		}
+		try {
+			const global = JSON.parse(readFileSync(join(agentDir(), "settings.json"), "utf8"));
+			return global?.cacheWarming === "idle";
+		} catch {
+			return true;
+		}
+	}
+	private startAway(reason: string) {
+		const a = this.awayPlan;
+		this.awayPlan = null;
+		if (!a) return;
+		this.ledger({ type: "away_unblocked", reason });
+		void this.runAway(a.p, a.ctx);
+	}
+	/** cache_warming_decision: Pi is about to refresh the cache ("warm") or to let it expire ("stop"). Only observed: never answered.
+	 *  While Pi warms, the away summary waits; once Pi stops, it is prepared as without warming (the cache now expires on its own). */
+	cacheWarmingDecision(e: Any): undefined {
+		const action = e?.action;
+		this.ledger({ type: "cache_warming", action, warmCost: e?.warmCost, missCost: e?.missCost, p: e?.continuationProbability, waiting: !!this.awayPlan });
+		const a = this.awayPlan;
+		if (!a || !this.active()) return undefined;
+		if (action === "stop") {
+			this.armAway(0, () => {
+				this.awayPlan = a;
+				this.startAway("Pi stopped warming");
+			});
+			return undefined;
+		}
+		if (action !== "warm") return undefined;
+		// Pi refreshes now, unless another extension overrides the decision (its answer is not visible here): a refresh shows up as a
+		// cache_warm usage entry within seconds. With one, wait for the next decision; without one, Pi stopped: prepare the summary now.
+		const t = Date.now(), ttl = ttlFor(a.ctx.model, this.branch(a.ctx), this.tier(a.ctx.model));
+		this.ledger({ type: "away_postponed", reason: "Pi warms the cache" });
+		this.armAway(warmCheckMs(ttl), () => {
+			this.awayPlan = a;
+			let done = NaN; // when the refresh finished: its cache_warm entry is appended right before Pi schedules the next decision
+			for (const en of this.branch(a.ctx)) if (en?.type === "usage" && en.kind === "cache_warm" && Date.parse(en.timestamp) >= t) done = Date.parse(en.timestamp);
+			if (Number.isNaN(done)) return this.startAway("no refresh after a warm decision");
+			// Pi's next decision is due one warming delay after the refresh finished (cache-warmer.js schedule), not after the decision
+			this.armAway(done + (warmingDelayMs(ttl) ?? ttl) + warmingMargin(ttl) - Date.now(), () => {
+				this.awayPlan = a;
+				this.startAway("no warming decision");
+			});
+		});
+		return undefined;
+	}
+
+	private async runAway(p0: PlanResult, ctx: Any) {
+		if (!this.active()) return;
+		let p = p0;
+		if (this.contextSig(ctx) === this.awaySig && p0.cutIdx === null) return; // nothing was planned and nothing changed
+		if (this.contextSig(ctx) !== this.awaySig) {
+			// something rewrote the context since the plan was made (Pi's own compaction, another extension's edit): the summary prepared
+			// for the old plan would be discarded at the return (its cut is not this plan's). Plan again on the session as it is now.
+			try {
+				const entries = ((ctx.sessionManager.buildSessionProjection() as Any)?.entries ?? []) as Any[];
+				const { o } = this.opts(ctx, true, "cold", entries);
+				const q = entries.length ? planContext(entries, o) : null;
+				this.ledger({ type: "away_replan", from: p0.firstKeptEntryId, to: q?.firstKeptEntryId ?? null });
+				if (!q || q.cutIdx === null) return this.discardBg();
+				if (this.bg && this.bg.key !== q.firstKeptEntryId) this.discardBg();
+				p = q;
+			} catch (err) {
+				this.ledger({ type: "error", where: "away_replan", error: errText(err) });
+				return;
+			}
+		}
 		const controller = new AbortController();
 		const bg: Bg = { key: p.firstKeptEntryId, done: null, promise: Promise.resolve(null), controller };
 		bg.promise = buildCut(p, ctx, controller.signal)
@@ -528,6 +1167,7 @@ export class Zip implements ZipControl {
 	}
 
 	async turnEnd(e: Any, ctx: Any): Promise<Any> {
+		this.logForeign(ctx, "turn_end");
 		if (!this.active()) return undefined;
 		try {
 			const fresh = this.collectSteer(e); // marked before anything is validated: a steering message is part of its turn
@@ -564,7 +1204,7 @@ export class Zip implements ZipControl {
 		const userTurns = countUserTurns(blocks);
 		const u = msg?.usage;
 		const usageTotal = u ? (u.input ?? 0) + (u.cacheRead ?? 0) + (u.cacheWrite ?? 0) : 0;
-		const o = { t0, blocks, userTurns, sys: this.sysTokens(ctx), usageTotal };
+		const o = { t0, blocks, userTurns, usageTotal };
 		if (this.runEdits) {
 			this.runEdits = false;
 			if (!this.runPlan?.sent && this.runPlan && (this.runPlan.folds.length || this.runPlan.cut)) {
@@ -590,14 +1230,44 @@ export class Zip implements ZipControl {
 			const got = await this.takeBg(p.firstKeptEntryId, ctx.signal, ctx);
 			cut = got.cut ?? (await this.working(ctx, `${PRODUCT}: writing a summary (the context is close to the window)`, buildCut(p, ctx))); // the user is here and the cache is warm; the alternative is Pi's lossy compaction
 		} else this.discardBg();
-		const plan: RunPlan = { source: "valve", folds: p.folds, cut, ctxBefore: p.ctxTokens, ctxAfter: p.ctxAfterFolds, ms: performance.now() - t0, k: p.k, persisted: false, untouched: p.k * untouchedEst(p.blocks, p.folds, !!cut, popts.sys) };
+		const ctxAfter = p.ctxAfterFolds - (cut ? p.scale.c * (cut.prefixTokens - cut.summaryTokens) : 0);
+		const plan: RunPlan = { source: "valve", folds: p.folds, cut, ctxBefore: p.ctxTokens, ctxAfter, ms: performance.now() - t0, scale: p.scale, persisted: false, untouched: sizeOf(p.scale, untouchedEst(p.blocks, p.folds, !!cut)) };
 		return this.commit(e, ctx, plan, o);
 	}
 
-	private commit(e: Any, ctx: Any, plan: RunPlan, o: { t0: number; blocks: Block[]; userTurns: number; sys: number; usageTotal: number }) {
+	/**
+	 * The transcript notice for one plan. Facts only, no claims: what changed (sizes), how long it took, and, expanded, why now
+	 * ("cache cold · away 47 min") and what was folded. Whether the cache really was cold is learned from the response, silently (/zip shows it).
+	 * `realAfter` > 0: the size the provider reported for the request that carried the plan (shown instead of the estimate).
+	 */
+	private noticeFor(ctx: Any, plan: RunPlan, live: FoldTarget[], cut: Cut | null, ctxTokens: number, realAfter: number) {
+		if (this.quiet || (!live.length && !cut)) return;
+		const { c } = plan.scale, valve = plan.source === "valve"; // amounts scale by c; sizes are O + c x content (plan.ts)
+		const before = c * live.reduce((a, t) => a + t.entryTokens, 0), after = c * live.reduce((a, t) => a + t.phTokens, 0);
+		const cutSaved = cut ? c * (cut.prefixTokens - cut.summaryTokens) : 0;
+		const estAfter = ctxTokens - (before - after) - cutSaved;
+		const waitMs = cut ? (plan.waitMs ?? (plan.source === "settle" ? this.bgWaitMs : cut.ms)) : 0;
+		const notices: NoticeAction[] = [];
+		if (live.length) notices.push({ kind: "fold", count: live.length, tokensBefore: ctxTokens, tokensAfter: cut || !realAfter ? ctxTokens - (before - after) : realAfter, ms: plan.ms, pressure: valve });
+		if (cut) {
+			const prepared = plan.source === "settle" && waitMs < 500; // finished while the user was away: report the real production time, not the zero wait
+			notices.push({ kind: "summary", count: cut.count, tokensBefore: ctxTokens - (before - after), tokensAfter: realAfter || estAfter, ms: Math.max(cut.ms, waitMs), waitMs, prepared, pressure: valve });
+		}
+		for (const t of live) this.labels.set(handleFor(t.entryId), `${t.tool}${t.args ? " " + t.args : ""}`);
+		const ITEMS = 8;
+		const items = live.slice(0, ITEMS).map((t) => ({ label: `${t.tool}${t.args ? " " + t.args : ""}`, tokens: Math.round(c * t.entryTokens), handle: handleFor(t.entryId) }));
+		const why = valve || !this.cold ? "cache warm · worth it at this size" : this.coldWhy;
+		// reqTs: a run plan is announced as its first request goes out, a valve plan at turn_end, before the next request that first carries
+		// it; either way the first assistant message stamped at or after this moment answered the request that carried the plan
+		const data: NoticeData = { v: 2, text: noticeText(notices), before: Math.round(notices[0].tokensBefore), after: Math.round(notices[notices.length - 1].tokensAfter), desc: noticeDesc(notices), why: why || undefined, items, more: Math.max(0, live.length - ITEMS) || undefined, first: !this.noticed && !this.branch(ctx).some((en: Any) => en?.type === "custom" && en.customType === NOTICE_CUSTOM), reqTs: Date.now() };
+		this.noticed = true;
+		this.notify(ctx, data.text, data);
+	}
+
+	private commit(e: Any, ctx: Any, plan: RunPlan, o: { t0: number; blocks: Block[]; userTurns: number; usageTotal: number }) {
 		plan.persisted = true;
-		const k = plan.k; // one scale for the whole run: stats, notices and the ledger agree with what the plan compared against the limits
-		const ctxTokens = k * (o.sys + o.blocks.reduce((a, b) => a + b.tokens, 0));
+		const sc = plan.scale, c = sc.c; // one scale for the whole run: stats, notices and the ledger agree with what the plan compared against the limits
+		const ctxTokens = sizeOf(sc, o.blocks.reduce((a, b) => a + b.tokens, 0));
 		const byId = new Map(o.blocks.map((b) => [b.entryId, b]));
 		const wasApplied = (t: FoldTarget) => !plan.applied || plan.applied.has(t.entryId); // persist what the requests actually carried
 		const live = plan.folds.filter((t) => byId.has(t.entryId) && wasApplied(t));
@@ -615,12 +1285,16 @@ export class Zip implements ZipControl {
 			return undefined;
 		}
 		if (!plan.sent) this.nextEdit = plan.untouched ?? 0; // persisted now, first sent with the next request
+		const sentBefore = !!plan.sent;
 		const ours: Any[] = live.map((t) => ({ type: "context_edit", targetId: t.entryId, replacement: { content: [{ type: "text", text: t.ph }] } }));
 		for (const t of live) if (t.toolCallId) this.foldedCalls.set(t.toolCallId, handleFor(t.entryId));
-		if (cut) ours.push({ type: "compaction", summary: cut.text, firstKeptEntryId: cut.firstKeptEntryId, details: { by: PRODUCT, trigger: cut.trigger }, usage: cut.usage });
-		const before = Math.round(k * live.reduce((a, t) => a + t.entryTokens, 0));
-		const after = Math.round(k * live.reduce((a, t) => a + t.phTokens, 0));
-		const cutSaved = cut ? Math.round(k * (cut.prefixTokens - cut.summaryTokens)) : 0;
+		// the compaction draft goes FIRST: Pi writes its tokensBefore from the newest usage only while no edit follows that usage, so a
+		// fold drafted before it would make Pi's "Compacted from N tokens" the chars/4 of a half-applied projection (research pi-tricks §1a)
+		if (cut) ours.unshift({ type: "compaction", summary: cut.text, firstKeptEntryId: cut.firstKeptEntryId, details: { by: PRODUCT, trigger: cut.trigger, carried: sentBefore }, usage: cut.usage });
+		ours.push({ type: "custom", customType: COMMIT_CUSTOM, data: { carried: sentBefore } }); // says who first carried these edits (state.ts, plan.ts calibrate)
+		const before = Math.round(c * live.reduce((a, t) => a + t.entryTokens, 0));
+		const after = Math.round(c * live.reduce((a, t) => a + t.phTokens, 0));
+		const cutSaved = cut ? Math.round(c * (cut.prefixTokens - cut.summaryTokens)) : 0;
 		const waitMs = cut ? (plan.source === "settle" ? this.bgWaitMs : cut.ms) : 0;
 		const s = this.stats;
 		s.folds += live.length;
@@ -641,30 +1315,13 @@ export class Zip implements ZipControl {
 		if (live.length) this.ledger({
 			type: "fold", trigger: plan.source, turnIndex: e.turnIndex, count: live.length, entries: live.map((t) => t.entryId), tools: live.map((t) => t.tool),
 			recoverability: live.map((t) => t.recover ?? "?"), trigs: live.map((t) => t.trig), handles: live.map((t) => handleFor(t.entryId)),
-			entryTokensBefore: before, entryTokensAfter: after, ctxBefore: Math.round(ctxTokens), ctxAfter: Math.round(ctxTokens - (before - after) - cutSaved), k: Math.round(k * 1000) / 1000, usageTotal: o.usageTotal,
+			entryTokensBefore: before, entryTokensAfter: after, ctxBefore: Math.round(ctxTokens), ctxAfter: Math.round(ctxTokens - (before - after) - cutSaved), O: Math.round(sc.O), c: Math.round(sc.c * 1000) / 1000, usageTotal: o.usageTotal,
 			coldReason: this.coldReason, prepared: plan.source === "settle", ...(stale ? { staleTargets: stale } : {}),
 		});
-		if (cut) this.ledger({ type: "summary", trigger: cut.trigger, source: plan.source, count: cut.count, prefixTokens: cut.prefixTokens, summaryTokens: cut.summaryTokens, ms: cut.ms, waitedMs: Math.round(waitMs), llmOk: cut.llmOk, llmError: cut.llmError, costUsd: cut.costUsd, ...this.usageOf(cut) });
-		const valve = plan.source === "valve";
-		// What the user sees should match Pi's own context meter. A run plan was carried by the request that just ended, so its
-		// usage is the REAL size after the edits: rescale the notice to it (display only; decisions stay on the plan's k). A
-		// valve plan only applies from the next request: keep the estimate.
-		const estAfter = ctxTokens - (before - after) - cutSaved - k * tokensOf(e.message);
-		const r = !valve && o.usageTotal > 0 && estAfter > 0 ? clamp(o.usageTotal / estAfter, 0.2, 5) : 1;
-		const notices: NoticeAction[] = [];
-		if (live.length) notices.push({ kind: "fold", count: live.length, tokensBefore: r * ctxTokens, tokensAfter: r * (ctxTokens - (before - after)), ms: plan.ms + (performance.now() - o.t0), pressure: valve });
-		if (cut) {
-			const prepared = plan.source === "settle" && waitMs < 500; // finished while the user was away: report the real production time, not the zero wait
-			notices.push({ kind: "summary", count: cut.count, tokensBefore: r * (ctxTokens - (before - after)), tokensAfter: r * (ctxTokens - (before - after) - cutSaved), ms: prepared ? cut.ms : waitMs, prepared, pressure: valve });
-		}
-		if (notices.length && !this.quiet) {
-			const ITEMS = 8;
-			const items = live.slice(0, ITEMS).map((t) => ({ label: `${t.tool}${t.args ? " " + t.args : ""}`, turn: byId.get(t.entryId)?.userTurn, tokens: Math.round(r * k * t.entryTokens), handle: handleFor(t.entryId) }));
-			const why = valve ? "cache still warm, but the context passed the warm-cache limit" : this.cold ? this.coldWhy : "cache warm: the reads saved pay for the rewrite";
-			const data: NoticeData = { v: 2, text: noticeText(notices), before: Math.round(notices[0].tokensBefore), after: Math.round(notices[notices.length - 1].tokensAfter), desc: noticeDesc(notices), why: why || undefined, items, more: Math.max(0, live.length - ITEMS) || undefined, first: !this.noticed && !this.branch(ctx).some((en: Any) => en?.type === "custom" && en.customType === NOTICE_CUSTOM) };
-			this.noticed = true;
-			this.notify(ctx, data.text, data);
-		}
+		if (cut) this.ledger({ type: "summary", trigger: cut.trigger, source: plan.source, count: cut.count, prefixTokens: Math.round(c * cut.prefixTokens), summaryTokens: Math.round(c * cut.summaryTokens), ms: cut.ms, waitedMs: Math.round(waitMs), llmOk: cut.llmOk, llmError: cut.llmError, costUsd: cut.costUsd, ...this.usageOf(cut) });
+		// a run plan was announced when its first request went out; a valve plan (between turns) is announced now
+		if (!plan.noticed) this.noticeFor(ctx, plan, live, cut, ctxTokens, plan.source === "valve" ? 0 : o.usageTotal);
+		plan.noticed = true;
 		return { entries: [...e.entries, ...ours] }; // append, never overwrite other extensions' drafts
 	}
 
@@ -674,17 +1331,21 @@ export class Zip implements ZipControl {
 		// the free cache signal: this response's cacheRead against what this request re-sent unchanged, after this gap (same model only)
 		this.pending = { gapS: last && (this.lastModelKey || this.prevKey) === key ? (now - last) / 1000 : -1, expect: edited ? this.nextEdit! : this.prevTotal, edited, key };
 		this.nextEdit = null;
+		this.reqMsBefore = this.lastReqMs;
 		this.lastReqMs = now;
 		this.lastModelKey = key;
 		this.stats.readSavedTokens += this.stats.activeSaved;
 		const p: Any = e.payload;
+		const seen = payloadRetention(p); // what this very request asked the provider for: it wins over any environment
+		if (seen && key && (seen !== this.retention?.tier || this.retention?.key !== key || this.retention?.src !== "payload")) {
+			this.retention = { key, tier: seen, src: "payload" };
+			this.ledger({ type: "retention", ...this.retention });
+		}
 		if (process.env.PI_ZIP_LEDGER && this.cold && !this.wireLedgered && p && Array.isArray(p.messages)) {
-			this.wireLedgered = true; // proof that the FIRST request after a cold return is already small
+			this.wireLedgered = true; // proof that the FIRST request after a cold return is already small (real scale: O + c x the wire's content)
 			let tok = 0;
-			for (const m of p.messages) tok += tok4(JSON.stringify(m?.content ?? "")) + 8;
-			const sys = p.system;
-			tok += typeof sys === "string" ? tok4(sys) : Array.isArray(sys) ? tok4(sys.map((x: Any) => x?.text ?? "").join("\n")) : 0;
-			this.ledger({ type: "cold_wire", tokens: Math.round(tok), messages: p.messages.length, folds: this.runPlan && !this.runPlan.persisted ? this.runPlan.folds.length : 0, summary: !!this.runPlan?.cut, source: this.runPlan?.source ?? null });
+			for (const m of p.messages) if (m?.role !== "system" && m?.role !== "developer") tok += tok4(JSON.stringify(m?.content ?? "")) + 8;
+			this.ledger({ type: "cold_wire", tokens: Math.round(sizeOf(this.runPlan?.scale ?? UNIT, tok)), messages: p.messages.length, folds: this.runPlan && !this.runPlan.persisted ? this.runPlan.folds.length : 0, summary: !!this.runPlan?.cut, source: this.runPlan?.source ?? null });
 		}
 		if (this.off) return undefined; // strict no-op
 		const r = repairPayload(p);
@@ -695,6 +1356,7 @@ export class Zip implements ZipControl {
 
 	messageEnd(m: Any) {
 		if (m?.role === "assistant" && m.stopReason !== "error" && m.stopReason !== "aborted") this.lastReqMs = Date.now(); // the response is complete: the entry was refreshed when it finished
+		else if (refused(m)) this.lastReqMs = this.reqMsBefore; // the provider refused the request: it touched no cache (cache.ts lastMessageMs reads the branch the same way)
 		if (m?.role === "user" && this.active()) {
 			// the first user message of a run is the prompt; later ones (steering, follow-up) are part of that run's turn. Pi does not mark them, we do.
 			if (this.runUserSeen++ > 0 && typeof m.timestamp === "number") this.steerTs.add(m.timestamp);
@@ -746,19 +1408,30 @@ export class Zip implements ZipControl {
 	private totals(ctx: Any) {
 		const branch = ctx ? this.branch(ctx) : [];
 		const byId = new Map(branch.map((e: Any) => [e?.id, e]));
-		let folds = 0, folded = 0, summaries = 0, recalls = 0, usd = 0;
+		let folds = 0, summaries = 0, recalls = 0, usd = 0, key = "";
 		let last: Any = null;
+		const fileRecalls = new Set<string>(); // tool call ids of built-in reads of recall files (file recall): unzips too
+		const byModel = new Map<string, number>(); // chars/4 folded, by the model of the newest response before the fold (the one that planned it)
 		for (const e of branch) {
 			const ph = String(e?.replacement?.content?.[0]?.text ?? "");
+			if (e?.type === "message" && e.message?.role === "assistant" && (e.message.provider || e.message.model)) key = `${e.message.provider ?? ""}/${e.message.model ?? ""}`;
+			if (e?.type === "message" && e.message?.role === "assistant" && Array.isArray(e.message.content))
+				for (const c of e.message.content) if (c?.type === "toolCall" && (c.name === "bash" ? commandNamesRecall(c.arguments?.command) : ["read", "grep", "find", "ls"].includes(c.name) && !!parseRecallPath(c.arguments?.path))) fileRecalls.add(c.id);
 			if (e?.type === "context_edit" && ph.startsWith(PH_MARK)) {
 				folds++;
-				folded += Math.max(0, textOf(byId.get(e.targetId)?.message?.content).length - ph.length) / 4;
+				byModel.set(key, (byModel.get(key) ?? 0) + Math.max(0, textOf(byId.get(e.targetId)?.message?.content).length - ph.length) / 4);
 			} else if (e?.type === "compaction" && e.details?.by === PRODUCT) {
 				summaries++;
 				usd += Number(e.usage?.cost?.total) || 0;
 			} else if (e?.type === "custom" && e.customType === UNUSED_SUMMARY_CUSTOM) usd += Number(e.data?.usd) || 0;
 			else if (e?.type === "custom" && e.customType === NOTICE_CUSTOM && e.data?.v === 2 && !e.data?.kind) last = e;
-			else if (e?.type === "message" && e.message?.role === "toolResult" && e.message?.toolName === RECALL_TOOL) recalls++;
+			else if (e?.type === "message" && e.message?.role === "toolResult" && (e.message?.toolName === RECALL_TOOL || fileRecalls.has(e.message?.toolCallId))) recalls++;
+		}
+		// chars/4 of the folded text, on the provider's scale: x c of the model that folded it (folded outputs are content)
+		let folded = 0;
+		if (folds) {
+			const entries = byModel.size > 1 ? ((ctx.sessionManager.buildSessionProjection() as Any)?.entries ?? []) : undefined;
+			for (const [k, v] of byModel) folded += v * (byModel.size > 1 && k ? this.scaleAt(ctx, entries, k) : this.scaleOf(ctx)).c;
 		}
 		return { folds, folded, summaries, recalls, usd, last };
 	}
@@ -766,37 +1439,49 @@ export class Zip implements ZipControl {
 	private sessionTotals(ctx: Any): string {
 		const { folds, folded, summaries, recalls, usd } = this.totals(ctx);
 		const n = (x: number, one: string, many: string) => `${x} ${x === 1 ? one : many}`;
-		return `this session: ${n(folds, "folded output", "folded outputs")} (~${fmtK(folded)} tokens), ${n(summaries, "summary", "summaries")}${usd > 0 ? ` (summary calls $${usd.toFixed(4)})` : ""}, ${n(recalls, "recall", "recalls")}`;
+		return `this session: ${folds} zipped (~${fmtK(folded)} tokens), ${n(summaries, "summary", "summaries")}${usd > 0 ? ` (summary calls $${usd.toFixed(4)})` : ""}, ${n(recalls, "unzip", "unzips")}`;
 	}
-	/** The /zip status card (rendered by ui.ts renderCard). */
+	/** The /zip card (rendered by ui.ts renderCard). */
 	card(ctx?: Any): CardData {
 		const t = this.totals(ctx);
 		const model = ctx?.model ?? this.model;
-		const key = modelKey(model), ttlS = ttlFor(model) / 1000, ent = key ? loadStats().models[key] : undefined;
-		const alive = key ? SPARK_GAPS.map((g) => pWarm(ent, g, ttlS).p) : undefined;
+		const key = modelKey(model), ttlS = ttlFor(model, [], this.tier(model)) / 1000, ent = key ? loadStats().models[key] : undefined;
 		let lifeS = 0;
 		for (let g = 30; g <= 7200; g += 30) if (pWarm(ent, g, ttlS).p >= 0.5) lifeS = g;
-		const learned = !!ent && ent.n > 0 && pWarm(ent, Math.max(30, lifeS), ttlS).src === "learned";
-		const life = key ? `${lifeS >= 7200 ? "over 2 h" : fmtLife(lifeS || ttlS)} (${learned ? `learned from ${Math.round(ent!.n)} ${Math.round(ent!.n) === 1 ? "reply" : "replies"}` : "declared"})` : undefined;
+		const life = key ? (lifeS >= 7200 ? "2 h+" : fmtLife(lifeS || ttlS)) : undefined;
+		// the chart: every learned bin that still rounds to a return (the weights are decayed), and where the learned curve says
+		// "still there" ends (s1) and "gone" starts (s2); never the declared TTL
+		const bins: ChartBin[] = Object.entries(ent?.bins ?? {})
+			.map(([b, [a, d]]) => ({ lo: GAP_EDGES[Number(b)], hi: GAP_EDGES[Number(b) + 1] ?? 7200, alive: Math.round(a), gone: Math.round(d) }))
+			.filter((x) => x.lo !== undefined && x.alive + x.gone > 0)
+			.sort((x, y) => x.lo - y.lo);
+		const cur = (ent ? curve(ent, ttlS) : []).map((x) => ({ lo: GAP_EDGES[x.bin], hi: GAP_EDGES[x.bin + 1] ?? 7200, p: x.p }));
+		let s1 = GAP_EDGES[0];
+		for (const x of cur) { if (x.p >= 0.8) s1 = x.hi; else break; }
+		const s2 = cur.find((x) => x.lo >= s1 && x.p <= 0.2)?.lo ?? 7200;
+		const usually = cur.some((x) => x.hi <= s1 && x.p < 0.95);
 		const ts = t.last?.timestamp ? new Date(t.last.timestamp) : null;
 		const hhmm = ts && !Number.isNaN(ts.getTime()) ? `${String(ts.getHours()).padStart(2, "0")}:${String(ts.getMinutes()).padStart(2, "0")}  ` : "";
 		const last = t.last ? `${hhmm}${t.last.data.desc}${t.last.data.why ? " · " + t.last.data.why : ""}` : undefined;
-		const state = this.off ? "off" : this.conflict ? "paused" : this.recallOk ? "on" : "reread-only";
+		const file = this.recallMode === "file" && !!this.fileRecall(ctx);
+		const state = this.off ? "off" : this.conflict ? "paused" : this.recallMode === "tool" || file ? "on" : "reread-only"; // file recall is a full mode
+		const rereadWhy = this.recallMode === "file" ? "a tool allowlist hides zip_recall · no session file, so no recall copies" : "a tool allowlist hides zip_recall · only re-readable outputs fold";
 		return {
-			state, stateNote: state === "paused" ? `${this.conflict} also manages context` : state === "off" ? "/zip on to resume" : undefined,
-			model: key || undefined, cls: ent?.cls, life, alive, folds: t.folds, foldedTokens: fmtK(t.folded), summaries: t.summaries, summaryUsd: t.usd, recalls: t.recalls, last, quiet: this.quiet,
+			state, stateNote: state === "paused" ? `${this.conflict} also manages context` : state === "off" ? "/zip on to resume" : state === "reread-only" ? rereadWhy : undefined,
+			model: key || undefined, life, ...(bins.length ? { bins, s1, s2, usually } : {}), folds: t.folds, foldedTokens: fmtK(t.folded), summaries: t.summaries, summaryUsd: t.usd, recalls: t.recalls, last, quiet: this.quiet,
+			...(file ? { unzip: `from files in ${recallRootShown()} (a tool allowlist hides zip_recall)` } : {}),
 		};
 	}
 	status(ctx?: Any): string {
 		const state = this.off ? "off" : this.conflict ? `paused ("${this.conflict}" also manages context; only the request guard is on)` : "on";
-		const key = modelKey(this.model), ttl = ttlFor(this.model), ent = loadStats().models[key];
+		const key = modelKey(this.model), ttl = ttlFor(this.model, [], this.tier()), ent = loadStats().models[key];
 		const pr = lawPrices(ent?.cls, ttl >= 3_600_000);
 		const cache = !key ? "" : `\ncache ${key}: ${pr ? `${pr.cls} (from usage)` : "class unknown until the first response"}` +
 			`, ${pr ? `read ${+pr.r.toFixed(4)} / write ${+pr.w.toFixed(4)} / output ${+pr.out.toFixed(4)} x input (class ratios)` : "no prices (legacy rule)"}` +
 			`, ${describe(ent, ttl / 1000)}, growth ${(this.g / 1000).toFixed(1)}K/request`;
 		return `${PRODUCT}: ${state}, cache TTL ${Math.round(ttl / 1000)} s, ${this.quiet ? "notices off, " : ""}${this.sessionTotals(ctx)}${cache}`;
 	}
-	statsLine = (ctx?: Any) => `${PRODUCT} ${this.sessionTotals(ctx)} (token counts are chars/4 estimates)`;
+	statsLine = (ctx?: Any) => `${PRODUCT} ${this.sessionTotals(ctx)} (tokens on the provider's scale, calibrated from this session's usage)`;
 	setOff(off: boolean): string {
 		this.off = off;
 		if (off) { this.runPlan = null; this.runEdits = false; this.cancelTimer(); this.discardBg(); }