pi-zip 0.3.0-rc.1 → 0.3.0-rc.2

package/README.md

@@ -43,14 +43,14 @@ One mark, ƶ, and three words: **zipped**, **unzip**, **summarized**. Only the n
 ƶ summarized 64 requests   182K → 41K   38.2 s · ready while you were away
 ```
 
-The second line appears once per session. A summary that made you wait says so (`waited 8.4 s`, highlighted from 2 s on). Click the line (or expand tool output with ctrl+o) to see what was zipped and why now:
+The second line appears once per session. A summary that made you wait says so (`waited 8.4 s`, highlighted from 2 s on). Click the line (or expand tool output with ctrl+o) to see what was zipped and why now (a cold return says `cache cold · away 47 min` or `cache cold · model switched`, a warm edit `cache warm · worth it at this size`):
 
 ```
 ƶ zipped 12 old outputs   74K → 43K   6 ms
   bash npm test         14K   k3x9q2m7ab
   read src/payment.ts  9.1K   p8d2x1qa0m
   … 10 more
-  away 47 min
+  cache cold · away 47 min
 ```
 
 These lines are saved in the session, so they are still there after a restart, but they are never sent to the model. On narrow terminals the time goes first, then the words; the numbers always stay. A summary still shows up as Pi's own `[compaction]` block as well; the ƶ line next to it tells you who made it. The pi-zip numbers are real tokens, the same scale as Pi's context meter (the meter adds the newest reply's output on top); the `Compacted from N tokens` figure in Pi's block is pi-zip's own size before for a summary prepared while you were away (that one goes in through Pi's compaction, before your prompt); for any other summary it is Pi's own estimate taken when the entry is saved, so it may not match.
@@ -82,23 +82,35 @@ The first one appears once per machine. While a summary started in the backgroun
 
 ```
 ƶ pi-zip  on
