@wierdbytes/pi-facelift 0.6.5 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.7.0
+
+- **Change:** still accent `●` instead of pi's animated spinner in the `Working...` line — no ~12×/s terminal repaints while the model streams; `animateWorkingIndicator` in `/facelift` brings the animation back.
+
+## 0.6.6
+
+- **Fix:** prompt-cache warm-ups no longer inflate `worked` time / deflate `tps` or start a phantom working timer while idle.
+
 ## 0.6.5
 
 - **Fix:** pi crashing with "extension ctx is stale" when the session was replaced or reloaded while the working timer was ticking.

package/README.md

@@ -49,7 +49,8 @@ tool output.
   `⏱ worked 45.2s (total: 1m15s) · tps: 756`
 
   - `worked` — model-only time (request dispatch → response end, so
-    time-to-first-token counts; tool execution is excluded).
+    time-to-first-token counts; tool execution and pi's prompt-cache
+    warm-up requests are excluded).
   - `total` — wall-clock time from your prompt to the final response,
     including retries, tool calls, and all other overhead.
   - `tps` — output tokens per second over the `worked` time. The live
@@ -61,6 +62,11 @@ tool output.
   (`0h12m0s` → `12m0s`); sub-minute values keep one decimal (`45.2s`).
 
   Toggle via `showWorkingTime` in `/facelift`.
+- **still working indicator** — pi's braille spinner in front of the
+  `Working...` line is replaced with a still accent `●`, so the terminal
+  isn't repainted ~12×/s while the model streams (GPU-rendered hosts such
+  as Herdr redraw the whole window for every frame). Turn the animation
+  back on via `animateWorkingIndicator` in `/facelift`.
 
 ## Install
 
@@ -127,7 +133,11 @@ Current schema:
   // each run's model time (`worked`, tools excluded) and wall-clock time
   // (`total`, retries + tools + overhead) as a muted line in chat
   // history. Default true.
