@wierdbytes/pi-facelift 0.5.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.6.1
+
+- **New:** live `Working... Ns` timer on the streaming spinner and a muted `⏱ worked … (total: …)` line persisted to chat history per run — `worked` is model time only (tools excluded), `total` is wall-clock incl. retries/tool calls/overhead; toggle via `showWorkingTime` in `/facelift`.
+
 ## 0.5.0
 
 - **Fix:** facelift no longer silently disables itself on pi 0.79.x — tool

package/README.md

@@ -40,6 +40,22 @@ tool output.
   don't happen — configurable via `diffLayout` (see below).
 
   [cd]: ../common/README.md#diff
+- **working timer** — while the model streams, the `Working...` spinner
+  line gains a live ticking timer (`Working... 12s`). When the run
+  settles, a muted line is left behind in chat history (a durable custom
+  entry, not sent to the LLM) reporting two numbers:
+
+  `⏱ worked 45.2s (total: 1m15s)`
+
+  - `worked` — model-only time (request dispatch → response end, so
+    time-to-first-token counts; tool execution is excluded).
+  - `total` — wall-clock time from your prompt to the final response,
+    including retries, tool calls, and all other overhead.
+
+  Durations auto-format as `1h12m36s` — leading zero parts are dropped
+  (`0h12m0s` → `12m0s`); sub-minute values keep one decimal (`45.2s`).
+
+  Toggle via `showWorkingTime` in `/facelift`.
 
 ## Install
 
@@ -100,7 +116,13 @@ Current schema:
   // "unified"   : always stacked single-column.
   // "per-edit"  : each diff picks independently (original pi-diff
   //               behaviour; can produce mixed layouts).
-  "diffLayout": "consistent"
+  "diffLayout": "consistent",
+
+  // Show a ticking timer in the streaming "Working..." line and persist
+  // 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
 }
 ```
 
@@ -118,6 +140,7 @@ icons, image protocols) or boot-time toggles:
 | `FACELIFT_ICONS`               | `nerd`          | Set to `none` / `off` to disable Nerd Font icons in `ls`/`find`/`grep`.       |
 | `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). |
 
 ## Development
 
@@ -126,7 +149,7 @@ This package lives in the [`pi-wierd-stuff`](../../README.md) monorepo.
 ```bash
 bun install                        # from the repo root
 cd packages/facelift
-bun run test                       # 64 tests
+bun run test                       # 80 tests
 bun run test:watch                 # vitest watch mode
 bun run demo                       # render every tool block to your terminal
 ```

package/bash-rendering.test.ts

@@ -54,6 +54,8 @@ function loadBashTool() {
 		registerTool: (tool: any) => tools.set(tool.name, tool),
 		registerCommand: () => {},
 		on: () => {},
+		registerEntryRenderer: () => {},
+		appendEntry: () => {},
 	};
 
 	piFaceliftExtension(pi, {

package/config.test.ts

@@ -38,34 +38,67 @@ beforeEach(() => {
 	configFile = join(dir, "config.json");
 	savedEnv.DIFF_LAYOUT = process.env.DIFF_LAYOUT;
 	delete process.env.DIFF_LAYOUT;
+	savedEnv.FACELIFT_SHOW_WORKING_TIME = process.env.FACELIFT_SHOW_WORKING_TIME;
+	delete process.env.FACELIFT_SHOW_WORKING_TIME;
 });
 
 afterEach(() => {
 	if (savedEnv.DIFF_LAYOUT !== undefined) process.env.DIFF_LAYOUT = savedEnv.DIFF_LAYOUT;
 	else delete process.env.DIFF_LAYOUT;
+	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;
 	rmSync(dir, { recursive: true, force: true });
 });
 
 describe("envDefaults", () => {
 	it("returns 'consistent' when DIFF_LAYOUT is unset", () => {
-		expect(envDefaults()).toEqual({ diffLayout: "consistent" });
+		expect(envDefaults()).toEqual({ diffLayout: "consistent", showWorkingTime: true });
 	});
 
 	for (const layout of VALID_DIFF_LAYOUTS) {
 		it(`honours DIFF_LAYOUT=${layout}`, () => {
 			process.env.DIFF_LAYOUT = layout;
-			expect(envDefaults()).toEqual({ diffLayout: layout });
+			expect(envDefaults()).toEqual({ diffLayout: layout, showWorkingTime: true });
 		});
 	}
 
 	it("ignores invalid DIFF_LAYOUT values", () => {
 		process.env.DIFF_LAYOUT = "rainbow";
-		expect(envDefaults()).toEqual({ diffLayout: "consistent" });
+		expect(envDefaults()).toEqual({ diffLayout: "consistent", showWorkingTime: true });
 	});
 
 	it("is case-insensitive on DIFF_LAYOUT", () => {
 		process.env.DIFF_LAYOUT = "SPLIT";
-		expect(envDefaults()).toEqual({ diffLayout: "split" });
+		expect(envDefaults()).toEqual({ diffLayout: "split", showWorkingTime: true });
+	});
+
+	it("defaults showWorkingTime to true", () => {
+		expect(envDefaults().showWorkingTime).toBe(true);
+	});
+
+	it("honours FACELIFT_SHOW_WORKING_TIME=0/off to disable", () => {
+		for (const v of ["0", "off", "false"]) {
+			process.env.FACELIFT_SHOW_WORKING_TIME = v;
+			expect(envDefaults().showWorkingTime).toBe(false);
+		}
+	});
+
+	it("ignores invalid FACELIFT_SHOW_WORKING_TIME values", () => {
+		process.env.FACELIFT_SHOW_WORKING_TIME = "maybe";
+		expect(envDefaults().showWorkingTime).toBe(true);
+	});
+});
+
+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 });
+	});
+
+	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 });
 	});
 });
 
