pi-crew 0.6.3 → 0.6.4

package/src/extension/registration/brief-tool-overrides.ts

@@ -0,0 +1,400 @@
+/**
+ * Brief tool overrides — re-registers built-in Pi tools with custom rendering.
+ *
+ * Inspired by oh-my-pi's pi-brief extension. Wraps each built-in tool
+ * (read, bash, edit, write, find, grep, ls) keeping the original execute
+ * but replacing renderCall/renderResult with themed, brief-aware versions.
+ *
+ * Brief mode shows CONTEXTUAL one-liners that preserve WHAT was done:
+ *   read  ~/file.ts:1-50 → 142 lines · 2.3s
+ *   bash  $ npm test → done · 12.5s
+ *   edit  ~/file.ts → +3 -1 · 0.8s
+ *   write ~/file.ts (42 lines) → ✓ · 0.2s
+ *   find  *.ts in ~/src → 5 files · 0.5s
+ *   grep /pattern/ in ~/src → 3 matches · 0.3s
+ *   ls    ~/src → 8 entries · 0.1s
+ *
+ * Timing: ctx.state.startedAt is set in renderCall, read in renderResult.
+ * NOTE: Pi's executionStarted is a boolean flag (NOT a timestamp).
+ */
+
+import { homedir } from "node:os";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	createBashTool,
+	createEditTool,
+	createFindTool,
+	createGrepTool,
+	createLsTool,
+	createReadTool,
+	createWriteTool,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { isBrief } from "../../ui/tool-renderers/brief-mode.ts";
+
+// ── Path shortening ────────────────────────────────────────────────────
+
+const HOME = homedir();
+function shortenPath(p: string): string {
+	if (!p) return "";
+	if (p.startsWith(HOME)) return `~${p.slice(HOME.length)}`;
+	return p;
+}
+
+// ── Types ──────────────────────────────────────────────────────────────
+
+interface TextResult {
+	content: Array<{ type: string; text?: string }>;
+}
+
+interface Theme {
+	fg: (slot: string, text: string) => string;
+	bold: (text: string) => string;
+}
+
+interface RenderCtx {
+	args?: Record<string, unknown>;
+	state?: Record<string, unknown>;
+}
+
+function fullText(result: TextResult): string | undefined {
+	const c = result.content.find((x): x is { type: "text"; text: string } => x.type === "text");
+	return c?.text;
+}
+
+function fullRender(result: TextResult, theme: Theme): Text {
+	const text = fullText(result);
+	if (!text) return new Text("", 0, 0);
+	const lines = text
+		.trim()
+		.split("\n")
+		.map((line) => theme.fg("toolOutput", line))
+		.join("\n");
+	return new Text(`\n${lines}`, 0, 0);
+}
+
+/** Record start time in ctx.state during renderCall (called once per tool invocation). */
+function noteStarted(ctx: RenderCtx | undefined): void {
+	if (ctx?.state && !ctx.state.briefStartedAt) {
+		ctx.state.briefStartedAt = Date.now();
+	}
+}
+
+/** Compute elapsed from ctx.state.briefStartedAt. Returns " · 1.2s" or "". */
+function elapsed(ctx: RenderCtx | undefined): string {
+	const startedAt = ctx?.state?.briefStartedAt as number | undefined;
+	if (!startedAt || typeof startedAt !== "number") return "";
+	const ms = Date.now() - startedAt;
+	if (ms < 1000) return "";
+	if (ms < 60_000) return ` · ${(ms / 1000).toFixed(1)}s`;
+	const m = Math.floor(ms / 60_000), s = Math.floor((ms % 60_000) / 1000);
+	return ` · ${m}m${s}s`;
+}
+
+/** Truncate to maxLen with ellipsis (visual). */
+function trunc(text: string, maxLen: number): string {
+	if (text.length <= maxLen) return text;
+	return text.slice(0, maxLen - 1) + "…";
+}
+
+/** Flatten multiline command to single line, truncated. */
+function flatCmd(cmd: string, maxLen: number): string {
+	return trunc(cmd.replace(/\s+/g, " ").trim(), maxLen);
+}
+
+// ── Tool registration ──────────────────────────────────────────────────
+
+export function registerBriefToolOverrides(pi: ExtensionAPI, cwd: string): void {
+	const tools = {
+		read: createReadTool(cwd),
+		bash: createBashTool(cwd),
+		edit: createEditTool(cwd),
+		write: createWriteTool(cwd),
+		find: createFindTool(cwd),
+		grep: createGrepTool(cwd),
+		ls: createLsTool(cwd),
+	};
+
+	// ─── Read ───
+	pi.registerTool({
+		name: "read",
+		label: "read",
+		description: tools.read.description,
+		parameters: tools.read.parameters,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: any) {
+			return tools.read.execute(toolCallId, params, signal, onUpdate);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderCall(args: any, theme: any, ctx: any): any {
+			noteStarted(ctx);
+			const p = shortenPath(args.path || "");
+			const pathDisplay = p ? theme.fg("accent", p) : theme.fg("toolOutput", "...");
+			let text = `${theme.fg("toolTitle", theme.bold("read"))} ${pathDisplay}`;
+			if (args.offset !== undefined || args.limit !== undefined) {
+				const startLine = args.offset ?? 1;
+				const endLine = args.limit !== undefined ? startLine + args.limit - 1 : "";
+				text += theme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+			}
+			return new Text(text, 0, 0);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderResult(result: any, options: any, theme: any, ctx: any): any {
+			if (!isBrief() || options.expanded) return fullRender(result, theme);
+			const args = ctx?.args ?? {};
+			const p = shortenPath(args.path || "?");
+			let range = "";
+			if (args.offset || args.limit) {
+				const s = args.offset ?? 1;
+				const e = args.limit ? s + args.limit - 1 : "";
+				range = `:${s}${e ? `-${e}` : ""}`;
+			}
+			const text = fullText(result);
+			const count = text ? text.trim().split("\n").filter(Boolean).length : 0;
+			const time = elapsed(ctx);
+			const label = count === 0 ? "empty" : `${count} lines`;
+			return new Text(
+				`${theme.fg("toolTitle", "read")} ${theme.fg("accent", p)}${theme.fg("warning", range)} ${theme.fg("dim", "→")} ${theme.fg("muted", label)}${theme.fg("dim", time)}`,
+				0, 0,
+			);
+		},
+	});
+
+	// ─── Bash ───
+	pi.registerTool({
+		name: "bash",
+		label: "bash",
+		description: tools.bash.description,
+		parameters: tools.bash.parameters,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: any) {
+			return tools.bash.execute(toolCallId, params, signal, onUpdate);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderCall(args: any, theme: any, ctx: any): any {
+			noteStarted(ctx);
+			const command = args.command || "...";
+			const timeout = args.timeout as number | undefined;
+			const timeoutSuffix = timeout ? theme.fg("muted", ` (${timeout}s)`) : "";
+			return new Text(theme.fg("toolTitle", theme.bold(`$ ${command}`)) + timeoutSuffix, 0, 0);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderResult(result: any, options: any, theme: any, ctx: any): any {
+			if (!isBrief() || options.expanded) return fullRender(result, theme);
+			const args = ctx?.args ?? {};
+			const cmd = flatCmd(String(args.command || "?"), 50);
+			const text = fullText(result);
+			const time = elapsed(ctx);
+			let label: string;
+			let color: string;
+			if (!text || !text.trim()) {
+				label = "done";
+				color = "muted";
+			} else {
+				const lines = text.trim().split("\n");
+				if (lines.length === 1) {
+					label = trunc(lines[0]!, 40);
+					color = "muted";
+				} else {
+					label = `${lines.length} lines`;
+					color = "muted";
+				}
+			}
+			return new Text(
+				`${theme.fg("toolTitle", "$")} ${theme.fg("accent", cmd)} ${theme.fg("dim", "→")} ${theme.fg(color, label)}${theme.fg("dim", time)}`,
+				0, 0,
+			);
+		},
+	});
+
+	// ─── Edit ───
+	pi.registerTool({
+		name: "edit",
+		label: "edit",
+		description: tools.edit.description,
+		parameters: tools.edit.parameters,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: any) {
+			return tools.edit.execute(toolCallId, params, signal, onUpdate);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderCall(args: any, theme: any, ctx: any): any {
+			noteStarted(ctx);
+			const p = shortenPath(args.path || "");
+			const pathDisplay = p ? theme.fg("accent", p) : theme.fg("toolOutput", "...");
+			return new Text(`${theme.fg("toolTitle", theme.bold("edit"))} ${pathDisplay}`, 0, 0);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderResult(result: any, options: any, theme: any, ctx: any): any {
+			if (!isBrief() || options.expanded) return fullRender(result, theme);
+			const args = ctx?.args ?? {};
+			const p = shortenPath(args.path || "?");
+			const text = fullText(result);
+			const time = elapsed(ctx);
+			if (text && (text.includes("Error") || text.includes("error"))) {
+				return new Text(
+					`${theme.fg("toolTitle", "edit")} ${theme.fg("accent", p)} ${theme.fg("dim", "→")} ${theme.fg("error", "failed")}${theme.fg("dim", time)}`,
+					0, 0,
+				);
+			}
+			const added = text ? (text.match(/^\+ /gm) ?? []).length : 0;
+			const removed = text ? (text.match(/^- /gm) ?? []).length : 0;
+			if (added === 0 && removed === 0) {
+				return new Text(
+					`${theme.fg("toolTitle", "edit")} ${theme.fg("accent", p)} ${theme.fg("dim", "→")} ${theme.fg("success", "edited")}${theme.fg("dim", time)}`,
+					0, 0,
+				);
+			}
+			return new Text(
+				`${theme.fg("toolTitle", "edit")} ${theme.fg("accent", p)} ${theme.fg("dim", "→")} ${theme.fg("toolDiffAdded", `+${added} `)}${theme.fg("toolDiffRemoved", `-${removed}`)}${theme.fg("dim", time)}`,
+				0, 0,
+			);
+		},
+	});
+
+	// ─── Write ───
+	pi.registerTool({
+		name: "write",
+		label: "write",
+		description: tools.write.description,
+		parameters: tools.write.parameters,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: any) {
+			return tools.write.execute(toolCallId, params, signal, onUpdate);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderCall(args: any, theme: any, ctx: any): any {
+			noteStarted(ctx);
+			const p = shortenPath(args.path || "");
+			const pathDisplay = p ? theme.fg("accent", p) : theme.fg("toolOutput", "...");
+			const lineCount = args.content ? String(args.content).split("\n").length : 0;
+			const lineInfo = lineCount > 0 ? theme.fg("muted", ` (${lineCount} lines)`) : "";
+			return new Text(`${theme.fg("toolTitle", theme.bold("write"))} ${pathDisplay}${lineInfo}`, 0, 0);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderResult(result: any, options: any, theme: any, ctx: any): any {
+			if (!isBrief() || options.expanded) return fullRender(result, theme);
+			const args = ctx?.args ?? {};
+			const p = shortenPath(args.path || "?");
+			const text = fullText(result);
+			const time = elapsed(ctx);
+			if (text) {
+				return new Text(
+					`${theme.fg("toolTitle", "write")} ${theme.fg("accent", p)} ${theme.fg("dim", "→")} ${theme.fg("error", trunc(text.trim().split("\n")[0] ?? "", 30))}${theme.fg("dim", time)}`,
+					0, 0,
+				);
+			}
+			return new Text(
+				`${theme.fg("toolTitle", "write")} ${theme.fg("accent", p)} ${theme.fg("dim", "→")} ${theme.fg("success", "✓")}${theme.fg("dim", time)}`,
+				0, 0,
+			);
+		},
+	});
+
+	// ─── Find ───
+	pi.registerTool({
+		name: "find",
+		label: "find",
+		description: tools.find.description,
+		parameters: tools.find.parameters,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: any) {
+			return tools.find.execute(toolCallId, params, signal, onUpdate);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderCall(args: any, theme: any, ctx: any): any {
+			noteStarted(ctx);
+			const pattern = args.pattern || "";
+			const p = shortenPath(args.path || ".");
+			let text = `${theme.fg("toolTitle", theme.bold("find"))} ${theme.fg("accent", pattern)}`;
+			text += theme.fg("toolOutput", ` in ${p}`);
+			return new Text(text, 0, 0);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderResult(result: any, options: any, theme: any, ctx: any): any {
+			if (!isBrief() || options.expanded) return fullRender(result, theme);
+			const args = ctx?.args ?? {};
+			const pattern = trunc(String(args.pattern || "*"), 20);
+			const p = shortenPath(args.path || ".");
+			const text = fullText(result);
+			const count = text ? text.trim().split("\n").filter(Boolean).length : 0;
+			const time = elapsed(ctx);
+			const label = count === 0 ? "none" : `${count} files`;
+			const color = count === 0 ? "dim" : "muted";
+			return new Text(
+				`${theme.fg("toolTitle", "find")} ${theme.fg("accent", pattern)} ${theme.fg("dim", `in ${p} →`)} ${theme.fg(color, label)}${theme.fg("dim", time)}`,
+				0, 0,
+			);
+		},
+	});
+
+	// ─── Grep ───
+	pi.registerTool({
+		name: "grep",
+		label: "grep",
+		description: tools.grep.description,
+		parameters: tools.grep.parameters,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: any) {
+			return tools.grep.execute(toolCallId, params, signal, onUpdate);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderCall(args: any, theme: any, ctx: any): any {
+			noteStarted(ctx);
+			const pattern = args.pattern || "";
+			const p = shortenPath(args.path || ".");
+			let text = `${theme.fg("toolTitle", theme.bold("grep"))} ${theme.fg("accent", `/${pattern}/`)}`;
+			text += theme.fg("toolOutput", ` in ${p}`);
+			return new Text(text, 0, 0);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderResult(result: any, options: any, theme: any, ctx: any): any {
+			if (!isBrief() || options.expanded) return fullRender(result, theme);
+			const args = ctx?.args ?? {};
+			const pattern = trunc(String(args.pattern || "?"), 20);
+			const p = shortenPath(args.path || ".");
+			const text = fullText(result);
+			const count = text ? text.trim().split("\n").filter(Boolean).length : 0;
+			const time = elapsed(ctx);
+			const label = count === 0 ? "none" : `${count} matches`;
+			const color = count === 0 ? "dim" : "muted";
+			return new Text(
+				`${theme.fg("toolTitle", "grep")} ${theme.fg("accent", `/${pattern}/`)} ${theme.fg("dim", `in ${p} →`)} ${theme.fg(color, label)}${theme.fg("dim", time)}`,
+				0, 0,
+			);
+		},
+	});
+
+	// ─── Ls ───
+	pi.registerTool({
+		name: "ls",
+		label: "ls",
+		description: tools.ls.description,
+		parameters: tools.ls.parameters,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		async execute(toolCallId: string, params: any, signal: any, onUpdate: any, ctx: any) {
+			return tools.ls.execute(toolCallId, params, signal, onUpdate);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderCall(args: any, theme: any, ctx: any): any {
+			noteStarted(ctx);
+			const p = shortenPath(args.path || ".");
+			return new Text(`${theme.fg("toolTitle", theme.bold("ls"))} ${theme.fg("accent", p)}`, 0, 0);
+		},
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		renderResult(result: any, options: any, theme: any, ctx: any): any {
+			if (!isBrief() || options.expanded) return fullRender(result, theme);
+			const args = ctx?.args ?? {};
+			const p = shortenPath(args.path || ".");
+			const text = fullText(result);
+			const count = text ? text.trim().split("\n").filter(Boolean).length : 0;
+			const time = elapsed(ctx);
+			const label = count === 0 ? "empty" : `${count} entries`;
+			const color = count === 0 ? "dim" : "muted";
+			return new Text(
+				`${theme.fg("toolTitle", "ls")} ${theme.fg("accent", p)} ${theme.fg("dim", "→")} ${theme.fg(color, label)}${theme.fg("dim", time)}`,
+				0, 0,
+			);
+		},
+	});
+}

package/src/extension/registration/commands.ts

@@ -571,6 +571,31 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 	pi.registerCommand("team-help", { description: "Show pi-crew command help", handler: async (_args: string, ctx: ExtensionCommandContext) => {
 		await notifyCommandResult(ctx, piTeamsHelp());
 	} });
+
+	// Brief mode command — toggle compact tool output display
+	pi.registerCommand("crew-brief", {
+		description: "Toggle brief tool output mode: on | off | status",
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const { isBrief, setBrief, BRIEF_ENTRY_TYPE, makeBriefEntry } = await import("../../ui/tool-renderers/brief-mode.ts");
+			const trimmed = args.trim();
+
+			if (trimmed === "on") {
+				setBrief(true);
+				pi.appendEntry(BRIEF_ENTRY_TYPE, { enabled: true });
+				ctx.ui.notify("Brief mode: on — tool output will show compact summaries", "info");
+				return;
+			}
+			if (trimmed === "off") {
+				setBrief(false);
+				pi.appendEntry(BRIEF_ENTRY_TYPE, { enabled: false });
+				ctx.ui.notify("Brief mode: off — full tool output restored", "info");
+				return;
+			}
+			// status (default)
+			ctx.ui.notify(`Brief mode: ${isBrief() ? "on" : "off"}`, "info");
+		},
+	});
+
 	time("register.commands");
 	printTimings();
 }

package/src/extension/registration/subagent-tools.ts

@@ -22,7 +22,8 @@ import { t } from "../../i18n.ts";
 import { loadRunManifestById } from "../../state/state-store.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { formatCompactToolProgress } from "../../ui/tool-progress-formatter.ts";
-import { renderAgentToolCall, renderAgentToolResult } from "../../ui/tool-render.ts";
+import { Text } from "@earendil-works/pi-tui";
+import { agentToolRenderer } from "../../ui/tool-renderers/index.ts";
 
 const TOOL_PROGRESS_TICK_MS = 1000;
 
@@ -98,11 +99,15 @@ export function registerSubagentTools(pi: ExtensionAPI, subagentManager: Subagen
 		},
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		renderCall(args: any, theme: any, context: any): any {
-			return renderAgentToolCall(args, theme, context);
+			return agentToolRenderer.renderCall(args, theme, context);
 		},
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		renderResult(result: any, options: any, theme: any, context: any): any {
-			return renderAgentToolResult(result, options, theme, context);
+			try {
+				return agentToolRenderer.renderResult(result, options, theme, context);
+			} catch (e: any) {
+				return new Text('agent-err: ' + (e?.message ?? 'unknown'), 0, 0);
+			}
 		},
 	};
 

package/src/extension/registration/team-tool.ts

@@ -1,15 +1,16 @@
-import * as fs from "node:fs";
+import { statSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { loadConfig } from "../../config/config.ts";
 import { TeamToolParams, type TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import type { CrewWidgetState } from "../../ui/crew-widget.ts";
-import { updateCrewWidget } from "../../ui/crew-widget.ts";
+import type { CrewWidgetState } from "../../ui/widget/index.ts";
+import { updateCrewWidget } from "../../ui/widget/index.ts";
 import { updatePiCrewPowerbar } from "../../ui/powerbar-publisher.ts";
 import type { createManifestCache } from "../../runtime/manifest-cache.ts";
 import type { createRunSnapshotCache } from "../../ui/run-snapshot-cache.ts";
 import type { MetricRegistry } from "../../observability/metric-registry.ts";
 import { resolveRealContainedPath } from "../../utils/safe-paths.ts";
-import { renderTeamToolCall, renderTeamToolResult } from "../../ui/tool-render.ts";
+import { Text } from "@earendil-works/pi-tui";
+import { teamToolRenderer, statusIcon } from "../../ui/tool-renderers/index.ts";
 // Team tool handler — lazy-loaded because team-tool.ts imports many modules
 import type { handleTeamTool as HandleTeamToolFn } from "../team-tool.ts";
 let _cachedHandleTeamTool: typeof HandleTeamToolFn | undefined;
@@ -48,7 +49,7 @@ export function resolveCwdOverride(baseCwd: string, override: string | undefined
 	if (!override) return { ok: true, cwd: baseCwd };
 	try {
 		const resolved = resolveRealContainedPath(baseCwd, override);
-		const stat = fs.statSync(resolved);
+		const stat = statSync(resolved);
 		if (!stat.isDirectory()) return { ok: false, error: `cwd override is not a directory: ${resolved}` };
 		return { ok: true, cwd: resolved };
 	} catch (error) {
@@ -107,11 +108,15 @@ export function registerTeamTool(pi: ExtensionAPI, deps: RegisterTeamToolDeps):
 		},
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		renderCall(args: any, theme: any, context: any): any {
-			return renderTeamToolCall(args, theme, context);
+			return teamToolRenderer.renderCall(args, theme, context);
 		},
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		renderResult(result: any, options: any, theme: any, context: any): any {
-			return renderTeamToolResult(result, options, theme, context);
+			try {
+				return teamToolRenderer.renderResult(result, options, theme, context);
+			} catch {
+				return new Text(statusIcon("completed", theme) + " done", 0, 0);
+			}
 		},
 	};
 	pi.registerTool(tool);
@@ -133,13 +138,15 @@ function startTeamToolProgressBinder(onUpdate: OnUpdate | undefined): TeamToolPr
 		try {
 			if (!cwd || !runId) {
 				const elapsed = Math.max(0, Math.round((Date.now() - startedAt) / 1000));
-				onUpdate({ content: [{ type: "text", text: `team status=starting elapsed=${elapsed}s` }] });
+				const msg = `team status=starting elapsed=${elapsed}s`;
+				onUpdate({ content: [{ type: "text", text: msg }] });
 				return;
 			}
-			const loaded = loadRunManifestById(cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
+			const loaded = loadRunManifestById(cwd, runId);
 			if (!loaded) {
 				const elapsed = Math.max(0, Math.round((Date.now() - startedAt) / 1000));
-				onUpdate({ content: [{ type: "text", text: `team run=${runId} elapsed=${elapsed}s (manifest pending)` }] });
+				const msg = `team run=${runId} elapsed=${elapsed}s (manifest pending)`;
+				onUpdate({ content: [{ type: "text", text: msg }] });
 				return;
 			}
 			let agents;
@@ -162,7 +169,7 @@ function startTeamToolProgressBinder(onUpdate: OnUpdate | undefined): TeamToolPr
 	const timer = setInterval(tick, TEAM_TOOL_PROGRESS_TICK_MS);
 	if (typeof timer.unref === "function") timer.unref();
 	return {
-		attach: (boundCwd, boundRunId) => { cwd = boundCwd; runId = boundRunId; tick(); },
+		attach: (boundCwd: string, boundRunId: string) => { cwd = boundCwd; runId = boundRunId; tick(); },
 		stop: () => clearInterval(timer),
 	};
 }

package/src/extension/team-tool/run.ts

@@ -254,6 +254,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		const asyncManifest = { ...effectiveManifest, async: { pid: spawned.pid, logPath: spawned.logPath, spawnedAt: new Date().toISOString() } };
 		atomicWriteJson(paths.manifestPath, asyncManifest);
 		void appendEventAsync(effectiveManifest.eventsPath, { type: "async.spawned", runId: effectiveManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });
+		ctx.onRunStarted?.(effectiveManifest.runId);
 		scheduleBackgroundEarlyExitGuard(resolvedCtx.cwd, effectiveManifest.runId, spawned.pid, spawned.logPath);
 		// Wait for the async run to complete and return actual results.
 		try {
@@ -341,7 +342,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			}
 
 			const runFailed = completed.manifest.status === "failed" || completed.manifest.status === "blocked";
-			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot }, runFailed);
+			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot, metrics }, runFailed);
 		} catch (waitError: unknown) {
 			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
 			return result(
@@ -474,7 +475,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			}
 
 			const runFailed = completed.manifest.status === "failed" || completed.manifest.status === "blocked";
-			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot }, runFailed);
+			return result(lines.join("\n"), { action: "run", status: runFailed ? "error" : "ok", runId: completed.manifest.runId, artifactsRoot: completed.manifest.artifactsRoot, metrics }, runFailed);
 		} catch (waitError: unknown) {
 			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
 			return result(
@@ -514,5 +515,5 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 				? "Experimental live-session worker execution was enabled."
 				: "Safe scaffold mode: child Pi workers were not launched because runtime.mode=scaffold or executeWorkers=false was configured.",
 	].join("\n");
-	return result(text, { action: "run", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
+	return result(text, { action: "run", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot, metrics: collectRunMetrics(resolvedCtx.cwd, executed.manifest.runId) }, executed.manifest.status === "failed");
 }

package/src/extension/team-tool-types.ts

@@ -10,6 +10,8 @@ export interface TeamToolDetails {
 	resumedIds?: string[];
 	retriedTaskIds?: string[];
 	mailboxIds?: string[];
+	/** Run metrics for compact display in TUI tool result rendering. */
+	metrics?: { taskCount?: number; completedCount?: number; totalTokens?: number; totalCost?: number; durationMs?: number; consistencyScore?: number };
 	/** Structured data for programmatic consumption (e.g. TUI widgets). */
 	data?: Record<string, unknown>;
 }

package/src/state/session-state-map.ts

@@ -0,0 +1,51 @@
+/**
+ * Session-scoped state container.
+ *
+ * Generic Map keyed by session ID. Used by widget, dashboard, and
+ * live-agent-manager to store per-session state without polluting globals.
+ *
+ * Inspired by @ayulab/pi-checkpoint SessionStateMap.
+ */
+export class SessionStateMap<T> {
+	private readonly map = new Map<string, T>();
+
+	getOrUndefined(sessionId: string): T | undefined {
+		return this.map.get(sessionId);
+	}
+
+	get(sessionId: string): T | undefined {
+		return this.map.get(sessionId);
+	}
+
+	set(sessionId: string, value: T): void {
+		this.map.set(sessionId, value);
+	}
+
+	has(sessionId: string): boolean {
+		return this.map.has(sessionId);
+	}
+
+	delete(sessionId: string): boolean {
+		return this.map.delete(sessionId);
+	}
+
+	clear(): void {
+		this.map.clear();
+	}
+
+	get size(): number {
+		return this.map.size;
+	}
+
+	entries(): IterableIterator<[string, T]> {
+		return this.map.entries();
+	}
+
+	values(): IterableIterator<T> {
+		return this.map.values();
+	}
+
+	keys(): IterableIterator<string> {
+		return this.map.keys();
+	}
+}

package/src/ui/powerbar-publisher.ts

@@ -10,7 +10,7 @@ import { listLiveAgents } from "../runtime/live-agent-manager.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import type { ManifestCache } from "../runtime/manifest-cache.ts";
 import type { RunSnapshotCache, RunUiSnapshot } from "./snapshot-types.ts";
-import { notificationBadge } from "./crew-widget.ts";
+import { notificationBadge } from "./widget/widget-formatters.ts";
 import { RenderCoalescer } from "./render-coalescer.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";

package/src/ui/status-colors.ts

@@ -1,6 +1,6 @@
 import type { CrewTheme, CrewThemeColor } from "./theme-adapter.ts";
 
-export type RunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "stopped" | "blocked" | (string & {});
+export type RunStatus = "queued" | "running" | "waiting" | "completed" | "failed" | "cancelled" | "stopped" | "blocked" | "stale" | "needs_attention" | (string & {});
 
 export function colorForStatus(status: RunStatus): CrewThemeColor {
 	switch (status) {
@@ -17,6 +17,8 @@ export function colorForStatus(status: RunStatus): CrewThemeColor {
 		case "blocked":
 		case "stopped":
 			return "warning";
+		case "needs_attention":
+			return "warning";
 		case "queued":
 		default:
 			return "dim";
@@ -42,6 +44,8 @@ export function iconForStatus(status: RunStatus, options?: { runningGlyph?: stri
 			return "◦";
 		case "blocked":
 			return "⏸";
+		case "needs_attention":
+			return "⚠";
 		default:
 			return "·";
 	}