pi-crew 0.1.15 → 0.1.17

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.1.17
+
+- Fixed terminal/completed workers being incorrectly escalated as stale heartbeat blockers after all tasks completed.
+- Cleaned child-process result extraction so result artifacts prefer final assistant output and no longer include worker prompt/context.
+- Made `/team-dashboard` visibly render as a top-right sidebar by default with explicit right-sidebar title text.
+- Added per-subagent model and usage fields to agent records, status output, and dashboard fallbacks so model/token totals stay visible while and after workers run.
+
+## 0.1.16
+
+- Added right-side `/team-dashboard` placement with model, token, and tool detail rows for subagents.
+- Added UI config for dashboard placement/width and model/token/tool visibility.
+- Foreground child-process runs now continue without blocking the interactive chat and remain tied to session shutdown.
+- Child-process observability now drops noisy `message_update`/encrypted thinking deltas and stores compact events to prevent massive JSONL/output logs from freezing sessions.
+- Cancel now syncs agent records and writes a foreground interrupt request so queued/running agents stop appearing stale.
+
 ## 0.1.15
 
 - Child-process model selection now uses Pi-configured/available models and auto-discovers provider/model entries from Pi settings/models config.

package/README.md

@@ -169,11 +169,26 @@ Supported config:
   "ui": {
     "widgetPlacement": "aboveEditor",
     "widgetMaxLines": 8,
-    "powerbar": true
+    "powerbar": true,
+    "dashboardPlacement": "right",
+    "dashboardWidth": 52,
+    "showModel": true,
+    "showTokens": true,
+    "showTools": true
   }
 }
 ```
 
+Safety notes:
+
+- Foreground child-process runs continue in the Pi extension process and return control to chat immediately, so large workflows do not block the interactive session. They are interrupted on session shutdown. Use `async: true` only for intentionally detached runs that may survive the current session.
+
+UI notes:
+
+- `widgetPlacement`/`widgetMaxLines` keep the persistent active-run widget compact.
+- `dashboardPlacement: "right"` opens `/team-dashboard` as a right-side overlay panel instead of a centered modal.
+- `showModel`, `showTokens`, and `showTools` show worker model attempts, token usage, and tool activity in dashboard agent rows.
+
 Show config:
 
 ```text

package/docs/usage.md

@@ -32,7 +32,12 @@ Supported fields:
   "ui": {
     "widgetPlacement": "aboveEditor",
     "widgetMaxLines": 8,
-    "powerbar": true
+    "powerbar": true,
+    "dashboardPlacement": "right",
+    "dashboardWidth": 52,
+    "showModel": true,
+    "showTokens": true,
+    "showTools": true
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/schema.json

@@ -86,7 +86,12 @@
       "properties": {
         "widgetPlacement": { "type": "string", "enum": ["aboveEditor", "belowEditor"] },
         "widgetMaxLines": { "type": "integer", "minimum": 1, "maximum": 50 },
-        "powerbar": { "type": "boolean" }
+        "powerbar": { "type": "boolean" },
+        "dashboardPlacement": { "type": "string", "enum": ["center", "right"], "description": "Place /team-dashboard as a centered overlay or right-side panel." },
+        "dashboardWidth": { "type": "integer", "minimum": 32, "maximum": 120 },
+        "showModel": { "type": "boolean", "description": "Show worker model attempts in dashboard agent rows." },
+        "showTokens": { "type": "boolean", "description": "Show token usage in dashboard agent rows." },
+        "showTools": { "type": "boolean", "description": "Show tool activity in dashboard agent rows." }
       }
     }
   }

package/src/config/config.ts

@@ -51,6 +51,11 @@ export interface CrewUiConfig {
 	widgetPlacement?: "aboveEditor" | "belowEditor";
 	widgetMaxLines?: number;
 	powerbar?: boolean;
+	dashboardPlacement?: "center" | "right";
+	dashboardWidth?: number;
+	showModel?: boolean;
+	showTokens?: boolean;
+	showTools?: boolean;
 }
 
 export interface AgentOverrideConfig {
@@ -309,6 +314,11 @@ function parseUiConfig(value: unknown): CrewUiConfig | undefined {
 		widgetPlacement: obj.widgetPlacement === "aboveEditor" || obj.widgetPlacement === "belowEditor" ? obj.widgetPlacement : undefined,
 		widgetMaxLines: parsePositiveInteger(obj.widgetMaxLines, 50),
 		powerbar: typeof obj.powerbar === "boolean" ? obj.powerbar : undefined,
+		dashboardPlacement: obj.dashboardPlacement === "center" || obj.dashboardPlacement === "right" ? obj.dashboardPlacement : undefined,
+		dashboardWidth: parsePositiveInteger(obj.dashboardWidth, 120),
+		showModel: typeof obj.showModel === "boolean" ? obj.showModel : undefined,
+		showTokens: typeof obj.showTokens === "boolean" ? obj.showTokens : undefined,
+		showTools: typeof obj.showTools === "boolean" ? obj.showTools : undefined,
 	};
 	return Object.values(ui).some((entry) => entry !== undefined) ? ui : undefined;
 }

package/src/extension/register.ts

@@ -7,7 +7,7 @@ import { notifyActiveRuns } from "./session-summary.ts";
 import { piTeamsHelp } from "./help.ts";
 import { handleTeamManagerCommand } from "./team-manager-command.ts";
 import { handleTeamTool, type TeamToolDetails } from "./team-tool.ts";
-import { listRuns } from "./run-index.ts";
+import { listRecentRuns } from "./run-index.ts";
 import { RunDashboard, type RunDashboardSelection } from "../ui/run-dashboard.ts";
 import { registerPiCrewRpc, type PiCrewRpcHandle } from "./cross-extension-rpc.ts";
 import { stopCrewWidget, updateCrewWidget, type CrewWidgetState } from "../ui/crew-widget.ts";
@@ -112,6 +112,25 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	let cleanedUp = false;
 	const widgetState: CrewWidgetState = { frame: 0 };
 	const foregroundControllers = new Set<AbortController>();