-  model    anthropic/claude-sonnet-5-5
-  cache    ██████████████▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁  expires after ~5 min idle
-  away         1m       5m    15m     1h  2h
-  session  56 zipped ~310K  ·  2 summaries $0.41  ·  3 unzips
+  model    zhipu/glm-5.3
+  cache    each dot is one time you came back
+                      6     5
+               ●      ●     ●   ●
+               ●      ●     ●   ●  ●
+               ●      ●     ●   ●  ●   ● still there  19
+           ━━━━━━━━━━━━━━━━┅┅┅┅┅┅┅┅┅┅───────────────────────────────────
+                      ○         ○  ○ ○   ○    ○   ○   ○   ○   ○   ○  ○   ○ gone  74
+                                   ○     ○    ○   ○   ○   ○   ○   ○  ○
+                                         ○    ○   ○   ○   ○   ○   ○  ○
+                                         ○    12  7   9   15  6   11 5
+  away     30s     1m     2m        5m      10m         30m    1h     2h
+           under 2 min: usually still there  ·  2–5 min: not sure yet  ·  over 5 min: gone
+  session  30 zipped ~310K  ·  8 summaries $1.75  ·  2 unzips
+  last     15:22  zipped 1 old output in 4 ms · cache cold · away 13 min
 ```
 
+
 ƶ (U+01B6) is a plain Latin letter, one column wide everywhere, CJK terminals included. Most coding fonts have it; where one does not (Hack, Source Code Pro), the terminal draws it from a fallback font.
 
-`expires after ~5 min idle` is the one thing worth knowing: come back sooner and pi-zip touches nothing; come back later and the old outputs get zipped, at no extra cost. The chart draws the same fact: across (`away`) is how long you were gone, from 30 s to 2 h on a log scale; up (`cache`) is how likely the cache still holds your conversation then. Bars in the accent colour are still there, dim ones are gone. It starts from the model's declared cache lifetime (a cliff at 5 min for Claude) and turns into `(measured)` once the provider's own replies have shown how long its cache really lasts (see below); a cache that fades out slowly draws a slope. In a narrow terminal the chart is left out and the sentence stays whole (the model name goes first). Notices state facts (how long you were away), not guesses: whether the cache really had expired is read from the provider's reply afterwards, so a wrong guess is not repeated.
+The chart is the one thing worth knowing: come back sooner than the solid part of the axis and pi-zip touches nothing; come back later and the old outputs get zipped, at no extra cost. Across (`away`) is how long you were gone, from 30 s to 2 h on a log scale. Every dot is one time you came back after that long: a filled dot above the axis is a time the cache was still there, an empty one below it a time it was gone, so the picture is your own history with this model, and a few gone samples take only a row or two. A column shows at most 4 dots a side; beyond that it shows 3 dots and the number at the far end of the stack (`12` = twelve times in that gap range). The axis is solid up to the longest gap that was (nearly) always safe, dashed while it is not sure, thin after it is mostly gone; the sentence under it says the same in words (`usually still there` when even the safe part had some misses). The counts are the learned ones, kept with older evidence halved after 16 newer observations of the same gap range, so they can be a little below the number of times you actually came back. Until something is learned there is no chart, one line only (`expires after ~5 min idle · a chart appears once you come back after a break`, from the model's declared cache lifetime; Claude's is 5 min). The chart needs 72 columns; where the legend does not fit beside it, it moves to one line under it, and in a narrower terminal only the sentence is shown. Notices state facts (how long you were away), not guesses: whether the cache really had expired is read from the provider's reply afterwards, so a wrong guess is not repeated.
 
 ## The three rules
 
 1. **Nothing is lost.** The session file stays the single source of truth. pi-zip only changes the view sent to the model, never deletes anything. User messages, tool-call arguments, the system prompt, tool definitions and thinking are never rewritten. Every folded block carries a handle and shows its key lines (errors, ids, first and last line).
-2. **Edit only when the cache is already gone.** Provider prompt caches expire (the model's declared TTL, usually minutes). Changing the context while the cache is warm means paying to rewrite it; changing it after it expired is free, because the whole context is rewritten anyway, and a smaller context makes that rewrite cheaper. So when you come back after the TTL (or after switching model, or when the session was last touched longer ago than the TTL), pi-zip folds old outputs down to about 40K real tokens of context in one step, system prompt and tool definitions included, and every request of that turn sends the same bytes. No edit can shrink the system prompt and the tools, so once they take more than half of the 40K (a large tool set) the target becomes them plus 20K of conversation: with a 50K tool set the context lands near 70K. It is never a 40K that no edit can reach (that folds everything and summarises at every return), and it does not keep a full 40K of conversation on top either (on a live bench with a 36K prefix that cost 13% more, with no quality difference measured). While the cache is warm it does nothing, with one exception, the warm valve: above that target it applies that plan, minus the previous user turn (a warm edit never folds the turn you just finished, except when you come back after the declared TTL: there the previous turn is eligible exactly as at a cold return, so a provider whose cache outlives its TTL does not keep it at every return), when the edit pays for the rewrite it causes, and never on the request right after an edited one (no back-to-back warm rewrites). That is one inequality, r Δ²/(2g) + η Δ ≥ K with K = (w − r)(P T − (1 − P) Δ): the reads the removed Δ tokens would cost while the context grows back at g tokens per request (measured in the session), plus, near Pi's compaction trigger, what Pi would charge for the same room (η), against the rewrite of the T = A tokens left after the edit (pricing only the suffix after the earliest edit fires warm edits earlier and lost quality in the offline evaluation; the suffix is logged as `Tsuf` for measurement). r and w are the read and rewrite price ratios of the cache class, never the model's price table: explicit write premium 0.1 / 1.25 x input (2 x on the 1-hour tier), automatic prefix cache 0.2 / 1 x input; the class is read from the provider's usage reports, and until the first response the old fixed rule applies. P is the probability that the cache is still warm. A cold return is P = 0, so K < 0 and it always fires; a single small fold never pays at a warm cache, a large one does.
+2. **Edit only when the cache is already gone.** Provider prompt caches expire (the model's declared TTL, usually minutes). Changing the context while the cache is warm means paying to rewrite it; changing it after it expired is free, because the whole context is rewritten anyway, and a smaller context makes that rewrite cheaper. So when you come back after the TTL (or after switching model, or when the session was last touched longer ago than the TTL), pi-zip folds old outputs down to about 40K real tokens of context in one step, system prompt and tool definitions included, and every request of that turn sends the same bytes. No edit can shrink the system prompt and the tools, so once they take more than half of the 40K (a large tool set) the target becomes them plus 20K of conversation: with a 50K tool set the context lands near 70K. It is never a 40K that no edit can reach (that folds everything and summarises at every return), and it does not keep a full 40K of conversation on top either (on a live bench with a 36K prefix that cost 13% more, with no quality difference measured). While the cache is warm it does nothing, with one exception, the warm valve: above that target it applies that plan, minus the previous user turn (a warm edit never folds the turn you just finished, except when you come back after the declared TTL: there the previous turn is eligible exactly as at a cold return, so a provider whose cache outlives its TTL does not keep it at every return; and it leaves alone what the last cold return had to protect, the previous turn's outputs of that return, until the next cold return, until the session has grown by more than about 11K tokens since, or until the context reaches Pi's compaction room: the window sliding by one prompt is not news, and folding them then would pay a warm rewrite for what the free rewrite at the cold return could not take), when the edit pays for the rewrite it causes, and never on the request right after an edited one (no back-to-back warm rewrites). That is one inequality, r Δ²/(2g) + η Δ ≥ K with K = (w − r)(P T − (1 − P) Δ): the reads the removed Δ tokens would cost while the context grows back at g tokens per request (measured in the session), plus, near Pi's compaction trigger, what Pi would charge for the same room (η), against the rewrite of the T = A tokens left after the edit (pricing only the suffix after the earliest edit fires warm edits earlier and lost quality in the offline evaluation; the suffix is logged as `Tsuf` for measurement). r and w are the read and rewrite price ratios of the cache class, never the model's price table: explicit write premium 0.1 / 1.25 x input (2 x on the 1-hour tier), automatic prefix cache 0.2 / 1 x input; the class is read from the provider's usage reports, and until the first response the old fixed rule applies. P is the probability that the cache is still warm. A cold return is P = 0, so K < 0 and it always fires; a single small fold never pays at a warm cache, a large one does.
 3. **Never in the way.** Planning is local and takes milliseconds. Anything that needs a model call (a summary, only when folding is not enough and the same inequality prices the extra model call in, at a cold return and in the warm valve alike; the call is priced as what it is: an uncached read of the conversation since the previous summary, which code carries forward and the model never rewrites, plus the narrative it writes) is prepared while you are away: if the cache is about to expire (0.8 x its lifetime after your last request) and you have not come back, a background timer writes the summary with a separate, uncached call. The timer is cancelled the moment you send a prompt. If you return before the summary finishes, only the remaining time is waited (Esc cancels the prompt; the summary goes on and is used when you send it again), and the notice says so. A summary that finished while you were away goes into the session through Pi's own compaction before your prompt (Pi's `[compaction]` block then shows pi-zip's size before), in milliseconds; when Pi cannot take it there (busy, nothing it would compact, an older Pi, another extension taking part in Pi's compaction: see Coexistence), it rides along with the first request as before. If you return while the cache is still warm and the valve does not fire, the prepared summary is discarded (its cost is still counted). With Pi's own idle cache warming on (`"cacheWarming": "idle"` in the global settings, the only place Pi reads it), the summary waits for Pi's decision instead of the 0.8 mark: while Pi keeps refreshing the cache, nothing is prepared (you would come back to a warm cache and not need it); once Pi stops, or no refresh follows its decision, or the next decision (due one warming delay after the refresh finished) does not come, the summary is prepared as usual. pi-zip only watches those decisions, it never answers them. In non-interactive modes (`-p`, `--mode json`) nothing is ever started in the background: a cold return that needs a summary computes it right then.
 
-**The cache lifetime is learned, not configured.** Every response says how much of the prompt came from the cache. pi-zip compares that read with what the request re-sent unchanged (the previous prompt, or the untouched prefix before one of its own edits: on an automatic prefix cache every edit leaves the first 8K tokens alone, so even the response right after a fold says whether the cache survived) and so learns, per provider and model, whether the cache survived a gap of that length: a few counts per gap bin (30 s to 90 min, with bin edges on the 5-minute and 1-hour tiers), monotone in the gap, older evidence halved after 16 newer observations of the same bin, stored without any content in `~/.pi/agent/pi-zip/cache-survival.json`. Before any evidence the model's declared TTL decides, exactly as before (300 s when it declares none; too short a guess is cheaper than too long); beyond it one clean read overrides it, inside it a lone miss counts as noise (warm caches do miss now and then) and only repeated misses do. A GLM cache read in full after 365 s makes the next 365 s return warm; a Claude 5-minute cache that read nothing after 360 s stays dead. Whether the provider bills cache writes (explicit cache) or not (automatic prefix cache) is read from the first response too. `/zip` shows the lifetime it currently believes, marked `(measured)` once it is learned.
+**The cache lifetime is learned, not configured.** Every response says how much of the prompt came from the cache. pi-zip compares that read with what the request re-sent unchanged (the previous prompt, or the untouched prefix before one of its own edits: on an automatic prefix cache every edit leaves the first 8K tokens alone, so even the response right after a fold says whether the cache survived) and so learns, per provider and model, whether the cache survived a gap of that length: a few counts per gap bin (30 s to 90 min, with bin edges on the 5-minute and 1-hour tiers), monotone in the gap, older evidence halved after 16 newer observations of the same bin, stored without any content in `~/.pi/agent/pi-zip/cache-survival.json`. Before any evidence the model's declared TTL decides, exactly as before (300 s when it declares none; too short a guess is cheaper than too long); beyond it one clean read overrides it, inside it a lone miss counts as noise (warm caches do miss now and then) and only repeated misses do. A GLM cache read in full after 365 s makes the next 365 s return warm; a Claude 5-minute cache that read nothing after 360 s stays dead. Whether the provider bills cache writes (explicit cache) or not (automatic prefix cache) is read from the first response too. `/zip` draws what it has learned as the dot chart above.
 
 Protected from folding: the current user turn and the previous one. When the context is above the target, re-readable outputs of the previous turn (an unchanged file, a read-only command) can still be folded at a cold return or at any return after the declared TTL (never on a warm request inside it), and any output in either turn can be folded once it is 60 assistant requests old (so a long agent run that is a single user turn with hundreds of tool calls is not exempt from folding; the newest 59 requests' outputs always stay, and every fold stays recallable). Messages you type while the agent is running (steering, follow-up) belong to that turn and do not start a new one. Outputs you have already recalled, and `zip_recall` results themselves (or reads of a recall file), are never folded again. "Read-only" is a conservative whitelist: `find -delete` or `-exec`, command substitution, redirects, background jobs, `git diff --output` and the like are not.
 
@@ -110,7 +122,7 @@ The cold cap is kept below Pi's own compaction trigger (window minus `compaction
 
 | Command | Effect |
 |---|---|
