pi-crew 0.6.1 → 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

@@ -154,7 +154,7 @@ function teamCommandContext(ctx: ExtensionCommandContext): ExtensionCommandConte
 }
 
 async function handleHealthDashboardAction(ctx: ExtensionCommandContext, selection: RunDashboardSelection): Promise<void> {
-	const loaded = loadRunManifestById(ctx.cwd, selection.runId);
+	const loaded = loadRunManifestById(ctx.cwd, selection.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) {
 		depsNotify(ctx, `Run '${selection.runId}' not found.`, "error");
 		return;
@@ -379,7 +379,7 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 	pi.registerCommand("team-result", { description: "Open a pi-crew agent result viewer: <runId> [taskId]", handler: async (args: string, ctx: ExtensionCommandContext) => {
 		const [runId, rawTaskId] = args.trim().split(/\s+/).filter(Boolean);
 		const selected = await selectAgentTask(ctx, runId, rawTaskId);
-		const loaded = selected ? loadRunManifestById(ctx.cwd, selected.runId) : undefined;
+		const loaded = selected ? loadRunManifestById(ctx.cwd, selected.runId) : undefined; // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 		if (ctx.hasUI && loaded) {
 			const agent = readCrewAgents(loaded.manifest).find((item) => item.taskId === selected?.taskId || item.id === selected?.taskId) ?? readCrewAgents(loaded.manifest)[0];
 			const resultText = agent?.resultArtifactPath ? commandText(await handleTeamTool({ action: "api", runId: selected?.runId ?? "", config: { operation: "read-agent-output", agentId: agent.taskId, maxBytes: 64_000 } }, teamCommandContext(ctx))) : "(no result)";
@@ -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-helpers.ts

@@ -34,7 +34,7 @@ export function sendAgentWakeUp(pi: ExtensionAPI, content: string): boolean {
 
 export function refreshPersistedSubagentRecord(ctx: ExtensionContext | ExtensionCommandContext, record: SubagentRecord): SubagentRecord {
 	if (!record.runId) return record;
-	const loaded = loadRunManifestById(ctx.cwd, record.runId);
+	const loaded = loadRunManifestById(ctx.cwd, record.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return record;
 	if (loaded.manifest.status === "completed" || loaded.manifest.status === "failed" || loaded.manifest.status === "cancelled" || loaded.manifest.status === "blocked") {
 		const refreshed = {
@@ -65,7 +65,7 @@ export function formatSubagentRecord(record: SubagentRecord): string {
 
 export function readSubagentRunResult(ctx: ExtensionContext | ExtensionCommandContext, record: SubagentRecord): string | undefined {
 	if (!record.runId) return record.result;
-	const loaded = loadRunManifestById(ctx.cwd, record.runId);
+	const loaded = loadRunManifestById(ctx.cwd, record.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	const task = loaded?.tasks.find((item) => item.resultArtifact) ?? loaded?.tasks[0];
 	const artifactPath = task?.resultArtifact?.path;
 	if (!artifactPath || !loaded) return undefined;

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);
+			}
 		},
 	};
 
@@ -204,7 +209,7 @@ function startAgentToolProgress(cwd: string, agentRecordId: string, onUpdate: On
 			let tasks;
 			let agents;
 			if (record.runId) {
-				const loaded = loadRunManifestById(cwd, record.runId);
+				const loaded = loadRunManifestById(cwd, record.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 				if (loaded) {
 					manifest = loaded.manifest;
 					tasks = loaded.tasks;

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);
 			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/registration/viewers.ts

@@ -23,7 +23,7 @@ async function getViewer(): Promise<typeof DurableTranscriptViewerType> {
 export async function selectAgentTask(ctx: ExtensionCommandContext, runId: string | undefined, taskId?: string): Promise<{ runId: string; taskId?: string } | undefined> {
 	if (!runId) return undefined;
 	if (taskId) return { runId, taskId };
-	const loaded = loadRunManifestById(ctx.cwd, runId);
+	const loaded = loadRunManifestById(ctx.cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return { runId };
 	const agents = readCrewAgents(loaded.manifest);
 	if (ctx.hasUI && agents.length > 1) {
@@ -39,7 +39,7 @@ export async function openTranscriptViewer(ctx: ExtensionCommandContext, initial
 	const runId = selected.runId;
 	const taskId = selected.taskId;
 	if (!runId || !ctx.hasUI) return false;
-	const loaded = loadRunManifestById(ctx.cwd, runId);
+	const loaded = loadRunManifestById(ctx.cwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return false;
 	const uiConfig = loadConfig(ctx.cwd).config.ui;
 	const DurableTranscriptViewer = await getViewer();

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

@@ -92,7 +92,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 	if (!params.runId) return result("API requires runId.", { action: "api", status: "error" }, true);
 	const runCwd = locateRunCwd(params.runId, ctx.cwd);
 	if (!runCwd) return result(`Run '${params.runId}' not found.`, { action: "api", status: "error" }, true);
-	const loaded = loadRunManifestById(runCwd, params.runId);
+	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "api", status: "error" }, true);
 	if (operation === "read-manifest") {
 		return result(JSON.stringify(loaded.manifest, null, 2), { action: "api", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
@@ -102,7 +102,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 		if (!permission.allowed) return result(permission.reason ?? "Plan approval is not allowed in this context.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 		try {
 			return withRunLockSync(loaded.manifest, () => {
-				const current = loadRunManifestById(ctx.cwd, loaded.manifest.runId) ?? loaded;
+				const current = loadRunManifestById(ctx.cwd, loaded.manifest.runId) ?? loaded; // NOTE: inside withRunLockSync - consistent read
 				const approval = current.manifest.planApproval;
 				if (!approval?.required || approval.status !== "pending") return result("Run has no pending plan approval request.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 				const now = new Date().toISOString();
@@ -121,7 +121,7 @@ export async function handleApi(params: TeamToolParamsValue, ctx: TeamContext):
 		if (!permission.allowed) return result(permission.reason ?? "Plan approval cancellation is not allowed in this context.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 		try {
 			return withRunLockSync(loaded.manifest, () => {
-				const current = loadRunManifestById(ctx.cwd, loaded.manifest.runId) ?? loaded;
+				const current = loadRunManifestById(ctx.cwd, loaded.manifest.runId) ?? loaded; // NOTE: inside withRunLockSync - consistent read
 				const approval = current.manifest.planApproval;
 				if (!approval?.required || approval.status !== "pending") return result("Run has no pending plan approval request.", { action: "api", status: "error", runId: loaded.manifest.runId }, true);
 				const now = new Date().toISOString();

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

@@ -41,7 +41,7 @@ export function abortOwned(
 ): AbortOwnedResult {
 	const runCwd = locateRunCwd(runId, ctx.cwd);
 	if (!runCwd) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
-	const loaded = loadRunManifestById(runCwd, runId);
+	const loaded = loadRunManifestById(runCwd, runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
 
 	const result: AbortOwnedResult = { abortedIds: [], missingIds: [], foreignIds: [] };
@@ -81,7 +81,7 @@ export async function handleRetry(params: TeamToolParamsValue, ctx: TeamContext,
 	if (!params.runId) return result("Retry requires runId.", { action: "retry", status: "error" }, true);
 	const runCwd = locateRunCwd(params.runId, ctx.cwd);
 	if (!runCwd) return result(`Run '${params.runId}' not found.`, { action: "retry", status: "error" }, true);
-	const loaded = loadRunManifestById(runCwd, params.runId);
+	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "retry", status: "error" }, true);
 
 	// Pre-lock ownership check: reject foreign-owned runs unless force is set
@@ -146,7 +146,7 @@ export async function handleCancel(params: TeamToolParamsValue, ctx: TeamContext
 	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
 	const runCwd = locateRunCwd(params.runId, ctx.cwd);
 	if (!runCwd) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
-	const loaded = loadRunManifestById(runCwd, params.runId);
+	const loaded = loadRunManifestById(runCwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
 
 	// Pre-lock ownership check: reject foreign-owned runs unless force is set

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

@@ -209,7 +209,7 @@ export function handleExplain(params: {
     return result("explain requires runId", { action: "explain", status: "error" }, true);
   }
 
-  const loaded = loadRunManifestById(cwd, params.runId);
+  const loaded = loadRunManifestById(cwd, params.runId); // NOTE: no withRunLock - best-effort only; concurrent writes may cause inconsistency
   if (!loaded) {
     return result(`Run '${params.runId}' not found.`, { action: "explain", status: "error" }, true);
   }