+	const startForegroundRun = (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>): void => {
+		const controller = new AbortController();
+		foregroundControllers.add(controller);
+		setImmediate(() => {
+			void runner(controller.signal)
+				.catch((error) => {
+					const message = error instanceof Error ? error.message : String(error);
+					ctx.ui.notify(`pi-crew foreground run failed: ${message}`, "error");
+				})
+				.finally(() => {
+					foregroundControllers.delete(controller);
+					if (currentCtx) {
+						const config = loadConfig(currentCtx.cwd).config.ui;
+						updateCrewWidget(currentCtx, widgetState, config);
+						updatePiCrewPowerbar(pi.events, currentCtx.cwd, config);
+					}
+				});
+		});
+	};
 	registerAutonomousPolicy(pi);
 	rpcHandle = registerPiCrewRpc((pi as unknown as { events?: Parameters<typeof registerPiCrewRpc>[0] }).events, () => currentCtx);
 	const cleanupRuntime = (): void => {
@@ -163,7 +182,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			const abort = (): void => controller.abort();
 			signal?.addEventListener("abort", abort, { once: true });
 			try {
-				const output = await handleTeamTool(params as TeamToolParamsValue, { ...ctx, signal: controller.signal });
+				const output = await handleTeamTool(params as TeamToolParamsValue, { ...ctx, signal: controller.signal, startForegroundRun: (runner) => startForegroundRun(ctx, runner) });
 				const config = loadConfig(ctx.cwd).config.ui;
 				updateCrewWidget(ctx, widgetState, config);
 				updatePiCrewPowerbar(pi.events, ctx.cwd, config);
@@ -188,7 +207,7 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	pi.registerCommand("team-run", {
 		description: "Manually start a pi-crew run (agent may also use the team tool autonomously)",
 		handler: async (args: string, ctx: ExtensionCommandContext) => {
-			const result = await handleTeamTool(parseRunArgs(args), ctx);
+			const result = await handleTeamTool(parseRunArgs(args), { ...ctx, startForegroundRun: (runner) => startForegroundRun(ctx as ExtensionContext, runner) });
 			await notifyCommandResult(ctx, commandText(result));
 		},
 	});
@@ -362,10 +381,15 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		description: "Open a pi-crew run dashboard overlay",
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
 			for (;;) {
-				const runs = listRuns(ctx.cwd).slice(0, 50);
-				const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, theme, _keybindings, done) => new RunDashboard(runs, done, theme), {
+				const runs = listRecentRuns(ctx.cwd, 50);
+				const uiConfig = loadConfig(ctx.cwd).config.ui;
+				const rightPanel = uiConfig?.dashboardPlacement !== "center";
+				const width = rightPanel ? Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? 56)) : "90%";
+				const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, theme, _keybindings, done) => new RunDashboard(runs, done, theme, { placement: rightPanel ? "right" : "center", showModel: uiConfig?.showModel, showTokens: uiConfig?.showTokens, showTools: uiConfig?.showTools }), {
 					overlay: true,
-					overlayOptions: { width: "90%", maxHeight: "80%", anchor: "center" },
+					overlayOptions: rightPanel
+						? { width, minWidth: 40, maxHeight: "100%", anchor: "top-right", offsetX: 0, offsetY: 0, margin: { top: 0, right: 0, bottom: 0, left: 0 } }
+						: { width, maxHeight: "90%", anchor: "center", margin: 2 },
 				});
 				if (!selection) return;
 				if (selection.action === "reload") continue;

package/src/extension/run-index.ts

@@ -11,18 +11,34 @@ function readManifest(filePath: string): TeamRunManifest | undefined {
 	}
 }
 
-function collectRuns(root: string): TeamRunManifest[] {
+function collectRuns(root: string, maxEntries?: number): TeamRunManifest[] {
 	const runsRoot = path.join(root, "state", "runs");
 	if (!fs.existsSync(runsRoot)) return [];
-	return fs.readdirSync(runsRoot)
+	const entries = fs.readdirSync(runsRoot).sort((a, b) => b.localeCompare(a));
+	const selected = maxEntries !== undefined ? entries.slice(0, Math.max(0, maxEntries)) : entries;
+	return selected
 		.map((entry) => readManifest(path.join(runsRoot, entry, "manifest.json")))
 		.filter((manifest): manifest is TeamRunManifest => manifest !== undefined);
 }
 
-export function listRuns(cwd: string): TeamRunManifest[] {
-	const projectRuns = collectRuns(path.join(projectPiRoot(cwd), "teams"));
-	const userRuns = collectRuns(path.join(userPiRoot(), "extensions", "pi-crew", "runs"));
+function mergeRuns(userRuns: TeamRunManifest[], projectRuns: TeamRunManifest[], max?: number): TeamRunManifest[] {
 	const byId = new Map<string, TeamRunManifest>();
 	for (const run of [...userRuns, ...projectRuns]) byId.set(run.runId, run);
-	return [...byId.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	const sorted = [...byId.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+	return max !== undefined ? sorted.slice(0, Math.max(0, max)) : sorted;
+}
+
+export function listRuns(cwd: string): TeamRunManifest[] {
+	return mergeRuns(
+		collectRuns(path.join(userPiRoot(), "extensions", "pi-crew", "runs")),
+		collectRuns(path.join(projectPiRoot(cwd), "teams")),
+	);
+}
+
+export function listRecentRuns(cwd: string, max = 20): TeamRunManifest[] {
+	return mergeRuns(
+		collectRuns(path.join(userPiRoot(), "extensions", "pi-crew", "runs"), max),
+		collectRuns(path.join(projectPiRoot(cwd), "teams"), max),
+		max,
+	);
 }

package/src/extension/team-tool.ts

@@ -35,7 +35,7 @@ import { formatValidationReport, validateResources } from "./validate-resources.
 import { formatRecommendation, recommendTeam } from "./team-recommendation.ts";
 import { toolResult, type PiTeamsToolResult } from "./tool-result.ts";
 import { touchWorkerHeartbeat } from "../runtime/worker-heartbeat.ts";
-import { agentEventsPath, agentOutputPath, readCrewAgentEvents, readCrewAgentEventsCursor, readCrewAgentStatus, readCrewAgents } from "../runtime/crew-agent-records.ts";
+import { agentEventsPath, agentOutputPath, readCrewAgentEvents, readCrewAgentEventsCursor, readCrewAgentStatus, readCrewAgents, recordFromTask, saveCrewAgents } from "../runtime/crew-agent-records.ts";
 import { resolveCrewRuntime } from "../runtime/runtime-resolver.ts";
 import { probeLiveSessionRuntime } from "../runtime/live-session-runtime.ts";
 import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../runtime/agent-control.ts";
@@ -57,6 +57,7 @@ type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext
 	sessionManager?: { getBranch?: () => unknown[] };
 	events?: { emit?: (event: string, data: unknown) => void };
 	signal?: AbortSignal;
+	startForegroundRun?: (runner: (signal?: AbortSignal) => Promise<void>) => void;
 };
 
 function result(text: string, details: TeamToolDetails, isError = false): PiTeamsToolResult {
@@ -307,6 +308,24 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const runtime = await resolveCrewRuntime(effectiveRunConfig(loadedConfig.config, params.config));
 	const executeWorkers = runtime.kind === "child-process";
 	const executedConfig = effectiveRunConfig(loadedConfig.config, params.config);
+	if (executeWorkers && ctx.startForegroundRun) {
+		ctx.startForegroundRun(async (signal) => {
+			await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal });
+		});
+		const text = [
+			`Started foreground pi-crew run ${updatedManifest.runId}.`,
+			`Team: ${team.name}`,
+			`Workflow: ${workflow.name}`,
+			"Status: running",
+			`Tasks: ${tasks.length}`,
+			`Runtime: ${runtime.kind}`,
+			`State: ${updatedManifest.stateRoot}`,
+			`Artifacts: ${updatedManifest.artifactsRoot}`,
+			"",
+			"The run continues in this Pi session without blocking the chat. It will be interrupted on session shutdown. Use /team-dashboard or /team-status to watch it.",
+		].join("\n");
+		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot });
+	}
 	const executed = await executeTeamRun({ manifest: updatedManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal });
 	const text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