-| `/zip` | the card above: state, how long the cache survives you being away (chart and sentence), this session's folds, summaries and recalls (counted from the session, so a restart does not reset them) |
+| `/zip` | the card above: state, how long the cache survives you being away (a dot chart of your own returns), this session's folds, summaries and recalls (counted from the session, so a restart does not reset them) |
 | `/zip off` | strict no-op: no folds, no summaries, requests left untouched (earlier folds stay recallable) |
 | `/zip on` | resume |
 | `/zip quiet` | toggle the per-turn notice (folding continues) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-zip",
-  "version": "0.3.0-rc.1",
+  "version": "0.3.0-rc.2",
   "description": "Keeps long Pi sessions cheap without losing anything: folds old tool output only when the prompt cache has already gone cold, and every fold can be recalled byte for byte. Zero config.",
   "type": "module",
   "license": "MIT",

package/src/plan.ts

@@ -38,6 +38,16 @@ export const LOOKAHEAD = false;
 export const NARRATIVE_PRICE = true;
 /** The narrative's token budget (chars/4), summary.ts buildCut: clamp(planned - skeleton, 300, NARRATIVE_MAX). */
 export const NARRATIVE_MAX = 4000;
+/** B2 for folds (formal TRIAGE (a) 6): the outputs a cold plan must protect (the previous user turn's, the mutating ones) are no longer
+ *  protected one prompt later, when the window slides, and the warm plan then folded them at a warm cache: a rewrite the free cold one
+ *  dominated. Now a warm plan holds back the blocks that were protected at the last cold return (PlanOpts.hold: that return's prompt)
+ *  until the next cold return, or until the session has grown by more than HOLD_RELEASE real tokens since it (new information), or the
+ *  context is at Pi's compaction room; and when even folding them all would not avoid a summary, it is the plan it was before. Chosen
+ *  over folding them early at the cold return (the user would lose the previous turn's outputs at the prompt that asks about them):
+ *  formal/TRIAGE.md, B2 for folds. */
+export const FOLD_HOLD = true;
+/** The spec's "no new information" is growth <= 10K real tokens (formal DELTA); the estimate is chars/4 x c, 15% off at worst (TOL_TARGET). */
+export const HOLD_RELEASE = 11_500;
 const SUMMARY_FLOOR = 1000;
 const SUMMARY_CAP = 8000;
 const SUMMARY_RATIO = 0.1;
