pi-crew 0.11.0 → 0.11.2

package/src/ui/settings-overlay.ts

@@ -5,8 +5,8 @@
  */
 
 import { truncateToWidth, visibleWidth } from "../utils/visual.ts";
-import { DynamicCrewBorder } from "./dynamic-border.ts";
 import { keyOf, matchesKey } from "./key-utils.ts";
+import { CURSOR, canopyLine, formatHint, overflowHint, RAIL, railLine } from "./rail.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
 import { discoverPiThemes, getActivePiTheme } from "./theme-discovery.ts";
 
@@ -509,19 +509,29 @@ class SelectSubmenu {
 		const end = Math.min(start + this.maxVisible, this.items.length);
 		const needsScroll = this.items.length > this.maxVisible;
 		if (needsScroll && start > 0) {
-			lines.push(this.theme.fg("dim", `  ▲ ${start} more above`));
+			lines.push(`  ${overflowHint(start, 0, this.theme)}`);
 		}
 		for (let i = start; i < end; i++) {
 			const isSelected = i === this.selectedIndex;
-			const prefix = isSelected ? " → " : "   ";
+			// `›` is the ONLY selection marker (RAIL): `→`-as-cursor is retired.
+			const prefix = isSelected ? ` ${CURSOR} ` : "   ";
 			const line = `${prefix}${this.items[i]}`;
 			lines.push(isSelected ? (this.theme.inverse?.(line) ?? line) : line);
 		}
 		if (needsScroll && end < this.items.length) {
-			lines.push(this.theme.fg("dim", `  ▼ ${this.items.length - end} more below`));
+			lines.push(`  ${overflowHint(0, this.items.length - end, this.theme)}`);
 		}
 		lines.push("");
-		lines.push(this.theme.fg("dim", "↑↓ navigate · Enter to select · Esc to go back"));
+		lines.push(
+			this.theme.fg(
+				"dim",
+				formatHint([
+					[["up", "down"], "navigate"],
+					["enter", "to select"],
+					["esc", "to go back"],
+				]),
+			),
+		);
 		return lines;
 	}
 
@@ -593,7 +603,16 @@ class TextinputSubmenu {
 		lines.push("");
 		lines.push(`  ${this.buffer}█`);
 		lines.push("");
-		lines.push(this.theme.fg("dim", "Enter to save · Esc to cancel · Clear to unset"));
+		lines.push(
+			this.theme.fg(
+				"dim",
+				formatHint([
+					["enter", "to save"],
+					["esc", "to cancel"],
+					["clear", "to unset"],
+				]),
+			),
+		);
 		return lines;
 	}
 
@@ -682,7 +701,7 @@ class AgentOverridesSubmenu {
 			const thinkingPart = thinking ? `thinking=${thinking}` : "";
 			const valueParts = [modelPart, thinkingPart].filter(Boolean).join(", ");
 			const valueText = valueParts || this.theme.fg("dim", "(default)");
-			const prefix = isSelected ? " → " : "   ";
+			const prefix = isSelected ? ` ${CURSOR} ` : "   ";
 			const line = `${prefix}${label} ${valueText}`;
 			lines.push(
 				isSelected
@@ -691,19 +710,38 @@ class AgentOverridesSubmenu {
 			);
 		}
 		lines.push("");
-		lines.push(this.theme.fg("dim", "Enter to edit model · e to edit thinking · Esc to go back"));
+		lines.push(
+			this.theme.fg(
+				"dim",
+				formatHint([
+					["enter", "to edit model"],
+					["e", "to edit thinking"],
+					["esc", "to go back"],
+				]),
+			),
+		);
 		return lines;
 	}
 
 	private renderEdit(width: number): string[] {
-		const agent = this.agents[this.selectedIndex];
+		// GUARD (M4 §4): an out-of-range cursor used to print `Edit undefined model`.
+		const agent = this.agents[this.selectedIndex] ?? "?";
 		const field = this.editField === "model" ? "model" : "thinking";
 		const lines: string[] = [];
 		lines.push(this.theme.bold(this.theme.fg("accent", `Edit ${agent} ${field}`)));
 		lines.push("");
 		lines.push(`  ${this.editBuffer}█`);
 		lines.push("");
-		lines.push(this.theme.fg("dim", "Enter to save · Esc to cancel · Clear to unset"));
+		lines.push(
+			this.theme.fg(
+				"dim",
+				formatHint([
+					["enter", "to save"],
+					["clear", "to unset"],
+					["esc", "to cancel"],
+				]),
+			),
+		);
 		return lines;
 	}
 
