pi-crew 0.6.3 → 0.7.1

package/src/extension/knowledge-injection.ts

@@ -0,0 +1,71 @@
+/**
+ * knowledge-injection.ts — Project knowledge that accumulates across runs (O4).
+ *
+ * ROADMAP Phase 1 / T1.3 ("downsized memory"): a deliberately minimal
+ * replacement for the deleted 244-LOC MemoryStore. Crews and the main
+ * session read `.crew/knowledge.md` and have it injected into the system
+ * prompt, so pi-crew "remembers" project context across runs.
+ *
+ * Philosophy (Round 6 stress-test): radically downsized. Just a Markdown
+ * file the user can edit, surfaced into every run. No vector DB, no
+ * embeddings, no graph. Simple = trustworthy.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { BeforeAgentStartEvent, ExtensionAPI } from "./pi-api.ts";
+import { projectCrewRoot } from "../utils/paths.ts";
+
+/** The knowledge file, relative to the project crew root. */
+export const KNOWLEDGE_FILENAME = "knowledge.md";
+/** Cap injected knowledge to avoid unbounded system-prompt growth. */
+const MAX_KNOWLEDGE_BYTES = 16_000;
+
+/** Resolve the knowledge file path for a cwd (may not exist yet). */
+export function knowledgePath(cwd: string): string {
+	return path.join(projectCrewRoot(cwd), KNOWLEDGE_FILENAME);
+}
+
+/** Read knowledge content, truncated to a safe size. "" if absent/empty. */
+export function readKnowledge(cwd: string): string {
+	try {
+		const p = knowledgePath(cwd);
+		if (!fs.existsSync(p)) return "";
+		let content = fs.readFileSync(p, "utf8").trim();
+		if (content.length > MAX_KNOWLEDGE_BYTES) {
+			content = `${content.slice(0, MAX_KNOWLEDGE_BYTES)}\n\n<!-- knowledge.md truncated at ${MAX_KNOWLEDGE_BYTES} bytes -->`;
+		}
+		return content;
+	} catch {
+		return "";
+	}
+}
+
+/** Build the injected prompt fragment (empty if no knowledge). */
+export function buildKnowledgeFragment(cwd: string): string {
+	const content = readKnowledge(cwd);
+	if (!content) return "";
+	return [
+		"",
+		"# Project knowledge (from .crew/knowledge.md)",
+		"The following project knowledge was captured by pi-crew from prior runs.",
+		"Use it to avoid repeating past mistakes and to respect project conventions.",
+		"You may update .crew/knowledge.md when you learn something durable.",
+		"",
+		content,
+	].join("\n");
+}
+
+/**
+ * Register the knowledge-injection hook. Appends project knowledge to the
+ * system prompt on every agent start (main session + each crew worker,
+ * since workers are child Pi processes that also fire before_agent_start).
+ */
+export function registerKnowledgeInjection(pi: ExtensionAPI): void {
+	pi.on("before_agent_start", (event: BeforeAgentStartEvent) => {
+		const options = (event as BeforeAgentStartEvent & { systemPromptOptions?: { cwd?: unknown } }).systemPromptOptions ?? {};
+		const cwd = typeof options.cwd === "string" ? options.cwd : process.cwd();
+		const fragment = buildKnowledgeFragment(cwd);
+		if (!fragment) return undefined;
+		return { systemPrompt: `${event.systemPrompt}${fragment}` };
+	});
+}

package/src/extension/pi-api.ts