@@ -550,6 +560,8 @@ export interface PlanOpts {
 	narrativePrice?: boolean; // F3, default NARRATIVE_PRICE
 	slide?: number; // internal (F2): plan as if this many more user turns had started (the protected window slid)
 	valveB?: number; // internal (F2): the real context the slid warm plan's law sees (the cold plan's folds already applied)
+	hold?: { anchor: string }; // B2 for folds: the entry id of the prompt of the last cold return (run.ts holdOf); undefined = nothing held
+	holdPass?: boolean; // internal: the held pass of a warm plan with a hold
 	warmStyle?: boolean; // internal: a cold plan at 0 < P(warm) < 0.5 that the law refused is planned once more the way a warm plan is (no relax folds unless pastTtl, the summary gated)
 }
 
@@ -603,6 +615,14 @@ export const contentKeyOf = (content: Any): string => {
  *  passes the same law (expected cost). The cap never exceeds Pi's compaction room. Returns null when there is nothing to plan on
  *  or the law says no. */
 export function planContext(entries: Any[], o: PlanOpts): PlanResult | null {
+	if (o.hold && !o.holdPass && (o.mode ?? "cold") === "warm") {
+		// the hold gives way to a summary: when the plan without it summarises, that is the plan (a summary voids the folds before its
+		// cut anyway); otherwise the held plan, with no summary of its own (the next cold return writes it)
+		const full = planContext(entries, { ...o, hold: undefined, trace: undefined });
+		if (!full) return null;
+		if (full.cutIdx !== null) return planContext(entries, { ...o, hold: undefined });
+		return planContext(entries, { ...o, noSummary: true, holdPass: true });
+	}
 	const s = settings();
 	const mode = o.mode ?? "cold";
 	const warmLike = mode === "warm" || o.warmStyle === true; // plans the way a warm plan does (the label of the trigger stays the mode's)
@@ -679,7 +699,22 @@ export function planContext(entries: Any[], o: PlanOpts): PlanResult | null {
 	const foldable = (b: Block) => b.kind === "toolResult" && !b.edited && !!b.entryId && b.tokens > foldMin && !isRecall(b) && start[b.idx] >= head && (!o.rereadOnly || classify(b) === "rereadable");
 	const protectedTurn = (b: Block) => b.userTurn >= userTurns - PROTECT_USER_TURNS + 1;
 	const savings = () => folds.reduce((a, t) => a + t.entryTokens - t.phTokens, 0);
-	const cands = blocks.filter((b) => foldable(b) && !protectedTurn(b));
+	// the blocks protected at the last cold return stay out of a warm plan's folds (see FOLD_HOLD)
+	const held: (b: Block) => boolean = (() => {
+		const NOT_HELD = () => false;
+		if (mode !== "warm" || !o.hold) return NOT_HELD;
+		const from = blocks.findIndex((b) => b.entryId === o.hold!.anchor); // gone (a later summary replaced it): nothing is held
+		if (from < 0) return NOT_HELD;
+		// what the session grew by before this decision: the blocks between the cold return's prompt and the newest response (that
+		// response, the tool results after it and a new prompt are what the decision is about, not yet something the cache has seen)
+		let lastAsst = blocks.length - 1;
+		while (lastAsst > 0 && blocks[lastAsst].kind !== "assistant") lastAsst--;
+		const grown = c * blocks.slice(from + 1, Math.max(from + 1, lastAsst)).reduce((a, b) => a + b.tokens, 0);
+		if (grown > HOLD_RELEASE || (room !== null && real(ctxEst) >= room)) return NOT_HELD;
+		const turn = blocks[from].userTurn;
+		return (b: Block) => b.userTurn >= turn - PROTECT_USER_TURNS + 1;
+	})();
+	const cands = blocks.filter((b) => foldable(b) && !protectedTurn(b) && !held(b));
 	for (const b of cands) addFold(b, trig);
 	if (relax && ((mode === "cold" && !o.warmStyle) || o.pastTtl === true)) {
 		// the protected window = the new prompt + the previous user turn; that turn's big reads are what makes a cold return

package/src/run.ts

@@ -4,17 +4,17 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 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, describe, lawPrices, loadStats, pWarm, record, sample, statsPath, GAP_EDGES, type Entry } from "./learn.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, 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 { 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 { 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, COMMIT_CUSTOM, envInt, PRODUCT, textOf, tok4 } from "./util.ts";
+import { type Any, COLD_CUSTOM, COMMIT_CUSTOM, envInt, PRODUCT, textOf, tok4 } from "./util.ts";
 import { replayGrowth } from "./state.ts";
-import { CHART_COLS, chartGap, fmtLife, type CardData, type StateWord } from "./ui.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";
@@ -387,7 +387,17 @@ export class Zip implements ZipControl {
 		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, reserve: this.reserve(ctx), steerIds: this.steerIds, law: this.law(ctx, pWarm), trace: [] } };
+		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 {
@@ -630,13 +640,18 @@ export class Zip implements ZipControl {
 		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" : cold && gapS !== null ? `away ${fmtAway(gapS)}` : "";
+		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];
@@ -1222,7 +1237,7 @@ export class Zip implements ZipControl {
 
 	/**
 	 * The transcript notice for one plan. Facts only, no claims: what changed (sizes), how long it took, and, expanded, why now
-	 * ("away 47 min") and what was folded. Whether the cache really was cold is learned from the response, silently (/zip shows it).
+	 * ("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) {
@@ -1433,9 +1448,18 @@ export class Zip implements ZipControl {
 		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 measured = !!ent && ent.n > 0 && pWarm(ent, Math.max(30, lifeS), ttlS).src === "learned";
 		const life = key ? (lifeS >= 7200 ? "2 h+" : fmtLife(lifeS || ttlS)) : undefined;
-		const alive = key ? Array.from({ length: CHART_COLS }, (_, i) => pWarm(ent, chartGap(i), ttlS).p) : 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;
@@ -1444,7 +1468,7 @@ export class Zip implements ZipControl {
 		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" : state === "reread-only" ? rereadWhy : undefined,
-			model: key || undefined, life, measured, alive, folds: t.folds, foldedTokens: fmtK(t.folded), summaries: t.summaries, summaryUsd: t.usd, recalls: t.recalls, last, quiet: this.quiet,
+			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)` } : {}),
 		};
 	}

package/src/ui.ts

@@ -49,13 +49,19 @@ export function renderState(word: StateWord, reason: string, width: number, th:
 
 // ---- status card ------------------------------------------------------------------------------------------------------
 
+/** One learned gap bin of the cache chart: how many times you came back after a gap in [lo, hi) s and the cache was still there / gone.
+ *  Counts are rounded decayed weights (learn.ts keeps no raw per-bin count: old evidence halves after HALF_LIFE newer ones of the bin). */
+export interface ChartBin { lo: number; hi: number; alive: number; gone: number }
+
 export interface CardData {
 	state: "on" | "off" | "paused" | "reread-only";
 	stateNote?: string; // why paused / reread-only
 	model?: string; // provider/id
-	life?: string; // "~5 min" | "~1 h" | "2 h+": how long the cache outlives the last reply
-	measured?: boolean; // life comes from this provider's own replies, not the declared TTL
-	alive?: number[]; // P(cache still there) after being away chartGap(i), one per chart column
+	life?: string; // "~5 min" | "~1 h" | "2 h+": how long the cache outlives the last reply (the declared TTL until something is learned)
+	bins?: ChartBin[]; // learned bins that round to at least one return; none = nothing learned yet: one line, no chart
+	s1?: number; // seconds: the cache is (nearly) always still there under this (learned curve, never the prior)
+	s2?: number; // seconds: it is mostly gone from here on; between s1 and s2 it is not sure yet
+	usually?: boolean; // some bin under s1 has P(still there) < 0.95: "usually still there" instead of "still there"
 	folds: number;
 	foldedTokens: string; // "310K"
 	summaries: number;
@@ -73,34 +79,106 @@ export function fmtLife(s: number): string {
 	return `~${+(s / 3600).toFixed(1)} h`;
 }
 
-/** The cache chart: one column per time away, log-spaced from 30 s to 2 h. The row labels are the axes ("cache" up, "away" across),
- *  so it reads like any chart; the bars still there are in the accent colour, the dead ones dim. */
-export const CHART_COLS = 32;
-const CHART_T0 = 30, CHART_T1 = 7200;
-export const chartGap = (i: number): number => CHART_T0 * (CHART_T1 / CHART_T0) ** (i / (CHART_COLS - 1));
-const chartCol = (s: number): number => Math.round(((CHART_COLS - 1) * Math.log(s / CHART_T0)) / Math.log(CHART_T1 / CHART_T0));
-const BARS = "▁▂▃▄▅▆▇█";
-const TICKS: [number, string][] = [[60, "1m"], [300, "5m"], [900, "15m"], [3600, "1h"], [7200, "2h"]];
-const bar = (p: number): string => BARS[Math.max(0, Math.min(7, Math.round(p * 7)))];
-const ALIVE = 0.5; // a bar at or above this is drawn as still there
-
-/** "1m      5m      15m      1h  2h": tick labels start at their column. */
-export function chartAxis(): string {
-	const s = Array<string>(CHART_COLS + 2).fill(" ");
-	for (const [t, lab] of TICKS) {
-		const c = Math.min(chartCol(t), CHART_COLS - lab.length + 1);
-		if (s.slice(Math.max(0, c - 1), c + lab.length + 1).every((x) => x === " ")) s.splice(c, lab.length, ...lab);
+// ---- the cache chart: one dot per time you came back ----------------------------------------------------------------------
+// Across: how long you were away, 30 s to 2 h on a log scale. Above the axis (accent): the times the cache was still there, below
+// (dim): the times it was gone. The axis itself says what to expect: solid while it is (nearly) always there, dashed while not sure,
+// thin after it is gone. A column shows at most STACK_CAP marks; beyond that STACK_CAP - 1 dots and then the count.
+
+export const CHART_W = 60; // columns 0..CHART_W
+const CT0 = 30, CT1 = 7200;
+export const STACK_CAP = 4;
+const IND = 11; // the values column of the card: "  " + the 9-wide label
+export const colW = (s: number): number => Math.round((CHART_W * Math.log(s / CT0)) / Math.log(CT1 / CT0));
+const gapW = (c: number): number => CT0 * (CT1 / CT0) ** (c / CHART_W);
+const AXIS_TICKS: [number, string][] = [[30, "30s"], [60, "1m"], [120, "2m"], [300, "5m"], [600, "10m"], [1800, "30m"], [3600, "1h"], [7200, "2h"]];
+const fmtGap = (s: number): string => (s < 60 ? `${Math.round(s)} s` : s < 3600 ? `${+(s / 60).toFixed(1)} min` : `${+(s / 3600).toFixed(1)} h`);
+
+/** What the marks of one side of the axis look like, as rows from the axis outwards: row r (1-based) holds, per column, a dot, a digit of
+ *  the count or a blank. `items` are (column, times); items on the same column merge. A count is drawn on the row of the stack's end,
+ *  centred on its column; when that would touch another mark in its row (neighbouring columns, other counts) it moves, the nearest free
+ *  place first, right before left, and keeps one blank on each side, so two counts never read as one number. Deterministic. */
+export function stackRows(items: { col: number; n: number }[], dot: string = "\u25cf", cap: number = STACK_CAP, width: number = CHART_W + 1): { rows: string[][]; height: number } {
+	const merged = new Map<number, number>();
+	for (const it of items) {
+		const col = Math.max(0, Math.min(width - 1, it.col));
+		if (it.n > 0) merged.set(col, (merged.get(col) ?? 0) + it.n);
+	}
+	const cols = [...merged.entries()].sort((a, b) => a[0] - b[0]);
+	const height = Math.max(1, ...cols.map(([, n]) => Math.min(n, cap)));
+	const rows = Array.from({ length: height }, () => Array<string>(width).fill(" "));
+	const counts: { col: number; text: string; row: number }[] = [];
+	for (const [col, n] of cols) {
+		const dots = n <= cap ? n : cap - 1;
+		for (let r = 0; r < dots; r++) rows[r][col] = dot;
+		if (n > cap) counts.push({ col, text: String(n), row: cap - 1 });
+	}
+	for (const { col, text, row } of counts) {
+		const len = text.length, want = col - Math.floor((len - 1) / 2), line = rows[row];
+		const free = (st: number, gap: boolean) => {
+			if (st < 0 || st + len > width) return false;
+			for (let x = st - (gap ? 1 : 0); x < st + len + (gap ? 1 : 0); x++) if (x >= 0 && x < width && line[x] !== " ") return false;
+			return true;
+		};
+		let at = -1;
+		for (const gap of [true, false]) {
+			for (let d = 0; d < width && at < 0; d++) for (const st of d ? [want + d, want - d] : [want]) if (at < 0 && free(st, gap)) at = st;
+			if (at >= 0) break;
+		}
+		if (at >= 0) for (let k = 0; k < len; k++) line[at + k] = text[k];
 	}
-	return s.join("").trimEnd();
+	return { rows, height };
 }
 
-const lifeText = (c: CardData): string => (c.life ? `expires after ${c.life} idle${c.measured ? " (measured)" : ""}` : "");
+/** Colours the cells of a row (one string per column, null = blank) with as few runs as possible. */
+function paint(cells: { ch: string; color: string }[], th: Th): string {
+	let out = "", run = "", color = "";
+	const flush = () => { if (run) out += color ? th.fg(color, run) : run; run = ""; };
+	for (const c of cells) {
+		if (c.color !== color) flush(), (color = c.color);
+		run += c.ch;
+	}
+	flush();
+	return out.trimEnd();
+}
+
+interface Seg { lead: string; word: string; color: string }
+/** "under 5 min: usually still there · 5–10 min: not sure yet · over 10 min: gone", as segments that wrap whole. */
+function captionSegs(c: CardData): Seg[] {
+	const s1 = c.s1 ?? CT0, s2 = c.s2 ?? CT1;
+	const range = s1 >= 60 && s2 < 3600 ? `${+(s1 / 60).toFixed(1)}–${fmtGap(s2)}` : `${fmtGap(s1)}–${fmtGap(s2)}`; // "5–10 min"
+	return [
+		{ lead: `under ${fmtGap(s1)}: `, word: c.usually ? "usually still there" : "still there", color: "accent" },
+		...(s2 > s1 ? [{ lead: `${range}: `, word: "not sure yet", color: "warning" }] : []),
+		{ lead: `over ${fmtGap(s2)}: `, word: "gone", color: "muted" },
+	];
+}
+const SEP = "  \u00b7  ";
+const segW = (g: Seg) => g.lead.length + g.word.length;
+/** The caption as lines of at most `room` columns, wrapped between segments (a segment wider than the room is cut). */
+function captionLines(segs: Seg[], room: number, th: Th, m: Measure): string[] {
+	if (room < 2) return []; // no room for even a cut sentence
+	const lines: Seg[][] = [[]];
+	for (const g of segs) {
+		const cur = lines[lines.length - 1], w = cur.reduce((a, x) => a + segW(x), 0) + SEP.length * cur.length + segW(g);
+		if (cur.length && w > room) lines.push([g]);
+		else cur.push(g);
+	}
+	return lines.map((l) => {
+		const plain = l.map((g) => g.lead + g.word).join(SEP);
+		if (plain.length > room) return th.fg("dim", m.cut(plain, room));
+		return l.map((g) => th.fg("dim", g.lead) + th.fg(g.color, g.word)).join(th.fg("dim", SEP));
+	});
+}
+const captionPlain = (c: CardData) => captionSegs(c).map((g) => g.lead + g.word).join(SEP);
+
+const idle = (c: CardData): string => (c.life ? `expires after ${c.life} idle` : "");
+const NO_DATA = "a chart appears once you come back after a break";
+const hasChart = (c: CardData): boolean => !!c.model && !!c.bins?.length;
 
 export function cardText(c: CardData): string[] {
 	const rows: [string, string][] = [];
-	// One fact the user can act on ("come back within ~5 min and nothing is touched"), drawn and said: no classes, no jargon.
-	if (c.model && c.alive?.length) rows.push(["model", c.model], ["cache", `${c.alive.map(bar).join("")}  ${lifeText(c)}`.trimEnd()], ["away", chartAxis()]);
-	else if (c.model) rows.push(["cache", `${c.model}${c.life ? ` · ${lifeText(c)}` : ""}`]);
+	if (c.model) rows.push(["model", c.model]);
+	if (c.model) rows.push(["cache", hasChart(c) ? `each dot is one time you came back · ${captionPlain(c)}` : `${idle(c) || "expires after ~5 min idle"} · ${NO_DATA}`]);
 	const n = (x: number, one: string, many = one + "s") => `${x} ${x === 1 ? one : many}`;
 	rows.push(["session", `${c.folds} zipped ~${c.foldedTokens}  ·  ${n(c.summaries, "summary", "summaries")}${c.summaryUsd > 0 ? ` $${c.summaryUsd.toFixed(2)}` : ""}  ·  ${n(c.recalls, "unzip")}`]);
 	if (c.last) rows.push(["last", c.last]);
@@ -109,47 +187,74 @@ export function cardText(c: CardData): string[] {
 	return rows.map(([k, v]) => `${k.padEnd(LABEL_W)}${v}`);
 }
 
+/** The chart rows (without the model row): header, marks above, axis, marks below, axis labels, [legend], caption. */
+function chartRows(c: CardData, width: number, th: Th, m: Measure): string[] {
+	const indent = "  ", label = (k: string) => th.fg("dim", (indent + k).padEnd(indent.length + LABEL_W)), pad = " ".repeat(IND);
+	const bins = c.bins ?? [];
+	const na = bins.reduce((a, b) => a + b.alive, 0), nd = bins.reduce((a, b) => a + b.gone, 0);
+	const up = stackRows(bins.map((b) => ({ col: colW(Math.sqrt(b.lo * b.hi)), n: b.alive })));
+	const down = stackRows(bins.map((b) => ({ col: colW(Math.sqrt(b.lo * b.hi)), n: b.gone })), "\u25cb");
+	const legUp = ["\u25cf", ` still there  ${na}`], legDown = ["\u25cb", ` gone  ${nd}`];
+	const legW = (l: string[]) => l[0].length + l[1].length;
+	const beside = width >= IND + CHART_W + 1 + 3 + Math.max(legW(legUp), legW(legDown));
+	const s1 = c.s1 ?? CT0, s2 = c.s2 ?? CT1;
+	const out: string[] = [label("cache") + th.fg("dim", "each dot is one time you came back")];
+	const side = (rows: string[][], color: string, leg: string[], first: number) =>
+		rows.map((cells, r) => {
+			const line = paint(cells.map((ch) => ({ ch, color: ch === " " ? "" : color })), th);
+			return pad + line + (beside && r === first ? "   " + th.fg(color, leg[0]) + th.fg("muted", leg[1]) : "");
+		});
+	out.push(...side(up.rows.slice().reverse(), "accent", legUp, up.height - 1)); // outermost row first; the legend sits on the row next to the axis
+	out.push(pad + paint(Array.from({ length: CHART_W + 1 }, (_, i) => ({ ch: gapW(i) < s1 ? "\u2501" : gapW(i) < s2 ? "\u2505" : "\u2500", color: gapW(i) < s1 ? "accent" : gapW(i) < s2 ? "warning" : "dim" })), th));
+	out.push(...side(down.rows, "dim", legDown, 0));
+	const ax = Array<string>(CHART_W + 3).fill(" ");
+	for (const [t, lab] of AXIS_TICKS) {
+		const col = Math.min(colW(t), CHART_W - lab.length + 1);
+		for (let k = 0; k < lab.length; k++) ax[col + k] = lab[k];
+	}
+	out.push(label("away") + th.fg("dim", ax.join("").trimEnd()));
+	if (!beside) out.push(pad + th.fg("accent", legUp[0]) + th.fg("muted", legUp[1]) + "   " + th.fg("dim", legDown[0]) + th.fg("muted", legDown[1]));
+	for (const l of captionLines(captionSegs(c), width - IND, th, m)) out.push(pad + l);
+	return out;
+}
+
 export function renderCard(c: CardData, width: number, th: Th, m: Measure = plainMeasure): string[] {
 	const out = renderState(c.state, c.stateNote ?? "", width, th, m);
 	const indent = "  "; // under the words after the monogram
-	// Too narrow for the chart and its axis: the sentence alone says the same thing.
-	if (c.alive?.length && width < indent.length + LABEL_W + Math.max(c.alive.length, chartAxis().length)) c = { ...c, alive: undefined };
-	let under = "";
-	for (const row of cardText(c)) {
-		if (under && !row.startsWith("away ")) out.push(under), (under = "");
-		if (c.alive?.length && row.startsWith("cache ")) {
-			const runs: string[] = [];
-			for (let i = 0; i < c.alive.length; ) {
-				const on = c.alive[i] >= ALIVE;
-				let j = i;
-				while (j < c.alive.length && c.alive[j] >= ALIVE === on) j++;
-				runs.push(th.fg(on ? "accent" : "dim", c.alive.slice(i, j).map(bar).join("")));
-				i = j;
-			}
-			// The sentence goes beside the bars when it fits there whole, else on its own line under the axis: never cut mid-fact.
-			const say = lifeText(c), beside = m.vw(say) <= width - indent.length - LABEL_W - c.alive.length - 2;
-			out.push(th.fg("dim", (indent + "cache").padEnd(indent.length + LABEL_W)) + runs.join("") + (say && beside ? "  " + th.fg("dim", say) : ""));
-			if (say && !beside) under = th.fg("dim", m.cut(" ".repeat(indent.length + LABEL_W) + say, width));
-			continue;
+	const head = (k: string) => th.fg("dim", (indent + k).padEnd(indent.length + LABEL_W));
+	const row = (k: string, v: string) => {
+		const line = m.cut(indent + k.padEnd(LABEL_W) + v, width);
+		if (!line) return;
+		const kk = line.slice(0, indent.length + LABEL_W);
+		out.push(th.fg("dim", kk) + th.fg("dim", line.slice(kk.length)));
+	};
+	if (c.model) {
+		row("model", c.model);
+		if (!hasChart(c)) {
+			// nothing learned yet: one line, the chart appears with the first return after a break
+			const room = width - indent.length - LABEL_W;
+			const v = [`${idle(c) || "expires after ~5 min idle"} \u00b7 ${NO_DATA}`, idle(c) || "expires after ~5 min idle"].find((x) => m.vw(x) <= room);
+			if (v) out.push(head("cache") + th.fg("dim", v));
+			else row("cache", idle(c) || "expires after ~5 min idle");
+		} else if (width >= IND + CHART_W + 1) out.push(...chartRows(c, width, th, m));
+		else {
+			// too narrow for the chart: the caption sentence alone says the same thing
+			const lines = captionLines(captionSegs(c), width - IND, th, m);
+			lines.forEach((l, i) => out.push((i ? " ".repeat(IND) : head("cache")) + l));
 		}
-		if (!c.alive?.length && c.model && c.life && row.startsWith("cache ")) {
-			// Narrow: keep the fact whole, dropping the model name first, then "(measured)".
-			const head = (indent + "cache").padEnd(indent.length + LABEL_W), room = width - m.vw(head);
-			const v = [row.slice(LABEL_W), lifeText(c), lifeText({ ...c, measured: false })].find((x) => m.vw(x) <= room);
-			if (v) { out.push(th.fg("dim", head + v)); continue; }
-		}
-		if (row.startsWith("unzip ")) {
+	}
+	for (const r of cardText({ ...c, model: undefined })) {
+		if (r.startsWith("unzip ")) {
 			// Narrow: the bracketed reason goes first, so where the files are stays whole.
-			const head = (indent + "unzip").padEnd(indent.length + LABEL_W), room = width - m.vw(head);
-			const v = [row.slice(LABEL_W), row.slice(LABEL_W).replace(/ \([^()]*\)$/, "")].find((x) => m.vw(x) <= room);
-			if (v) { out.push(th.fg("dim", head + v)); continue; }
+			const h = head("unzip"), room = width - m.vw(h);
+			const v = [r.slice(LABEL_W), r.slice(LABEL_W).replace(/ \([^()]*\)$/, "")].find((x) => m.vw(x) <= room);
+			if (v) { out.push(th.fg("dim", h + v)); continue; }
 		}
-		const line = m.cut(indent + row, width);
+		const line = m.cut(indent + r, width);
 		if (!line) continue;
 		const k = line.slice(0, indent.length + LABEL_W), v = line.slice(indent.length + LABEL_W);
-		out.push(th.fg("dim", k) + (row.startsWith("session") ? th.fg("text", v) : th.fg("dim", v)));
+		out.push(th.fg("dim", k) + (r.startsWith("session") ? th.fg("text", v) : th.fg("dim", v)));
 	}
-	if (under) out.push(under);
 	return out;
 }
 

package/src/util.ts

@@ -103,3 +103,8 @@ export function tokensOf(m: Any): number {
 	}
 	return Math.ceil(chars / 4);
 }
+
+/** Custom session entry pi-zip appends right before the prompt of a cold return. A warm plan holds back what that return protected
+ *  (plan.ts FOLD_HOLD); the entry makes the return a fact of the session, so a restart reads it instead of guessing from timestamps at
+ *  the TTL's edge. Custom entries never reach the model. */
+export const COLD_CUSTOM = "pi-zip/cold";