@@ -801,33 +839,30 @@ class SettingsOverlay {
 	}
 
 	render(width: number): string[] {
-		// Border wrapper — same style as RunDashboard
-		const innerWidth = Math.max(30, width - 4);
-		const borderWidth = Math.min(innerWidth, Math.max(0, width - 2));
-		const fg = (color: Parameters<CrewTheme["fg"]>[0], text: string) => this.theme.fg(color, text);
-		const borderFill = (count: number) => new DynamicCrewBorder(this.theme).render(Math.max(0, count))[0];
-		const border = (left: string, right: string) => `${fg("border", left)}${borderFill(borderWidth)}${fg("border", right)}`;
-		const row = (text: string) => `│ ${padToWidth(truncateToWidth(text, innerWidth - 1), innerWidth - 1)}│`;
+		// RAIL frame (M4, 2026-09-16) — the rounded box, the `├ ┤` rule and the
+		// `│` tab separator are retired: canopy `┏ SETTINGS ▸ pi-crew`, `┃` body
+		// rows (tab bar + content) and a `┗ <hint>` cap. railLine owns the glyph +
+		// space and the pad/truncate to `budget`, so no line can exceed `width`.
+		const budget = Math.max(0, width - 2);
+		const row = (text: string) => railLine(RAIL.body, "border", text, this.theme, budget);
 
 		const lines: string[] = [];
 
-		// ── Title bar ──
-		lines.push(border("╭", "╮"));
-		lines.push(row(`${fg("accent", "▐")} ${this.theme.bold("pi-crew Settings")}`));
+		// ── Title bar (canopy) ──
+		lines.push(canopyLine({ word: "SETTINGS", subject: "pi-crew", theme: this.theme, budget }));
 
-		// ── Tab bar ──
-		const tabLine = this.renderTabBarContent(innerWidth - 2);
-		lines.push(row(tabLine));
-		lines.push(border("├", "┤"));
+		// ── Tab bar (a rail body row; tabs joined by ` · `, never `│`) ──
+		lines.push(row(this.renderTabBarContent(budget)));
 
 		// ── Content ──
-		const content = this.submenu ? this.renderSubmenuContent(innerWidth - 4) : this.renderSettingsContent(innerWidth - 4);
+		const bodyBudget = Math.max(0, budget - 2);
+		const content = this.submenu ? this.renderSubmenuContent(bodyBudget) : this.renderSettingsContent(bodyBudget);
 		for (const line of content) {
-			lines.push(row(` ${truncateToWidth(line, innerWidth - 2)}`));
+			lines.push(row(` ${truncateToWidth(line, Math.max(0, budget - 1))}`));
 		}
 
-		// ── Bottom border ──
-		lines.push(border("╰", "╯"));
+		// ── Cap (close action LAST) ──
+		lines.push(railLine(RAIL.close, "border", formatHint([["esc", "close"]]), this.theme, budget));
 
 		return lines;
 	}
@@ -839,7 +874,7 @@ class SettingsOverlay {
 			const text = `${tab.icon} ${tab.label}`;
 			parts.push(isActive ? this.theme.bold(this.theme.fg("accent", text)) : this.theme.fg("dim", text));
 		}
