pi-crew 0.1.17 → 0.1.18

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.18
+
+- Added a built-in `parallel-research` team/workflow for map-reduce style source audits with dynamic `Source/pi-*` fanout and parallel explorer shards.
+- Made the live right sidebar the default foreground UI: active foreground runs auto-open a top-right live sidebar when the terminal is wide enough.
+- Added live sidebar sections for active agents, waiting tasks, completed agents, task graph, model, tool, and token/usage details.
+- Stopped materializing queued dependency tasks as child-process agents; status now separates active agents, waiting tasks, and completed agents.
+- Added workflow-aware default concurrency so research/parallel-research can use ready parallel work instead of always running one worker.
+- Dropped user/system prompt messages from child event persistence to avoid prompt/context leakage in agent event logs.
+- Tightened child event compaction with separate assistant/tool input/tool result caps and improved powerbar active/waiting/model/token summaries.
+
 ## 0.1.17
 
 - Fixed terminal/completed workers being incorrectly escalated as stale heartbeat blockers after all tasks completed.

package/README.md

@@ -52,6 +52,7 @@ Current highlights:
 - run-level and task-level mailbox files with validation/repair support
 - `/team-manager` interactive helper
 - `/team-dashboard` custom TUI overlay with progress preview, action shortcuts, and reload
+- `parallel-research` team/workflow for dynamic `Source/pi-*` fanout and parallel shard exploration
 - package polish: `schema.json`, TypeScript semantic check, strip-types import smoke, cross-platform CI workflow, dry-run package verification
 
 ## Install
@@ -171,7 +172,10 @@ Supported config:
     "widgetMaxLines": 8,
     "powerbar": true,
     "dashboardPlacement": "right",
-    "dashboardWidth": 52,
+    "dashboardWidth": 56,
+    "dashboardLiveRefreshMs": 1000,
+    "autoOpenDashboard": true,
+    "autoOpenDashboardForForegroundRuns": true,
     "showModel": true,
     "showTokens": true,
     "showTools": true
@@ -186,7 +190,9 @@ Safety notes:
 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.
+- `dashboardPlacement: "right"` is the default; foreground runs auto-open a live top-right sidebar when the terminal is wide enough.
+- `autoOpenDashboard`/`autoOpenDashboardForForegroundRuns` control whether the live sidebar opens automatically.
+- `dashboardLiveRefreshMs` controls the live sidebar refresh cadence.
 - `showModel`, `showTokens`, and `showTools` show worker model attempts, token usage, and tool activity in dashboard agent rows.
 
 Show config:

package/docs/usage.md

@@ -34,7 +34,10 @@ Supported fields:
     "widgetMaxLines": 8,
     "powerbar": true,
     "dashboardPlacement": "right",
-    "dashboardWidth": 52,
+    "dashboardWidth": 56,
+    "dashboardLiveRefreshMs": 1000,
+    "autoOpenDashboard": true,
+    "autoOpenDashboardForForegroundRuns": true,
     "showModel": true,
     "showTokens": true,
     "showTools": true

package/package.json

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

package/schema.json

@@ -87,9 +87,12 @@
         "widgetPlacement": { "type": "string", "enum": ["aboveEditor", "belowEditor"] },
         "widgetMaxLines": { "type": "integer", "minimum": 1, "maximum": 50 },
         "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." },
+        "dashboardPlacement": { "type": "string", "enum": ["center", "right"], "default": "right", "description": "Place /team-dashboard as a centered overlay or right-side panel." },
+        "dashboardWidth": { "type": "integer", "minimum": 32, "maximum": 120, "default": 56 },
+        "dashboardLiveRefreshMs": { "type": "integer", "minimum": 250, "maximum": 60000, "default": 1000 },
+        "autoOpenDashboard": { "type": "boolean", "default": true, "description": "Automatically open the live right sidebar for foreground runs when UI is available." },
+        "autoOpenDashboardForForegroundRuns": { "type": "boolean", "default": true },
+        "showModel": { "type": "boolean", "default": true, "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

@@ -53,6 +53,9 @@ export interface CrewUiConfig {
 	powerbar?: boolean;
 	dashboardPlacement?: "center" | "right";
 	dashboardWidth?: number;
+	dashboardLiveRefreshMs?: number;
+	autoOpenDashboard?: boolean;
+	autoOpenDashboardForForegroundRuns?: boolean;
 	showModel?: boolean;
 	showTokens?: boolean;
 	showTools?: boolean;
@@ -316,6 +319,9 @@ function parseUiConfig(value: unknown): CrewUiConfig | undefined {
 		powerbar: typeof obj.powerbar === "boolean" ? obj.powerbar : undefined,
 		dashboardPlacement: obj.dashboardPlacement === "center" || obj.dashboardPlacement === "right" ? obj.dashboardPlacement : undefined,
 		dashboardWidth: parsePositiveInteger(obj.dashboardWidth, 120),
+		dashboardLiveRefreshMs: parsePositiveInteger(obj.dashboardLiveRefreshMs, 60_000),
+		autoOpenDashboard: typeof obj.autoOpenDashboard === "boolean" ? obj.autoOpenDashboard : undefined,
+		autoOpenDashboardForForegroundRuns: typeof obj.autoOpenDashboardForForegroundRuns === "boolean" ? obj.autoOpenDashboardForForegroundRuns : undefined,
 		showModel: typeof obj.showModel === "boolean" ? obj.showModel : undefined,
 		showTokens: typeof obj.showTokens === "boolean" ? obj.showTokens : undefined,
 		showTools: typeof obj.showTools === "boolean" ? obj.showTools : undefined,

package/src/extension/register.ts

@@ -9,6 +9,7 @@ import { handleTeamManagerCommand } from "./team-manager-command.ts";
 import { handleTeamTool, type TeamToolDetails } from "./team-tool.ts";
 import { listRecentRuns } from "./run-index.ts";
 import { RunDashboard, type RunDashboardSelection } from "../ui/run-dashboard.ts";
+import { LiveRunSidebar } from "../ui/live-run-sidebar.ts";
 import { registerPiCrewRpc, type PiCrewRpcHandle } from "./cross-extension-rpc.ts";
 import { stopCrewWidget, updateCrewWidget, type CrewWidgetState } from "../ui/crew-widget.ts";
 import { clearPiCrewPowerbar, registerPiCrewPowerbarSegments, updatePiCrewPowerbar } from "../ui/powerbar-publisher.ts";
@@ -112,6 +113,29 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	let cleanedUp = false;
 	const widgetState: CrewWidgetState = { frame: 0 };
 	const foregroundControllers = new Set<AbortController>();
+	let liveSidebarRunId: string | undefined;
+	let liveSidebarTimer: ReturnType<typeof setInterval> | undefined;
+	const requestRender = (ctx: ExtensionContext): void => (ctx.ui as { requestRender?: () => void }).requestRender?.();
+	const openLiveSidebar = (ctx: ExtensionContext, runId: string): void => {
+		const uiConfig = loadConfig(ctx.cwd).config.ui;
+		const autoOpen = uiConfig?.autoOpenDashboard ?? true;
+		const foregroundAutoOpen = uiConfig?.autoOpenDashboardForForegroundRuns ?? true;
+		if (!ctx.hasUI || !autoOpen || !foregroundAutoOpen || (uiConfig?.dashboardPlacement ?? "right") !== "right") return;
+		if (liveSidebarRunId === runId) return;
+		if (liveSidebarTimer) clearInterval(liveSidebarTimer);
+		liveSidebarRunId = runId;
+		const width = Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? 56));
+		liveSidebarTimer = setInterval(() => requestRender(ctx), uiConfig?.dashboardLiveRefreshMs ?? 1000);
+		liveSidebarTimer.unref?.();
+		void ctx.ui.custom<undefined>((_tui, theme, _keybindings, done) => new LiveRunSidebar({ cwd: ctx.cwd, runId, done, theme, config: uiConfig }), {
+			overlay: true,
+			overlayOptions: { width, minWidth: 40, maxHeight: "100%", anchor: "top-right", offsetX: 0, offsetY: 0, margin: { top: 0, right: 0, bottom: 0, left: 0 }, visible: (termWidth: number) => termWidth >= 100 },
+		}).finally(() => {
+			if (liveSidebarRunId === runId) liveSidebarRunId = undefined;
+			if (liveSidebarTimer) clearInterval(liveSidebarTimer);
+			liveSidebarTimer = undefined;
+		});
+	};
 	const startForegroundRun = (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>): void => {
 		const controller = new AbortController();
 		foregroundControllers.add(controller);
@@ -141,6 +165,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		terminateActiveChildPiProcesses();
 		stopAsyncRunNotifier(notifierState);
 		stopCrewWidget(currentCtx, widgetState, currentCtx ? loadConfig(currentCtx.cwd).config.ui : undefined);
+		if (liveSidebarTimer) clearInterval(liveSidebarTimer);
+		liveSidebarTimer = undefined;
+		liveSidebarRunId = undefined;
 		clearPiCrewPowerbar(pi.events);
 		rpcHandle?.unsubscribe();
 		rpcHandle = undefined;
@@ -182,7 +209,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, startForegroundRun: (runner) => startForegroundRun(ctx, runner) });
+				const output = await handleTeamTool(params as TeamToolParamsValue, { ...ctx, signal: controller.signal, startForegroundRun: (runner) => startForegroundRun(ctx, runner), onRunStarted: (runId) => openLiveSidebar(ctx, runId) });
 				const config = loadConfig(ctx.cwd).config.ui;
 				updateCrewWidget(ctx, widgetState, config);
 				updatePiCrewPowerbar(pi.events, ctx.cwd, config);