@@ -0,0 +1,47 @@
+/**
+ * pi-api.ts — pi-crew's stable seam against the Pi extension API.
+ *
+ * PURPOSE (roadmap Phase 0 / Pillar 4 "Pi-Native, Protocol-Aware"):
+ * Centralize every symbol pi-crew imports from
+ * `@earendil-works/pi-coding-agent` so that:
+ *   1. The coupling surface is auditable in ONE file (8 symbols today).
+ *   2. A Pi API rename/restructure requires updating only this seam.
+ *   3. New code imports from here ("./pi-api") rather than the raw package,
+ *      establishing the indirection that hedges Pi-coupling risk.
+ *
+ * COUpling SURFACE (kept intentionally small — public extension API only):
+ *   - ExtensionAPI              the registration entry point (pi)
+ *   - ExtensionContext          per-event/session context (ctx)
+ *   - ExtensionCommandContext   slash-command context
+ *   - ToolDefinition            tool schema type
+ *   - defineTool                tool factory
+ *   - createBashTool            built-in bash tool (for custom tooling)
+ *   - AgentSessionEvent         session event type
+ *   - BeforeAgentStartEvent     pre-turn system-prompt hook event
+ *
+ * NEW code should `import { ExtensionAPI, ExtensionContext } from "./pi-api"`.
+ * Existing files may keep their direct imports; migrate opportunistically
+ * (no big-bang refactor — see roadmap Phase 0 T0.3/T0.4 notes).
+ *
+ * Note: these are TYPE-level re-exports (erased at runtime). Runtime coupling
+ * to Pi is via the `pi` and `ctx` objects passed by Pi's loader — that is
+ * unavoidable and correct (pi-crew IS a Pi extension). This seam documents
+ * and centralizes the type-level surface.
+ */
+export type {
+	ExtensionAPI,
+	ExtensionContext,
+	ExtensionCommandContext,
+	ToolDefinition,
+	AgentSessionEvent,
+	BeforeAgentStartEvent,
+} from "@earendil-works/pi-coding-agent";
+
+export { defineTool, createBashTool } from "@earendil-works/pi-coding-agent";
+
+/**
+ * The Pi package version pi-crew was built against. Used for diagnostics
+ * and to surface version-drift if Pi upgrades introduce breaking changes.
+ * Update this when bumping the pi-coding-agent dependency.
+ */
+export const BUILT_AGAINST_PI_VERSION = "0.79.3";

package/src/extension/register.ts

@@ -17,6 +17,7 @@ import {
 	stopAsyncRunNotifier,
 } from "./async-notifier.ts";
 import { registerAutonomousPolicy } from "./autonomous-policy.ts";
+import { registerKnowledgeInjection } from "./knowledge-injection.ts";
 import { registerCleanupHandler } from "./crew-cleanup.ts";
 import type { ScheduledJob } from "../runtime/scheduler.ts";
 import { clearHooksScoped } from "../hooks/registry.ts";
@@ -61,8 +62,9 @@ import {
 	type CrewWidgetState,
 	stopCrewWidget,
 	updateCrewWidget,
-} from "../ui/crew-widget.ts";
+} from "../ui/widget/index.ts";
 import { summarizeHeartbeats } from "../ui/heartbeat-aggregator.ts";
+import { deployBundledThemes } from "../ui/deploy-bundled-themes.ts";
 import {
 	requestRender,
 	setExtensionWidget,
@@ -187,6 +189,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	const disposeI18n = initI18n(pi);
 	resetTimings();
 	time("register:start");
+	// Deploy bundled themes (crew-dark, crew-dracula, etc.) to ~/.pi/agent/themes/
+	// so Pi's theme loader discovers them. Best-effort, idempotent.
+	deployBundledThemes();
 	const globalStore = globalThis as Record<string | symbol, unknown>;
 	const runtimeCleanupStoreKey = Symbol("__piCrewRuntimeCleanup");
 	const previousRuntimeCleanup = globalStore[runtimeCleanupStoreKey];
@@ -981,6 +986,8 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	};
 	time("register.policy");
 	registerAutonomousPolicy(pi);
+	registerKnowledgeInjection(pi);
+	time("register.knowledge");
 	time("register.rpc");
 	function getPiEvents():
 		| Parameters<typeof registerPiCrewRpc>[0]