-		return parts.join("  " + this.theme.fg("border", "│") + "  ");
+		return truncateToWidth(parts.join(`  ${this.theme.fg("dim", "·")}  `), innerWidth);
 	}
 
 	private renderSettingsContent(innerWidth: number): string[] {
@@ -864,7 +899,8 @@ class SettingsOverlay {
 			const valueStr = formatValue(effective, def.id);
 			const suffix = isDefault && (effective !== undefined || EFFECTIVE_DEFAULTS[def.id] !== undefined) ? " (default)" : "";
 
-			const prefix = isSelected ? " → " : "   ";
+			// Cursor: `›` is the ONLY selection marker (RAIL).
+			const prefix = isSelected ? ` ${CURSOR} ` : "   ";
 			const labelPad = padToWidth(def.label, maxLabelWidth);
 			const valueMax = innerWidth - maxLabelWidth - 6 - prefix.length - suffix.length;
 			const valueText = truncateToWidth(valueStr, Math.max(10, valueMax));
@@ -877,15 +913,12 @@ class SettingsOverlay {
 			}
 		}
 
-		// Scroll indicator
+		// Scroll indicator — RAIL overflow dialect (`▲ n above · ▼ m below`).
 		if (startIdx > 0 || endIdx < settings.length) {
 			const remaining = settings.length - endIdx;
-			const count = startIdx > 0 ? `↑${startIdx}` : "";
-			const below = remaining > 0 ? `↓${remaining}` : "";
-			const parts = [count, below].filter(Boolean);
-			if (parts.length > 0) {
-				lines.push(this.theme.fg("dim", `   (${this.selectedIndex + 1}/${settings.length}) ${parts.join(" ")}`));
-			}
+			lines.push(
+				`${this.theme.fg("dim", `   (${this.selectedIndex + 1}/${settings.length})`)} ${overflowHint(startIdx, remaining, this.theme)}`,
+			);
 		}
 
 		// Description
@@ -895,9 +928,18 @@ class SettingsOverlay {
 			lines.push(this.theme.fg("muted", `  ${selectedDef.description}`));
 		}
 
-		// Hints
+		// Hints — one format (`formatHint`); the close action lives in the cap.
 		lines.push("");
-		lines.push(this.theme.fg("dim", "  ↑↓ Navigate · Enter/Space change · Tab switch · Esc close"));
+		lines.push(
+			this.theme.fg(
+				"dim",
+				`  ${formatHint([
+					[["up", "down"], "Navigate"],
+					[["enter", "space"], "Change"],
+					["tab", "switch"],
+				])}`,
+			),
+		);
 
 		return lines;
 	}

package/src/ui/spinner.ts

@@ -1,7 +1,31 @@
 export const SUBAGENT_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
 export const SUBAGENT_SPINNER_FRAME_MS = 160;
 