@@ -207,7 +234,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, startForegroundRun: (runner) => startForegroundRun(ctx as ExtensionContext, runner) });
+			const result = await handleTeamTool(parseRunArgs(args), { ...ctx, startForegroundRun: (runner) => startForegroundRun(ctx as ExtensionContext, runner), onRunStarted: (runId) => openLiveSidebar(ctx as ExtensionContext, runId) });
 			await notifyCommandResult(ctx, commandText(result));
 		},
 	});

package/src/extension/team-recommendation.ts

@@ -12,8 +12,8 @@ export interface RecommendedSubtask {
 }
 
 export interface TeamRecommendation {
-	team: "default" | "implementation" | "review" | "fast-fix" | "research";
-	workflow: "default" | "implementation" | "review" | "fast-fix" | "research";
+	team: string;
+	workflow: string;
 	action: "plan" | "run";
 	async: boolean;
 	workspaceMode: "single" | "worktree";
@@ -23,7 +23,8 @@ export interface TeamRecommendation {
 }
 
 const REVIEW_TERMS = ["review", "audit", "security", "vulnerability", "diff", "pr", "pull request"];
-const RESEARCH_TERMS = ["research", "investigate", "compare", "analyze", "document", "docs", "explain", "architecture"];
+const RESEARCH_TERMS = ["research", "investigate", "compare", "analyze", "document", "docs", "explain", "architecture", "đọc sâu", "source", "projects"];
+const PARALLEL_RESEARCH_RE = /(?:đọc sâu|deep read|deep research|source audit|multiple projects|các project|pi-\*|source\/|@source)/i;
 const FAST_FIX_TERMS = ["quick fix", "fast-fix", "small bug", "typo", "one-line", "minor", "lint"];
 const IMPLEMENTATION_TERMS = ["implement", "refactor", "migrate", "feature", "tests", "test", "integration", "upgrade", "build", "create", "add"];
 const RISKY_TERMS = ["migration", "refactor", "large", "multiple", "parallel", "concurrent", "risky", "critical"];
@@ -122,6 +123,11 @@ export function recommendTeam(goal: string, config: PiTeamsAutonomousConfig = {}
 		workflow = "review";
 		confidence = "high";
 		reasons.push(`Review/audit terms detected: ${reviewMatches.join(", ") || "explicit review intent"}.`);
+	} else if (PARALLEL_RESEARCH_RE.test(goal) || (researchMatches.length >= 2 && (normalized.includes("multiple") || normalized.includes("source") || normalized.includes("project") || normalized.includes("pi-")))) {
+		team = "parallel-research";
+		workflow = "parallel-research";
+		confidence = "high";
+		reasons.push("Deep/multi-source research detected; use parallel shard exploration.");
 	} else if (intents.includes("research") || (researchMatches.length > 0 && implementationMatches.length === 0)) {
 		team = "research";
 		workflow = "research";

package/src/extension/team-tool.ts

@@ -5,6 +5,7 @@ import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
+import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
 import { effectiveAutonomousConfig, loadConfig, updateAutonomousConfig, updateConfig, type PiTeamsAutonomousConfig, type PiTeamsConfig } from "../config/config.ts";
 import { projectPiRoot, userPiRoot } from "../utils/paths.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
@@ -44,6 +45,7 @@ import { readForegroundControlStatus, writeForegroundInterruptRequest } from "..
 import { listLiveAgents, resumeLiveAgent, steerLiveAgent, stopLiveAgent } from "../runtime/live-agent-manager.ts";
 import { appendLiveAgentControlRequest } from "../runtime/live-agent-control.ts";
 import { liveControlRealtimeMessage, publishLiveControlRealtime } from "../runtime/live-control-realtime.ts";
+import { formatTaskGraphLines, waitingReason } from "../runtime/task-display.ts";
 
 export interface TeamToolDetails {
 	action: string;
@@ -58,6 +60,7 @@ type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext
 	events?: { emit?: (event: string, data: unknown) => void };
 	signal?: AbortSignal;
 	startForegroundRun?: (runner: (signal?: AbortSignal) => Promise<void>) => void;
+	onRunStarted?: (runId: string) => void;
 };
 
 function result(text: string, details: TeamToolDetails, isError = false): PiTeamsToolResult {
@@ -168,6 +171,48 @@ function commandExists(command: string, args: string[]): { ok: boolean; detail:
 	return { ok: false, detail: output.error?.message ?? firstOutputLine(output.stdout, output.stderr) };
 }
 
+function sourcePiProjects(cwd: string): string[] {
+	const sourceDir = path.join(cwd, "Source");
+	try {
+		return fs.readdirSync(sourceDir, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory() && entry.name.startsWith("pi-"))
+			.map((entry) => `Source/${entry.name}`)
+			.sort();
+	} catch {
+		return [];
+	}
+}
+
+function chunkProjects(projects: string[], target = 4): string[][] {
+	const chunks = Array.from({ length: Math.min(Math.max(1, target), Math.max(1, projects.length)) }, () => [] as string[]);
+	projects.forEach((project, index) => chunks[index % chunks.length]!.push(project));
+	return chunks.filter((chunk) => chunk.length > 0);
+}
+
+function expandParallelResearchWorkflow(workflow: WorkflowConfig, cwd: string): WorkflowConfig {
+	if (workflow.name !== "parallel-research") return workflow;
+	const projects = sourcePiProjects(cwd);
+	if (projects.length === 0) return workflow;
+	const chunks = chunkProjects(projects, Math.min(6, Math.max(4, Math.ceil(projects.length / 4))));
+	const exploreSteps: WorkflowStep[] = chunks.map((paths, index) => ({
+		id: `explore-shard-${index + 1}`,
+		role: "explorer",
+		dependsOn: ["discover"],
+		parallelGroup: "explore",
+		reads: paths,
+		task: [`Explore this dynamic shard for: {goal}`, "", "Paths:", ...paths.map((item) => `- ${item}`), "", "Focus on purpose, architecture, runtime/UI patterns, package config, docs, and lessons for pi-crew."].join("\n"),
+	}));
+	return {
+		...workflow,
+		steps: [
+			{ id: "discover", role: "explorer", task: `Discover and validate ${projects.length} pi-* projects for: {goal}\n\nProjects:\n${projects.map((item) => `- ${item}`).join("\n")}` },
+			...exploreSteps,
+			{ id: "synthesize", role: "analyst", dependsOn: exploreSteps.map((step) => step.id), task: "Synthesize all dynamic shard findings. Identify common patterns, gaps, and concrete recommendations." },
+			{ id: "write", role: "writer", dependsOn: ["synthesize"], output: "research-summary.md", task: "Write a concise final summary with evidence, risks, and actionable next steps." },
+		],
+	};
+}
+
 function effectiveRunConfig(base: PiTeamsConfig, rawOverride: unknown): PiTeamsConfig {
 	const patch = configPatchFromConfig(rawOverride);
 	return {
@@ -259,8 +304,9 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const team = teams.find((item) => item.name === teamName);
 	if (!team) return result(`Team '${teamName}' not found.`, { action: "run", status: "error" }, true);
 	const workflowName = params.workflow ?? team.defaultWorkflow ?? "default";
-	const workflow = workflows.find((item) => item.name === workflowName);
-	if (!workflow) return result(`Workflow '${workflowName}' not found.`, { action: "run", status: "error" }, true);
+	const baseWorkflow = workflows.find((item) => item.name === workflowName);
+	if (!baseWorkflow) return result(`Workflow '${workflowName}' not found.`, { action: "run", status: "error" }, true);
+	const workflow = expandParallelResearchWorkflow(baseWorkflow, ctx.cwd);
 
 	const validationErrors = validateWorkflowForTeam(workflow, team);
 	if (validationErrors.length > 0) {
@@ -309,6 +355,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const executeWorkers = runtime.kind === "child-process";
 	const executedConfig = effectiveRunConfig(loadedConfig.config, params.config);
 	if (executeWorkers && ctx.startForegroundRun) {
+		ctx.onRunStarted?.(updatedManifest.runId);
 		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 });
 		});
@@ -368,6 +415,10 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	const crewAgents = readCrewAgents(manifest).map((agent) => applyAttentionState(manifest, agent, controlConfig));
 	const artifactLines = manifest.artifacts.slice(-10).map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}`);
 	const totalUsage = aggregateUsage(tasks);
+	const activeAgents = crewAgents.filter((agent) => agent.status === "running");
+	const completedAgents = crewAgents.filter((agent) => agent.status !== "running");
+	const waitingTasks = tasks.filter((task) => task.status === "queued");
+	const agentLine = (agent: typeof crewAgents[number]): string => `- ${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}` : ""}`;
 	const lines = [
 		`Run: ${manifest.runId}`,
 		`Team: ${manifest.team}`,
@@ -380,11 +431,17 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		`State: ${manifest.stateRoot}`,
 		`Artifacts: ${manifest.artifactsRoot}`,
 		...(asyncLivenessLine ? [asyncLivenessLine] : []),
+		"Task graph:",
+		...formatTaskGraphLines(tasks),
 		"Tasks:",
 		...(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.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)"]),
+		"Active agents:",
+		...(activeAgents.length ? activeAgents.map(agentLine) : ["- (none)"]),
+		"Waiting tasks:",
+		...(waitingTasks.length ? waitingTasks.map((task) => `- ${task.id} [queued] ${task.role} -> ${task.agent} ${waitingReason(task, tasks) ?? "waiting"}`) : ["- (none)"]),
+		"Completed agents:",
+		...(completedAgents.length ? completedAgents.map(agentLine) : ["- (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)}`,

package/src/runtime/child-pi.ts

@@ -9,6 +9,9 @@ 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_ASSISTANT_TEXT_CHARS = 8192;
+const MAX_TOOL_RESULT_CHARS = 1024;
+const MAX_TOOL_INPUT_CHARS = 2048;
 const MAX_COMPACT_CONTENT_CHARS = 4096;
 const activeChildProcesses = new Map<number, ChildProcess>();
 
@@ -87,9 +90,9 @@ function compactValue(value: unknown): unknown {
 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) };
+	if (record.type === "text") return { type: "text", text: typeof record.text === "string" ? compactString(record.text, MAX_ASSISTANT_TEXT_CHARS) : "" };
+	if (record.type === "toolCall") return { type: "toolCall", name: record.name, input: compactValue(typeof record.input === "string" ? compactString(record.input, MAX_TOOL_INPUT_CHARS) : record.input) };
+	if (record.type === "toolResult") return { type: "toolResult", name: record.name, content: compactValue(typeof record.content === "string" ? compactString(record.content, MAX_TOOL_RESULT_CHARS) : record.content) };
 	return undefined;
 }
 
@@ -102,6 +105,7 @@ function compactChildPiEvent(event: unknown): unknown | undefined {
 	}
 	if (record.type === "tool_result_end" || record.type === "message_end" || record.type === "message") {
 		const message = asRecord(record.message);
+		if (message?.role === "user" || message?.role === "system") return undefined;
 		const content = Array.isArray(message?.content) ? message.content.map(compactContentPart).filter((part) => part !== undefined) : undefined;
 		return {
 			type: record.type,

package/src/runtime/task-display.ts

@@ -0,0 +1,38 @@
+import type { TeamTaskState } from "../state/types.ts";
+import type { CrewAgentRecord, CrewRuntimeKind } from "./crew-agent-runtime.ts";
+import { recordFromTask } from "./crew-agent-records.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+
+export function shouldMaterializeAgent(task: TeamTaskState): boolean {
+	return task.status !== "queued" && task.status !== "skipped";
+}
+
+export function recordsForMaterializedTasks(manifest: TeamRunManifest, tasks: TeamTaskState[], runtime: CrewRuntimeKind): CrewAgentRecord[] {
+	return tasks.filter(shouldMaterializeAgent).map((task) => recordFromTask(manifest, task, runtime));
+}
+
+export function taskById(tasks: TeamTaskState[]): Map<string, TeamTaskState> {
+	const map = new Map<string, TeamTaskState>();
+	for (const task of tasks) {
+		map.set(task.id, task);
+		if (task.stepId) map.set(task.stepId, task);
+	}
+	return map;
+}
+
+export function waitingReason(task: TeamTaskState, tasks: TeamTaskState[]): string | undefined {
+	if (task.status !== "queued") return undefined;
+	const byId = taskById(tasks);
+	const waiting = task.dependsOn.map((id) => byId.get(id)?.id ?? id).filter((id) => byId.get(id)?.status !== "completed");
+	if (waiting.length === 0) return "ready";
+	return `waiting for ${waiting.join(", ")}`;
+}
+
+export function formatTaskGraphLines(tasks: TeamTaskState[]): string[] {
+	if (tasks.length === 0) return ["- (none)"];
+	return tasks.map((task) => {
+		const icon = task.status === "completed" ? "✓" : task.status === "running" ? "⠋" : task.status === "failed" ? "✗" : task.status === "cancelled" || task.status === "skipped" ? "■" : "◦";
+		const wait = waitingReason(task, tasks);
+		return `- ${icon} ${task.id} [${task.status}] ${task.role}->${task.agent}${wait && wait !== "ready" ? ` (${wait})` : ""}`;
+	});
+}

package/src/runtime/team-runner.ts

@@ -1,240 +1,242 @@
-import type { AgentConfig } from "../agents/agent-config.ts";
-import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
-import type { CrewRuntimeCapabilities } from "./runtime-resolver.ts";
-import { writeArtifact } from "../state/artifact-store.ts";
-import { appendEvent } from "../state/event-log.ts";
-import type { TeamConfig } from "../teams/team-config.ts";
-import type { ArtifactDescriptor, PolicyDecision, TeamRunManifest, TeamTaskState } from "../state/types.ts";
-import { saveRunManifest, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
-import { aggregateUsage, formatUsage } from "../state/usage.ts";
-import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
-import { evaluateCrewPolicy, summarizePolicyDecisions } from "./policy-engine.ts";
-import { buildRecoveryLedger } from "./recovery-recipes.ts";
-import { getReadyTasks, refreshTaskGraphQueues, taskGraphSnapshot } from "./task-graph-scheduler.ts";
-import { checkBranchFreshness } from "../worktree/branch-freshness.ts";
-import { aggregateTaskOutputs } from "./task-output-context.ts";
-import { recordFromTask, saveCrewAgents } from "./crew-agent-records.ts";
-import { deliverGroupJoin, resolveGroupJoinMode } from "./group-join.ts";
-import { runTeamTask } from "./task-runner.ts";
-
-export interface ExecuteTeamRunInput {
-	manifest: TeamRunManifest;
-	tasks: TeamTaskState[];
-	team: TeamConfig;
-	workflow: WorkflowConfig;
-	agents: AgentConfig[];
-	executeWorkers: boolean;
-	limits?: CrewLimitsConfig;
-	runtime?: CrewRuntimeCapabilities;
-	runtimeConfig?: CrewRuntimeConfig;
-	parentContext?: string;
-	parentModel?: unknown;
-	modelRegistry?: unknown;
-	modelOverride?: string;
-	signal?: AbortSignal;
-}
-
-function findReadyTask(tasks: TeamTaskState[]): TeamTaskState | undefined {
-	return getReadyTasks(tasks, 1)[0];
-}
-
-function findStep(workflow: WorkflowConfig, task: TeamTaskState): WorkflowStep {
-	const step = workflow.steps.find((candidate) => candidate.id === task.stepId);
-	if (!step) throw new Error(`Workflow step '${task.stepId}' not found for task '${task.id}'.`);
-	return step;
-}
-
-function findAgent(agents: AgentConfig[], task: TeamTaskState): AgentConfig {
-	const agent = agents.find((candidate) => candidate.name === task.agent);
-	if (!agent) throw new Error(`Agent '${task.agent}' not found for task '${task.id}'.`);
-	return agent;
-}
-
-function markBlocked(tasks: TeamTaskState[], reason: string): TeamTaskState[] {
-	return tasks.map((task) => task.status === "queued" ? { ...task, status: "skipped", error: reason, finishedAt: new Date().toISOString(), graph: task.graph ? { ...task.graph, queue: "blocked" } : undefined } : task);
-}
-
-function mergeArtifacts(items: ArtifactDescriptor[]): ArtifactDescriptor[] {
-	const byPath = new Map<string, ArtifactDescriptor>();
-	for (const item of items) byPath.set(item.path, item);
-	return [...byPath.values()];
-}
-
-function mergeTaskUpdates(base: TeamTaskState[], results: Array<{ tasks: TeamTaskState[] }>): TeamTaskState[] {
-	let merged = base;
-	for (const result of results) {
-		for (const updated of result.tasks) {
-			const current = merged.find((task) => task.id === updated.id);
-			if (!current) continue;
-			if (updated.status !== current.status || updated.finishedAt || updated.startedAt || updated.resultArtifact || updated.error) {
-				merged = merged.map((task) => task.id === updated.id ? updated : task);
-			}
-		}
-	}
-	return refreshTaskGraphQueues(merged);
-}
-
-function formatTaskProgress(task: TeamTaskState): string {
-	return `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.error ? ` - ${task.error}` : ""}`;
-}
-
-function writeProgress(manifest: TeamRunManifest, tasks: TeamTaskState[], producer: string): TeamRunManifest {
-	const counts = new Map<string, number>();
-	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
-	const queue = taskGraphSnapshot(tasks);
-	const progress = writeArtifact(manifest.artifactsRoot, {
-		kind: "progress",
-		relativePath: "progress.md",
-		producer,
-		content: [
-			`# pi-crew progress ${manifest.runId}`,
-			"",
-			`Status: ${manifest.status}`,
-			`Team: ${manifest.team}`,
-			`Workflow: ${manifest.workflow ?? "(none)"}`,
-			`Updated: ${new Date().toISOString()}`,
-			`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
-			`Queue: ready=${queue.ready.length}, blocked=${queue.blocked.length}, running=${queue.running.length}, done=${queue.done.length}, failed=${queue.failed.length}, cancelled=${queue.cancelled.length}`,
-			"",
-			"## Tasks",
-			...tasks.map(formatTaskProgress),
-			"",
-		].join("\n"),
-	});
-	return { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "progress" && artifact.path === progress.path)), progress] };
-}
-
-function applyPolicy(manifest: TeamRunManifest, tasks: TeamTaskState[], limits?: CrewLimitsConfig): TeamRunManifest {
-	const branchFreshness = checkBranchFreshness(manifest.cwd);
-	const branchArtifact = writeArtifact(manifest.artifactsRoot, {
-		kind: "metadata",
-		relativePath: "metadata/branch-freshness.json",
-		producer: "branch-freshness",
-		content: `${JSON.stringify(branchFreshness, null, 2)}\n`,
-	});
-	let decisions: PolicyDecision[] = evaluateCrewPolicy({ manifest, tasks, limits });
-	if (branchFreshness.status === "stale" || branchFreshness.status === "diverged") {
-		const branchDecision: PolicyDecision = {
-			action: "notify",
-			reason: "branch_stale",
-			message: branchFreshness.message,
-			createdAt: new Date().toISOString(),
-		};
-		decisions = [...decisions, branchDecision];
-		appendEvent(manifest.eventsPath, { type: "branch.stale", runId: manifest.runId, message: branchFreshness.message, data: { branchFreshness } });
-	}
-	const policyArtifact = writeArtifact(manifest.artifactsRoot, {
-		kind: "metadata",
-		relativePath: "policy-decisions.json",
-		producer: "policy-engine",
-		content: `${JSON.stringify(decisions, null, 2)}\n`,
-	});
-	const recoveryLedger = buildRecoveryLedger(decisions);
-	const recoveryArtifact = writeArtifact(manifest.artifactsRoot, {
-		kind: "metadata",
-		relativePath: "recovery-ledger.json",
-		producer: "recovery-engine",
-		content: `${JSON.stringify(recoveryLedger, null, 2)}\n`,
-	});
-	for (const item of decisions) appendEvent(manifest.eventsPath, { type: item.action === "escalate" ? "policy.escalated" : "policy.action", runId: manifest.runId, taskId: item.taskId, message: item.message, data: { action: item.action, reason: item.reason } });
-	for (const item of recoveryLedger.entries) appendEvent(manifest.eventsPath, { type: item.state === "escalation_required" ? "recovery.escalated" : "recovery.attempted", runId: manifest.runId, taskId: item.taskId, message: item.message, data: { scenario: item.scenario, steps: item.steps, attempt: item.attempt, state: item.state } });
-	return { ...manifest, updatedAt: new Date().toISOString(), policyDecisions: decisions, artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "metadata" && (artifact.path.endsWith("policy-decisions.json") || artifact.path.endsWith("recovery-ledger.json") || artifact.path.endsWith("branch-freshness.json")))), branchArtifact, policyArtifact, recoveryArtifact] };
-}
-
-export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
-	let manifest = updateRunStatus(input.manifest, "running", input.executeWorkers ? "Executing team workflow." : "Creating workflow prompts and placeholder results.");
-	let tasks = refreshTaskGraphQueues(input.tasks);
-	manifest = writeProgress(manifest, tasks, "team-runner");
-	saveRunManifest(manifest);
-	const runtimeKind = input.runtime?.kind ?? (input.executeWorkers ? "child-process" : "scaffold");
-	saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
-
-	while (tasks.some((task) => task.status === "queued")) {
-		if (input.signal?.aborted) {
-			tasks = tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled", finishedAt: new Date().toISOString(), error: "Run cancelled." } : task);
-			saveRunTasks(manifest, tasks);
-			manifest = updateRunStatus(manifest, "cancelled", "Run cancelled.");
-			return { manifest, tasks };
-		}
-
-		const failed = tasks.find((task) => task.status === "failed");
-		if (failed) {
-			tasks = markBlocked(tasks, `Blocked by failed task '${failed.id}'.`);
-			saveRunTasks(manifest, tasks);
-			saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
-			manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
-			return { manifest, tasks };
-		}
-
-		const maxConcurrent = Math.max(1, input.limits?.maxConcurrentWorkers ?? 1);
-		const readyBatch = getReadyTasks(tasks, maxConcurrent);
-		if (readyBatch.length === 0) {
-			tasks = markBlocked(tasks, "No ready queued task; dependency graph may be invalid.");
-			saveRunTasks(manifest, tasks);
-			saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
-			manifest = updateRunStatus(manifest, "blocked", "No ready queued task.");
-			return { manifest, tasks };
-		}
-
-		appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, message: `Starting ready batch with ${readyBatch.length} task(s).`, data: { taskIds: readyBatch.map((task) => task.id), maxConcurrent } });
-		const results = await Promise.all(readyBatch.map((task) => {
-			const step = findStep(input.workflow, task);
-			const agent = findAgent(input.agents, task);
-			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, modelOverride: input.modelOverride, limits: input.limits });
-		}));
-		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
-		tasks = mergeTaskUpdates(tasks, results);
-		saveRunTasks(manifest, tasks);
-		saveCrewAgents(manifest, tasks.map((task) => recordFromTask(manifest, task, runtimeKind)));
-		const completedBatch = readyBatch.map((task) => tasks.find((item) => item.id === task.id) ?? task);
-		const batchArtifact = writeArtifact(manifest.artifactsRoot, {
-			kind: "summary",
-			relativePath: `batches/${readyBatch.map((task) => task.id).join("+")}.md`,
-			producer: "team-runner",
-			content: aggregateTaskOutputs(completedBatch),
-		});
-		const groupDelivery = deliverGroupJoin({ manifest, mode: resolveGroupJoinMode(input.runtimeConfig), batch: readyBatch, allTasks: tasks });
-		manifest = { ...manifest, artifacts: mergeArtifacts([...manifest.artifacts, batchArtifact, ...(groupDelivery?.artifact ? [groupDelivery.artifact] : [])]) };
-		manifest = writeProgress(manifest, tasks, "team-runner");
-		saveRunManifest(manifest);
-	}
-
-	const failed = tasks.find((task) => task.status === "failed");
-	manifest = applyPolicy(manifest, tasks, input.limits);
-	const blockingDecision = manifest.policyDecisions?.find((item) => item.action === "block" || item.action === "escalate");
-	if (failed) {
-		manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
-	} else if (blockingDecision) {
-		manifest = updateRunStatus(manifest, "blocked", blockingDecision.message);
-	} else {
-		manifest = updateRunStatus(manifest, "completed", input.executeWorkers ? "Team workflow completed." : "Team workflow scaffold completed without launching child workers.");
-	}
-	manifest = writeProgress(manifest, tasks, "team-runner");
-	saveRunManifest(manifest);
-	const usage = aggregateUsage(tasks);
-	const summaryArtifact = writeArtifact(manifest.artifactsRoot, {
-		kind: "summary",
-		relativePath: "summary.md",
-		producer: "team-runner",
-		content: [
-			`# pi-crew run ${manifest.runId}`,
-			"",
-			`Status: ${manifest.status}`,
-			`Team: ${manifest.team}`,
-			`Workflow: ${manifest.workflow ?? "(none)"}`,
-			`Goal: ${manifest.goal}`,
-			`Usage: ${formatUsage(usage)}`,
-			"",
-			"## Tasks",
-			...tasks.map(formatTaskProgress),
-			"",
-			"## Policy decisions",
-			...(manifest.policyDecisions?.length ? summarizePolicyDecisions(manifest.policyDecisions) : ["- (none)"]),
-			"",
-		].join("\n"),
-	});
-	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, summaryArtifact] };
-	saveRunManifest(manifest);
-	saveRunTasks(manifest, tasks);
-	return { manifest, tasks };
-}
+import type { AgentConfig } from "../agents/agent-config.ts";
+import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
+import type { CrewRuntimeCapabilities } from "./runtime-resolver.ts";
+import { writeArtifact } from "../state/artifact-store.ts";
+import { appendEvent } from "../state/event-log.ts";
+import type { TeamConfig } from "../teams/team-config.ts";
+import type { ArtifactDescriptor, PolicyDecision, TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import { saveRunManifest, saveRunTasks, updateRunStatus } from "../state/state-store.ts";
+import { aggregateUsage, formatUsage } from "../state/usage.ts";
+import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
+import { evaluateCrewPolicy, summarizePolicyDecisions } from "./policy-engine.ts";
+import { buildRecoveryLedger } from "./recovery-recipes.ts";
+import { getReadyTasks, refreshTaskGraphQueues, taskGraphSnapshot } from "./task-graph-scheduler.ts";
+import { checkBranchFreshness } from "../worktree/branch-freshness.ts";
+import { aggregateTaskOutputs } from "./task-output-context.ts";
+import { saveCrewAgents } from "./crew-agent-records.ts";
+import { recordsForMaterializedTasks } from "./task-display.ts";
+import { deliverGroupJoin, resolveGroupJoinMode } from "./group-join.ts";
+import { runTeamTask } from "./task-runner.ts";
+
+export interface ExecuteTeamRunInput {
+	manifest: TeamRunManifest;
+	tasks: TeamTaskState[];
+	team: TeamConfig;
+	workflow: WorkflowConfig;
+	agents: AgentConfig[];
+	executeWorkers: boolean;
+	limits?: CrewLimitsConfig;
+	runtime?: CrewRuntimeCapabilities;
+	runtimeConfig?: CrewRuntimeConfig;
+	parentContext?: string;
+	parentModel?: unknown;
+	modelRegistry?: unknown;
+	modelOverride?: string;
+	signal?: AbortSignal;
+}
+
+function findReadyTask(tasks: TeamTaskState[]): TeamTaskState | undefined {
+	return getReadyTasks(tasks, 1)[0];
+}
+
+function findStep(workflow: WorkflowConfig, task: TeamTaskState): WorkflowStep {
+	const step = workflow.steps.find((candidate) => candidate.id === task.stepId);
+	if (!step) throw new Error(`Workflow step '${task.stepId}' not found for task '${task.id}'.`);
+	return step;
+}
+
+function findAgent(agents: AgentConfig[], task: TeamTaskState): AgentConfig {
+	const agent = agents.find((candidate) => candidate.name === task.agent);
+	if (!agent) throw new Error(`Agent '${task.agent}' not found for task '${task.id}'.`);
+	return agent;
+}
+
+function markBlocked(tasks: TeamTaskState[], reason: string): TeamTaskState[] {
+	return tasks.map((task) => task.status === "queued" ? { ...task, status: "skipped", error: reason, finishedAt: new Date().toISOString(), graph: task.graph ? { ...task.graph, queue: "blocked" } : undefined } : task);
+}
+
+function mergeArtifacts(items: ArtifactDescriptor[]): ArtifactDescriptor[] {
+	const byPath = new Map<string, ArtifactDescriptor>();
+	for (const item of items) byPath.set(item.path, item);
+	return [...byPath.values()];
+}
+
+function mergeTaskUpdates(base: TeamTaskState[], results: Array<{ tasks: TeamTaskState[] }>): TeamTaskState[] {
+	let merged = base;
+	for (const result of results) {
+		for (const updated of result.tasks) {
+			const current = merged.find((task) => task.id === updated.id);
+			if (!current) continue;
+			if (updated.status !== current.status || updated.finishedAt || updated.startedAt || updated.resultArtifact || updated.error) {
+				merged = merged.map((task) => task.id === updated.id ? updated : task);
+			}
+		}
+	}
+	return refreshTaskGraphQueues(merged);
+}
+
+function formatTaskProgress(task: TeamTaskState): string {
+	return `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.error ? ` - ${task.error}` : ""}`;
+}
+
+function writeProgress(manifest: TeamRunManifest, tasks: TeamTaskState[], producer: string): TeamRunManifest {
+	const counts = new Map<string, number>();
+	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
+	const queue = taskGraphSnapshot(tasks);
+	const progress = writeArtifact(manifest.artifactsRoot, {
+		kind: "progress",
+		relativePath: "progress.md",
+		producer,
+		content: [
+			`# pi-crew progress ${manifest.runId}`,
+			"",
+			`Status: ${manifest.status}`,
+			`Team: ${manifest.team}`,
+			`Workflow: ${manifest.workflow ?? "(none)"}`,
+			`Updated: ${new Date().toISOString()}`,
+			`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
+			`Queue: ready=${queue.ready.length}, blocked=${queue.blocked.length}, running=${queue.running.length}, done=${queue.done.length}, failed=${queue.failed.length}, cancelled=${queue.cancelled.length}`,
+			"",
+			"## Tasks",
+			...tasks.map(formatTaskProgress),
+			"",
+		].join("\n"),
+	});
+	return { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "progress" && artifact.path === progress.path)), progress] };
+}
+
+function applyPolicy(manifest: TeamRunManifest, tasks: TeamTaskState[], limits?: CrewLimitsConfig): TeamRunManifest {
+	const branchFreshness = checkBranchFreshness(manifest.cwd);
+	const branchArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: "metadata/branch-freshness.json",
+		producer: "branch-freshness",
+		content: `${JSON.stringify(branchFreshness, null, 2)}\n`,
+	});
+	let decisions: PolicyDecision[] = evaluateCrewPolicy({ manifest, tasks, limits });
+	if (branchFreshness.status === "stale" || branchFreshness.status === "diverged") {
+		const branchDecision: PolicyDecision = {
+			action: "notify",
+			reason: "branch_stale",
+			message: branchFreshness.message,
+			createdAt: new Date().toISOString(),
+		};
+		decisions = [...decisions, branchDecision];
+		appendEvent(manifest.eventsPath, { type: "branch.stale", runId: manifest.runId, message: branchFreshness.message, data: { branchFreshness } });
+	}
+	const policyArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: "policy-decisions.json",
+		producer: "policy-engine",
+		content: `${JSON.stringify(decisions, null, 2)}\n`,
+	});
+	const recoveryLedger = buildRecoveryLedger(decisions);
+	const recoveryArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: "recovery-ledger.json",
+		producer: "recovery-engine",
+		content: `${JSON.stringify(recoveryLedger, null, 2)}\n`,
+	});
+	for (const item of decisions) appendEvent(manifest.eventsPath, { type: item.action === "escalate" ? "policy.escalated" : "policy.action", runId: manifest.runId, taskId: item.taskId, message: item.message, data: { action: item.action, reason: item.reason } });
+	for (const item of recoveryLedger.entries) appendEvent(manifest.eventsPath, { type: item.state === "escalation_required" ? "recovery.escalated" : "recovery.attempted", runId: manifest.runId, taskId: item.taskId, message: item.message, data: { scenario: item.scenario, steps: item.steps, attempt: item.attempt, state: item.state } });
+	return { ...manifest, updatedAt: new Date().toISOString(), policyDecisions: decisions, artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "metadata" && (artifact.path.endsWith("policy-decisions.json") || artifact.path.endsWith("recovery-ledger.json") || artifact.path.endsWith("branch-freshness.json")))), branchArtifact, policyArtifact, recoveryArtifact] };
+}
+
+export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
+	let manifest = updateRunStatus(input.manifest, "running", input.executeWorkers ? "Executing team workflow." : "Creating workflow prompts and placeholder results.");
+	let tasks = refreshTaskGraphQueues(input.tasks);
+	manifest = writeProgress(manifest, tasks, "team-runner");
+	saveRunManifest(manifest);
+	const runtimeKind = input.runtime?.kind ?? (input.executeWorkers ? "child-process" : "scaffold");
+	saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+
+	while (tasks.some((task) => task.status === "queued")) {
+		if (input.signal?.aborted) {
+			tasks = tasks.map((task) => task.status === "queued" || task.status === "running" ? { ...task, status: "cancelled", finishedAt: new Date().toISOString(), error: "Run cancelled." } : task);
+			saveRunTasks(manifest, tasks);
+			manifest = updateRunStatus(manifest, "cancelled", "Run cancelled.");
+			return { manifest, tasks };
+		}
+
+		const failed = tasks.find((task) => task.status === "failed");
+		if (failed) {
+			tasks = markBlocked(tasks, `Blocked by failed task '${failed.id}'.`);
+			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
+			return { manifest, tasks };
+		}
+
+		const defaultConcurrency = input.workflow.name === "parallel-research" ? 4 : input.workflow.name === "research" ? 2 : input.workflow.name === "implementation" || input.workflow.name === "review" || input.workflow.name === "default" ? 2 : 1;
+		const maxConcurrent = Math.max(1, input.limits?.maxConcurrentWorkers ?? input.team.maxConcurrency ?? defaultConcurrency);
+		const readyBatch = getReadyTasks(tasks, maxConcurrent);
+		if (readyBatch.length === 0) {
+			tasks = markBlocked(tasks, "No ready queued task; dependency graph may be invalid.");
+			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "blocked", "No ready queued task.");
+			return { manifest, tasks };
+		}
+
+		appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, message: `Starting ready batch with ${readyBatch.length} task(s).`, data: { taskIds: readyBatch.map((task) => task.id), maxConcurrent } });
+		const results = await Promise.all(readyBatch.map((task) => {
+			const step = findStep(input.workflow, task);
+			const agent = findAgent(input.agents, task);
+			return runTeamTask({ manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, modelOverride: input.modelOverride, limits: input.limits });
+		}));
+		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
+		tasks = mergeTaskUpdates(tasks, results);
+		saveRunTasks(manifest, tasks);
+		saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+		const completedBatch = readyBatch.map((task) => tasks.find((item) => item.id === task.id) ?? task);
+		const batchArtifact = writeArtifact(manifest.artifactsRoot, {
+			kind: "summary",
+			relativePath: `batches/${readyBatch.map((task) => task.id).join("+")}.md`,
+			producer: "team-runner",
+			content: aggregateTaskOutputs(completedBatch),
+		});
+		const groupDelivery = deliverGroupJoin({ manifest, mode: resolveGroupJoinMode(input.runtimeConfig), batch: readyBatch, allTasks: tasks });
+		manifest = { ...manifest, artifacts: mergeArtifacts([...manifest.artifacts, batchArtifact, ...(groupDelivery?.artifact ? [groupDelivery.artifact] : [])]) };
+		manifest = writeProgress(manifest, tasks, "team-runner");
+		saveRunManifest(manifest);
+	}
+
+	const failed = tasks.find((task) => task.status === "failed");
+	manifest = applyPolicy(manifest, tasks, input.limits);
+	const blockingDecision = manifest.policyDecisions?.find((item) => item.action === "block" || item.action === "escalate");
+	if (failed) {
+		manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
+	} else if (blockingDecision) {
+		manifest = updateRunStatus(manifest, "blocked", blockingDecision.message);
+	} else {
+		manifest = updateRunStatus(manifest, "completed", input.executeWorkers ? "Team workflow completed." : "Team workflow scaffold completed without launching child workers.");
+	}
+	manifest = writeProgress(manifest, tasks, "team-runner");
+	saveRunManifest(manifest);
+	const usage = aggregateUsage(tasks);
+	const summaryArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "summary",
+		relativePath: "summary.md",
+		producer: "team-runner",
+		content: [
+			`# pi-crew run ${manifest.runId}`,
+			"",
+			`Status: ${manifest.status}`,
+			`Team: ${manifest.team}`,
+			`Workflow: ${manifest.workflow ?? "(none)"}`,
+			`Goal: ${manifest.goal}`,
+			`Usage: ${formatUsage(usage)}`,
+			"",
+			"## Tasks",
+			...tasks.map(formatTaskProgress),
+			"",
+			"## Policy decisions",
+			...(manifest.policyDecisions?.length ? summarizePolicyDecisions(manifest.policyDecisions) : ["- (none)"]),
+			"",
+		].join("\n"),
+	});
+	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, summaryArtifact] };
+	saveRunManifest(manifest);
+	saveRunTasks(manifest, tasks);
+	return { manifest, tasks };
+}

package/src/ui/live-run-sidebar.ts

@@ -0,0 +1,95 @@
+import * as fs from "node:fs";
+import type { CrewUiConfig } from "../config/config.ts";
+import { readCrewAgents } from "../runtime/crew-agent-records.ts";
+import { applyAttentionState, resolveCrewControlConfig } from "../runtime/agent-control.ts";
+import { formatTaskGraphLines, waitingReason } from "../runtime/task-display.ts";
+import { loadRunManifestById } from "../state/state-store.ts";
+import { aggregateUsage, formatUsage } from "../state/usage.ts";
+import type { TeamTaskState } from "../state/types.ts";
+
+const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
+type ThemeLike = { fg?: (color: string, text: string) => string; bold?: (text: string) => string };
+type Done = (value: undefined) => void;
+
+function visibleLength(value: string): number { return value.replace(ANSI_PATTERN, "").length; }
+function truncate(value: string, width: number): string {
+	if (width <= 0) return "";
+	if (visibleLength(value) <= width) return value;
+	return `${value.slice(0, Math.max(0, width - 1))}…`;
+}
+function pad(value: string, width: number): string { return `${value}${" ".repeat(Math.max(0, width - visibleLength(value)))}`; }
+function line(text: string, width: number): string { return `│ ${pad(truncate(text, width - 4), width - 4)} │`; }
+function border(left: string, fill: string, right: string, width: number): string { return `${left}${fill.repeat(Math.max(0, width - 2))}${right}`; }
+function readTasks(path: string): TeamTaskState[] {
+	try { const parsed = JSON.parse(fs.readFileSync(path, "utf-8")); return Array.isArray(parsed) ? parsed as TeamTaskState[] : []; } catch { return []; }
+}
+function shortUsage(tasks: TeamTaskState[]): string {
+	const usage = aggregateUsage(tasks);
+	return usage ? formatUsage(usage) : "usage=(none)";
+}
+function glyph(status: string): string {
+	if (status === "running") return "⠋";
+	if (status === "completed") return "✓";
+	if (status === "failed") return "✗";
+	if (status === "cancelled" || status === "stopped") return "■";
+	return "◦";
+}
+
+export class LiveRunSidebar {
+	private readonly cwd: string;
+	private readonly runId: string;
+	private readonly done: Done;
+	private readonly theme: ThemeLike;
+	private readonly config: CrewUiConfig;
+
+	constructor(input: { cwd: string; runId: string; done: Done; theme?: unknown; config?: CrewUiConfig }) {
+		this.cwd = input.cwd;
+		this.runId = input.runId;
+		this.done = input.done;
+		this.theme = (input.theme ?? {}) as ThemeLike;
+		this.config = input.config ?? {};
+	}
+
+	invalidate(): void {}
+
+	render(width: number): string[] {
+		const fg = this.theme.fg?.bind(this.theme) ?? ((_color: string, text: string) => text);
+		const bold = this.theme.bold?.bind(this.theme) ?? ((text: string) => text);
+		const w = Math.max(36, width);
+		const loaded = loadRunManifestById(this.cwd, this.runId);
+		if (!loaded) return [border("╭", "─", "╮", w), line(`${bold("pi-crew live sidebar")} · run not found`, w), border("╰", "─", "╯", w)];
+		const tasks = readTasks(loaded.manifest.tasksPath);
+		const controlConfig = resolveCrewControlConfig({ ui: this.config });
+		const agents = readCrewAgents(loaded.manifest).map((agent) => applyAttentionState(loaded.manifest, agent, controlConfig));
+		const active = agents.filter((agent) => agent.status === "running");
+		const completed = agents.filter((agent) => agent.status !== "running").slice(-5);
+		const waiting = tasks.filter((task) => task.status === "queued");
+		const lines: string[] = [
+			border("╭", "─", "╮", w),
+			line(`${fg("accent", "▐")} ${bold("pi-crew live sidebar")} · right default`, w),
+			line(`run ${loaded.manifest.runId.slice(-12)} · ${loaded.manifest.status}`, w),
+			line(`${loaded.manifest.team}/${loaded.manifest.workflow ?? "none"} · ${shortUsage(tasks)}`, w),
+			border("├", "─", "┤", w),
+			line(`Active agents (${active.length})`, w),
+		];
+		for (const agent of active.slice(0, 8)) {
+			const usage = agent.usage ? formatUsage(agent.usage) : agent.progress?.tokens ? `tokens=${agent.progress.tokens}` : "usage=pending";
+			lines.push(line(`${glyph(agent.status)} ${agent.taskId} ${agent.role}->${agent.agent}`, w));
+			lines.push(line(`  ${agent.model ? `model ${agent.model}` : "model pending"}`, w));
+			lines.push(line(`  ${agent.progress?.currentTool ? `tool ${agent.progress.currentTool} · ` : ""}${agent.toolUses ?? 0} tools · ${usage}`, w));
+		}
+		if (active.length === 0) lines.push(line("- none", w));
+		lines.push(border("├", "─", "┤", w), line(`Waiting tasks (${waiting.length})`, w));
+		for (const task of waiting.slice(0, 8)) lines.push(line(`◦ ${task.id} ${waitingReason(task, tasks) ?? "waiting"}`, w));
+		if (waiting.length === 0) lines.push(line("- none", w));
+		lines.push(border("├", "─", "┤", w), line(`Completed agents (${completed.length})`, w));
+		for (const agent of completed) lines.push(line(`${glyph(agent.status)} ${agent.taskId} ${agent.model ? `· ${agent.model}` : ""}${agent.usage ? ` · ${formatUsage(agent.usage)}` : ""}`, w));
+		if (completed.length === 0) lines.push(line("- none", w));
+		lines.push(border("├", "─", "┤", w), ...formatTaskGraphLines(tasks).slice(0, 6).map((entry) => line(entry, w)), line("q close · /team-dashboard details", w), border("╰", "─", "╯", w));
+		return lines.map((entry) => truncate(entry, w));
+	}
+
+	handleInput(data: string): void {
+		if (data === "q" || data === "\u001b") this.done(undefined);
+	}
+}

package/src/ui/powerbar-publisher.ts

@@ -1,6 +1,9 @@
 import type { CrewUiConfig } from "../config/config.ts";
 import { listRecentRuns } from "../extension/run-index.ts";
+import * as fs from "node:fs";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
+import type { TeamTaskState } from "../state/types.ts";
+import { aggregateUsage } from "../state/usage.ts";
 import { isDisplayActiveRun } from "../runtime/process-status.ts";
 
 type EventBus = { emit?: (event: string, data: unknown) => void } | undefined;
@@ -9,6 +12,14 @@ function safeEmit(events: EventBus, event: string, data: unknown): void {
 	try { events?.emit?.(event, data); } catch {}
 }
 
+function readTasks(tasksPath: string): TeamTaskState[] {
+	try { const parsed = JSON.parse(fs.readFileSync(tasksPath, "utf-8")); return Array.isArray(parsed) ? parsed as TeamTaskState[] : []; } catch { return []; }
+}
+
+function compactTokens(total: number): string {
+	return total >= 1000 ? `${Math.round(total / 1000)}k` : `${total}`;
+}
+
 export function registerPiCrewPowerbarSegments(events: EventBus, config?: CrewUiConfig): void {
 	if (config?.powerbar === false) return;
 	safeEmit(events, "powerbar:register-segment", { id: "pi-crew-active", label: "pi-crew active agents" });
@@ -28,22 +39,26 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 		return;
 	}
 	const agents = active.flatMap((item) => item.agents);
+	const tasks = active.flatMap((item) => readTasks(item.run.tasksPath));
 	const running = agents.filter((agent) => agent.status === "running").length;
-	const queued = agents.filter((agent) => agent.status === "queued").length;
+	const waiting = tasks.filter((task) => task.status === "queued").length;
 	const completed = agents.filter((agent) => agent.status === "completed").length;
-	const total = Math.max(1, agents.length);
+	const total = Math.max(1, agents.length + waiting);
+	const usage = aggregateUsage(tasks);
+	const tokenTotal = usage ? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) : 0;
+	const model = agents.find((agent) => agent.model)?.model?.split("/").at(-1);
 	safeEmit(events, "powerbar:update", {
 		id: "pi-crew-active",
 		icon: "⚙",
-		text: `crew ${running || active.length}`,
-		suffix: queued ? `${queued}q` : undefined,
+		text: `crew ${running}a/${waiting}w`,
+		suffix: [model, tokenTotal ? compactTokens(tokenTotal) : undefined].filter(Boolean).join(" · ") || undefined,
 		color: running ? "accent" : "warning",
 	});
 	safeEmit(events, "powerbar:update", {
 		id: "pi-crew-progress",
 		text: active[0]?.run.team ?? "crew",
 		bar: Math.round((completed / total) * 100),
-		suffix: `${completed}/${total}`,
+		suffix: `${completed}/${total}${tokenTotal ? ` · ${compactTokens(tokenTotal)}` : ""}`,
 		color: completed === total ? "success" : "accent",
 		barSegments: 8,
 	});

package/teams/parallel-research.team.md

@@ -0,0 +1,14 @@
+---
+name: parallel-research
+description: Parallel research team for multi-project/source audits
+workspaceMode: single
+defaultWorkflow: parallel-research
+maxConcurrency: 4
+triggers: đọc sâu, deep read, deep research, source audit, multiple projects, parallel research, pi-*
+category: research
+cost: cheap
+---
+
+- explorer: agent=explorer gather source facts in parallel shards
+- analyst: agent=analyst synthesize shard findings
+- writer: agent=writer produce final notes

package/workflows/parallel-research.workflow.md

@@ -0,0 +1,50 @@
+---
+name: parallel-research
+description: Parallel research with shard exploration and synthesis
+---
+
+## discover
+role: explorer
+
+Discover the relevant files/projects for: {goal}. Return a shard plan with paths grouped by topic. Do not deeply read every file yet; focus on routing the work.
+
+## explore-core
+role: explorer
+dependsOn: discover
+parallelGroup: explore
+
+Explore the core/runtime shard from the discover output. Focus on architecture, package config, docs, and reusable patterns for: {goal}
+
+## explore-ui
+role: explorer
+dependsOn: discover
+parallelGroup: explore
+
+Explore the UI/TUI/extension-interface shard from the discover output. Focus on widgets, overlays, commands, status bars, package config, docs, and reusable patterns for: {goal}
+
+## explore-runtime
+role: explorer
+dependsOn: discover
+parallelGroup: explore
+
+Explore the worker/runtime/subagent/runtime-control shard from the discover output. Focus on process/session/runtime orchestration, event streams, logs, package config, docs, and reusable patterns for: {goal}
+
+## explore-extensions
+role: explorer
+dependsOn: discover
+parallelGroup: explore
+
+Explore the extension bundle/small-package shard from the discover output. Focus on package config, extension registration, commands/tools, docs, and reusable patterns for: {goal}
+
+## synthesize
+role: analyst
+dependsOn: explore-core, explore-ui, explore-runtime, explore-extensions
+
+Synthesize all shard findings. Identify common patterns, gaps, and concrete recommendations.
+
+## write
+role: writer
+dependsOn: synthesize
+output: research-summary.md
+
+Write a concise final summary with evidence, risks, and actionable next steps.