pi-zip 0.2.7 → 0.2.8

package/README.md

@@ -43,7 +43,7 @@ At most one line per turn in the transcript, only when the context was folded or
 ▸ pi-zip  182K → 41K  ▰▰▱▱▱▱▱▱▱▱  summarized 64 requests · ready while you were away
 ```
 
-The second line appears once per session. Expand tool output (ctrl+o) to see why it happened now and what was folded:
+The second line appears once per session. Click the notice (or expand tool output with ctrl+o) to see why it happened now and what was folded:
 
 ```
 ▸ pi-zip  74K → 43K  ▰▰▰▰▰▰▱▱▱▱  folded 12 old outputs
@@ -53,7 +53,7 @@ The second line appears once per session. Expand tool output (ctrl+o) to see why
           … 10 more
 ```
 
-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 words go first, then the bar; the numbers always stay. A summary still shows up as Pi's own `[compaction]` block as well; the pi-zip line next to it tells you who made it.
+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 words go first, then the bar; the numbers always stay. A summary still shows up as Pi's own `[compaction]` block as well; the pi-zip 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 "after" side is what the edited request actually carried); the `Compacted from N tokens` figure in Pi's block is Pi's own estimate taken when the entry is saved, so it will not match.
 
 Everything else pi-zip shows uses the same one-line grammar, and only when something changed:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-zip",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "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/index.ts

@@ -19,20 +19,35 @@ export default function piZip(pi: ExtensionAPI) {
 			if (typeof m?.visibleWidth === "function" && typeof m?.truncateToWidth === "function")
 				setMeasure({ vw: m.visibleWidth, cut: (s: string, w: number) => (m.visibleWidth(s) <= w ? s : w <= 0 ? "" : m.truncateToWidth(s, w, "…")) });
 		}, () => {});
+		// A click on a notice toggles its detail, like Pi's own compaction row; ctrl+o (Pi's global expand) still wins: a click
+		// only overrides the global state it was made under. Keyed by entry id because Pi rebuilds the component on every toggle.
+		const clicked = new Map<string, { open: boolean; under: boolean }>();
 		pi.registerEntryRenderer?.(NOTICE_CUSTOM, (entry: Any, o: Any, theme: Any) => {
 			const d = entry?.data;
 			if (!d?.text) return undefined;
+			const global = !!o?.expanded;
+			const key = typeof entry?.id === "string" ? entry.id : "";
+			const open = () => {
+				const c = key ? clicked.get(key) : undefined;
+				return c && c.under === global ? c.open : global;
+			};
+			const expandable = d.v === 2 && d.kind !== "state" && d.kind !== "card" && !!(d.why || d.items?.length);
 			return {
 				render: (width: number) => {
 					try {
 						if (d.v !== 2) return [theme.fg("dim", measure.cut(d.text, width))];
 						if (d.kind === "state") return renderState(d.word, d.reason ?? "", width, theme, measure);
 						if (d.kind === "card" && d.card) return renderCard(d.card, width, theme, measure);
-						return renderNotice(d as NoticeData, !!o?.expanded, width, theme, measure.vw);
+						return renderNotice(d as NoticeData, open(), width, theme, measure.vw);
 					} catch {
 						return [];
 					}
 				},
+				handleMouse: (ev: Any) => {
+					if (!expandable || !key || ev?.type !== "click" || ev?.button !== "left") return undefined;
+					clicked.set(key, { open: !open(), under: global });
+					return { handled: true, render: true };
+				},
 				invalidate: () => {},
 			};
 		});

package/src/run.ts

@@ -11,7 +11,7 @@ import { applyPlanToMessages, buildBlocks, calibrate, countUserTurns, G0, planCo
 import { handleFor, PH_MARK, RECALL_TOOL } from "./placeholder.ts";
 import { recalledHandlesFromBranch } from "./recall.ts";
 import { buildCut } from "./summary.ts";
-import { type Any, PRODUCT, textOf, tok4 } from "./util.ts";
+import { type Any, PRODUCT, clamp, textOf, tok4, tokensOf } from "./util.ts";
 import { fmtLife, SPARK_GAPS, type CardData, type StateWord } from "./ui.ts";
 
 export const PLAN_CUSTOM = "pi-zip/plan";
@@ -646,15 +646,20 @@ export class Zip implements ZipControl {
 		});
 		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: ctxTokens, tokensAfter: ctxTokens - (before - after), ms: plan.ms + (performance.now() - o.t0), pressure: valve });
+		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: ctxTokens - (before - after), tokensAfter: ctxTokens - (before - after) - cutSaved, ms: prepared ? cut.ms : waitMs, prepared, pressure: valve });
+			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(k * t.entryTokens), handle: handleFor(t.entryId) }));
+			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;