pi-crew 0.1.16 → 0.1.18

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # 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.
+- Cleaned child-process result extraction so result artifacts prefer final assistant output and no longer include worker prompt/context.
+- Made `/team-dashboard` visibly render as a top-right sidebar by default with explicit right-sidebar title text.
+- Added per-subagent model and usage fields to agent records, status output, and dashboard fallbacks so model/token totals stay visible while and after workers run.
+
 ## 0.1.16
 
 - Added right-side `/team-dashboard` placement with model, token, and tool detail rows for subagents.

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.16",
+  "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

@@ -7,8 +7,9 @@ import { notifyActiveRuns } from "./session-summary.ts";
 import { piTeamsHelp } from "./help.ts";
 import { handleTeamManagerCommand } from "./team-manager-command.ts";
 import { handleTeamTool, type TeamToolDetails } from "./team-tool.ts";
-import { listRuns } from "./run-index.ts";
+import { listRecentRuns } from "./run-index.ts";
 import { RunDashboard, type RunDashboardSelection } from "../ui/run-dashboard.ts";
+import { 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));
 		},
 	});
@@ -381,13 +408,15 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		description: "Open a pi-crew run dashboard overlay",
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
 			for (;;) {
-				const runs = listRuns(ctx.cwd).slice(0, 50);
+				const runs = listRecentRuns(ctx.cwd, 50);
 				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 }), {
+				const width = rightPanel ? Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? 56)) : "90%";
+				const selection = await ctx.ui.custom<RunDashboardSelection | undefined>((_tui, theme, _keybindings, done) => new RunDashboard(runs, done, theme, { placement: rightPanel ? "right" : "center", showModel: uiConfig?.showModel, showTokens: uiConfig?.showTokens, showTools: uiConfig?.showTools }), {
 					overlay: true,
-					overlayOptions: { width, 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 },
+					overlayOptions: rightPanel
+						? { width, minWidth: 40, maxHeight: "100%", anchor: "top-right", offsetX: 0, offsetY: 0, margin: { top: 0, right: 0, bottom: 0, left: 0 } }
+						: { width, maxHeight: "90%", anchor: "center", margin: 2 },
 				});
 				if (!selection) return;
 				if (selection.action === "reload") continue;