@@ -74,7 +107,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 });
+			expect(loadConfig(configFile)).toEqual({ diffLayout: layout, showWorkingTime: true });
 		});
 	}
 
@@ -83,23 +116,23 @@ describe("loadConfig + saveConfig round-trip", () => {
 			configFile,
 			JSON.stringify({ diffLayout: "consistent", iconMode: "rainbow", junk: 42 }),
 		);
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent" });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true });
 	});
 
 	it("rejects invalid diffLayout strings and falls back to default", () => {
 		writeFileSync(configFile, JSON.stringify({ diffLayout: "tutti-frutti" }));
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent" });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true });
 	});
 
 	it("returns defaults when the file is missing (no write)", () => {
 		expect(existsSync(configFile)).toBe(false);
-		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent" });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true });
 		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" });
+		expect(loadConfig(configFile)).toEqual({ diffLayout: "consistent", showWorkingTime: true });
 	});
 
 	it("writes a trailing newline", () => {
@@ -112,22 +145,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" });
+		expect(cfg).toEqual({ diffLayout: "consistent", showWorkingTime: true });
 		expect(existsSync(configFile)).toBe(true);
-		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "consistent" });
+		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "consistent", showWorkingTime: true });
 	});
 
 	it("respects DIFF_LAYOUT when seeding", () => {
 		process.env.DIFF_LAYOUT = "unified";
 		const cfg = loadOrInitConfig(configFile);
-		expect(cfg).toEqual({ diffLayout: "unified" });
-		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "unified" });
+		expect(cfg).toEqual({ diffLayout: "unified", showWorkingTime: true });
+		expect(JSON.parse(readFileSync(configFile, "utf-8"))).toEqual({ diffLayout: "unified", showWorkingTime: true });
 	});
 
 	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" });
+		expect(cfg).toEqual({ diffLayout: "split", showWorkingTime: true });
 	});
 });

package/config.ts

@@ -10,9 +10,9 @@
  *     extension.
  *   - Saves write atomically (one JSON.stringify + trailing newline).
  *
- * The only knob we expose today is `diffLayout`, but the schema is
- * designed to accept more fields (icon mode, max preview lines, etc.)
- * without breaking older config files.
+ * The knobs we expose today are `diffLayout` and `showWorkingTime`, and
+ * the schema is designed to accept more fields (icon mode, max preview
+ * lines, etc.) without breaking older config files.
  */
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -47,12 +47,33 @@ export interface WierdFaceliftConfig {
 	 *     pi-diff behaviour; can produce mixed layouts in one call).
 	 */
 	diffLayout: DiffLayoutPreference;
+
+	/**
+	 * Show a ticking timer in the streaming "Working…" line and persist
+	 * the total model working time per agent run as a muted line in chat
+	 * history (via a durable custom entry). Tool execution time is
+	 * excluded — only time the model spends streaming is counted.
+	 *
+	 * Defaults to `true`; override with env `FACELIFT_SHOW_WORKING_TIME`
+	 * (`0`/`false`/`off` to disable).
+	 */
+	showWorkingTime: boolean;
 }
 
 function isDiffLayout(value: unknown): value is DiffLayoutPreference {
 	return typeof value === "string" && (VALID_DIFF_LAYOUTS as readonly string[]).includes(value);
 }
 