-  "showWorkingTime": true
+  "showWorkingTime": true,
+
+  // Animate the spinner in front of the "Working..." line (pi's default,
+  // redrawn every 80ms). Default false: a still accent "●".
+  "animateWorkingIndicator": false
 }
 ```
 
@@ -146,6 +156,7 @@ icons, image protocols) or boot-time toggles:
 | `FACELIFT_IMAGE_PROTOCOL`      | auto            | Force `kitty` / `iterm2` / `none`. Auto-detected from `$TERM_PROGRAM` etc.    |
 | `DIFF_LAYOUT`                  | (none)          | One-shot override for `diffLayout` on first-run seeding.                      |
 | `FACELIFT_SHOW_WORKING_TIME`   | `true`          | One-shot override for `showWorkingTime` on first-run seeding (`0`/`off` ⇒ off). |
+| `FACELIFT_ANIMATE_WORKING`     | `false`         | Default for `animateWorkingIndicator` when the config doesn't set it (`1`/`on` ⇒ animated). |
 
 ## Development
 

package/config.test.ts

@@ -40,6 +40,8 @@ beforeEach(() => {
 	delete process.env.DIFF_LAYOUT;
 	savedEnv.FACELIFT_SHOW_WORKING_TIME = process.env.FACELIFT_SHOW_WORKING_TIME;
 	delete process.env.FACELIFT_SHOW_WORKING_TIME;
+	savedEnv.FACELIFT_ANIMATE_WORKING = process.env.FACELIFT_ANIMATE_WORKING;
+	delete process.env.FACELIFT_ANIMATE_WORKING;
 });
 
 afterEach(() => {
@@ -48,29 +50,32 @@ afterEach(() => {
 	if (savedEnv.FACELIFT_SHOW_WORKING_TIME !== undefined)
 		process.env.FACELIFT_SHOW_WORKING_TIME = savedEnv.FACELIFT_SHOW_WORKING_TIME;
 	else delete process.env.FACELIFT_SHOW_WORKING_TIME;
+	if (savedEnv.FACELIFT_ANIMATE_WORKING !== undefined)
+		process.env.FACELIFT_ANIMATE_WORKING = savedEnv.FACELIFT_ANIMATE_WORKING;
+	else delete process.env.FACELIFT_ANIMATE_WORKING;
 	rmSync(dir, { recursive: true, force: true });
 });
 
 describe("envDefaults", () => {
 	it("returns 'consistent' when DIFF_LAYOUT is unset", () => {
-		expect(envDefaults()).toEqual({ diffLayout: "consistent", showWorkingTime: true });
+		expect(envDefaults()).toEqual({ diffLayout: "consistent", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 
 	for (const layout of VALID_DIFF_LAYOUTS) {
 		it(`honours DIFF_LAYOUT=${layout}`, () => {
 			process.env.DIFF_LAYOUT = layout;
-			expect(envDefaults()).toEqual({ diffLayout: layout, showWorkingTime: true });
+			expect(envDefaults()).toEqual({ diffLayout: layout, showWorkingTime: true, animateWorkingIndicator: false });
 		});
 	}
 
 	it("ignores invalid DIFF_LAYOUT values", () => {
 		process.env.DIFF_LAYOUT = "rainbow";
-		expect(envDefaults()).toEqual({ diffLayout: "consistent", showWorkingTime: true });
+		expect(envDefaults()).toEqual({ diffLayout: "consistent", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 
 	it("is case-insensitive on DIFF_LAYOUT", () => {
 		process.env.DIFF_LAYOUT = "SPLIT";
-		expect(envDefaults()).toEqual({ diffLayout: "split", showWorkingTime: true });
+		expect(envDefaults()).toEqual({ diffLayout: "split", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 
 	it("defaults showWorkingTime to true", () => {
@@ -90,15 +95,43 @@ describe("envDefaults", () => {
 	});
 });
 
+describe("animateWorkingIndicator", () => {
+	it("defaults to false (a still indicator)", () => {
+		expect(envDefaults().animateWorkingIndicator).toBe(false);
+	});
+
+	it("honours FACELIFT_ANIMATE_WORKING=1/on/true to animate", () => {
+		for (const v of ["1", "on", "true"]) {
+			process.env.FACELIFT_ANIMATE_WORKING = v;
+			expect(envDefaults().animateWorkingIndicator).toBe(true);
+		}
+	});
+
+	it("persists animateWorkingIndicator=true through save/load", () => {
+		saveConfig({ diffLayout: "split", showWorkingTime: true, animateWorkingIndicator: true }, configFile);
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "split", showWorkingTime: true, animateWorkingIndicator: true });
+	});
+
+	it("sanitises a non-boolean value back to the default", () => {
+		writeFileSync(configFile, JSON.stringify({ diffLayout: "split", animateWorkingIndicator: "yes" }));
+		expect(loadConfig(configFile).animateWorkingIndicator).toBe(false);
+	});
+
+	it("keeps older config files (no field) on the default", () => {
+		writeFileSync(configFile, JSON.stringify({ diffLayout: "split", showWorkingTime: false }));
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "split", showWorkingTime: false, animateWorkingIndicator: false });
+	});
+});
+
 describe("showWorkingTime round-trip", () => {
 	it("persists showWorkingTime=false through save/load", () => {
-		saveConfig({ diffLayout: "consistent", showWorkingTime: false }, configFile);
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: false });
+		saveConfig({ diffLayout: "consistent", showWorkingTime: false, animateWorkingIndicator: false }, configFile);
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: false, animateWorkingIndicator: false });
 	});
 
 	it("sanitises a non-boolean showWorkingTime back to the default", () => {
 		writeFileSync(configFile, JSON.stringify({ diffLayout: "split", showWorkingTime: "nope" }));
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "split", showWorkingTime: true });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "split", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 });
 
@@ -107,7 +140,7 @@ describe("loadConfig + saveConfig round-trip", () => {
 		it(`persists diffLayout=${layout}`, () => {
 			saveConfig({ diffLayout: layout } as WierdFaceliftConfig, configFile);
 			expect(existsSync(configFile)).toBe(true);
-			expect(loadConfig(configFile)).toEqual({ diffLayout: layout, showWorkingTime: true });
+			expect(loadConfig(configFile)).toEqual({ diffLayout: layout, showWorkingTime: true, animateWorkingIndicator: false });
 		});
 	}
 
@@ -116,23 +149,23 @@ describe("loadConfig + saveConfig round-trip", () => {
 			configFile,
 			JSON.stringify({ diffLayout: "consistent", iconMode: "rainbow", junk: 42 }),
 		);
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 
 	it("rejects invalid diffLayout strings and falls back to default", () => {
 		writeFileSync(configFile, JSON.stringify({ diffLayout: "tutti-frutti" }));
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 
 	it("returns defaults when the file is missing (no write)", () => {
 		expect(existsSync(configFile)).toBe(false);
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true, animateWorkingIndicator: false });
 		expect(existsSync(configFile)).toBe(false);
 	});
 
 	it("returns defaults when the file is malformed JSON", () => {
 		writeFileSync(configFile, "{ not valid json");
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 
 	it("writes a trailing newline", () => {
@@ -145,22 +178,22 @@ describe("loadOrInitConfig", () => {
 	it("seeds a missing file from env defaults", () => {
 		expect(existsSync(configFile)).toBe(false);
 		const cfg = loadOrInitConfig(configFile);
-		expect(cfg).toEqual({ diffLayout: "consistent", showWorkingTime: true });
+		expect(cfg).toEqual({ diffLayout: "consistent", showWorkingTime: true, animateWorkingIndicator: false });
 		expect(existsSync(configFile)).toBe(true);
-		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "consistent", showWorkingTime: true });
+		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "consistent", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 
 	it("respects DIFF_LAYOUT when seeding", () => {
 		process.env.DIFF_LAYOUT = "unified";
 		const cfg = loadOrInitConfig(configFile);
-		expect(cfg).toEqual({ diffLayout: "unified", showWorkingTime: true });
-		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "unified", showWorkingTime: true });
+		expect(cfg).toEqual({ diffLayout: "unified", showWorkingTime: true, animateWorkingIndicator: false });
+		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "unified", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 
 	it("does not overwrite an existing file", () => {
 		writeFileSync(configFile, JSON.stringify({ diffLayout: "split" }));
 		process.env.DIFF_LAYOUT = "unified"; // would override on a fresh seed
 		const cfg = loadOrInitConfig(configFile);
-		expect(cfg).toEqual({ diffLayout: "split", showWorkingTime: true });
+		expect(cfg).toEqual({ diffLayout: "split", showWorkingTime: true, animateWorkingIndicator: false });
 	});
 });

package/config.ts

@@ -10,7 +10,8 @@
  *     extension.
  *   - Saves write atomically (one JSON.stringify + trailing newline).
  *
- * The knobs we expose today are `diffLayout` and `showWorkingTime`, and
+ * The knobs we expose today are `diffLayout`, `showWorkingTime` and
+ * `animateWorkingIndicator`, and
  * the schema is designed to accept more fields (icon mode, max preview
  * lines, etc.) without breaking older config files.
  */
@@ -58,6 +59,18 @@ export interface WierdFaceliftConfig {
 	 * (`0`/`false`/`off` to disable).
 	 */
 	showWorkingTime: boolean;
+
+	/**
+	 * Animate the spinner in front of the streaming "Working…" line (pi's
+	 * default: a braille spinner redrawn every 80ms). Off ⇒ a still accent
+	 * `●` instead, so an idle-looking terminal isn't repainted 12×/s while
+	 * the model streams — GPU-rendered hosts (e.g. Herdr) redraw the whole
+	 * window for each of those frames.
+	 *
+	 * Defaults to `false`; override with env `FACELIFT_ANIMATE_WORKING`
+	 * (`1`/`true`/`on` to animate).
+	 */
+	animateWorkingIndicator: boolean;
 }
 
 function isDiffLayout(value: unknown): value is DiffLayoutPreference {
@@ -88,6 +101,7 @@ export function envDefaults(): WierdFaceliftConfig {
 	return {
 		diffLayout: fromEnv ?? DEFAULT_DIFF_LAYOUT,
 		showWorkingTime: parseBool(process.env.FACELIFT_SHOW_WORKING_TIME, true),
+		animateWorkingIndicator: parseBool(process.env.FACELIFT_ANIMATE_WORKING, false),
 	};
 }
 
@@ -98,6 +112,7 @@ function sanitize(raw: unknown): WierdFaceliftConfig {
 	const cfg: WierdFaceliftConfig = { ...defaults };
 	if (isDiffLayout(obj.diffLayout)) cfg.diffLayout = obj.diffLayout;
 	if (typeof obj.showWorkingTime === "boolean") cfg.showWorkingTime = obj.showWorkingTime;
+	if (typeof obj.animateWorkingIndicator === "boolean") cfg.animateWorkingIndicator = obj.animateWorkingIndicator;
 	return cfg;
 }
 
@@ -143,6 +158,7 @@ export function saveConfig(
 	const out: Record<string, unknown> = {
 		diffLayout: cfg.diffLayout,
 		showWorkingTime: cfg.showWorkingTime,
+		animateWorkingIndicator: cfg.animateWorkingIndicator,
 	};
 	writeFileSync(path, `${JSON.stringify(out, null, 2)}\n`, "utf-8");
 	return path;

package/index.ts

@@ -1211,11 +1211,22 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 		workingTracker.ensureRun();
 	});
 
+	// pi emits `turn_start` (awaited) right before every agent request, so it
+	// arms the tracker. Cache-warmer replays also fire `before_provider_request`
+	// but arrive outside this window (during tools or after settle) and never
+	// get a `message_end` — unguarded they would hold a segment open forever.
+	pi.on("turn_start", () => {
+		if (!faceliftConfig.showWorkingTime) return;
+		workingTracker.armRequest();
+	});
+
 	pi.on("before_provider_request", (_event, ctx) => {
 		if (!faceliftConfig.showWorkingTime) return;
 		// Start the segment when the request is dispatched (not on the first
-		// token), so time-to-first-token counts as working time too.
-		workingTracker.beginSegment();
+		// token), so time-to-first-token counts as working time too. A `false`
+		// means a cache warm-up (not armed) or a repeat payload hook for an
+		// already-open request — leave the ticker alone.
+		if (!workingTracker.beginSegment()) return;
 		stopWorkingTick();
 		renderWorkingMessage(ctx);
 		workingTick = setInterval(() => renderWorkingMessage(ctx), 1000);
@@ -1247,6 +1258,31 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 		if (entry) pi.appendEntry(WORKING_TIME_ENTRY, entry);
 	});
 
+	// ===================================================================
+	// Working indicator — a still `●` instead of pi's 80ms spinner
+	// -------------------------------------------------------------------
+	// pi's braille spinner repaints the terminal ~12×/s for as long as the
+	// model streams; a GPU-rendered host (Herdr) redraws its whole window
+	// for every one of those frames. A single frame starts no animation
+	// timer at all. pi resets the indicator on every reload / session
+	// switch, so it is applied on each `session_start` (and at once when
+	// the setting changes).
+	// ===================================================================
+
+	const applyWorkingIndicator = (ctx: SessionContextLike): void => {
+		try {
+			if (!ctx.hasUI || typeof ctx.ui.setWorkingIndicator !== "function") return;
+			if (faceliftConfig.animateWorkingIndicator) ctx.ui.setWorkingIndicator();
+			else ctx.ui.setWorkingIndicator({ frames: [ctx.ui.theme.fg("accent", "●")] });
+		} catch {
+			// Stale ctx or an older pi without the API: keep pi's default.
+		}
+	};
+
+	pi.on("session_start", (_event, ctx) => {
+		applyWorkingIndicator(ctx);
+	});
+
 	// ===================================================================
 	// read — syntax-highlighted file content
 	// ===================================================================
@@ -1855,6 +1891,15 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 				value: faceliftConfig.showWorkingTime,
 				default: true,
 			},
+			{
+				key: "animateWorkingIndicator",
+				type: "boolean",
+				label: "Animated spinner",
+				description:
+					"Animate the spinner in front of the \u201cWorking\u2026\u201d line (pi\u2019s default, redrawn every 80ms). Off shows a still \u25cf, so the terminal isn\u2019t repainted 12\u00d7/s while the model streams \u2014 cheaper in GPU-rendered hosts such as Herdr.",
+				value: faceliftConfig.animateWorkingIndicator,
+				default: false,
+			},
 		];
 		await openSettingsModal(extCtx, {
 			title: "@wierdbytes/pi-facelift",
@@ -1868,6 +1913,11 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 					faceliftConfig = { ...faceliftConfig, showWorkingTime: value as boolean };
 					persistFaceliftConfig(extCtx);
 				}
+				if (key === "animateWorkingIndicator") {
+					faceliftConfig = { ...faceliftConfig, animateWorkingIndicator: value as boolean };
+					persistFaceliftConfig(extCtx);
+					applyWorkingIndicator(extCtx);
+				}
 			},
 		});
 	};
@@ -1877,6 +1927,7 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 			`config:     ${getFaceliftConfigPath()}`,
 			`diffLayout: ${faceliftConfig.diffLayout}`,
 			`workingTime: ${faceliftConfig.showWorkingTime ? "on" : "off"}`,
+			`spinner:    ${faceliftConfig.animateWorkingIndicator ? "animated" : "still"}`,
 		];
 		extCtx.ui.notify(`@wierdbytes/pi-facelift\n${lines.join("\n")}`, "info");
 	};
@@ -1884,6 +1935,7 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 	const resetFaceliftConfig = (extCtx: ExtensionContext): void => {
 		faceliftConfig = faceliftEnvDefaults();
 		persistFaceliftConfig(extCtx);
+		applyWorkingIndicator(extCtx);
 		extCtx.ui.notify("pi-facelift: config reset to defaults.", "info");
 	};
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wierdbytes/pi-facelift",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "description": "Cosmetic facelift for built-in pi tool output — open-right rounded frames, syntax-highlighted reads, status-aware bash summaries, find/grep.",
   "type": "module",
   "files": [

package/working-indicator.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Tests for the still working indicator: on `session_start` facelift
+ * replaces pi's 80ms braille spinner with a single accent `●` frame (a
+ * single frame starts no animation timer), unless the config asks for
+ * the animated default (`animateWorkingIndicator: true`).
+ *
+ * The extension reads its config from `${PI_AGENT_DIR}/wierd-facelift/`,
+ * so each test points PI_AGENT_DIR at a temp dir with the config it needs.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import piFaceliftExtension from "./index.ts";
+
+class MockText {
+	constructor(
+		private text = "",
+		_x = 0,
+		_y = 0,
+	) {}
+	setText(value: string) {
+		this.text = value;
+	}
+	getText() {
+		return this.text;
+	}
+}
+
+let dir: string;
+let savedAgentDir: string | undefined;
+let savedAnimate: string | undefined;
+
+beforeEach(() => {
+	dir = mkdtempSync(join(tmpdir(), "facelift-indicator-"));
+	savedAgentDir = process.env.PI_AGENT_DIR;
+	savedAnimate = process.env.FACELIFT_ANIMATE_WORKING;
+	process.env.PI_AGENT_DIR = dir;
+	delete process.env.FACELIFT_ANIMATE_WORKING;
+});
+
+afterEach(() => {
+	if (savedAgentDir !== undefined) process.env.PI_AGENT_DIR = savedAgentDir;
+	else delete process.env.PI_AGENT_DIR;
+	if (savedAnimate !== undefined) process.env.FACELIFT_ANIMATE_WORKING = savedAnimate;
+	else delete process.env.FACELIFT_ANIMATE_WORKING;
+	rmSync(dir, { recursive: true, force: true });
+});
+
+function writeConfig(config: Record<string, unknown>) {
+	mkdirSync(join(dir, "wierd-facelift"), { recursive: true });
+	writeFileSync(join(dir, "wierd-facelift", "config.json"), JSON.stringify(config));
+}
+
+function loadExtension(ui: Record<string, unknown> = {}, hasUI = true) {
+	const handlers = new Map<string, (event: unknown, ctx: unknown) => void>();
+	const pi = {
+		registerTool: () => {},
+		registerCommand: () => {},
+		on: (name: string, h: (event: unknown, ctx: unknown) => void) => handlers.set(name, h),
+		registerEntryRenderer: () => {},
+		appendEntry: () => {},
+	};
+	piFaceliftExtension(pi as any, {
+		sdk: {
+			createReadToolDefinition: (_cwd: string) => ({
+				name: "mock",
+				description: "mock",
+				parameters: { type: "object", properties: {} },
+				execute: async () => ({ content: [{ type: "text", text: "" }] }),
+			}),
+			getAgentDir: () => dir,
+		},
+		TextComponent: MockText as any,
+	});
+	const setWorkingIndicator = vi.fn();
+	const ctx = {
+		hasUI,
+		ui: {
+			setWorkingMessage: vi.fn(),
+			setWorkingIndicator,
+			theme: { fg: (token: string, text: string) => `<${token}>${text}</${token}>` },
+			...ui,
+		},
+	};
+	const fire = (name: string) => handlers.get(name)?.({}, ctx);
+	return { fire, setWorkingIndicator, ctx };
+}
+
+describe("working indicator", () => {
+	it("sets a single still accent frame on session_start by default", () => {
+		const { fire, setWorkingIndicator } = loadExtension();
+		fire("session_start");
+		expect(setWorkingIndicator).toHaveBeenCalledTimes(1);
+		expect(setWorkingIndicator).toHaveBeenCalledWith({ frames: ["<accent>●</accent>"] });
+	});
+
+	it("keeps an older config file (no field) on the still indicator", () => {
+		writeConfig({ diffLayout: "split" });
+		const { fire, setWorkingIndicator } = loadExtension();
+		fire("session_start");
+		expect(setWorkingIndicator).toHaveBeenCalledWith({ frames: ["<accent>●</accent>"] });
+	});
+
+	it("restores pi's animated default when animateWorkingIndicator is on", () => {
+		writeConfig({ diffLayout: "split", animateWorkingIndicator: true });
+		const { fire, setWorkingIndicator } = loadExtension();
+		fire("session_start");
+		expect(setWorkingIndicator).toHaveBeenCalledTimes(1);
+		expect(setWorkingIndicator).toHaveBeenCalledWith();
+	});
+
+	it("does nothing without a UI (pi -p, RPC)", () => {
+		const { fire, setWorkingIndicator } = loadExtension({}, false);
+		fire("session_start");
+		expect(setWorkingIndicator).not.toHaveBeenCalled();
+	});
+
+	it("tolerates a pi without setWorkingIndicator", () => {
+		const { fire } = loadExtension({ setWorkingIndicator: undefined });
+		expect(() => fire("session_start")).not.toThrow();
+	});
+
+	it("swallows a stale ctx instead of crashing pi", () => {
+		const { fire } = loadExtension({
+			setWorkingIndicator: () => {
+				throw new Error("extension ctx is stale");
+			},
+		});
+		expect(() => fire("session_start")).not.toThrow();
+	});
+});

package/working-time.test.ts

@@ -4,9 +4,13 @@
  * The tracker measures two metrics: `worked` (model streaming only,
  * tools excluded) and `totalMs` (wall-clock from user prompt to settle,
  * retries/tools/overhead included). The wiring drives it from pi
- * lifecycle events: before_agent_start / agent_start /
+ * lifecycle events: before_agent_start / agent_start / turn_start /
  * before_provider_request / message_end / agent_settled. The durable
  * history line is produced via pi.appendEntry + registerEntryRenderer.
+ *
+ * `before_provider_request` also fires for pi's prompt-cache warm-ups,
+ * which never produce a `message_end`; only requests armed by `turn_start`
+ * may open a segment.
  */
 
 import { beforeEach, describe, expect, it, vi } from "vitest";
@@ -27,6 +31,7 @@ describe("WorkingTimeTracker", () => {
 		const t = new WorkingTimeTracker(() => now);
 		t.beginRun();
 		now = 2000;
+		t.armRequest();
 		t.beginSegment();
 		now = 4500;
 		t.endSegment();
@@ -40,11 +45,13 @@ describe("WorkingTimeTracker", () => {
 		let now = 0;
 		const t = new WorkingTimeTracker(() => now);
 		t.beginRun();
+		t.armRequest();
 		t.beginSegment();
 		now = 1000;
 		t.endSegment();
 		// tool + overhead from 1000..9000 counts toward total, not worked
 		now = 9000;
+		t.armRequest();
 		t.beginSegment();
 		now = 10000;
 		t.endSegment();
@@ -57,6 +64,7 @@ describe("WorkingTimeTracker", () => {
 		let now = 0;
 		const t = new WorkingTimeTracker(() => now);
 		t.beginRun();
+		t.armRequest();
 		t.beginSegment();
 		now = 500;
 		t.endSegment();
@@ -71,6 +79,7 @@ describe("WorkingTimeTracker", () => {
 		let now = 0;
 		const t = new WorkingTimeTracker(() => now);
 		t.beginRun();
+		t.armRequest();
 		t.beginSegment();
 		t.addDelta(4000); // ~1000 estimated tokens at 4 chars/token
 		now = 2000; // 2s of worked time
@@ -81,6 +90,7 @@ describe("WorkingTimeTracker", () => {
 	it("liveTps is 0 before any time elapses", () => {
 		const t = new WorkingTimeTracker(() => 0);
 		t.beginRun();
+		t.armRequest();
 		t.beginSegment();
 		t.addDelta(400);
 		expect(t.liveTps()).toBe(0);
@@ -90,6 +100,7 @@ describe("WorkingTimeTracker", () => {
 		let now = 0;
 		const t = new WorkingTimeTracker(() => now);
 		t.beginRun();
+		t.armRequest();
 		t.beginSegment();
 		now = 2000;
 		t.recordExactTokens(1500);
@@ -104,12 +115,14 @@ describe("WorkingTimeTracker", () => {
 		const t = new WorkingTimeTracker(() => now);
 		t.beginRun();
 		// first model segment: 0..1000
+		t.armRequest();
 		t.beginSegment();
 		now = 1000;
 		t.endSegment();
 		// "tool" runs from 1000..9000 — must NOT count
 		now = 9000;
 		// second model segment: 9000..10000
+		t.armRequest();
 		t.beginSegment();
 		now = 10000;
 		t.endSegment();
@@ -120,6 +133,7 @@ describe("WorkingTimeTracker", () => {
 		let now = 0;
 		const t = new WorkingTimeTracker(() => now);
 		t.beginRun();
+		t.armRequest();
 		t.beginSegment();
 		now = 3000;
 		expect(t.elapsedMs()).toBe(3000);
@@ -132,10 +146,63 @@ describe("WorkingTimeTracker", () => {
 		expect(t.settle()).toBeUndefined();
 	});
 
+	it("ignores an unarmed request (cache warm-up while idle)", () => {
+		let now = 0;
+		const t = new WorkingTimeTracker(() => now);
+		expect(t.beginSegment()).toBe(false);
+		now = 5000;
+		expect(t.isActive()).toBe(false);
+		expect(t.elapsedMs()).toBe(0);
+	});
+
+	it("ignores a cache warm-up during tool execution", () => {
+		let now = 0;
+		const t = new WorkingTimeTracker(() => now);
+		t.beginRun();
+		t.armRequest();
+		expect(t.beginSegment()).toBe(true);
+		now = 1000;
+		t.endSegment();
+		// tool runs 1000..9000; the warmer replays the request at 4000
+		now = 4000;
+		expect(t.beginSegment()).toBe(false);
+		now = 9000;
+		t.armRequest();
+		expect(t.beginSegment()).toBe(true);
+		now = 10000;
+		t.endSegment();
+		expect(t.settle()?.ms).toBe(2000);
+	});
+
+	it("keeps the first start when the request hook fires again mid-segment", () => {
+		let now = 0;
+		const t = new WorkingTimeTracker(() => now);
+		t.beginRun();
+		t.armRequest();
+		expect(t.beginSegment()).toBe(true);
+		now = 1000;
+		expect(t.beginSegment()).toBe(false); // e.g. a provider re-sending the payload
+		now = 3000;
+		t.endSegment();
+		expect(t.settle()?.ms).toBe(3000);
+	});
+
+	it("disarms on settle and on beginRun", () => {
+		const t = new WorkingTimeTracker(() => 0);
+		t.beginRun();
+		t.armRequest();
+		t.settle();
+		expect(t.beginSegment()).toBe(false);
+		t.armRequest();
+		t.beginRun();
+		expect(t.beginSegment()).toBe(false);
+	});
+
 	it("resets state after settle", () => {
 		let now = 0;
 		const t = new WorkingTimeTracker(() => now);
 		t.beginRun();
+		t.armRequest();
 		t.beginSegment();
 		now = 1000;
 		t.endSegment();
@@ -264,11 +331,13 @@ describe("working-time wiring", () => {
 		fire("before_agent_start", {}); // anchors the total clock
 		vi.advanceTimersByTime(500); // pre-loop overhead
 		fire("agent_start", {});
+		fire("turn_start", {});
 		fire("before_provider_request", {});
 		vi.advanceTimersByTime(5000);
 		fire("message_end", asst);
 		// tool gap — counts toward total, NOT worked
 		vi.advanceTimersByTime(3000);
+		fire("turn_start", {});
 		fire("before_provider_request", {});
 		vi.advanceTimersByTime(2000);
 		fire("message_end", asst);
@@ -287,6 +356,7 @@ describe("working-time wiring", () => {
 		const { fire, entries, ctx } = loadExtension();
 		fire("before_agent_start", {});
 		fire("agent_start", {});
+		fire("turn_start", {});
 		fire("before_provider_request", {});
 		// Stream ~4000 chars => ~1000 estimated tokens over 2s of worked time.
 		fire("message_update", {
@@ -311,6 +381,7 @@ describe("working-time wiring", () => {
 		const { fire, entries } = loadExtension();
 		fire("before_agent_start", {});
 		fire("agent_start", {});
+		fire("turn_start", {});
 		fire("before_provider_request", {});
 		vi.advanceTimersByTime(1000);
 		fire("message_end", user); // stray non-assistant end — ignored
@@ -327,6 +398,7 @@ describe("working-time wiring", () => {
 		const { fire, ctx } = loadExtension();
 		fire("before_agent_start", {});
 		fire("agent_start", {});
+		fire("turn_start", {});
 		fire("before_provider_request", {});
 		vi.advanceTimersByTime(2000);
 		const calls = ctx.ui.setWorkingMessage.mock.calls.map((c) => c[0]);
@@ -340,6 +412,64 @@ describe("working-time wiring", () => {
 		expect(last?.[0]).toBeUndefined();
 	});
 
+	it("ignores a cache warm-up during tool execution (no segment, no ticker)", () => {
+		vi.useFakeTimers();
+		const { fire, entries, ctx } = loadExtension();
+		fire("before_agent_start", {});
+		fire("agent_start", {});
+		fire("turn_start", {});
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(1000);
+		fire("message_end", asst);
+		// tool executes; the cache warmer replays the request mid-tool
+		vi.advanceTimersByTime(2000);
+		const callsBefore = ctx.ui.setWorkingMessage.mock.calls.length;
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(5000);
+		expect(ctx.ui.setWorkingMessage.mock.calls.length).toBe(callsBefore);
+		fire("turn_start", {});
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(1000);
+		fire("message_end", asst);
+		fire("agent_settled", {});
+		vi.useRealTimers();
+		expect(entries).toHaveLength(1);
+		const data = entries[0].data as WorkingTimeEntry;
+		expect(data.ms).toBe(2000); // the 7s tool gap stays excluded
+		expect(data.totalMs).toBe(9000);
+	});
+
+	it("ignores a cache warm-up after settle (idle warming): no phantom run or ticker", () => {
+		vi.useFakeTimers();
+		const { fire, entries, ctx } = loadExtension();
+		fire("before_agent_start", {});
+		fire("agent_start", {});
+		fire("turn_start", {});
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(1000);
+		fire("message_end", asst);
+		fire("agent_settled", {});
+		ctx.ui.setWorkingMessage.mockClear();
+		// idle warm-up minutes later
+		vi.advanceTimersByTime(270_000);
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(5000);
+		expect(ctx.ui.setWorkingMessage).not.toHaveBeenCalled();
+		// the next real run is measured from its own prompt
+		fire("before_agent_start", {});
+		fire("agent_start", {});
+		fire("turn_start", {});
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(1500);
+		fire("message_end", asst);
+		fire("agent_settled", {});
+		vi.useRealTimers();
+		expect(entries).toHaveLength(2);
+		const data = entries[1].data as WorkingTimeEntry;
+		expect(data.ms).toBe(1500);
+		expect(data.totalMs).toBe(1500);
+	});
+
 	it("registers an entry renderer that produces a dim worked+total line", () => {
 		const { entryRenderers } = loadExtension();
 		const renderer = entryRenderers.get(WORKING_TIME_ENTRY);

package/working-time.ts

@@ -61,6 +61,7 @@ export interface WorkingTimeEntry {
  * Lifecycle (driven by pi events):
  *   before_agent_start      → beginRun()   (total clock starts here)
  *   agent_start             → ensureRun()  (fallback if before_agent_start skipped)
+ *   turn_start              → armRequest() (an agent request is coming)
  *   before_provider_request → beginSegment() + start the live ticker
  *   message_update  (asst)  → addDelta()     (feed the live tps estimate)
  *   message_end     (asst)  → recordExactTokens() + endSegment() + stop ticker
@@ -68,6 +69,15 @@ export interface WorkingTimeEntry {
  *
  * Retries / auto-compaction fire their own agent_start but pi only emits
  * `agent_settled` when it truly stops, so a run is measured end-to-end.
+ *
+ * `before_provider_request` is not exclusive to agent turns: pi's prompt
+ * cache warmer replays the last request (`maxTokens: 1`) with the same
+ * options, so the hook fires for warm-ups too — mid-run while tools execute,
+ * and after the run settles in `idle` warming mode. Those requests never
+ * produce a `message_end`, so an unguarded segment would stay open and
+ * swallow tool time (or start a phantom run while idle). Segments therefore
+ * open only while armed: from `turn_start` (pi emits one before every agent
+ * request) until the assistant `message_end`.
  */
 export class WorkingTimeTracker {
 	private readonly now: () => number;
@@ -76,6 +86,7 @@ export class WorkingTimeTracker {
 	private runStart: number | undefined;
 	private runEstChars = 0;
 	private runExactTokens = 0;
+	private requestArmed = false;
 
 	constructor(now: () => number = () => Date.now()) {
 		this.now = now;
@@ -88,6 +99,7 @@ export class WorkingTimeTracker {
 		this.runStart = this.now();
 		this.runEstChars = 0;
 		this.runExactTokens = 0;
+		this.requestArmed = false;
 	}
 
 	/** Start a run only if one isn't already in progress (idempotent). */
@@ -95,14 +107,29 @@ export class WorkingTimeTracker {
 		if (this.runStart === undefined) this.beginRun();
 	}
 
-	/** Begin timing an assistant streaming segment. */
-	beginSegment(): void {
+	/**
+	 * Mark that the agent is about to issue a real request (pi `turn_start`).
+	 * Only an armed tracker lets `beginSegment` open a segment.
+	 */
+	armRequest(): void {
 		this.ensureRun();
-		if (this.segmentStart === undefined) this.segmentStart = this.now();
+		this.requestArmed = true;
+	}
+
+	/**
+	 * Begin timing an assistant streaming segment. Ignored unless armed (see
+	 * `armRequest`) or when a segment is already open. Returns `true` only
+	 * when a new segment was opened.
+	 */
+	beginSegment(): boolean {
+		if (!this.requestArmed || this.segmentStart !== undefined) return false;
+		this.segmentStart = this.now();
+		return true;
 	}
 
-	/** Close the current segment, folding its duration into the total. */
+	/** Close the current segment, folding its duration into the total, and disarm. */
 	endSegment(): void {
+		this.requestArmed = false;
 		if (this.segmentStart !== undefined) {
 			this.accumulatorMs += Math.max(0, this.now() - this.segmentStart);
 			this.segmentStart = undefined;