package/src/extension/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.progress?.activityState === "needs_attention" ? " needs_attention" : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`) : ["- (none)"]),
+		"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,10 @@ 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>();
 
 function appendBoundedTail(current: string, chunk: string, maxBytes = MAX_CAPTURE_BYTES): string {
@@ -68,12 +72,27 @@ function appendTranscript(input: ChildPiRunInput, line: string): void {
 	fs.appendFileSync(input.transcriptPath, `${line}\n`, "utf-8");
 }
 
+function compactString(value: string, maxChars = MAX_COMPACT_CONTENT_CHARS): string {
+	if (value.length <= maxChars) return value;
+	return `${value.slice(0, maxChars)}\n[pi-crew compacted ${value.length - maxChars} chars]`;
+}
+
+function compactValue(value: unknown): unknown {
+	if (typeof value === "string") return compactString(value);
+	if (Array.isArray(value)) return value.slice(0, 20).map(compactValue);
+	const record = asRecord(value);
+	if (!record) return value;
+	const compacted: Record<string, unknown> = {};
+	for (const [key, entry] of Object.entries(record).slice(0, 20)) compacted[key] = compactValue(entry);
+	return compacted;
+}
+
 function compactContentPart(part: unknown): unknown | undefined {
 	const record = asRecord(part);
 	if (!record) return undefined;
-	if (record.type === "text") return { type: "text", text: typeof record.text === "string" ? 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 };
+	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;
 }
 
@@ -86,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,
@@ -106,7 +126,9 @@ function displayTextFromCompactEvent(event: unknown): string | undefined {
 	if (record.type === "tool_execution_start") {
 		return typeof record.toolName === "string" ? `tool: ${record.toolName}` : "tool started";
 	}
+	if (record.type !== "message" && record.type !== "message_end") return undefined;
 	const message = asRecord(record.message);
+	if (message?.role !== undefined && message.role !== "assistant") return undefined;
 	const content = Array.isArray(message?.content) ? message.content : [];
 	const text = content.flatMap((part) => {
 		const item = asRecord(part);

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

@@ -124,6 +124,12 @@ export function emptyCrewAgentProgress(): CrewAgentProgress {
 	return { recentTools: [], recentOutput: [], toolCount: 0 };
 }
 
+function modelFromTask(task: TeamTaskState): string | undefined {
+	const attempts = task.modelAttempts;
+	if (!attempts?.length) return undefined;
+	return attempts.find((attempt) => attempt.success)?.model ?? attempts.at(-1)?.model;
+}
+
 export function recordFromTask(manifest: TeamRunManifest, task: TeamTaskState, runtime: CrewRuntimeKind): CrewAgentRecord {
 	return {
 		id: `${manifest.runId}:${task.id}`,
@@ -142,6 +148,8 @@ export function recordFromTask(manifest: TeamRunManifest, task: TeamTaskState, r
 		outputPath: agentOutputPath(manifest, task.id),
 		toolUses: task.agentProgress?.toolCount,
 		jsonEvents: task.jsonEvents,
+		model: modelFromTask(task),
+		usage: task.usage,
 		progress: task.agentProgress,
 		error: task.error,
 	};

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

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

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

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

package/src/runtime/policy-engine.ts

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

package/src/runtime/task-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/task-runner.ts

@@ -190,6 +190,17 @@ function shouldFlushProgressEvent(event: unknown): boolean {
 	return type === "tool_execution_start" || type === "tool_execution_end" || type === "message_end" || type === "tool_result_end";
 }
 
+function cleanResultText(text: string | undefined): string | undefined {
+	const trimmed = text?.trim();
+	if (!trimmed) return undefined;
+	const doneIndex = trimmed.lastIndexOf("\nDONE\n");
+	if (doneIndex >= 0) return trimmed.slice(doneIndex + 1).trim();
+	if (trimmed === "DONE" || trimmed.startsWith("DONE\n")) return trimmed;
+	const fencedPromptIndex = trimmed.lastIndexOf("</file>");
+	if (fencedPromptIndex >= 0 && fencedPromptIndex < trimmed.length - 7) return trimmed.slice(fencedPromptIndex + 7).trim() || trimmed;
+	return trimmed;
+}
+
 function progressEventSummary(task: TeamTaskState, event: unknown): Record<string, unknown> {
 	const type = asRecord(event)?.type;
 	return {
@@ -309,6 +320,10 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		for (let i = 0; i < attemptModels.length; i++) {
 			const model = attemptModels[i];
 			const attemptStartedAt = new Date();
+			const pendingAttempt: ModelAttemptSummary = { model: model ?? "default", success: false };
+			task = { ...task, modelAttempts: [...modelAttempts, pendingAttempt] };
+			tasks = updateTask(tasks, task);
+			upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
 			const childResult = await runChildPi({
 				cwd: task.cwd,
 				task: prompt,
@@ -329,11 +344,13 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 			exitCode = childResult.exitCode;
 			finalStdout = childResult.stdout;
 			finalStderr = childResult.stderr;
-			parsedOutput = parsePiJsonOutput(childResult.stdout);
+			parsedOutput = parsePiJsonOutput(fs.existsSync(transcriptPath) ? fs.readFileSync(transcriptPath, "utf-8") : childResult.stdout);
 			error = childResult.error || (childResult.exitCode && childResult.exitCode !== 0 ? childResult.stderr || `Child Pi exited with ${childResult.exitCode}` : undefined);
 			persistChildProgress({ type: "attempt_finished" }, true);
 			const attempt: ModelAttemptSummary = { model: model ?? "default", success: !error, exitCode, error };
 			modelAttempts.push(attempt);
+			task = { ...task, modelAttempts: [...modelAttempts] };
+			tasks = updateTask(tasks, task);
 			logs.push(`MODEL ATTEMPT ${i + 1}: ${attempt.model}`, `success=${attempt.success}`, `exitCode=${attempt.exitCode ?? "null"}`, attempt.error ? `error=${attempt.error}` : "", "");
 			if (!error) break;
 			const nextModel = attemptModels[i + 1];
@@ -343,7 +360,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		resultArtifact = writeArtifact(manifest.artifactsRoot, {
 			kind: "result",
 			relativePath: `results/${task.id}.txt`,
-			content: parsedOutput?.finalText || finalStdout || finalStderr || "(no output)",
+			content: cleanResultText(parsedOutput?.finalText) ?? cleanResultText(finalStdout) ?? cleanResultText(finalStderr) ?? "(no output)",
 			producer: task.id,
 		});
 		logArtifact = writeArtifact(manifest.artifactsRoot, {