@@ -365,7 +384,7 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		...(tasks.length ? tasks.map((task) => `- ${task.id} [${task.status}] ${task.role} -> ${task.agent}${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.modelAttempts?.length ? ` attempts=${task.modelAttempts.length}` : ""}${task.jsonEvents !== undefined ? ` jsonEvents=${task.jsonEvents}` : ""}${task.usage ? ` usage=${JSON.stringify(task.usage)}` : ""}${task.worktree ? ` worktree=${task.worktree.path}` : ""}${task.error ? ` error=${task.error}` : ""}`) : ["- (none)"]),
 		`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
 		"Agents:",
-		...(crewAgents.length ? crewAgents.map((agent) => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.progress?.activityState === "needs_attention" ? " needs_attention" : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`) : ["- (none)"]),
+		...(crewAgents.length ? crewAgents.map((agent) => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.model ? ` model=${agent.model}` : ""}${agent.usage ? ` usage=${formatUsage(agent.usage)}` : ""}${agent.progress?.activityState === "needs_attention" ? " needs_attention" : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${!agent.usage && agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`) : ["- (none)"]),
 		"Policy decisions:",
 		...(manifest.policyDecisions?.length ? manifest.policyDecisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`) : ["- (none)"]),
 		`Total usage: ${formatUsage(totalUsage)}`,
@@ -409,6 +428,8 @@ export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		}
 		const tasks = loaded.tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: "Run cancelled by user request." } : task);
 		saveRunTasks(loaded.manifest, tasks);
+		try { saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process"))); } catch {}
+		try { writeForegroundInterruptRequest(loaded.manifest, "Run cancelled by user request."); } catch {}
 		const updated = updateRunStatus(loaded.manifest, "cancelled", "Run cancelled by user request. Already-finished worker processes are not retroactively changed.");
 		return result(`Cancelled run ${updated.runId}.`, { action: "cancel", status: "ok", runId: updated.runId, artifactsRoot: updated.artifactsRoot });
 	});

package/src/runtime/child-pi.ts

@@ -8,8 +8,18 @@ import { getPiSpawnCommand } from "./pi-spawn.ts";
 const POST_EXIT_STDIO_GUARD_MS = 3000;
 const FINAL_DRAIN_MS = 5000;
 const HARD_KILL_MS = 3000;
+const MAX_CAPTURE_BYTES = 256 * 1024;
+const MAX_COMPACT_CONTENT_CHARS = 4096;
 const activeChildProcesses = new Map<number, ChildProcess>();
 