+function parseBool(value: unknown, fallback: boolean): boolean {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const v = value.trim().toLowerCase();
+		if (["0", "false", "off", "no", "disabled"].includes(v)) return false;
+		if (["1", "true", "on", "yes", "enabled"].includes(v)) return true;
+	}
+	return fallback;
+}
+
 /**
  * Seed defaults from the environment. `DIFF_LAYOUT` is the only env
  * override today; everything else falls back to the hard-coded default.
@@ -66,6 +87,7 @@ export function envDefaults(): WierdFaceliftConfig {
 	const fromEnv = envLayout && isDiffLayout(envLayout) ? envLayout : undefined;
 	return {
 		diffLayout: fromEnv ?? DEFAULT_DIFF_LAYOUT,
+		showWorkingTime: parseBool(process.env.FACELIFT_SHOW_WORKING_TIME, true),
 	};
 }
 
@@ -75,6 +97,7 @@ function sanitize(raw: unknown): WierdFaceliftConfig {
 	const obj = raw as Record<string, unknown>;
 	const cfg: WierdFaceliftConfig = { ...defaults };
 	if (isDiffLayout(obj.diffLayout)) cfg.diffLayout = obj.diffLayout;
+	if (typeof obj.showWorkingTime === "boolean") cfg.showWorkingTime = obj.showWorkingTime;
 	return cfg;
 }
 
@@ -119,6 +142,7 @@ export function saveConfig(
 	}
 	const out: Record<string, unknown> = {
 		diffLayout: cfg.diffLayout,
+		showWorkingTime: cfg.showWorkingTime,
 	};
 	writeFileSync(path, `${JSON.stringify(out, null, 2)}\n`, "utf-8");
 	return path;

package/edit-line-numbers.test.ts

@@ -52,6 +52,8 @@ function loadEditTool(editExec: any) {
 		registerTool: (tool: any) => tools.set(tool.name, tool),
 		registerCommand: () => {},
 		on: () => {},
+		registerEntryRenderer: () => {},
+		appendEntry: () => {},
 	};
 
 	piFaceliftExtension(pi, {

package/image-rendering.test.ts

@@ -55,6 +55,8 @@ function loadReadTool(readExec: any) {
 		registerTool: (tool: any) => tools.set(tool.name, tool),
 		registerCommand: () => {},
 		on: () => {},
+		registerEntryRenderer: () => {},
+		appendEntry: () => {},
 	};
 
 	piFaceliftExtension(pi, {

package/index.ts

@@ -83,6 +83,13 @@ import {
 	type DiffLayoutPreference,
 	type WierdFaceliftConfig,
 } from "./config.ts";
+import {
+	WorkingTimeTracker,
+	WORKING_TIME_ENTRY,
+	workingMessageText,
+	workingTimeLine,
+	type WorkingTimeEntry,
+} from "./working-time.ts";
 import {
 	formatDuration,
 	frameBodyLines,
@@ -991,6 +998,11 @@ type PiFaceliftApi = {
 		},
 	) => void;
 	on: (event: string, handler: (event: unknown, ctx: SessionContextLike) => Promise<void> | void) => void;
+	registerEntryRenderer: <T = unknown>(
+		customType: string,
+		renderer: (entry: { data?: T }, options: { expanded: boolean }, theme: ThemeLike) => unknown,
+	) => void;
+	appendEntry: <T = unknown>(customType: string, data?: T) => void;
 };
 type ReadParams = ReadToolInput;
 type BashParams = BashToolInput;
@@ -1136,6 +1148,78 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 		}
 	})();
 
+	// ===================================================================
+	// Working-time — live timer in the "Working…" line + durable history
+	// -------------------------------------------------------------------
+	// Two metrics per run: `worked` (model streaming only — request
+	// dispatch → assistant message_end, so tools between turns are
+	// excluded, time-to-first-token included) and `total` (wall-clock
+	// from user prompt to settle — retries, tools, overhead included).
+	// While streaming, a 1s ticker rewrites the working *message* (spinner
+	// frames are left alone). On `agent_settled` both are persisted as a
+	// durable custom entry rendered as a plain muted line in history.
+	// ===================================================================
+
+	pi.registerEntryRenderer<WorkingTimeEntry>(WORKING_TIME_ENTRY, (entry, _opts, theme) => {
+		const data = entry.data;
+		if (!data || typeof data.ms !== "number") return undefined;
+		return new TextComponent(workingTimeLine(data, (s) => theme.fg("dim", s)), 0, 0);
+	});
+
+	const workingTracker = new WorkingTimeTracker();
+	let workingTick: NodeJS.Timeout | undefined;
+
+	const stopWorkingTick = (): void => {
+		if (workingTick !== undefined) {
+			clearInterval(workingTick);
+			workingTick = undefined;
+		}
+	};
+
+	const renderWorkingMessage = (ctx: SessionContextLike): void => {
+		if (ctx.hasUI) ctx.ui.setWorkingMessage(workingMessageText(workingTracker.elapsedMs()));
+	};
+
+	// `before_agent_start` fires right after the user submits the prompt,
+	// so it anchors the wall-clock `total` (retries + tools + overhead).
+	pi.on("before_agent_start", () => {
+		if (!faceliftConfig.showWorkingTime) return;
+		workingTracker.beginRun();
+	});
+
+	pi.on("agent_start", () => {
+		if (!faceliftConfig.showWorkingTime) return;
+		// Fallback for flows where before_agent_start didn't fire first.
+		workingTracker.ensureRun();
+	});
+
+	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();
+		stopWorkingTick();
+		renderWorkingMessage(ctx);
+		workingTick = setInterval(() => renderWorkingMessage(ctx), 1000);
+	});
+
+	pi.on("message_end", (event, _ctx) => {
+		if (!faceliftConfig.showWorkingTime) return;
+		const role = (event as { message?: { role?: string } }).message?.role;
+		if (role !== "assistant") return;
+		workingTracker.endSegment();
+		stopWorkingTick();
+	});
+
+	pi.on("agent_settled", (_event, ctx) => {
+		if (!faceliftConfig.showWorkingTime) return;
+		stopWorkingTick();
+		const entry = workingTracker.settle();
+		// Restore pi's default working message for the next run.
+		if (ctx.hasUI) ctx.ui.setWorkingMessage();
+		if (entry) pi.appendEntry(WORKING_TIME_ENTRY, entry);
+	});
+
 	// ===================================================================
 	// read — syntax-highlighted file content
 	// ===================================================================
@@ -1735,6 +1819,15 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 				options: VALID_DIFF_LAYOUTS,
 				optionLabels: diffLayoutLabels,
 			},
+			{
+				key: "showWorkingTime",
+				type: "boolean",
+				label: "Working timer",
+				description:
+					"Show a ticking timer in the streaming \u201cWorking\u2026\u201d line and persist each agent run\u2019s total model time (tools excluded) as a muted line in chat history.",
+				value: faceliftConfig.showWorkingTime,
+				default: true,
+			},
 		];
 		await openSettingsModal(extCtx, {
 			title: "@wierdbytes/pi-facelift",
@@ -1744,6 +1837,10 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 					faceliftConfig = { ...faceliftConfig, diffLayout: value as DiffLayoutPreference };
 					persistFaceliftConfig(extCtx);
 				}
+				if (key === "showWorkingTime") {
+					faceliftConfig = { ...faceliftConfig, showWorkingTime: value as boolean };
+					persistFaceliftConfig(extCtx);
+				}
 			},
 		});
 	};
@@ -1752,6 +1849,7 @@ export default function piFaceliftExtension(pi: PiFaceliftApi, deps?: PiFacelift
 		const lines = [
 			`config:     ${getFaceliftConfigPath()}`,
 			`diffLayout: ${faceliftConfig.diffLayout}`,
+			`workingTime: ${faceliftConfig.showWorkingTime ? "on" : "off"}`,
 		];
 		extCtx.ui.notify(`@wierdbytes/pi-facelift\n${lines.join("\n")}`, "info");
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wierdbytes/pi-facelift",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "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/read-rendering.test.ts

@@ -73,6 +73,8 @@ function loadReadTool(readExec: any) {
 		registerTool: (tool: any) => tools.set(tool.name, tool),
 		registerCommand: () => {},
 		on: () => {},
+		registerEntryRenderer: () => {},
+		appendEntry: () => {},
 	};
 
 	piFaceliftExtension(pi, {

package/working-time.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Tests for the working-time tracker and its extension wiring.
+ *
+ * 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 /
+ * before_provider_request / message_end / agent_settled. The durable
+ * history line is produced via pi.appendEntry + registerEntryRenderer.
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import piFaceliftExtension from "./index.ts";
+import {
+	formatClock,
+	WorkingTimeTracker,
+	WORKING_TIME_ENTRY,
+	workingMessageText,
+	workingTimeLine,
+	type WorkingTimeEntry,
+} from "./working-time.ts";
+
+describe("WorkingTimeTracker", () => {
+	it("accumulates a single streaming segment", () => {
+		let now = 1000;
+		const t = new WorkingTimeTracker(() => now);
+		t.beginRun();
+		now = 2000;
+		t.beginSegment();
+		now = 4500;
+		t.endSegment();
+		expect(t.elapsedMs()).toBe(2500);
+		const entry = t.settle();
+		expect(entry?.ms).toBe(2500);
+		expect(entry?.startedAt).toBe(1000);
+	});
+
+	it("measures totalMs as wall-clock across the whole run (incl. tool gap)", () => {
+		let now = 0;
+		const t = new WorkingTimeTracker(() => now);
+		t.beginRun();
+		t.beginSegment();
+		now = 1000;
+		t.endSegment();
+		// tool + overhead from 1000..9000 counts toward total, not worked
+		now = 9000;
+		t.beginSegment();
+		now = 10000;
+		t.endSegment();
+		const entry = t.settle();
+		expect(entry?.ms).toBe(2000);
+		expect(entry?.totalMs).toBe(10000);
+	});
+
+	it("ensureRun does not reset an in-progress run", () => {
+		let now = 0;
+		const t = new WorkingTimeTracker(() => now);
+		t.beginRun();
+		t.beginSegment();
+		now = 500;
+		t.endSegment();
+		now = 1000;
+		t.ensureRun(); // agent_start fallback mid-run — must not reset
+		expect(t.elapsedMs()).toBe(500);
+		now = 3000;
+		expect(t.settle()?.totalMs).toBe(3000);
+	});
+
+	it("excludes the gap between segments (tool execution time)", () => {
+		let now = 0;
+		const t = new WorkingTimeTracker(() => now);
+		t.beginRun();
+		// first model segment: 0..1000
+		t.beginSegment();
+		now = 1000;
+		t.endSegment();
+		// "tool" runs from 1000..9000 — must NOT count
+		now = 9000;
+		// second model segment: 9000..10000
+		t.beginSegment();
+		now = 10000;
+		t.endSegment();
+		expect(t.settle()?.ms).toBe(2000);
+	});
+
+	it("includes an open segment in elapsedMs while streaming", () => {
+		let now = 0;
+		const t = new WorkingTimeTracker(() => now);
+		t.beginRun();
+		t.beginSegment();
+		now = 3000;
+		expect(t.elapsedMs()).toBe(3000);
+		expect(t.isActive()).toBe(true);
+	});
+
+	it("returns undefined for a zero-time run", () => {
+		const t = new WorkingTimeTracker(() => 0);
+		t.beginRun();
+		expect(t.settle()).toBeUndefined();
+	});
+
+	it("resets state after settle", () => {
+		let now = 0;
+		const t = new WorkingTimeTracker(() => now);
+		t.beginRun();
+		t.beginSegment();
+		now = 1000;
+		t.endSegment();
+		t.settle();
+		expect(t.isActive()).toBe(false);
+		expect(t.elapsedMs()).toBe(0);
+	});
+});
+
+describe("formatClock", () => {
+	it("keeps one decimal below a minute", () => {
+		expect(formatClock(0)).toBe("0.0s");
+		expect(formatClock(45_200)).toBe("45.2s");
+		expect(formatClock(59_900)).toBe("59.9s");
+	});
+
+	it("formats minutes and seconds, always ending in seconds", () => {
+		expect(formatClock(60_000)).toBe("1m0s");
+		expect(formatClock(75_000)).toBe("1m15s");
+		expect(formatClock(720_000)).toBe("12m0s"); // 0h12m0s -> 12m0s
+	});
+
+	it("formats hours, keeping interior zeros", () => {
+		expect(formatClock(4_356_000)).toBe("1h12m36s");
+		expect(formatClock(3_605_000)).toBe("1h0m5s");
+		expect(formatClock(3_600_000)).toBe("1h0m0s");
+	});
+
+	it("drops the leading zero hours part", () => {
+		expect(formatClock(65_000)).toBe("1m5s"); // 0h1m5s -> 1m5s
+	});
+
+	it("never returns a negative duration", () => {
+		expect(formatClock(-5000)).toBe("0.0s");
+	});
+});
+
+describe("workingMessageText / workingTimeLine", () => {
+	it("formats the live message in whole seconds", () => {
+		expect(workingMessageText(0)).toBe("Working... 0s");
+		expect(workingMessageText(1999)).toBe("Working... 1s");
+		expect(workingMessageText(65_000)).toBe("Working... 65s");
+	});
+
+	it("renders a muted history line with worked + total", () => {
+		const dim = (s: string) => `<dim>${s}</dim>`;
+		const entry: WorkingTimeEntry = { ms: 45_200, totalMs: 75_000, startedAt: 0, endedAt: 0 };
+		expect(workingTimeLine(entry, dim)).toBe("<dim>⏱ worked 45.2s (total: 1m15s)</dim>");
+	});
+});
+
+// --- extension wiring ---------------------------------------------------
+
+class MockText {
+	private text: string;
+	constructor(text = "", _x = 0, _y = 0) {
+		this.text = text;
+	}
+	setText(value: string) {
+		this.text = value;
+	}
+	getText() {
+		return this.text;
+	}
+}
+
+function mockToolFactory(exec: any) {
+	return (_cwd: string) => ({
+		name: "mock",
+		description: "mock",
+		parameters: { type: "object", properties: {} },
+		execute: exec,
+	});
+}
+
+interface MockCtx {
+	hasUI: boolean;
+	ui: { setWorkingMessage: ReturnType<typeof vi.fn> };
+}
+
+function loadExtension() {
+	const handlers = new Map<string, (event: unknown, ctx: MockCtx) => void>();
+	const entryRenderers = new Map<string, (entry: any, opts: any, theme: any) => unknown>();
+	const entries: Array<{ type: string; data: unknown }> = [];
+
+	const pi = {
+		registerTool: () => {},
+		registerCommand: () => {},
+		on: (name: string, h: (event: unknown, ctx: MockCtx) => void) => handlers.set(name, h),
+		registerEntryRenderer: (type: string, r: any) => entryRenderers.set(type, r),
+		appendEntry: (type: string, data: unknown) => entries.push({ type, data }),
+	};
+
+	const noopExec = async () => ({ content: [{ type: "text", text: "" }] });
+	piFaceliftExtension(pi as any, {
+		sdk: {
+			createReadToolDefinition: mockToolFactory(noopExec),
+			getAgentDir: () => "/tmp/pi-facelift-test",
+		},
+		TextComponent: MockText as any,
+	});
+
+	const ctx: MockCtx = { hasUI: true, ui: { setWorkingMessage: vi.fn() } };
+	const fire = (name: string, event: unknown) => handlers.get(name)?.(event, ctx);
+	return { fire, ctx, entries, entryRenderers };
+}
+
+const asst = { message: { role: "assistant" } };
+const user = { message: { role: "user" } };
+
+describe("working-time wiring", () => {
+	beforeEach(() => vi.restoreAllMocks());
+
+	it("worked counts request→message_end; total counts the whole run", () => {
+		vi.useFakeTimers();
+		const { fire, entries } = loadExtension();
+
+		fire("before_agent_start", {}); // anchors the total clock
+		vi.advanceTimersByTime(500); // pre-loop overhead
+		fire("agent_start", {});
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(5000);
+		fire("message_end", asst);
+		// tool gap — counts toward total, NOT worked
+		vi.advanceTimersByTime(3000);
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(2000);
+		fire("message_end", asst);
+		fire("agent_settled", {});
+
+		vi.useRealTimers();
+		expect(entries).toHaveLength(1);
+		expect(entries[0].type).toBe(WORKING_TIME_ENTRY);
+		const data = entries[0].data as WorkingTimeEntry;
+		expect(data.ms).toBe(7000);
+		expect(data.totalMs).toBe(10500); // 500 + 5000 + 3000 + 2000
+	});
+
+	it("ignores non-assistant message_end (does not close the segment early)", () => {
+		vi.useFakeTimers();
+		const { fire, entries } = loadExtension();
+		fire("before_agent_start", {});
+		fire("agent_start", {});
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(1000);
+		fire("message_end", user); // stray non-assistant end — ignored
+		vi.advanceTimersByTime(1000);
+		fire("message_end", asst);
+		fire("agent_settled", {});
+		vi.useRealTimers();
+		expect(entries).toHaveLength(1);
+		expect((entries[0].data as WorkingTimeEntry).ms).toBe(2000);
+	});
+
+	it("updates the live working message from request send and restores on settle", () => {
+		vi.useFakeTimers();
+		const { fire, ctx } = loadExtension();
+		fire("before_agent_start", {});
+		fire("agent_start", {});
+		fire("before_provider_request", {});
+		vi.advanceTimersByTime(2000);
+		const calls = ctx.ui.setWorkingMessage.mock.calls.map((c) => c[0]);
+		expect(calls[0]).toBe("Working... 0s");
+		expect(calls).toContain("Working... 2s");
+		fire("message_end", asst);
+		fire("agent_settled", {});
+		vi.useRealTimers();
+		// last call restores the default (undefined)
+		const last = ctx.ui.setWorkingMessage.mock.calls.at(-1);
+		expect(last?.[0]).toBeUndefined();
+	});
+
+	it("registers an entry renderer that produces a dim worked+total line", () => {
+		const { entryRenderers } = loadExtension();
+		const renderer = entryRenderers.get(WORKING_TIME_ENTRY);
+		expect(renderer).toBeDefined();
+		const theme = { fg: (_k: string, s: string) => `dim(${s})` };
+		const out = renderer!(
+			{ data: { ms: 1500, totalMs: 4000, startedAt: 0, endedAt: 0 } },
+			{ expanded: false },
+			theme,
+		) as MockText;
+		expect(out.getText()).toBe("dim(⏱ worked 1.5s (total: 4.0s))");
+	});
+});

package/working-time.ts

@@ -0,0 +1,162 @@
+/**
+ * Working-time tracking for @wierdbytes/pi-facelift.
+ *
+ * Two metrics are measured per agent run:
+ *
+ *   • `worked` — model-only time: from the moment a provider request is
+ *     dispatched (`before_provider_request`, so time-to-first-token
+ *     counts too) until the assistant message ends. Tool execution is
+ *     deliberately excluded — tools run between an assistant
+ *     `message_end` and the next request, so measuring only
+ *     request→message-end lifetimes naturally drops them.
+ *
+ *   • `total` — wall-clock time from when the user submits the prompt
+ *     (`before_agent_start`) until the run settles (`agent_settled`).
+ *     Retries, tool calls, and every other overhead are included.
+ *
+ * Two consumers:
+ *   • Live: while the current assistant message streams, a 1s interval
+ *     calls `setWorkingMessage` with a ticking timer (spinner frames are
+ *     left untouched — we only replace the message text).
+ *   • Durable: on `agent_settled` both metrics are persisted via
+ *     `pi.appendEntry` as a `WorkingTimeEntry` and rendered in chat
+ *     history by the entry renderer registered in `index.ts`.
+ *
+ * The class is pure logic (an injectable `now()` clock) so it is fully
+ * unit-testable without a running pi session.
+ */
+
+/** Custom entry type used with `pi.appendEntry` / `registerEntryRenderer`. */
+export const WORKING_TIME_ENTRY = "facelift-working-time";
+
+/** Payload stored on the durable working-time entry. */
+export interface WorkingTimeEntry {
+	/** Model-only streaming time for the run, in milliseconds (tools excluded). */
+	ms: number;
+	/** Wall-clock time from user prompt to final response, in milliseconds. */
+	totalMs: number;
+	/** Epoch ms when the run started (user prompt submitted). */
+	startedAt: number;
+	/** Epoch ms when the run settled. */
+	endedAt: number;
+}
+
+/**
+ * Tracks model streaming time and total wall-clock time across the turns
+ * of a single agent run.
+ *
+ * Lifecycle (driven by pi events):
+ *   before_agent_start      → beginRun()   (total clock starts here)
+ *   agent_start             → ensureRun()  (fallback if before_agent_start skipped)
+ *   before_provider_request → beginSegment() + start the live ticker
+ *   message_end     (asst)  → endSegment()   + stop the ticker
+ *   agent_settled           → settle() ⇒ { ms, totalMs }, then reset
+ *
+ * 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.
+ */
+export class WorkingTimeTracker {
+	private readonly now: () => number;
+	private accumulatorMs = 0;
+	private segmentStart: number | undefined;
+	private runStart: number | undefined;
+
+	constructor(now: () => number = () => Date.now()) {
+		this.now = now;
+	}
+
+	/** Start a fresh run, discarding any prior accumulated time. */
+	beginRun(): void {
+		this.accumulatorMs = 0;
+		this.segmentStart = undefined;
+		this.runStart = this.now();
+	}
+
+	/** Start a run only if one isn't already in progress (idempotent). */
+	ensureRun(): void {
+		if (this.runStart === undefined) this.beginRun();
+	}
+
+	/** Begin timing an assistant streaming segment. */
+	beginSegment(): void {
+		this.ensureRun();
+		if (this.segmentStart === undefined) this.segmentStart = this.now();
+	}
+
+	/** Close the current segment, folding its duration into the total. */
+	endSegment(): void {
+		if (this.segmentStart !== undefined) {
+			this.accumulatorMs += Math.max(0, this.now() - this.segmentStart);
+			this.segmentStart = undefined;
+		}
+	}
+
+	/** Milliseconds accumulated so far, including any open segment. */
+	elapsedMs(): number {
+		const open = this.segmentStart !== undefined ? Math.max(0, this.now() - this.segmentStart) : 0;
+		return this.accumulatorMs + open;
+	}
+
+	/** True while a run is in progress (between beginRun and settle). */
+	isActive(): boolean {
+		return this.runStart !== undefined;
+	}
+
+	/**
+	 * Finalize the run and return the durable entry, or `undefined` when
+	 * no measurable time accrued (guards against junk 0ms entries).
+	 * `totalMs` spans the whole run (retries, tools, overhead included).
+	 */
+	settle(): WorkingTimeEntry | undefined {
+		this.endSegment();
+		const endedAt = this.now();
+		const ms = this.accumulatorMs;
+		const startedAt = this.runStart;
+		this.accumulatorMs = 0;
+		this.segmentStart = undefined;
+		this.runStart = undefined;
+		if (startedAt === undefined || ms <= 0) return undefined;
+		return { ms, totalMs: Math.max(0, endedAt - startedAt), startedAt, endedAt };
+	}
+}
+
+/**
+ * Build the live working message, e.g. `Working... 12s`. The animated
+ * spinner frames are drawn by pi separately (via `setWorkingIndicator`),
+ * so this only supplies the trailing text — preserving whatever spinner
+ * the user/other extensions have configured.
+ */
+export function workingMessageText(elapsedMs: number): string {
+	const sec = Math.max(0, Math.floor(elapsedMs / 1000));
+	return `Working... ${sec}s`;
+}
+
+/**
+ * Format a duration as a compact clock string.
+ *
+ * - Sub-minute durations keep one decimal: `45.2s`.
+ * - Longer durations use integer `h`/`m`/`s` parts and always end in
+ *   seconds. Leading zero parts are dropped — `0h12m0s` → `12m0s`,
+ *   `0h0m5s` → `5s` — but once a part is present every following part is
+ *   shown, interior zeros included (`1h0m5s`, `1h0m0s`).
+ */
+export function formatClock(ms: number): string {
+	const totalSec = Math.max(0, ms) / 1000;
+	if (totalSec < 60) return `${totalSec.toFixed(1)}s`;
+	const totalSecInt = Math.floor(totalSec);
+	const hours = Math.floor(totalSecInt / 3600);
+	const min = Math.floor((totalSecInt % 3600) / 60);
+	const sec = totalSecInt % 60;
+	let out = "";
+	if (hours > 0) out += `${hours}h`;
+	if (hours > 0 || min > 0) out += `${min}m`;
+	return `${out}${sec}s`;
+}
+
+/**
+ * Render the durable entry body as a plain muted line (no frame):
+ * `⏱ worked 45.2s (total: 1m15s)`.
+ */
+export function workingTimeLine(entry: WorkingTimeEntry, dim: (s: string) => string): string {
+	return dim(`⏱ worked ${formatClock(entry.ms)} (total: ${formatClock(entry.totalMs)})`);
+}

package/write-edit-concurrency.test.ts

@@ -56,6 +56,8 @@ function loadTools(opts: { writeExec?: any; editExec?: any } = {}) {
 		registerTool: (tool: any) => tools.set(tool.name, tool),
 		registerCommand: () => {},
 		on: () => {},
+		registerEntryRenderer: () => {},
+		appendEntry: () => {},
 	};
 
 	piFaceliftExtension(pi, {