@adeildo/pi-look 5.9.2 → 5.10.0

package/src/index.ts

@@ -1,3 +1,5 @@
+import { dirname, join } from "node:path";
+
 import {
 	accountStateOf,
 	createApp,
@@ -6,6 +8,7 @@ import {
 	defineFeature,
 	drawSkillRefs,
 	type FeatureScope,
+	hideImagesUnderOverlays,
 	SKILL_REF,
 	skillNames,
 } from "@adeildo/pi-kit";
@@ -14,21 +17,20 @@ import type {
 	ExtensionContext,
 	ReadonlyFooterDataProvider,
 } from "@earendil-works/pi-coding-agent";
-import type { TUI } from "@earendil-works/pi-tui";
+import { Key, type TUI } from "@earendil-works/pi-tui";
 
 import { type GitState, readGit } from "./data/git.ts";
+import { type GithubState, readGithub } from "./data/github.ts";
 import { emptySnapshot, type LiveInputs, type Snapshot, SnapshotReader } from "./data/snapshot.ts";
+import type { LastVisit } from "./data/start-notes.ts";
 import { Telemetry } from "./data/telemetry.ts";
 import type { DeltaKind } from "./data/telemetry.ts";
 import { REQUEST_ENTRY, type RequestRecord } from "./data/totals.ts";
-import { resolveIcons } from "./render/glyphs.ts";
+import { visit } from "./data/visits.ts";
+import { type Glyphs, glyphsOf } from "./render/glyphs.ts";
 import { PLAIN, themePaint } from "./render/paint.ts";
 import { claimedStatuses, renderSegments, SEGMENTS } from "./render/segments.ts";
 import {
-	below,
-	belowRight,
-	bottomLeft,
-	bottomRight,
 	cursor,
 	frame,
 	gaugeCells,
@@ -37,27 +39,29 @@ import {
 	labels,
 	LOOK_SETTINGS,
 	pathLength,
-	peek,
-	separator,
 	SECTIONS,
-	SEPARATORS,
-	strip,
-	stripRight,
-	topLeft,
-	topRight,
+	SEPARATOR,
+	SLOTS,
+	userFrame,
 } from "./settings.ts";
 import { applyCursor, LookEditor } from "./ui/editor.ts";
 import { FooterComponent, StripComponent } from "./ui/footer.ts";
-import { HeaderComponent, type LoadedCounts } from "./ui/header.ts";
+import { HARNESS_VERSION, HeaderComponent, type LoadedCounts } from "./ui/header.ts";
+import { OutputView, outputsOf } from "./ui/outputs.ts";
+import { framePiEntries } from "./ui/pi-entries.ts";
+import { frameQueue } from "./ui/queue.ts";
 import type { Screen, SlotName } from "./ui/screen.ts";
 import { registerToolFrames } from "./ui/tool-frame.ts";
 import { type Activity, describe, draftedTool } from "./ui/working.ts";
 
 export { SEGMENT_IDS, SEGMENTS, type SegmentId } from "./render/segments.ts";
+import type { SegmentId } from "./render/segments.ts";
 export { ROLE_TOKENS } from "./render/paint.ts";
 
 const STRIP_WIDGET = "pi-look:strip";
 const TICK_MS = 500;
+/** GitHub is asked once per process, however many sessions it opens. */
+let probedGithub = false;
 
 interface Live {
 	ctx: ExtensionContext | undefined;
@@ -65,6 +69,7 @@ interface Live {
 	tui: TUI | undefined;
 	repaint: (() => void) | undefined;
 	git: GitState | undefined;
+	github: GithubState | undefined;
 	probing: boolean;
 	ticker: ReturnType<typeof setInterval> | undefined;
 	frame: Snapshot | undefined;
@@ -86,21 +91,36 @@ export const look = defineFeature({
 			tui: undefined,
 			repaint: undefined,
 			git: undefined,
+			github: undefined,
 			probing: false,
 			ticker: undefined,
 			frame: undefined,
 			activity: undefined,
 		};
 
-		const screen = createScreen(scope, live, reader, telemetry);
+		const glyphs = glyphsOf(() => icons.get(scope));
+		const screen = createScreen(scope, live, reader, telemetry, glyphs);
 		registerToolFrames(scope);
-		const repaint = () => live.repaint?.();
+		framePiEntries(() => {
+			if (live.ctx === undefined) return undefined;
+			return { theme: live.ctx.ui.theme, set: glyphs().set, you: userFrame.get(scope) };
+		});
+		frameQueue(() => live.ctx?.ui.theme);
+		const repaint = () => {
+			screen.bump();
+			live.repaint?.();
+		};
 
 		for (const entry of LOOK_SETTINGS) entry.listen(scope, repaint);
 		frame.listen(scope, () => live.ctx && installEditor(live.ctx, screen, live, scope));
-		header.listen(scope, () => live.ctx && installHeader(live.ctx, screen, scope));
-		cursor.listen(scope, (style) => live.tui && applyCursor(live.tui, style));
-		peek.listen(scope, (on) => !on && live.ctx?.ui.setWorkingMessage());
+		const visitsFile = join(dirname(scope.settings.globalPath), "look-visits.json");
+		let visited = false;
+		let lastVisit: LastVisit | undefined;
+
+		scope.registerShortcut(Key.alt("o"), {
+			description: "A tool call's whole output, to scroll; the arrows move between calls",
+			handler: (ctx) => openOutputs(ctx),
+		});
 
 		scope.onSessionStart((ctx) => {
 			live.ctx = ctx;
@@ -113,7 +133,12 @@ export const look = defineFeature({
 					new FooterComponent(tui, data, screen, {
 						attach: (footerData, paint) => {
 							live.footerData = footerData;
-							live.repaint = paint;
+							// Everything that asks for a redraw says what the screen draws may have changed, which is
+							// what a component that keeps its drawing for a moment compares.
+							live.repaint = () => {
+								screen.bump();
+								paint();
+							};
 						},
 						detach: () => {
 							live.footerData = undefined;
@@ -125,7 +150,23 @@ export const look = defineFeature({
 				placement: "aboveEditor",
 			});
 			installEditor(ctx, screen, live, scope);
-			installHeader(ctx, screen, scope);
+			// Once per launch: a new session in the same pi is not a return to the folder.
+			if (!visited) {
+				visited = true;
+				lastVisit = visit(visitsFile, ctx.cwd, HARNESS_VERSION, Date.now());
+			}
+			// Once per launch, off the critical path: the card shows these lines when the answers arrive.
+			if (!probedGithub) {
+				probedGithub = true;
+				void probeGithub(live, lastVisit?.at);
+			}
+			installHeader(
+				ctx,
+				screen,
+				scope,
+				() => lastVisit,
+				() => live.github,
+			);
 		});
 
 		scope.onShutdown(() => {
@@ -150,13 +191,13 @@ export const look = defineFeature({
 
 		scope.on("agent_start", () => {
 			telemetry.runStarted();
-			setActivity(live, scope, { kind: "waiting" });
+			setActivity(live, { kind: "waiting" });
 			startTicking(live);
 		});
 
 		scope.on("turn_start", () => {
 			telemetry.requestStarted();
-			setActivity(live, scope, { kind: "waiting" });
+			setActivity(live, { kind: "waiting" });
 		});
 
 		scope.on("message_start", (event) => {
@@ -172,12 +213,12 @@ export const look = defineFeature({
 			telemetry.answerGrew(delta, message.usage, kind);
 
 			if (update.type === "thinking_start" || update.type === "thinking_delta") {
-				setActivity(live, scope, { kind: "thinking" });
+				setActivity(live, { kind: "thinking" });
 			} else if (update.type === "text_delta" || update.type === "text_start") {
-				setActivity(live, scope, { kind: "writing" });
+				setActivity(live, { kind: "writing" });
 			} else if (update.type === "toolcall_start" || update.type === "toolcall_delta") {
 				const tool = draftedTool(message.content);
-				if (tool !== undefined) setActivity(live, scope, { kind: "drafting", tool });
+				if (tool !== undefined) setActivity(live, { kind: "drafting", tool });
 			}
 		});
 
@@ -190,7 +231,7 @@ export const look = defineFeature({
 		});
 
 		scope.on("tool_execution_start", (event) => {
-			setActivity(live, scope, { kind: "running", tool: event.toolName });
+			setActivity(live, { kind: "running", tool: event.toolName });
 		});
 
 		scope.on("tool_execution_end", () => void probeGit(live));
@@ -211,9 +252,9 @@ export const look = defineFeature({
 
 		scope.screen.action({
 			id: "explain",
-			section: "Slots",
+			section: "Appearance",
 			label: "What is on screen",
-			description: "Every piece the slots show right now, and what it means.",
+			description: "Every piece around the editor right now, and what it means.",
 			run: () => explain(screen),
 		});
 	},
@@ -234,10 +275,17 @@ function explain(screen: Screen): string {
 	const snapshot = screen.snapshot();
 	const paint = screen.paint();
 	const lines: string[] = [paint.bold("What is on screen")];
-	for (const name of Object.keys(SLOT_TITLES) as SlotName[]) {
-		const ids = screen.slot(name);
+	const groups: [string, readonly SegmentId[]][] = [
+		...(Object.keys(SLOT_TITLES) as SlotName[]).map((name): [string, readonly SegmentId[]] => [
+			SLOT_TITLES[name],
+			screen.slot(name),
+		]),
+		// Not on screen: the timings of the last call, kept for when an answer feels slow.
+		["The last call to the model", ["last", "wait", "speed", "server", "request"]],
+	];
+	for (const [title, ids] of groups) {
 		if (ids.length === 0) continue;
-		lines.push("", paint.role("brand", SLOT_TITLES[name]));
+		lines.push("", paint.role("brand", title));
 		for (const id of ids) {
 			const [piece] = renderSegments([id], {
 				snapshot,
@@ -252,13 +300,7 @@ function explain(screen: Screen): string {
 			lines.push(`  ${shown}`, `    ${paint.dim(`${id}: ${meaning}`)}`);
 		}
 	}
-	lines.push(
-		"",
-		paint.dim("Arrows are from where you sit: ↑ in is sent to the model, ↓ out comes back."),
-		paint.dim(
-			"Slots and labels live under look. in ~/.pi/agent/extensions/pi-harness/settings.json.",
-		),
-	);
+	lines.push("", paint.dim("In is what was sent to the model, out is what came back."));
 	return lines.join("\n");
 }
 
@@ -267,18 +309,10 @@ function createScreen(
 	live: Live,
 	reader: SnapshotReader,
 	telemetry: Telemetry,
+	glyphs: () => Glyphs,
 ): Screen {
-	const slots: Record<SlotName, typeof strip> = {
-		strip,
-		stripRight,
-		topLeft,
-		topRight,
-		bottomLeft,
-		bottomRight,
-		below,
-		belowRight,
-	};
-
+	// What the components that keep a drawing for a moment compare: an event, a probe, a new branch.
+	let revision = 0;
 	return {
 		snapshot() {
 			const ctx = live.ctx;
@@ -300,18 +334,22 @@ function createScreen(
 			});
 			return snapshot;
 		},
-		glyphs: () => resolveIcons(icons.get(scope)),
+		glyphs,
+		revision: () => revision,
+		bump: () => {
+			revision++;
+		},
 		paint: (border) => (live.ctx === undefined ? PLAIN : themePaint(live.ctx.ui.theme, border)),
-		separator: () => SEPARATORS[separator.get(scope)],
+		separator: () => SEPARATOR,
 		options: () => ({
-			pathLength: pathLength.get(scope),
-			gaugeCells: gaugeCells.get(scope),
-			labels: labels.get(scope),
-			claimed: claimedStatuses(Object.values(slots).map((entry) => entry.get(scope))),
+			pathLength,
+			gaugeCells,
+			labels,
+			claimed: claimedStatuses(Object.values(SLOTS)),
 		}),
-		slot: (name) => slots[name].get(scope),
+		slot: (name) => SLOTS[name],
 		frameStyle: () => frame.get(scope),
-		cursor: () => cursor.get(scope),
+		cursor: () => cursor,
 		decorate: (line) => {
 			const theme = live.ctx?.ui.theme;
 			if (theme === undefined) return line;
@@ -345,23 +383,31 @@ function installEditor(
 	}
 	ctx.ui.setEditorComponent((tui, theme, keybindings) => {
 		live.tui = tui;
-		applyCursor(tui, cursor.get(scope));
+		applyCursor(tui, cursor);
 		return new LookEditor(tui, theme, keybindings, screen);
 	});
 }
 
-function installHeader(ctx: ExtensionContext, screen: Screen, scope: FeatureScope): void {
+function installHeader(
+	ctx: ExtensionContext,
+	screen: Screen,
+	scope: FeatureScope,
+	lastVisit: () => LastVisit | undefined,
+	github: () => GithubState | undefined,
+): void {
 	if (ctx.mode !== "tui") return;
-	if (header.get(scope) === "off") {
-		ctx.ui.setHeader(undefined);
-		return;
-	}
 	ctx.ui.setHeader(
-		() =>
-			new HeaderComponent(screen, {
-				style: () => header.get(scope),
-				counts: () => loadedCounts(scope),
-			}),
+		(tui) =>
+			new HeaderComponent(
+				screen,
+				{
+					style: () => header,
+					counts: () => loadedCounts(scope),
+					lastVisit,
+					github,
+				},
+				tui,
+			),
 	);
 }
 
@@ -383,14 +429,23 @@ function loadedCounts(pi: ExtensionAPI): LoadedCounts {
 	};
 }
 
-function setActivity(live: Live, scope: FeatureScope, activity: Activity): void {
-	if (!peek.get(scope)) return;
+function setActivity(live: Live, activity: Activity): void {
 	const message = describe(activity);
 	if (message === live.activity) return;
 	live.activity = message;
 	live.ctx?.ui.setWorkingMessage(message);
 }
 
+async function probeGithub(live: Live, since: number | undefined): Promise<void> {
+	const ctx = live.ctx;
+	if (ctx === undefined) return;
+	const github = await readGithub(ctx.cwd, since);
+	if (live.ctx === undefined) return;
+	live.github = github;
+	// The card keeps its drawing for a second; this is the redraw that makes the new lines appear.
+	live.repaint?.();
+}
+
 async function probeGit(live: Live): Promise<void> {
 	const ctx = live.ctx;
 	if (ctx === undefined || live.probing) return;
@@ -418,3 +473,24 @@ function stopTicking(live: Live): void {
 export default function piLook(pi: ExtensionAPI): void {
 	createApp(pi, { name: "pi-look" }).use(look).build();
 }
+
+/** Alt+O: the session's tool output, one call at a time, newest first. */
+async function openOutputs(ctx: ExtensionContext): Promise<void> {
+	if (ctx.mode !== "tui") return;
+	const outputs = outputsOf(ctx.sessionManager.getBranch());
+	await ctx.ui.custom<void>(
+		(tui, theme, _keybindings, done) => {
+			hideImagesUnderOverlays(tui);
+			return new OutputView({
+				theme,
+				outputs,
+				rows: () => Math.floor(tui.terminal.rows * 0.85),
+				close: () => done(),
+			});
+		},
+		{
+			overlay: true,
+			overlayOptions: { anchor: "center", width: "90%", minWidth: 60, maxHeight: "85%" },
+		},
+	);
+}

package/src/render/fit.ts

@@ -1,3 +1,4 @@
+import { CUT } from "@adeildo/pi-kit";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 export interface Piece {
@@ -55,7 +56,7 @@ export function fitRegions(
 	return joined.map((text) =>
 		text === ""
 			? ""
-			: truncateToWidth(text, Math.max(0, width - overhead), options.ellipsis ?? "..."),
+			: truncateToWidth(text, Math.max(0, width - overhead), options.ellipsis ?? CUT),
 	);
 }
 

package/src/render/format.ts

@@ -1,5 +1,6 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 
+import { formatCost, formatTokens } from "@adeildo/pi-kit";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 export const CELL = {
@@ -17,14 +18,8 @@ export function cell(text: string, width: number): string {
 
 export const UNKNOWN = "–";
 
-export function count(value: number): string {
-	const n = Math.max(0, Math.round(value));
-	if (n < 1000) return String(n);
-	if (n < 10_000) return `${trim((n / 1000).toFixed(1))}k`;
-	if (n < 1_000_000) return `${Math.round(n / 1000)}k`;
-	if (n < 10_000_000) return `${trim((n / 1_000_000).toFixed(1))}M`;
-	return `${Math.round(n / 1_000_000)}M`;
-}
+/** The look's word for the kit's format, which is where the shape was decided. */
+export const count = formatTokens;
 
 export function rate(perSecond: number): string {
 	if (perSecond < 10) return trim(perSecond.toFixed(1));
@@ -55,10 +50,7 @@ export function latency(milliseconds: number): string {
 	return duration(milliseconds);
 }
 
-export function money(amount: number): string {
-	if (amount === 0) return "$0.00";
-	return amount >= 10 ? `$${amount.toFixed(2)}` : `$${amount.toFixed(3)}`;
-}
+export const money = formatCost;
 
 export function percent(value: number): string {
 	return value >= 10 || value === 0 ? `${Math.round(value)}%` : `${value.toFixed(1)}%`;
@@ -107,6 +99,11 @@ export function fitWidth(text: string, width: number, ellipsis = "..."): string
 	return truncateToWidth(text, Math.max(0, width), ellipsis);
 }
 
+/** Tabs become three spaces: a tab is as wide as the terminal says, and these lines have a width. */
+export function tabs(text: string): string {
+	return text.replace(/\t/g, "   ");
+}
+
 function underHome(cwd: string, home: string): string {
 	const rest = relative(resolve(home), resolve(cwd));
 	const inside =

package/src/render/glyphs.ts

@@ -160,3 +160,17 @@ export function resolveIcons(mode: IconMode, env: NodeJS.ProcessEnv = process.en
 	if (env.SSH_TTY !== undefined || env.SSH_CONNECTION !== undefined) return UNICODE;
 	return NERD;
 }
+
+/**
+ * The glyphs for a scope, resolved once and again only when the setting behind them changes. Every
+ * frame, rule and slot of the screen asks for them on each drawing, and resolving each time was a
+ * fifth of what typing cost.
+ */
+export function glyphsOf(modeOf: () => IconMode): () => Glyphs {
+	let known: { mode: IconMode; glyphs: Glyphs } | undefined;
+	return () => {
+		const mode = modeOf();
+		if (known?.mode !== mode) known = { mode, glyphs: resolveIcons(mode) };
+		return known.glyphs;
+	};
+}

package/src/render/segments.ts

@@ -1,4 +1,4 @@
-import { type AccountWindow, type PeerMark, tasksWith } from "@adeildo/pi-kit";
+import { type AccountWindow, formatClock, type PeerMark, tasksWith } from "@adeildo/pi-kit";
 import { visibleWidth } from "@earendil-works/pi-tui";
 
 import type { Snapshot } from "../data/snapshot.ts";
@@ -233,8 +233,7 @@ export const SEGMENTS: Record<BuiltinSegment, Segment> = {
 		priority: 15,
 		describe: "the time of day",
 		render: ({ snapshot, glyphs, paint }) => {
-			const now = new Date(snapshot.now);
-			const time = `${pad(now.getHours())}:${pad(now.getMinutes())}`;
+			const time = formatClock(snapshot.now);
 			return { text: `${mark(glyphs.clock, paint, "clock")}${paint.role("clock", time)}` };
 		},
 	},
@@ -344,18 +343,18 @@ export const SEGMENTS: Record<BuiltinSegment, Segment> = {
 	elapsed: {
 		priority: 65,
 		describe:
-			"how long the agent has worked on this prompt, and how many calls to the model it made",
-		render: ({ snapshot, glyphs, paint, options }) => {
+			"the run: while the agent works, how long and how many calls to the model; once it answered, the same and what it cost",
+		render: ({ snapshot, glyphs, paint }) => {
 			const run = snapshot.run;
 			if (run === undefined) return undefined;
 			const role: Role = run.running ? "running" : "done";
 			const icon = mark(run.running ? glyphs.running : glyphs.done, paint, role);
 			const time = paint.role(role, stopwatch(run.elapsedMs));
-			const calls =
-				run.requests <= 1
-					? ""
-					: paint.dim(options.labels ? `  ${run.requests} calls` : ` ×${run.requests}`);
-			return { text: `${icon}${time}${calls}`, compact: `${icon}${time}` };
+			const lead = run.running ? time : `${paint.dim("answered in ")}${time}`;
+			const calls = run.requests <= 1 ? "" : paint.dim(`  ${run.requests} calls`);
+			const cost =
+				run.running || run.cost === 0 ? "" : `  ${paint.money(run.cost, money(run.cost))}`;
+			return { text: `${icon}${lead}${calls}${cost}`, compact: `${icon}${time}` };
 		},
 	},
 	last: {
@@ -440,9 +439,10 @@ export const SEGMENTS: Record<BuiltinSegment, Segment> = {
 			// A session that spent nothing has nothing to say yet.
 			if (amount === 0) return undefined;
 			const value = paint.money(amount, money(amount));
-			const sub = snapshot.subscription ? paint.dim(" sub") : "";
+			// On a plan nothing is billed per token: the amount is what the tokens would cost.
+			const what = paint.dim(snapshot.subscription ? " at API prices" : " this session");
 			const icon = glyphs.cost === "$" ? "" : mark(glyphs.cost, paint, "cost");
-			return { text: `${icon}${value}${sub}`, compact: `${icon}${value}` };
+			return { text: `${icon}${value}${what}`, compact: `${icon}${value}` };
 		},
 	},
 	tokens: {
@@ -453,12 +453,13 @@ export const SEGMENTS: Record<BuiltinSegment, Segment> = {
 			const totals = snapshot.totals;
 			if (tokensOf(totals) === 0) return undefined;
 			// Everything sent, not just the uncached part: `66 in` next to a million cached reads is a lie.
-			const sent = `${paint.role("sent", glyphs.sent)}${paint.role("sent", count(promptOf(totals)))}`;
-			const got = `${paint.role("received", glyphs.received)}${paint.role("received", count(totals.output))}`;
-			if (!options.labels) return { text: `${sent} ${got}` };
+			const sent = paint.role("sent", count(promptOf(totals)));
+			const got = paint.role("received", count(totals.output));
+			const arrows = `${paint.role("sent", glyphs.sent)}${sent} ${paint.role("received", glyphs.received)}${got}`;
+			if (!options.labels) return { text: arrows };
 			return {
-				text: `${sent}${paint.dim(" in")} ${got}${paint.dim(" out")}`,
-				compact: `${sent} ${got}`,
+				text: `${paint.dim("in ")}${sent}  ${paint.dim("out ")}${got}`,
+				compact: `${paint.dim("in ")}${sent} ${paint.dim("out ")}${got}`,
 			};
 		},
 	},
@@ -476,8 +477,11 @@ export const SEGMENTS: Record<BuiltinSegment, Segment> = {
 			const value =
 				hit >= 90 ? paint.role("done", percent(hit)) : paint.stress(100 - hit, percent(hit));
 			return {
-				text: `${icon}${value}${options.labels ? paint.dim(" cached") : ""}`,
-				compact: `${icon}${value}`,
+				// The numbers around it are the session's, so the label says this one is the last prompt's.
+				text: options.labels
+					? `${paint.dim("last prompt ")}${value}${paint.dim(" cached")}`
+					: `${icon}${value}`,
+				compact: options.labels ? `${paint.dim("cache ")}${value}` : `${icon}${value}`,
 			};
 		},
 	},
@@ -485,17 +489,13 @@ export const SEGMENTS: Record<BuiltinSegment, Segment> = {
 		priority: 25,
 		describe:
 			"the session's average speeds: ↓ the model writing, ↑ it reading the prompt, cache included",
-		render: ({ snapshot, glyphs, paint }) => {
+		render: ({ snapshot, paint }) => {
 			const { decode, prefill } = snapshot.averages;
 			if (decode === undefined && prefill === undefined) return undefined;
 			const down =
-				decode === undefined
-					? ""
-					: `${paint.role("received", glyphs.received)}${paint.role("speed", rate(decode))}`;
+				decode === undefined ? "" : `${paint.dim("out ")}${paint.role("speed", rate(decode))}`;
 			const up =
-				prefill === undefined
-					? ""
-					: `${paint.role("sent", glyphs.sent)}${paint.role("sent", rate(prefill))}`;
+				prefill === undefined ? "" : `${paint.dim("in ")}${paint.role("sent", rate(prefill))}`;
 			const label = paint.dim("avg ");
 			const unit = paint.dim(" tok/s");
 			return {
@@ -572,7 +572,10 @@ function cacheParts(
 	options: SegmentOptions,
 	fixed = false,
 ): string {
-	const value = (tokens: number) => (fixed ? tokenCell(tokens) : tokens > 0 ? count(tokens) : "");
+	const value = (tokens: number): string => {
+		if (fixed) return tokenCell(tokens);
+		return tokens > 0 ? count(tokens) : "";
+	};
 	const read = value(usage.cacheRead);
 	const write = value(usage.cacheWrite);
 	if (options.labels) {
@@ -612,7 +615,3 @@ function speedCell(value: number | undefined): string {
 function tokenCell(value: number): string {
 	return cell(value === 0 ? UNKNOWN : count(value), CELL.count);
 }
-
-function pad(value: number): string {
-	return String(value).padStart(2, "0");
-}