@@ -1194,6 +1201,17 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 
 	pi.on("session_start", (_event, ctx) => {
 		runArtifactCleanup(ctx.cwd);
+
+		// Restore brief mode state from session entries
+		try {
+			const entries = ctx.sessionManager?.getEntries?.();
+			if (entries) {
+				import("../ui/tool-renderers/brief-mode.ts").then(({ restoreBriefState }) => {
+					restoreBriefState(entries);
+				}).catch(() => {/* non-critical */});
+			}
+		} catch { /* non-critical */ }
+
 		time("register.session-start");
 		cleanedUp = false;
 		sessionGeneration++;
@@ -1974,6 +1992,19 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 
 	registerCleanupHandler(pi);
 
+
+	// Resilient edit (Phase 2): OPT-IN via CREW_RESILIENT_EDIT=1.
+	// Wraps the native edit tool with the cascading replace() fallback so that
+	// slightly-wrong oldText (indentation drift, whitespace) still matches.
+	// Auto-disables if pi-diff is loaded (it has its own replace integration).
+	if (process.env.CREW_RESILIENT_EDIT === "1") {
+		import("../runtime/resilient-edit.ts")
+			.then(({ wrapEditWithResilientReplace }) => {
+				wrapEditWithResilientReplace(pi);
+			})
+			.catch(() => { /* non-critical */ });
+	}
+
 	registerTeamCommands(pi, {
 		startForegroundRun,
 		abortForegroundRun,

package/src/extension/registration/commands.ts

@@ -364,13 +364,52 @@ export function registerTeamCommands(pi: ExtensionAPI, deps: RegisterTeamCommand
 					} catch (error) {
 						ctx.ui.notify(`Failed to save: ${error instanceof Error ? error.message : String(error)}`, "error");
 					}
-				}, () => done(undefined));
+				}, () => done(undefined), async (action: string, value: unknown) => {
+					// Action callbacks (Pi theme switch) write to a different store
+					// than pi-crew config (e.g. ~/.pi/agent/settings.json).
+					try {
+						if (action === "piTheme" && typeof value === "string") {
+							// Live theme switch: ctx.ui.setTheme() swaps the global theme,
+							// persists it to settings.json, and triggers a UI redraw — no
+							// restart needed. Falls back to file-write + restart hint if
+							// the live API is unavailable (e.g. non-TUI mode).
+							if (typeof ctx.ui.setTheme === "function") {
+								const res = ctx.ui.setTheme(value);
+								if (res.success) {
+									ctx.ui.notify(`Theme: ${value} (applied live)`, "info");
+								} else {
+									const { setPiTheme } = await import("../../ui/theme-discovery.ts");
+									setPiTheme(value);
+									ctx.ui.notify(`Theme saved as '${value}' but failed to apply: ${res.error ?? "unknown"}. Restart Pi.`, "warning");
+								}
+							} else {
+								const { setPiTheme } = await import("../../ui/theme-discovery.ts");
+								setPiTheme(value);
+								ctx.ui.notify(`Pi theme set to '${value}'. Restart Pi to apply.`, "info");
+							}
+						}
+					} catch (error) {
+						ctx.ui.notify(`Failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+					}
+				});
 				return overlay;
 			}, { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } });
 			return;
 		}
 		const result = await handleTeamTool({ action: "settings", config: { args: args.trim() } }, teamCommandContext(ctx));
 		await notifyCommandResult(ctx, commandText(result));
+		// Live-switch hook: when the text subcommand 'theme <name>' succeeds,
+		// also apply the theme live via ctx.ui.setTheme() (no restart). The
+		// handler above only writes to settings.json.
+		const trimmed = args.trim();
+		if (trimmed.startsWith("theme ")) {
+			const themeName = trimmed.slice(6).trim();
+			if (themeName && typeof ctx.ui.setTheme === "function") {
+				const res = ctx.ui.setTheme(themeName);
+				if (res.success) ctx.ui.notify(`Theme: ${themeName} (applied live)`, "info");
+				else ctx.ui.notify(`Saved but live-switch failed: ${res.error ?? "unknown"}. Restart Pi.`, "warning");
+			}
+		}
 	},
 })
 
@@ -571,6 +610,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/compaction-guard.ts

@@ -12,6 +12,8 @@ const HARD_RATIO = 0.95;
 const DEFAULT_CONTEXT_WINDOW = 200_000;
 const MAX_ARTIFACT_INDEX_RUNS = 10;
 const MAX_ARTIFACT_INDEX_ITEMS = 80;
+/** Run statuses that mean the run is still in-flight and may need resuming. */
+const IN_FLIGHT_RUN_STATUSES = new Set(["queued", "planning", "running"]);
 
 function contextWindow(ctx: { model?: { contextWindow?: number } }): number {
 	const value = ctx.model?.contextWindow;
@@ -66,6 +68,99 @@ function formatCrewArtifactIndex(entries: CrewArtifactIndexEntry[]): string {
 	return lines.join("\n");
 }
 
+/**
+ * Collect in-flight (non-terminal) crew runs that must be resumable after
+ * compaction. These are runs the agent was actively working on or awaiting.
+ */
+export function collectInFlightRuns(cwd: string): TeamRunManifest[] {
+	return listRecentRuns(cwd, MAX_ARTIFACT_INDEX_RUNS).filter((run) =>
+		IN_FLIGHT_RUN_STATUSES.has(run.status),
+	);
+}
+
+/**
+ * Build an explicit resume directive that survives compaction. This is the
+ * core of O10 (compaction resilience): after compaction, the agent MUST know
+ * what crew tasks were in-flight and how to continue them.
+ */
+function formatResumeDirective(runs: TeamRunManifest[]): string {
+	if (!runs.length) return "";
+	const lines = [
+		"",
+		"# pi-crew in-flight task resume directive (CRITICAL — do not drop)",
+		"The following pi-crew runs were in progress when the context was compacted.",
+		"After compaction, you MUST continue these tasks — do NOT consider them finished.",
+	];
+	for (const run of runs) {
+		const wf = run.workflow ? `, workflow=${run.workflow}` : "";
+		lines.push(
+			`- runId=${run.runId} (status=${run.status}, team=${run.team}${wf}): ${run.goal}`,
+		);
+	}
+	lines.push("");
+	lines.push("To resume: call the `team` tool with action='status' to check progress, then");
+	lines.push("action='wait' (to join a still-running task) or action='summary' / action='get'");
+	lines.push("to retrieve results. If a task was mid-execution and the worker is still alive,");
+	lines.push("it continues independently — just re-attach. Do not restart completed work.");
+	return lines.join("\n");
+}
+
+/**
+ * Build a short continuation prompt for sendUserMessage. This is what actually
+ * makes the agent resume after compaction — Pi's threshold compaction does NOT
+ * auto-retry (it stops and waits for user input). By injecting this as a user
+ * message that triggers a turn, the agent automatically continues the in-flight
+ * crew task instead of stalling until the user types "continue".
+ */
+export function buildContinuationPrompt(runs: TeamRunManifest[]): string {
+	if (!runs.length) return "";
+	const lines = [
+		"[pi-crew] Context was compacted while crew tasks were still in-flight. Continue the work — do not wait for me.",
+	];
+	for (const run of runs) {
+		const wf = run.workflow ? `, workflow=${run.workflow}` : "";
+		lines.push(`- runId=${run.runId} (status=${run.status}, team=${run.team}${wf}): ${run.goal}`);
+	}
+	lines.push("");
+	lines.push("Resume: call `team` with action='status' to check progress, then action='wait' (join a running task), action='summary', or action='get' as appropriate. If a worker is still alive it continues independently — just re-attach. Do NOT restart completed work.");
+	return lines.join("\n");
+}
+
+/**
+ * Trigger automatic agent continuation after compaction. Fire-and-forget the
+ * promise — never block the compaction flow. The sendUserMessage type is
+ * declared `void` but the runtime returns a Promise (it triggers an agent turn).
+ */
+export function triggerContinuation(pi: ExtensionAPI, ctx: ExtensionContext, runs: TeamRunManifest[]): void {
+	if (!runs.length) return;
+	const prompt = buildContinuationPrompt(runs);
+	try {
+		const result = pi.sendUserMessage(prompt) as unknown;
+		Promise.resolve(result).catch(() => {
+			// best-effort: if continuation fails, at least notify
+			try {
+				ctx.ui.notify("pi-crew: auto-continuation after compaction failed — use team status to resume manually.", "warning");
+			} catch {
+				// swallow
+			}
+		});
+	} catch {
+		// best-effort
+	}
+}
+
+/** Combined customInstructions injected into proactive compaction summaries. */
+function buildCompactionInstructions(cwd: string): string {
+	const artifactIndex = collectCrewArtifactIndex(cwd);
+	const inFlight = collectInFlightRuns(cwd);
+	const parts = [
+		"Prioritize keeping pi-crew run state, task results, artifact references, run IDs, and next actions. Keep completed-task detail concise.",
+	];
+	if (artifactIndex.length > 0) parts.push(formatCrewArtifactIndex(artifactIndex));
+	if (inFlight.length > 0) parts.push(formatResumeDirective(inFlight));
+	return parts.join("\n");
+}
+
 export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompactionGuardOptions): void {
 	let pendingCompactReason: string | null = null;
 	let compactionInProgress = false;
@@ -73,18 +168,32 @@ export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompa
 	const startCompact = (ctx: ExtensionContext, reason: string): void => {
 		if (compactionInProgress) return;
 		compactionInProgress = true;
-		const artifactIndex = collectCrewArtifactIndex(ctx.cwd);
-		if (artifactIndex.length > 0) {
-			pi.appendEntry("crew:artifact-index", {
+		const customInstructions = buildCompactionInstructions(ctx.cwd);
+		// Append a durable resume entry so it appears in the post-compaction
+		// context regardless of how summarization treats customInstructions.
+		const inFlight = collectInFlightRuns(ctx.cwd);
+		if (inFlight.length > 0) {
+			pi.appendEntry("crew:resume-directive", {
 				reason,
 				createdAt: new Date().toISOString(),
-				artifacts: artifactIndex,
+				runs: inFlight.map((r) => ({
+					runId: r.runId,
+					status: r.status,
+					team: r.team,
+					workflow: r.workflow,
+					goal: r.goal,
+				})),
 			});
 		}
 		ctx.compact({
-			customInstructions: `Prioritize keeping pi-crew run state, task results, artifact references, run IDs, and next actions. Keep completed-task detail concise.${formatCrewArtifactIndex(artifactIndex)}`,
+			customInstructions,
 			onComplete: () => {
 				compactionInProgress = false;
+				// O10 FIX: Pi's threshold compaction does NOT auto-retry — it
+				// stops and waits for user input. Trigger automatic
+				// continuation so the agent resumes the in-flight crew task.
+				const runs = collectInFlightRuns(ctx.cwd);
+				triggerContinuation(pi, ctx, runs);
 				ctx.ui.notify(reason === "deferred" ? "Deferred compaction completed" : "Auto-compacted context during team run", "info");
 			},
 			onError: (error) => {
@@ -94,17 +203,49 @@ export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompa
 		});
 	};
 
-	// Phase 1.2: Always allow compaction to proceed.
-	// Previously this deferred compaction during foreground runs, but that prevented
-	// context-mode's PreCompact hook from running (which needs compaction to build resume snapshots).
-	// pi-crew state is preserved via customInstructions and artifactIndex appended above.
-	pi.on("session_before_compact", async (_event, ctx) => {
-		// Always allow compaction - context-mode needs it for resume snapshots
+	// Allow compaction to proceed. pi-crew state is preserved via the
+	// customInstructions + resume-directive entry appended in startCompact,
+	// and re-injected post-compaction by the session_compact handler below.
+	pi.on("session_before_compact", async (_event, _ctx) => {
 		return;
 	});
 
-	// Phase 2.1: Proactive compaction with dynamic threshold.
-	// Only trigger compaction when context usage >=75%, or when deferred from a previous high-usage turn.
+	// O10: After ANY compaction (proactive OR reactive/Pi-triggered), detect
+	// in-flight crew runs and trigger automatic continuation. This is the
+	// critical fix: Pi's threshold compaction does NOT auto-retry — it stops
+	// and waits for user input. By injecting a continuation user message that
+	// triggers a turn, the agent automatically resumes the in-flight crew task.
+	// This covers the common case where Pi auto-compacts without going through
+	// our proactive startCompact path.
+	pi.on("session_compact", (_event, ctx) => {
+		try {
+			const inFlight = collectInFlightRuns(ctx.cwd);
+			if (inFlight.length === 0) return;
+			// Re-append the resume directive entry for durable record.
+			pi.appendEntry("crew:resume-directive", {
+				reason: "post-compaction-continuation",
+				createdAt: new Date().toISOString(),
+				runs: inFlight.map((r) => ({
+					runId: r.runId,
+					status: r.status,
+					team: r.team,
+					workflow: r.workflow,
+					goal: r.goal,
+				})),
+			});
+			ctx.ui.notify(
+				`Context compacted. ${inFlight.length} pi-crew run(s) still in-flight — auto-resuming.`,
+				"info",
+			);
+			// THE FIX: trigger automatic continuation. Without this, Pi stops
+			// after threshold compaction and the user must type "continue".
+			triggerContinuation(pi, ctx, inFlight);
+		} catch {
+			// best-effort: never block compaction completion
+		}
+	});
+
+	// Proactive compaction with dynamic threshold.
 	pi.on("turn_end", (_event, ctx) => {
 		if (compactionInProgress) return;
 		const hasActiveForeground = options.foregroundControllers.size > 0 || options.foregroundTeamRunControllers.size > 0;
@@ -112,7 +253,6 @@ export function registerCompactionGuard(pi: ExtensionAPI, options: RegisterCompa
 		// If deferred compaction is pending and foreground just ended, check if still needed
 		if (!hasActiveForeground && pendingCompactReason) {
 			pendingCompactReason = null;
-			// Only compact if ratio still >= TRIGGER_RATIO, otherwise skip
 			if (ratio === undefined || ratio < TRIGGER_RATIO) return;
 			startCompact(ctx, "deferred");
 			return;

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),
 	};
 }