+function appendBoundedTail(current: string, chunk: string, maxBytes = MAX_CAPTURE_BYTES): string {
+	const combined = current + chunk;
+	if (Buffer.byteLength(combined, "utf-8") <= maxBytes) return combined;
+	let tail = combined.slice(Math.max(0, combined.length - maxBytes));
+	while (Buffer.byteLength(tail, "utf-8") > maxBytes) tail = tail.slice(1024);
+	return `[pi-crew captured output truncated to last ${Math.round(maxBytes / 1024)} KiB]\n${tail}`;
+}
+
 function killProcessTree(pid: number | undefined): void {
 	if (!pid || !Number.isInteger(pid) || pid <= 0) return;
 	try {
@@ -59,6 +69,80 @@ function appendTranscript(input: ChildPiRunInput, line: string): void {
 	fs.appendFileSync(input.transcriptPath, `${line}\n`, "utf-8");
 }
 
+function compactString(value: string, maxChars = MAX_COMPACT_CONTENT_CHARS): string {
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars)}\n[pi-crew compacted ${value.length - maxChars} chars]`;
+}
+
+function compactValue(value: unknown): unknown {
+	if (typeof value === "string") return compactString(value);
+	if (Array.isArray(value)) return value.slice(0, 20).map(compactValue);
+	const record = asRecord(value);
+	if (!record) return value;
+	const compacted: Record<string, unknown> = {};
+	for (const [key, entry] of Object.entries(record).slice(0, 20)) compacted[key] = compactValue(entry);
+	return compacted;
+}
+
+function compactContentPart(part: unknown): unknown | undefined {
+	const record = asRecord(part);
+	if (!record) return undefined;
+	if (record.type === "text") return { type: "text", text: typeof record.text === "string" ? compactString(record.text) : "" };
+	if (record.type === "toolCall") return { type: "toolCall", name: record.name, input: compactValue(record.input) };
+	if (record.type === "toolResult") return { type: "toolResult", name: record.name, content: compactValue(record.content) };
+	return undefined;
+}
+
+function compactChildPiEvent(event: unknown): unknown | undefined {
+	const record = asRecord(event);
+	if (!record) return undefined;
+	if (record.type === "message_update") return undefined;
+	if (record.type === "tool_execution_start" || record.type === "tool_execution_end") {
+		return { type: record.type, toolName: record.toolName, args: record.args };
+	}
+	if (record.type === "tool_result_end" || record.type === "message_end" || record.type === "message") {
+		const message = asRecord(record.message);
+		const content = Array.isArray(message?.content) ? message.content.map(compactContentPart).filter((part) => part !== undefined) : undefined;
+		return {
+			type: record.type,
+			...(typeof record.text === "string" ? { text: record.text } : {}),
+			...(message ? { message: { role: message.role, ...(content ? { content } : {}), usage: message.usage, model: message.model, errorMessage: message.errorMessage, stopReason: message.stopReason } } : {}),
+			usage: record.usage,
+			model: record.model,
+			provider: record.provider,
+			stopReason: record.stopReason,
+		};
+	}
+	return record.type ? { type: record.type } : undefined;
+}
+
+function displayTextFromCompactEvent(event: unknown): string | undefined {
+	const record = asRecord(event);
+	if (!record) return undefined;
+	if (record.type === "tool_execution_start") {
+		return typeof record.toolName === "string" ? `tool: ${record.toolName}` : "tool started";
+	}
+	if (record.type !== "message" && record.type !== "message_end") return undefined;
+	const message = asRecord(record.message);
+	if (message?.role !== undefined && message.role !== "assistant") return undefined;
+	const content = Array.isArray(message?.content) ? message.content : [];
+	const text = content.flatMap((part) => {
+		const item = asRecord(part);
+		return item?.type === "text" && typeof item.text === "string" ? [item.text] : [];
+	}).join("\n").trim();
+	return text || (typeof record.text === "string" ? record.text : undefined);
+}
+
+function compactChildPiLine(line: string): { persistedLine: string; event?: unknown; displayLine?: string; json: boolean } {
+	try {
+		const parsed = JSON.parse(line);
+		const compact = compactChildPiEvent(parsed);
+		return { json: true, event: compact, persistedLine: compact ? JSON.stringify(compact) : "", displayLine: displayTextFromCompactEvent(compact) };
+	} catch {
+		return { json: false, persistedLine: line, displayLine: line };
+	}
+}
+
 export class ChildPiLineObserver {
 	private buffer = "";
 	private readonly input: ChildPiRunInput;
@@ -83,13 +167,10 @@ export class ChildPiLineObserver {
 
 	private emitLine(line: string): void {
 		if (!line.trim()) return;
-		appendTranscript(this.input, line);
-		this.input.onStdoutLine?.(line);
-		try {
-			this.input.onJsonEvent?.(JSON.parse(line));
-		} catch {
-			// Raw stdout is allowed.
-		}
+		const compact = compactChildPiLine(line);
+		if (compact.event !== undefined) this.input.onJsonEvent?.(compact.event);
+		if (compact.persistedLine) appendTranscript(this.input, compact.persistedLine);
+		if (compact.displayLine?.trim()) this.input.onStdoutLine?.(compact.displayLine);
 	}
 }
 
@@ -156,6 +237,10 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			let forcedFinalDrain = false;
 			const lineObserver = new ChildPiLineObserver({
 				...input,
+				onStdoutLine: (line) => {
+					stdout = appendBoundedTail(stdout, `${line}\n`);
+					input.onStdoutLine?.(line);
+				},
 				onJsonEvent: (event) => {
 					input.onJsonEvent?.(event);
 					if (!isFinalAssistantEvent(event) || childExited || settled || finalDrainTimer) return;
@@ -202,12 +287,10 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 
 			input.signal?.addEventListener("abort", abort, { once: true });
 			child.stdout?.on("data", (chunk: Buffer) => {
-				const text = chunk.toString("utf-8");
-				stdout += text;
-				lineObserver.observe(text);
+				lineObserver.observe(chunk.toString("utf-8"));
 			});
 			child.stderr?.on("data", (chunk: Buffer) => {
-				stderr += chunk.toString("utf-8");
+				stderr = appendBoundedTail(stderr, chunk.toString("utf-8"));
 			});
 			child.on("error", (error) => {
 				settle({ exitCode: null, stdout, stderr, error: error.message });

package/src/runtime/crew-agent-records.ts

@@ -52,8 +52,13 @@ export function readCrewAgentStatus(manifest: TeamRunManifest, taskOrAgentId: st
 	return readJsonFile<CrewAgentRecord>(agentStatusPath(manifest, taskId));
 }
 
+const agentEventSeqCache = new Map<string, { size: number; mtimeMs: number; seq: number }>();
+
 function nextAgentEventSeq(filePath: string): number {
 	if (!fs.existsSync(filePath)) return 1;
+	const stat = fs.statSync(filePath);
+	const cached = agentEventSeqCache.get(filePath);
+	if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.seq + 1;
 	let max = 0;
 	for (const line of fs.readFileSync(filePath, "utf-8").split(/\r?\n/)) {
 		if (!line.trim()) continue;
@@ -65,13 +70,19 @@ function nextAgentEventSeq(filePath: string): number {
 			max += 1;
 		}
 	}
+	agentEventSeqCache.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: max });
 	return max + 1;
 }
 
 export function appendCrewAgentEvent(manifest: TeamRunManifest, taskId: string, event: unknown): void {
 	fs.mkdirSync(agentStateDir(manifest, taskId), { recursive: true });
 	const filePath = agentEventsPath(manifest, taskId);
-	fs.appendFileSync(filePath, `${JSON.stringify({ seq: nextAgentEventSeq(filePath), time: new Date().toISOString(), event })}\n`, "utf-8");
+	const seq = nextAgentEventSeq(filePath);
+	fs.appendFileSync(filePath, `${JSON.stringify({ seq, time: new Date().toISOString(), event })}\n`, "utf-8");
+	try {
+		const stat = fs.statSync(filePath);
+		agentEventSeqCache.set(filePath, { size: stat.size, mtimeMs: stat.mtimeMs, seq });
+	} catch {}
 }
 
 export interface CrewAgentEventCursorOptions {
@@ -113,6 +124,12 @@ export function emptyCrewAgentProgress(): CrewAgentProgress {
 	return { recentTools: [], recentOutput: [], toolCount: 0 };
 }
 
+function modelFromTask(task: TeamTaskState): string | undefined {
+	const attempts = task.modelAttempts;
+	if (!attempts?.length) return undefined;
+	return attempts.find((attempt) => attempt.success)?.model ?? attempts.at(-1)?.model;
+}
+
 export function recordFromTask(manifest: TeamRunManifest, task: TeamTaskState, runtime: CrewRuntimeKind): CrewAgentRecord {
 	return {
 		id: `${manifest.runId}:${task.id}`,
@@ -131,6 +148,8 @@ export function recordFromTask(manifest: TeamRunManifest, task: TeamTaskState, r
 		outputPath: agentOutputPath(manifest, task.id),
 		toolUses: task.agentProgress?.toolCount,
 		jsonEvents: task.jsonEvents,
+		model: modelFromTask(task),
+		usage: task.usage,
 		progress: task.agentProgress,
 		error: task.error,
 	};

package/src/runtime/crew-agent-runtime.ts

@@ -1,4 +1,5 @@
 import type { TeamTaskStatus } from "../state/contracts.ts";
+import type { UsageState } from "../state/types.ts";
 
 export type CrewRuntimeKind = "scaffold" | "child-process" | "live-session";
 export type CrewAgentStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "stopped";
@@ -41,6 +42,8 @@ export interface CrewAgentRecord {
 	outputPath?: string;
 	toolUses?: number;
 	jsonEvents?: number;
+	model?: string;
+	usage?: UsageState;
 	progress?: CrewAgentProgress;
 	error?: string;
 }

package/src/runtime/pi-json-output.ts

@@ -72,13 +72,14 @@ function textFromContent(content: unknown): string[] {
 function extractText(value: unknown): string[] {
 	const obj = asRecord(value);
 	if (!obj) return [];
+	const message = asRecord(obj.message);
+	if (message?.role !== undefined && message.role !== "assistant") return [];
 	const text: string[] = [];
 	if (typeof obj.text === "string") text.push(obj.text);
 	if (typeof obj.output === "string") text.push(obj.output);
 	if (typeof obj.finalOutput === "string") text.push(obj.finalOutput);
 	if (typeof obj.final_output === "string") text.push(obj.final_output);
-	text.push(...textFromContent(obj.content));
-	const message = asRecord(obj.message);
+	if (!message) text.push(...textFromContent(obj.content));
 	if (message) text.push(...textFromContent(message.content));
 	return text.filter((entry) => entry.trim().length > 0);
 }

package/src/runtime/policy-engine.ts

@@ -56,7 +56,7 @@ export function evaluateCrewPolicy(input: PolicyEngineInput): PolicyDecision[] {
 			const maxRetries = input.limits?.maxRetriesPerTask ?? 0;
 			decisions.push(decision(retryCount < maxRetries ? "retry" : "escalate", "task_failed", task.error ? `Task failed: ${task.error}` : "Task failed.", task.id));
 		}
-		if (task.heartbeat && isWorkerHeartbeatStale(task.heartbeat, input.limits?.heartbeatStaleMs ?? 60_000, input.now)) {
+		if ((task.status === "running" || task.status === "queued") && task.heartbeat && task.heartbeat.alive !== false && isWorkerHeartbeatStale(task.heartbeat, input.limits?.heartbeatStaleMs ?? 60_000, input.now)) {
 			decisions.push(decision("escalate", "worker_stale", "Worker heartbeat is stale.", task.id));
 		}
 		if (task.taskPacket?.verification) {

package/src/runtime/task-runner.ts

@@ -185,6 +185,35 @@ function applyUsageToProgress(progress: CrewAgentProgress | undefined, usage: Us
 	};
 }
 
+function shouldFlushProgressEvent(event: unknown): boolean {
+	const type = asRecord(event)?.type;
+	return type === "tool_execution_start" || type === "tool_execution_end" || type === "message_end" || type === "tool_result_end";
+}
+
+function cleanResultText(text: string | undefined): string | undefined {
+	const trimmed = text?.trim();
+	if (!trimmed) return undefined;
+	const doneIndex = trimmed.lastIndexOf("\nDONE\n");
+	if (doneIndex >= 0) return trimmed.slice(doneIndex + 1).trim();
+	if (trimmed === "DONE" || trimmed.startsWith("DONE\n")) return trimmed;
+	const fencedPromptIndex = trimmed.lastIndexOf("</file>");
+	if (fencedPromptIndex >= 0 && fencedPromptIndex < trimmed.length - 7) return trimmed.slice(fencedPromptIndex + 7).trim() || trimmed;
+	return trimmed;
+}
+
+function progressEventSummary(task: TeamTaskState, event: unknown): Record<string, unknown> {
+	const type = asRecord(event)?.type;
+	return {
+		eventType: typeof type === "string" ? type : "event",
+		currentTool: task.agentProgress?.currentTool,
+		toolCount: task.agentProgress?.toolCount,
+		tokens: task.agentProgress?.tokens,
+		turns: task.agentProgress?.turns,
+		activityState: task.agentProgress?.activityState,
+		lastActivityAt: task.agentProgress?.lastActivityAt,
+	};
+}
+
 function applyAgentProgressEvent(progress: CrewAgentProgress, event: unknown, startedAt: string | undefined): CrewAgentProgress {
 	const obj = asRecord(event);
 	const now = new Date().toISOString();
@@ -275,9 +304,26 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		let finalStderr = "";
 		modelAttempts = [];
 		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
+		let lastAgentRecordPersistedAt = 0;
+		let lastRunProgressPersistedAt = 0;
+		const persistChildProgress = (event: unknown, force = false): void => {
+			const now = Date.now();
+			if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
+				upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
+				lastAgentRecordPersistedAt = now;
+			}
+			if (force || shouldFlushProgressEvent(event) || now - lastRunProgressPersistedAt >= 1000) {
+				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: progressEventSummary(task, event) });
+				lastRunProgressPersistedAt = now;
+			}
+		};
 		for (let i = 0; i < attemptModels.length; i++) {
 			const model = attemptModels[i];
 			const attemptStartedAt = new Date();
+			const pendingAttempt: ModelAttemptSummary = { model: model ?? "default", success: false };
+			task = { ...task, modelAttempts: [...modelAttempts, pendingAttempt] };
+			tasks = updateTask(tasks, task);
+			upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
 			const childResult = await runChildPi({
 				cwd: task.cwd,
 				task: prompt,
@@ -291,18 +337,20 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 					appendCrewAgentEvent(manifest, task.id, event);
 					task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
 					tasks = updateTask(tasks, task);
-					upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
-					appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { event } });
+					persistChildProgress(event);
 				},
 			});
 			startupEvidence = createStartupEvidence({ command: "pi", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: childResult.exitCode === 0 && !childResult.error, stderr: childResult.stderr, error: childResult.error, exitCode: childResult.exitCode });
 			exitCode = childResult.exitCode;
 			finalStdout = childResult.stdout;
 			finalStderr = childResult.stderr;
-			parsedOutput = parsePiJsonOutput(childResult.stdout);
+			parsedOutput = parsePiJsonOutput(fs.existsSync(transcriptPath) ? fs.readFileSync(transcriptPath, "utf-8") : childResult.stdout);
 			error = childResult.error || (childResult.exitCode && childResult.exitCode !== 0 ? childResult.stderr || `Child Pi exited with ${childResult.exitCode}` : undefined);
+			persistChildProgress({ type: "attempt_finished" }, true);
 			const attempt: ModelAttemptSummary = { model: model ?? "default", success: !error, exitCode, error };
 			modelAttempts.push(attempt);
+			task = { ...task, modelAttempts: [...modelAttempts] };
+			tasks = updateTask(tasks, task);
 			logs.push(`MODEL ATTEMPT ${i + 1}: ${attempt.model}`, `success=${attempt.success}`, `exitCode=${attempt.exitCode ?? "null"}`, attempt.error ? `error=${attempt.error}` : "", "");
 			if (!error) break;
 			const nextModel = attemptModels[i + 1];
@@ -312,7 +360,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		resultArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "result",
 			relativePath: `results/${task.id}.txt`,
-			content: parsedOutput?.finalText || finalStdout || finalStderr || "(no output)",
+			content: cleanResultText(parsedOutput?.finalText) ?? cleanResultText(finalStdout) ?? cleanResultText(finalStderr) ?? "(no output)",
 			producer: task.id,
 		});
 		logArtifact = writeArtifact(manifest.artifactsRoot, {
@@ -339,6 +387,19 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		}
 	} else if (runtimeKind === "live-session") {
 		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
+		let lastAgentRecordPersistedAt = 0;
+		let lastRunProgressPersistedAt = 0;
+		const persistLiveProgress = (event: unknown, force = false): void => {
+			const now = Date.now();
+			if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
+				upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
+				lastAgentRecordPersistedAt = now;
+			}
+			if (force || shouldFlushProgressEvent(event) || now - lastRunProgressPersistedAt >= 1000) {
+				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: progressEventSummary(task, event) });
+				lastRunProgressPersistedAt = now;
+			}
+		};
 		const attemptStartedAt = new Date();
 		const liveResult = await runLiveSessionTask({
 			manifest,
@@ -357,8 +418,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				appendCrewAgentEvent(manifest, task.id, event);
 				task = { ...task, agentProgress: applyAgentProgressEvent(task.agentProgress ?? emptyCrewAgentProgress(), event, task.startedAt) };
 				tasks = updateTask(tasks, task);
-				upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
-				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { event } });
+				persistLiveProgress(event);
 			},
 		});
 		startupEvidence = createStartupEvidence({ command: "live-session", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: liveResult.exitCode === 0 && !liveResult.error, stderr: liveResult.stderr, error: liveResult.error, exitCode: liveResult.exitCode });
@@ -366,6 +426,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		error = liveResult.error || (liveResult.exitCode && liveResult.exitCode !== 0 ? liveResult.stderr || `Live session exited with ${liveResult.exitCode}` : undefined);
 		parsedOutput = { finalText: liveResult.stdout, textEvents: liveResult.stdout ? [liveResult.stdout] : [], jsonEvents: liveResult.jsonEvents, usage: liveResult.usage };
 		if (liveResult.usage) task = { ...task, usage: liveResult.usage, agentProgress: applyUsageToProgress(task.agentProgress, liveResult.usage) };
+		persistLiveProgress({ type: "attempt_finished" }, true);
 		resultArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "result",
 			relativePath: `results/${task.id}.txt`,

package/src/state/event-log.ts

@@ -42,8 +42,13 @@ export type AppendTeamEvent = Omit<TeamEvent, "time" | "metadata"> & { metadata?
 
 const TERMINAL_EVENT_TYPES = new Set(["run.blocked", "run.completed", "run.failed", "run.cancelled", "task.completed", "task.failed", "task.cancelled", "task.skipped"]);
 
+const sequenceCache = new Map<string, { size: number; mtimeMs: number; seq: number }>();
+
 function nextSequence(eventsPath: string): number {
 	if (!fs.existsSync(eventsPath)) return 1;
+	const stat = fs.statSync(eventsPath);
+	const cached = sequenceCache.get(eventsPath);
+	if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) return cached.seq + 1;
 	let max = 0;
 	for (const line of fs.readFileSync(eventsPath, "utf-8").split("\n")) {
 		if (!line.trim()) continue;
@@ -54,6 +59,7 @@ function nextSequence(eventsPath: string): number {
 			max += 1;
 		}
 	}
+	sequenceCache.set(eventsPath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: max });
 	return max + 1;
 }
 
@@ -82,6 +88,10 @@ export function appendEvent(eventsPath: string, event: AppendTeamEvent): TeamEve
 		fullEvent.metadata = metadata;
 	}
 	fs.appendFileSync(eventsPath, `${JSON.stringify(fullEvent)}\n`, "utf-8");
+	try {
+		const stat = fs.statSync(eventsPath);
+		sequenceCache.set(eventsPath, { size: stat.size, mtimeMs: stat.mtimeMs, seq: fullEvent.metadata?.seq ?? 0 });
+	} catch {}
 	return fullEvent;
 }
 

package/src/ui/crew-widget.ts

@@ -1,6 +1,6 @@
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import type { CrewUiConfig } from "../config/config.ts";
-import { listRuns } from "../extension/run-index.ts";
+import { listRecentRuns } from "../extension/run-index.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
@@ -106,8 +106,7 @@ function agentsFor(run: TeamRunManifest): CrewAgentRecord[] {
 }
 
 function activeWidgetRuns(cwd: string): WidgetRun[] {
-	const runs = listRuns(cwd).slice(0, 20);
-	return runs.map((run) => ({ run, agents: agentsFor(run) })).filter((item) => isDisplayActiveRun(item.run, item.agents));
+	return listRecentRuns(cwd, 20).map((run) => ({ run, agents: agentsFor(run) })).filter((item) => isDisplayActiveRun(item.run, item.agents));
 }
 
 function statusSummary(runs: WidgetRun[]): string {
@@ -136,8 +135,8 @@ function shortRunLabel(run: TeamRunManifest): string {
 	return `${run.team}/${run.workflow ?? "none"}`;
 }
 
-export function buildCrewWidgetLines(cwd: string, frame = 0, maxLines = 8): string[] {
-	const runs = activeWidgetRuns(cwd);
+export function buildCrewWidgetLines(cwd: string, frame = 0, maxLines = 8, providedRuns?: WidgetRun[]): string[] {
+	const runs = providedRuns ?? activeWidgetRuns(cwd);
 	if (!runs.length) return [];
 	const runningGlyph = SPINNER[frame % SPINNER.length] ?? "⠋";
 	const lines: string[] = [widgetHeader(runs, runningGlyph)];
@@ -193,9 +192,10 @@ export function updateCrewWidget(ctx: Pick<ExtensionContext, "cwd" | "hasUI" | "
 	if (!ctx.hasUI) return;
 	state.frame += 1;
 	const maxLines = config?.widgetMaxLines ?? 10;
-	const lines = buildCrewWidgetLines(ctx.cwd, state.frame, maxLines);
+	const runs = activeWidgetRuns(ctx.cwd);
+	const lines = buildCrewWidgetLines(ctx.cwd, state.frame, maxLines, runs);
 	const placement = config?.widgetPlacement ?? "aboveEditor";
-	ctx.ui.setStatus(STATUS_KEY, lines.length ? statusSummary(activeWidgetRuns(ctx.cwd)) : undefined);
+	ctx.ui.setStatus(STATUS_KEY, lines.length ? statusSummary(runs) : undefined);
 	ctx.ui.setWidget(LEGACY_WIDGET_KEY, undefined, { placement });
 	if (!lines.length) {
 		ctx.ui.setWidget(WIDGET_KEY, undefined, { placement });

package/src/ui/powerbar-publisher.ts

@@ -1,5 +1,5 @@
 import type { CrewUiConfig } from "../config/config.ts";
-import { listRuns } from "../extension/run-index.ts";
+import { listRecentRuns } from "../extension/run-index.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
 
@@ -17,7 +17,7 @@ export function registerPiCrewPowerbarSegments(events: EventBus, config?: CrewUi
 
 export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: CrewUiConfig): void {
 	if (config?.powerbar === false) return;
-	const active = listRuns(cwd).slice(0, 20).map((run) => {
+	const active = listRecentRuns(cwd, 20).map((run) => {
 		let agents = [] as ReturnType<typeof readCrewAgents>;
 		try { agents = readCrewAgents(run); } catch {}
 		return { run, agents };

package/src/ui/run-dashboard.ts

@@ -1,5 +1,5 @@
 import * as fs from "node:fs";
-import type { TeamRunManifest } from "../state/types.ts";
+import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { isDisplayActiveRun, isLikelyOrphanedActiveRun } from "../runtime/process-status.ts";
@@ -12,6 +12,13 @@ interface DashboardComponent {
 
 type DashboardTheme = { fg?: (color: string, text: string) => string; bold?: (text: string) => string };
 
+export interface RunDashboardOptions {
+	placement?: "center" | "right";
+	showModel?: boolean;
+	showTokens?: boolean;
+	showTools?: boolean;
+}
+
 export type RunDashboardAction = "status" | "summary" | "artifacts" | "api" | "events" | "agents" | "agent-events" | "agent-output" | "agent-transcript" | "reload";
 export interface RunDashboardSelection {
 	runId: string;
@@ -89,12 +96,52 @@ function formatAge(iso: string | undefined): string | undefined {
 	return `${Math.floor(ms / 3_600_000)}h`;
 }
 
-function agentPreviewLine(agent: CrewAgentRecord): string {
+function readRunTasks(run: TeamRunManifest): TeamTaskState[] {
+	try {
+		if (!fs.existsSync(run.tasksPath)) return [];
+		const parsed = JSON.parse(fs.readFileSync(run.tasksPath, "utf-8"));
+		return Array.isArray(parsed) ? parsed as TeamTaskState[] : [];
+	} catch { return []; }
+}
+
+function formatTokens(usage: UsageState | undefined): string | undefined {
+	if (!usage) return undefined;
+	const total = (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+	if (!total) return undefined;
+	const compact = total >= 1000 ? `${(total / 1000).toFixed(total >= 10_000 ? 0 : 1)}k` : `${total}`;
+	const parts = [`tok=${compact}`];
+	if (usage.input) parts.push(`in=${usage.input}`);
+	if (usage.output) parts.push(`out=${usage.output}`);
+	if (usage.cacheRead) parts.push(`cache=${usage.cacheRead}`);
+	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+	return parts.join("/");
+}
+
+function taskForAgent(tasks: TeamTaskState[], agent: CrewAgentRecord): TeamTaskState | undefined {
+	return tasks.find((task) => task.id === agent.taskId);
+}
+
+function modelForTask(task: TeamTaskState | undefined): string | undefined {
+	const attempts = task?.modelAttempts;
+	if (!attempts?.length) return undefined;
+	return attempts.find((attempt) => attempt.success)?.model ?? attempts.at(-1)?.model;
+}
+
+function modelForAgent(agent: CrewAgentRecord, task: TeamTaskState | undefined): string | undefined {
+	return modelForTask(task) ?? agent.model;
+}
+
+function usageForAgent(agent: CrewAgentRecord, task: TeamTaskState | undefined): UsageState | undefined {
+	return task?.usage ?? agent.usage;
+}
+
+function agentPreviewLine(agent: CrewAgentRecord, task: TeamTaskState | undefined, options: RunDashboardOptions): string {
 	const stats = [
 		agent.progress?.activityState,
-		agent.progress?.currentTool ? `tool=${agent.progress.currentTool}` : undefined,
-		agent.toolUses !== undefined ? `${agent.toolUses} tools` : undefined,
-		agent.progress?.tokens !== undefined ? `${agent.progress.tokens} tok` : undefined,
+		options.showModel !== false && modelForAgent(agent, task) ? `model=${modelForAgent(agent, task)}` : undefined,
+		options.showTokens !== false ? formatTokens(usageForAgent(agent, task)) ?? (agent.progress?.tokens !== undefined ? `tok=${agent.progress.tokens}` : undefined) : undefined,
+		options.showTools !== false && agent.progress?.currentTool ? `tool=${agent.progress.currentTool}` : undefined,
+		options.showTools !== false && agent.toolUses !== undefined ? `${agent.toolUses} tools` : undefined,
 		agent.progress?.turns !== undefined ? `${agent.progress.turns} turns` : undefined,
 		agent.progress?.failedTool ? `failedTool=${agent.progress.failedTool}` : undefined,
 		agent.startedAt ? `age=${formatAge(agent.completedAt ?? agent.startedAt)}` : undefined,
@@ -103,11 +150,21 @@ function agentPreviewLine(agent: CrewAgentRecord): string {
 	return `Agent: ${statusIcon(agent.status)} ${agent.taskId} ${agent.role}->${agent.agent}${stats.length ? ` · ${stats.join(" · ")}` : ""}${recent ? ` ⎿ ${recent}` : ""}`;
 }
 
-function readAgentPreview(run: TeamRunManifest, maxLines = 5): string[] {
+function readAgentPreview(run: TeamRunManifest, maxLines = 5, options: RunDashboardOptions = {}): string[] {
 	try {
 		const agents = readCrewAgents(run);
+		const tasks = readRunTasks(run);
 		if (!agents.length) return ["Agents: (none)"];
-		return ["Agents:", ...agents.slice(0, maxLines).map(agentPreviewLine), ...(agents.length > maxLines ? [`Agents: +${agents.length - maxLines} more`] : [])];
+		const totals = tasks.reduce((acc, task) => {
+			acc.input += task.usage?.input ?? 0;
+			acc.output += task.usage?.output ?? 0;
+			acc.cacheRead += task.usage?.cacheRead ?? 0;
+			acc.cacheWrite += task.usage?.cacheWrite ?? 0;
+			acc.cost += task.usage?.cost ?? 0;
+			return acc;
+		}, { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 });
+		const header = formatTokens(totals) ? `Agents: ${formatTokens(totals)}` : "Agents:";
+		return [header, ...agents.slice(0, maxLines).map((agent) => agentPreviewLine(agent, taskForAgent(tasks, agent), options)), ...(agents.length > maxLines ? [`Agents: +${agents.length - maxLines} more`] : [])];
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		return [`Agents: failed to read (${message})`];
@@ -154,11 +211,13 @@ export class RunDashboard implements DashboardComponent {
 	private readonly runs: TeamRunManifest[];
 	private readonly done: (selection: RunDashboardSelection | undefined) => void;
 	private readonly theme: DashboardTheme;
+	private readonly options: RunDashboardOptions;
 
-	constructor(runs: TeamRunManifest[], done: (selection: RunDashboardSelection | undefined) => void, theme: unknown = {}) {
+	constructor(runs: TeamRunManifest[], done: (selection: RunDashboardSelection | undefined) => void, theme: unknown = {}, options: RunDashboardOptions = {}) {
 		this.runs = runs;
 		this.done = done;
 		this.theme = theme as DashboardTheme;
+		this.options = options;
 	}
 
 	invalidate(): void {}
@@ -169,9 +228,10 @@ export class RunDashboard implements DashboardComponent {
 		const innerWidth = Math.max(20, width - 4);
 		const borderWidth = Math.min(innerWidth, Math.max(0, width - 2));
 		const border = (text: string) => fg("border", text);
+		const title = this.options.placement === "right" ? "pi-crew right sidebar" : "pi-crew dashboard";
 		const lines = [
 			border(`╭${"─".repeat(borderWidth)}╮`),
-			`│ ${padVisible(truncate(`${fg("accent", "●")} ${bold("pi-crew dashboard")}`, innerWidth - 1), innerWidth - 1)}│`,
+			`│ ${padVisible(truncate(`${fg("accent", "▐")} ${bold(title)} ${this.options.placement === "right" ? fg("dim", "anchored top-right") : ""}`, innerWidth - 1), innerWidth - 1)}│`,
 			`│ ${padVisible(truncate(fg("dim", "↑/↓/j/k select • r reload • p progress • s/u/a/i actions • d agents • e/v/o viewers • q close"), innerWidth - 1), innerWidth - 1)}│`,
 			`│ ${padVisible(truncate(`Runs: ${this.runs.length} • ${countByStatus(this.runs)}`, innerWidth - 1), innerWidth - 1)}│`,
 			border(`├${"─".repeat(borderWidth)}┤`),
@@ -203,7 +263,7 @@ export class RunDashboard implements DashboardComponent {
 					selectedRun.async ? `Async: pid=${selectedRun.async.pid ?? "unknown"} log=${selectedRun.async.logPath}` : "Async: no",
 					`Goal: ${selectedRun.goal}`,
 				];
-				for (const detail of [...details, ...readAgentPreview(selectedRun), ...readProgressPreview(selectedRun, this.showFullProgress ? 20 : 5)]) {
+				for (const detail of [...details, ...readAgentPreview(selectedRun, this.showFullProgress ? 20 : 8, this.options), ...readProgressPreview(selectedRun, this.showFullProgress ? 20 : 5)]) {
 					lines.push(`│ ${padVisible(truncate(detail, innerWidth - 1), innerWidth - 1)}│`);
 				}
 			}