-export function spinnerBucket(now = Date.now(), frameMs = SUBAGENT_SPINNER_FRAME_MS): number {
+// Clock source indirection (2026-09-22): spinner phase is derived from wall
+// time at ~30 call sites that don't thread an injectable `now` through their
+// render signatures. Deterministic consumers (docs/ui-samples/capture.ts,
+// tests) swap the source once at startup instead of refactoring every
+// signature; production keeps the real clock. Same pattern as the `__test__`
+// hooks in state-store.
+let spinnerClockSource: () => number = Date.now;
+
+/** @internal — swap the spinner clock source. Returns the previous source
+ * (pass it back to restore). Production default is Date.now. */
+export function __setSpinnerClockSource(source: () => number): () => number {
+	const previous = spinnerClockSource;
+	spinnerClockSource = source;
+	return previous;
+}
+
+/** The spinner clock as a shared read: elapsed-time fallbacks that have no
+ * injected `now` (tool-progress, record durations) read it here so deterministic
+ * captures pin BOTH spinner phase and elapsed text with one hook. Production
+ * default stays Date.now(). */
+export function spinnerClockNow(): number {
+	return spinnerClockSource();
+}
+
+export function spinnerBucket(now = spinnerClockSource(), frameMs = SUBAGENT_SPINNER_FRAME_MS): number {
 	return Math.floor(now / Math.max(1, frameMs));
 }
 
@@ -11,7 +35,7 @@ function hashKey(key: string): number {
 	return hash;
 }
 
-export function spinnerFrame(key = "", now = Date.now()): string {
+export function spinnerFrame(key = "", now = spinnerClockSource()): string {
 	const offset = key ? hashKey(key) % SUBAGENT_SPINNER_FRAMES.length : 0;
 	return SUBAGENT_SPINNER_FRAMES[(spinnerBucket(now) + offset) % SUBAGENT_SPINNER_FRAMES.length] ?? SUBAGENT_SPINNER_FRAMES[0];
 }

package/src/ui/terminal-status.ts

@@ -26,6 +26,12 @@
  *   - run just completed → Ghostty state 1/100 (green flash), schedule clear.
  *   - idle (no active runs) → restore pi's natural title, Ghostty state 0.
  *
+ * M3-1 (2026-09-15): the wiring now exists — see
+ * `src/extension/registration/terminal-status-wiring.ts` (installed from
+ * `register.ts`). From v0.8.3 (819d71ad) until this change the controller was
+ * constructed only by its unit tests: `ctx.terminalStatus` was never assigned,
+ * so neither channel ever ran (UI-AUDIT P0-2/P1-1).
+ *
  * @module terminal-status
  */
 
@@ -61,7 +67,7 @@ const MAX_TITLE_ROLES = 3;
 const IDLE_REASSERT_START_MS = 200;
 const IDLE_REASSERT_MAX_MS = 5000;
 /** How long the green completion flash stays before clearing. */
-const COMPLETE_FLASH_MS = 1500;
+export const COMPLETE_FLASH_MS = 1500;
 
 /** Injected for tests (defaults write to the real /dev/tty). */
 export type GhosttyWriter = (seq: string) => void;

package/src/ui/theme-adapter.ts

@@ -49,51 +49,6 @@ export type CrewThemeColor =
 
 export type CrewThemeBg = "selectedBg" | "userMessageBg" | "customMessageBg" | "toolPendingBg" | "toolSuccessBg" | "toolErrorBg";
 
-/** ANSI fallback values for theme color slots when the active theme doesn't define them. */
-export const THEME_COLOR_FALLBACKS: Record<CrewThemeColor, string> = {
-	accent: "\x1b[36m",
-	border: "\x1b[38;5;240m",
-	borderAccent: "\x1b[35m",
-	borderMuted: "\x1b[38;5;236m",
-	success: "\x1b[32m",
-	error: "\x1b[31m",
-	warning: "\x1b[33m",
-	muted: "\x1b[38;5;245m",
-	dim: "\x1b[38;5;240m",
-	text: "\x1b[39m",
-	thinkingText: "\x1b[38;5;245m",
-	toolTitle: "\x1b[36m",
-	toolOutput: "\x1b[38;5;245m",
-	toolDiffAdded: "\x1b[32m",
-	toolDiffRemoved: "\x1b[31m",
-	toolDiffContext: "\x1b[38;5;245m",
-	mdHeading: "\x1b[33m",
-	mdLink: "\x1b[35m",
-	mdCode: "\x1b[32m",
-	mdCodeBlock: "\x1b[39m",
-	mdQuote: "\x1b[38;5;245m",
-	mdHr: "\x1b[38;5;240m",
-	mdListBullet: "\x1b[36m",
-	syntaxKeyword: "\x1b[35m",
-	syntaxString: "\x1b[32m",
-	syntaxNumber: "\x1b[33m",
-	syntaxComment: "\x1b[38;5;245m",
-	syntaxFunction: "\x1b[36m",
-	syntaxVariable: "\x1b[39m",
-	syntaxType: "\x1b[35m",
-	syntaxOperator: "\x1b[35m",
-	syntaxPunctuation: "\x1b[35m",
-	userMessageText: "\x1b[39m",
-	customMessageLabel: "\x1b[35m",
-	thinkingOff: "\x1b[38;5;236m",
-	thinkingMinimal: "\x1b[38;5;245m",
-	thinkingLow: "\x1b[35m",
-	thinkingMedium: "\x1b[35m",
-	thinkingHigh: "\x1b[36m",
-	thinkingXhigh: "\x1b[35m",
-	bashMode: "\x1b[32m",
-};
-
 export interface CrewTheme {
 	fg(color: CrewThemeColor, text: string): string;
 	bg?(color: CrewThemeBg, text: string): string;

package/src/ui/theme-discovery.ts

@@ -7,7 +7,19 @@
  *  - setPiTheme() to persist a choice in ~/.pi/agent/settings.json
  *
  * Wired into the `team-settings themes` / `theme` subcommands.
+ *
+ * P0-1 (2026-09-15): this module used bare `require("node:fs")` in three
+ * places. It is an ESM module, so `require` is undefined there and every
+ * filesystem probe threw a ReferenceError that the surrounding try/catch
+ * swallowed: `discoverPiThemes()` collapsed to the 2 builtins, and
+ * `getActivePiTheme()` always returned undefined (so no crew theme was
+ * selectable and the active theme was misreported). The fs access is now a
+ * static top-level import. `node:fs` is a builtin and this module is already
+ * eagerly reachable from handle-settings.ts / settings-overlay.ts, so this
+ * does not change lazy-load behaviour (check:lazy-imports only polices
+ * `await import(` without a `// LAZY:` marker).
  */
+import * as fs from "node:fs";
 
 export interface PiThemeInfo {
 	/** Theme name (filename stem or builtin id). */
@@ -72,8 +84,6 @@ export function discoverPiThemes(): PiThemeInfo[] {
 	// Custom themes from ~/.pi/agent/themes/
 	const dir = customThemesDir();
 	try {
-		// eslint-disable-next-line @typescript-eslint/no-require-imports
-		const fs = require("node:fs");
 		if (dir && fs.existsSync(dir)) {
 			for (const file of fs.readdirSync(dir) as string[]) {
 				if (!file.endsWith(".json")) continue;
@@ -109,8 +119,6 @@ export function discoverPiThemes(): PiThemeInfo[] {
 /** Read the currently active Pi theme from ~/.pi/agent/settings.json. */
 export function getActivePiTheme(): string | undefined {
 	try {
-		// eslint-disable-next-line @typescript-eslint/no-require-imports
-		const fs = require("node:fs");
 		const p = settingsPath();
 		if (!p || !fs.existsSync(p)) return undefined;
 		const json = JSON.parse(fs.readFileSync(p, "utf8"));
@@ -122,8 +130,6 @@ export function getActivePiTheme(): string | undefined {
 
 /** Persist a Pi theme choice in ~/.pi/agent/settings.json. Returns the path or throws. */
 export function setPiTheme(name: string): string {
-	// eslint-disable-next-line @typescript-eslint/no-require-imports
-	const fs = require("node:fs");
 	const p = settingsPath();
 	if (!p) throw new Error("Could not determine settings path (no HOME).");
 	let settings: Record<string, unknown> = {};

package/src/ui/tool-progress-formatter.ts

@@ -1,5 +1,6 @@
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { spinnerClockNow } from "./spinner.ts";
 
 export interface ToolProgressInput {
 	/** Subagent record id or synthetic agent label shown in the header. */
@@ -22,6 +23,119 @@ export interface ToolProgressInput {
 
 const MAX_OUTPUT_LINE = 80;
 
+// ── Producer↔consumer contract (audit P1-13) ───────────────────────────
+
+/**
+ * Every token that `formatCompactToolProgress` (producer) emits and that the
+ * `team`/`agent` tool renderers (consumer, `parseCompactToolProgress` below)
+ * look for. The two sides used to be coupled only by hand-written regexes, so a
+ * one-character format change made the streaming progress block silently empty.
+ * Both sides now read the tokens from here.
+ */
+export const PROGRESS_FORMAT = {
+	/** Header: `agent=<id> status=<status> elapsed=<n>s` (`agent` with no id). */
+	agentKey: "agent",
+	statusKey: "status",
+	elapsedKey: "elapsed",
+	/** Unit suffix for `elapsed=` (seconds). */
+	elapsedUnit: "s",
+	/** Task tally: `tasks <completed>/<total> done <status>=<n> …`. */
+	tasksKey: "tasks",
+	tallySeparator: "/",
+	doneWord: "done",
+	/** Active worker row: `<role>-><agent> turn=<n> tokens=<n>`. */
+	roleSeparator: "->",
+	turnKey: "turn",
+	tokensKey: "tokens",
+	/** Current tool row: `tool: <name> (#<n>)`. */
+	toolKey: "tool",
+	toolSeparator: ":",
+	/** Pending-run row: `run=<id> (starting)`. */
+	runKey: "run",
+	/** Failure row: `error: <text>`. */
+	errorKey: "error",
+	/** Fallback row before the run materializes. */
+	waitingLine: "waiting for run to start",
+} as const;
+
+/**
+ * Structured image of a compact progress block. Consumed by the tool renderers;
+ * `null` from the parser means "nothing progress-like in this text".
+ */
+export interface ParsedToolProgress {
+	/** `elapsed=<n>s` in milliseconds (0 when absent). */
+	elapsedMs: number;
+	/** `status=<x>` value (note: the renderer only surfaces it when no task counts exist). */
+	status: string | null;
+	/** Completed task count from the tally row (null when absent). */
+	completed: number | null;
+	/** Total task count from the tally row (completed + remaining for the legacy bucket form). */
+	total: number | null;
+	/** `<role>/<agent>` of the active worker row, if present. */
+	activeAgent: string | null;
+	/** Current tool name from `tool: <name>`, if present. */
+	currentTool: string | null;
+	/** Turn count of the active worker row, if present. */
+	turns: number | null;
+	/** Token count of the active worker row, if present. */
+	tokens: number | null;
+}
+
+const ELAPSED_RE = new RegExp(`${PROGRESS_FORMAT.elapsedKey}=(\\d+)${PROGRESS_FORMAT.elapsedUnit}`);
+const STATUS_RE = new RegExp(`${PROGRESS_FORMAT.statusKey}=(\\w+)`);
+const TALLY_RE = new RegExp(
+	`${PROGRESS_FORMAT.tasksKey}\\s+(\\d+)${PROGRESS_FORMAT.tallySeparator}(\\d+)\\s+${PROGRESS_FORMAT.doneWord}\\b`,
+);
+// Legacy bucket form (`tasks completed=2 running=1`) — kept for older/foreign
+// producers; the tally form above wins when both are present.
+const BUCKETS_RE = new RegExp(
+	`${PROGRESS_FORMAT.tasksKey}[^\\n]*(?:completed|${PROGRESS_FORMAT.doneWord})=(\\d+)[^\\n]*(?:running|waiting|queued)=(\\d+)`,
+);
+const AGENT_ROW_RE = new RegExp(`\\s+(\\w+)${PROGRESS_FORMAT.roleSeparator}(\\w+)\\s+${PROGRESS_FORMAT.turnKey}=`);
+const TURN_RE = new RegExp(`${PROGRESS_FORMAT.turnKey}=(\\d+)`);
+const TOKENS_RE = new RegExp(`${PROGRESS_FORMAT.tokensKey}=(\\d+)`);
+const TOOL_ROW_RE = new RegExp(`${PROGRESS_FORMAT.toolKey}${PROGRESS_FORMAT.toolSeparator}\\s+(\\S+)`);
+
+/** Parse a compact progress block back into structured fields (see PROGRESS_FORMAT). */
+export function parseCompactToolProgress(text: string): ParsedToolProgress | null {
+	if (!text) return null;
+
+	const elapsedMatch = ELAPSED_RE.exec(text);
+	const elapsedMs = elapsedMatch ? Number.parseInt(elapsedMatch[1]!, 10) * 1000 : 0;
+
+	let completed: number | null = null;
+	let total: number | null = null;
+	const tally = TALLY_RE.exec(text);
+	if (tally) {
+		completed = Number.parseInt(tally[1]!, 10);
+		total = Number.parseInt(tally[2]!, 10);
+	} else {
+		const buckets = BUCKETS_RE.exec(text);
+		if (buckets) {
+			completed = Number.parseInt(buckets[1]!, 10);
+			total = completed + Number.parseInt(buckets[2]!, 10);
+		}
+	}
+
+	// Nothing progress-like: mirrors the historical "no elapsed/task signal → null".
+	if (elapsedMs === 0 && completed === null) return null;
+
+	const agentRow = AGENT_ROW_RE.exec(text);
+	const toolRow = TOOL_ROW_RE.exec(text);
+	const turns = TURN_RE.exec(text);
+	const tokens = TOKENS_RE.exec(text);
+	return {
+		elapsedMs,
+		status: STATUS_RE.exec(text)?.[1] ?? null,
+		completed,
+		total,
+		activeAgent: agentRow ? `${agentRow[1]}/${agentRow[2]}` : null,
+		currentTool: toolRow ? toolRow[1]! : null,
+		turns: turns ? Number.parseInt(turns[1]!, 10) : null,
+		tokens: tokens ? Number.parseInt(tokens[1]!, 10) : null,
+	};
+}
+
 function pickActiveAgent(agents: CrewAgentRecord[] | undefined): CrewAgentRecord | undefined {
 	if (!agents || agents.length === 0) return undefined;
 	return (
@@ -55,7 +169,7 @@ function taskCounts(tasks: TeamTaskState[] | undefined): string | undefined {
 	const buckets = new Map<string, number>();
 	for (const task of tasks) buckets.set(task.status, (buckets.get(task.status) ?? 0) + 1);
 	const summary = [...buckets.entries()].map(([status, count]) => `${status}=${count}`).join(" ");
-	return `tasks ${completed}/${total} done ${summary}`;
+	return `${PROGRESS_FORMAT.tasksKey} ${completed}${PROGRESS_FORMAT.tallySeparator}${total} ${PROGRESS_FORMAT.doneWord} ${summary}`;
 }
 
 /**
@@ -64,9 +178,12 @@ function taskCounts(tasks: TeamTaskState[] | undefined): string | undefined {
  * the chat widget overlay does not jitter.
  */
 export function formatCompactToolProgress(input: ToolProgressInput): string {
-	const elapsedSec = Math.max(0, Math.round((Date.now() - input.startedAt) / 1000));
-	const head = input.agentId ? `agent=${input.agentId}` : "agent";
-	const lines: string[] = [`${head} status=${input.status} elapsed=${elapsedSec}s`];
+	const elapsedSec = Math.max(0, Math.round((spinnerClockNow() - input.startedAt) / 1000));
+	const head = input.agentId ? `${PROGRESS_FORMAT.agentKey}=${input.agentId}` : PROGRESS_FORMAT.agentKey;
+	// Emitted from PROGRESS_FORMAT so the parser can never drift from the wire format.
+	const lines: string[] = [
+		`${head} ${PROGRESS_FORMAT.statusKey}=${input.status} ${PROGRESS_FORMAT.elapsedKey}=${elapsedSec}${PROGRESS_FORMAT.elapsedUnit}`,
+	];
 
 	const counts = taskCounts(input.tasks);
 	if (counts) lines.push(`  ${counts}`);
@@ -75,19 +192,21 @@ export function formatCompactToolProgress(input: ToolProgressInput): string {
 	if (active) {
 		const turns = active.progress?.turns ?? 0;
 		const tokens = totalTokens(active);
-		lines.push(`  ${active.role}->${active.agent} turn=${turns} tokens=${tokens}`);
+		lines.push(
+			`  ${active.role}${PROGRESS_FORMAT.roleSeparator}${active.agent} ${PROGRESS_FORMAT.turnKey}=${turns} ${PROGRESS_FORMAT.tokensKey}=${tokens}`,
+		);
 		if (active.progress?.currentTool) {
 			const count = active.progress.toolCount ? ` (#${active.progress.toolCount})` : "";
-			lines.push(`  tool: ${active.progress.currentTool}${count}`);
+			lines.push(`  ${PROGRESS_FORMAT.toolKey}${PROGRESS_FORMAT.toolSeparator} ${active.progress.currentTool}${count}`);
 		}
 		const recent = active.progress?.recentOutput?.at(-1);
 		if (recent?.trim()) lines.push(`  ${trimLine(recent)}`);
 	} else if (input.runId && !counts) {
-		lines.push(`  run=${input.runId} (starting)`);
+		lines.push(`  ${PROGRESS_FORMAT.runKey}=${input.runId} (starting)`);
 	} else if (input.error) {
-		lines.push(`  error: ${trimLine(input.error)}`);
+		lines.push(`  ${PROGRESS_FORMAT.errorKey}: ${trimLine(input.error)}`);
 	} else if (!counts) {
-		lines.push("  waiting for run to start");
+		lines.push(`  ${PROGRESS_FORMAT.waitingLine}`);
 	}
 	return lines.join("\n");
 }

package/src/ui/tool-renderers/brief-mode.ts

@@ -8,6 +8,7 @@
 
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
 import { formatDuration, formatTokens, truncLine } from "../format-helpers.ts";
+import { spinnerClockNow } from "../spinner.ts";
 import type { CrewTheme } from "../theme-adapter.ts";
 
 // ── State ──────────────────────────────────────────────────────────────
@@ -57,24 +58,17 @@ export { BRIEF_ENTRY_TYPE };
 
 // ── Brief renderers ────────────────────────────────────────────────────
 
-/** Brief summary for a single tool result. */
+/** Brief summary for a single tool result.
+ *
+ * SCOPE (audit P1-12): this is only ever called with the hard-coded names
+ * "team" (`tool-renderers/index.ts:303`) and "agent" (`:414`). The 7
+ * native-tool arms (read/bash/edit/write/find/grep/ls) were unreachable and
+ * were REMOVED in M3-3 — turning /crew-brief on cannot change native tool
+ * output; only team/agent results and the default fallback render brief.
+ */
 export function briefToolResult(toolName: string, result: { content?: unknown[] }, theme: CrewTheme): string {
 	const text = extractText(result?.content);
 	switch (toolName) {
-		case "read":
-			return briefRead(text, theme);
-		case "bash":
-			return briefBash(text, theme);
-		case "edit":
-			return briefEdit(text, theme);
-		case "write":
-			return briefWrite(text, theme);
-		case "find":
-			return briefFind(text, theme);
-		case "grep":
-			return briefGrep(text, theme);
-		case "ls":
-			return briefLs(text, theme);
 		case "team":
 			return briefTeam(result, theme);
 		case "agent":
@@ -84,57 +78,6 @@ export function briefToolResult(toolName: string, result: { content?: unknown[]
 	}
 }
 
-function briefRead(text: string, theme: CrewTheme): string {
-	if (!text) return theme.fg("dim", "→ empty");
-	const count = text.trim().split("\n").filter(Boolean).length;
-	return theme.fg("muted", `→ ${count} lines`);
-}
-
-function briefBash(text: string, theme: CrewTheme): string {
-	if (!text?.trim()) return theme.fg("dim", "→ done");
-	const lines = text.trim().split("\n");
-	if (lines.length === 1 && lines[0]!.length < 40) {
-		return theme.fg("muted", `→ ${lines[0]}`);
-	}
-	return theme.fg("muted", `→ ${lines.length} lines`);
-}
-
-function briefEdit(text: string, theme: CrewTheme): string {
-	if (!text) return theme.fg("dim", "→ edited");
-	if (text.includes("Error") || text.includes("error")) {
-		return theme.fg("error", "→ failed");
-	}
-	const added = (text.match(/^\+ /gm) ?? []).length;
-	const removed = (text.match(/^- /gm) ?? []).length;
-	if (added === 0 && removed === 0) {
-		return theme.fg("success", "→ edited");
-	}
-	return theme.fg("success", "→ edited ") + theme.fg("toolDiffAdded", `+${added} `) + theme.fg("toolDiffRemoved", `-${removed}`);
-}
-
-function briefWrite(text: string, theme: CrewTheme): string {
-	if (text) return theme.fg("error", `→ ${text}`);
-	return theme.fg("success", "→ written");
-}
-
-function briefFind(text: string, theme: CrewTheme): string {
-	if (!text) return theme.fg("dim", "→ none");
-	const count = text.trim().split("\n").filter(Boolean).length;
-	return theme.fg("muted", `→ ${count} files`);
-}
-
-function briefGrep(text: string, theme: CrewTheme): string {
-	if (!text) return theme.fg("dim", "→ none");
-	const count = text.trim().split("\n").filter(Boolean).length;
-	return theme.fg("muted", `→ ${count} matches`);
-}
-
-function briefLs(text: string, theme: CrewTheme): string {
-	if (!text) return theme.fg("dim", "→ empty");
-	const count = text.trim().split("\n").filter(Boolean).length;
-	return theme.fg("muted", `→ ${count} entries`);
-}
-
 function briefTeam(result: { content?: unknown[] }, theme: CrewTheme): string {
 	// Try to extract structured details
 	const details = (result as Record<string, unknown>).details ?? result;
@@ -207,7 +150,7 @@ function computeTotalDuration(records: CrewAgentRecord[]): number {
 	for (const r of records) {
 		if (r.startedAt) {
 			const start = new Date(r.startedAt).getTime();
-			const end = r.completedAt ? new Date(r.completedAt).getTime() : Date.now();
+			const end = r.completedAt ? new Date(r.completedAt).getTime() : spinnerClockNow();
 			if (Number.isFinite(start) && Number.isFinite(end)) total += Math.max(0, end - start);
 		}
 	}