pi-crew 0.1.15 → 0.1.16

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 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.16",
   "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

@@ -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));
 		},
 	});
@@ -363,9 +382,12 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		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 uiConfig = loadConfig(ctx.cwd).config.ui;
+				const rightPanel = uiConfig?.dashboardPlacement !== "center";
+				const width = rightPanel ? Math.min(120, Math.max(32, uiConfig?.dashboardWidth ?? 52)) : "90%";
+				const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, theme, _keybindings, done) => new RunDashboard(runs, done, theme, { showModel: uiConfig?.showModel, showTokens: uiConfig?.showTokens, showTools: uiConfig?.showTools }), {
 					overlay: true,
-					overlayOptions: { width: "90%", maxHeight: "80%", anchor: "center" },
+					overlayOptions: { width, minWidth: rightPanel ? 32 : undefined, maxHeight: "90%", anchor: rightPanel ? "right-center" : "center", offsetX: rightPanel ? -1 : 0, margin: rightPanel ? { top: 1, right: 1, bottom: 1, left: 0 } : 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}.`,
@@ -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,17 @@ 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 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 +68,63 @@ function appendTranscript(input: ChildPiRunInput, line: string): void {
 	fs.appendFileSync(input.transcriptPath, `${line}\n`, "utf-8");
 }
 
+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" ? record.text : "" };
+	if (record.type === "toolCall") return { type: "toolCall", name: record.name, input: record.input };
+	if (record.type === "toolResult") return { type: "toolResult", name: record.name, content: 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";
+	}
+	const message = asRecord(record.message);
+	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 +149,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 +219,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 +269,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 {

package/src/runtime/task-runner.ts

@@ -185,6 +185,24 @@ 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 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,6 +293,19 @@ 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();
@@ -291,8 +322,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, "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 });
@@ -301,6 +331,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 			finalStderr = childResult.stderr;
 			parsedOutput = parsePiJsonOutput(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);
 			logs.push(`MODEL ATTEMPT ${i + 1}: ${attempt.model}`, `success=${attempt.success}`, `exitCode=${attempt.exitCode ?? "null"}`, attempt.error ? `error=${attempt.error}` : "", "");
@@ -339,6 +370,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 +401,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 +409,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,12 @@ interface DashboardComponent {
 
 type DashboardTheme = { fg?: (color: string, text: string) => string; bold?: (text: string) => string };
 
+export interface RunDashboardOptions {
+	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 +95,44 @@ 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 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 && modelForTask(task) ? `model=${modelForTask(task)}` : undefined,
+		options.showTokens !== false ? formatTokens(task?.usage) ?? (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 +141,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 +202,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 {}
@@ -203,7 +253,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)}│`);
 				}
 			}