pi-crew 0.1.18 → 0.1.20

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.1.20
+
+- Reworked the implementation workflow into an adaptive planner-led orchestration flow that decides the number, roles, and phases of subagents from the task instead of using a fixed fanout template.
+- Added dynamic adaptive task injection, persisted adaptive task metadata, and resume reconstruction for planner-selected subagent steps.
+- Block implementation runs when the planner does not produce a valid adaptive plan, including missing/unreadable planner artifacts and malformed/oversized plans.
+- Added tests for adaptive plan parsing, dynamic batch fanout, invalid-plan blocking, writer-role support, and adaptive resume recovery.
+- Hardened subagent/runtime fixes from post-0.1.19 review: env-isolated depth tests, foreground failure status updates, generic tool conflict aliases, and max_turns propagation.
+
+## 0.1.19
+
+- Added Claude-style `Agent`, `get_subagent_result`, and `steer_subagent` tools backed by pi-crew's durable worker runtime, plus conflict-safe `crew_agent`, `crew_agent_result`, and `crew_agent_steer` aliases.
+- Added a durable subagent manager with background queueing, completion notifications, result joins, session-bound cleanup, and direct single-agent runs via `team run agent=...`.
+- Disabled risky auto-opening of the right sidebar by default, added foreground completion notifications, and reduced duplicate widget/sidebar UI.
+- Added progress coalescing and workflow concurrency helpers to keep foreground sessions responsive during busy worker output.
+- Fixed live-session runs being classified as scaffold when workers are enabled and hardened session switch/shutdown cleanup for foreground child processes.
+
 ## 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.

package/README.md

@@ -174,7 +174,7 @@ Supported config:
     "dashboardPlacement": "right",
     "dashboardWidth": 56,
     "dashboardLiveRefreshMs": 1000,
-    "autoOpenDashboard": true,
+    "autoOpenDashboard": false,
     "autoOpenDashboardForForegroundRuns": true,
     "showModel": true,
     "showTokens": true,
@@ -190,7 +190,7 @@ Safety notes:
 UI notes:
 
 - `widgetPlacement`/`widgetMaxLines` keep the persistent active-run widget compact.
-- `dashboardPlacement: "right"` is the default; foreground runs auto-open a live top-right sidebar when the terminal is wide enough.
+- `dashboardPlacement: "right"` is the default for `/team-dashboard`; automatic overlay opening is opt-in because Pi custom overlays can be modal/focus-capturing in some terminals.
 - `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.

package/docs/usage.md

@@ -36,7 +36,7 @@ Supported fields:
     "dashboardPlacement": "right",
     "dashboardWidth": 56,
     "dashboardLiveRefreshMs": 1000,
-    "autoOpenDashboard": true,
+    "autoOpenDashboard": false,
     "autoOpenDashboardForForegroundRuns": true,
     "showModel": true,
     "showTokens": true,

package/package.json

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

package/schema.json

@@ -90,7 +90,7 @@
         "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." },
+        "autoOpenDashboard": { "type": "boolean", "default": false, "description": "Opt in to automatically opening the live right sidebar for foreground runs when UI is available. Disabled by default because Pi overlays are modal in some terminals." },
         "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." },

package/src/extension/register.ts

@@ -1,4 +1,6 @@
+import * as fs from "node:fs";
 import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
 import { loadConfig } from "../config/config.ts";
 import { registerAutonomousPolicy } from "./autonomous-policy.ts";
 import { TeamToolParams, type TeamToolParamsValue } from "../schema/team-tool-schema.ts";
@@ -14,9 +16,10 @@ import { registerPiCrewRpc, type PiCrewRpcHandle } from "./cross-extension-rpc.t
 import { stopCrewWidget, updateCrewWidget, type CrewWidgetState } from "../ui/crew-widget.ts";
 import { clearPiCrewPowerbar, registerPiCrewPowerbarSegments, updatePiCrewPowerbar } from "../ui/powerbar-publisher.ts";
 import { DurableTextViewer, DurableTranscriptViewer } from "../ui/transcript-viewer.ts";
-import { loadRunManifestById } from "../state/state-store.ts";
+import { loadRunManifestById, updateRunStatus } from "../state/state-store.ts";
 import { readCrewAgents } from "../runtime/crew-agent-records.ts";
 import { terminateActiveChildPiProcesses } from "../runtime/child-pi.ts";
+import { SubagentManager, type SubagentRecord, type SubagentSpawnOptions } from "../runtime/subagent-manager.ts";
 
 function parseRunArgs(args: string): TeamToolParamsValue {
 	const tokens = args.match(/"[^"]*"|'[^']*'|\S+/g)?.map((token) => token.replace(/^['"]|['"]$/g, "")) ?? [];
@@ -100,6 +103,55 @@ function setNestedConfig(config: Record<string, unknown>, key: string, value: un
 	target[parts[parts.length - 1]!] = value;
 }
 
+function sendFollowUp(pi: ExtensionAPI, content: string): void {
+	const sender = (pi as unknown as { sendMessage?: (message: unknown, options?: unknown) => void }).sendMessage;
+	if (typeof sender !== "function") return;
+	sender.call(pi, { customType: "pi-crew-subagent-notification", content, display: true }, { deliverAs: "followUp", triggerTurn: true });
+}
+
+function formatSubagentRecord(record: SubagentRecord): string {
+	const duration = record.completedAt ? `${Math.round((record.completedAt - record.startedAt) / 1000)}s` : "running";
+	return [
+		`Agent: ${record.id}`,
+		`Type: ${record.type}`,
+		`Status: ${record.status}`,
+		record.runId ? `Run: ${record.runId}` : undefined,
+		`Description: ${record.description}`,
+		record.model ? `Model: ${record.model}` : undefined,
+		`Duration: ${duration}`,
+		record.error ? `Error: ${record.error}` : undefined,
+	].filter((line): line is string => Boolean(line)).join("\n");
+}
+
+function readSubagentRunResult(ctx: ExtensionContext | ExtensionCommandContext, record: SubagentRecord): string | undefined {
+	if (!record.runId) return record.result;
+	const loaded = loadRunManifestById(ctx.cwd, record.runId);
+	const task = loaded?.tasks.find((item) => item.resultArtifact) ?? loaded?.tasks[0];
+	const path = task?.resultArtifact?.path;
+	if (!path) return undefined;
+	try {
+		return fs.readFileSync(path, "utf-8").trim();
+	} catch {
+		return undefined;
+	}
+}
+
+function subagentToolResult(text: string, details: Record<string, unknown> = {}, isError = false) {
+	return { content: [{ type: "text" as const, text }], details, isError };
+}
+
+export function __test__subagentSpawnParams(params: Record<string, unknown>, ctx: Pick<ExtensionContext, "cwd">): SubagentSpawnOptions {
+	return {
+		cwd: ctx.cwd,
+		type: typeof params.subagent_type === "string" && params.subagent_type.trim() ? params.subagent_type.trim() : "executor",
+		description: typeof params.description === "string" && params.description.trim() ? params.description.trim() : "pi-crew subagent",
+		prompt: typeof params.prompt === "string" ? params.prompt : "",
+		background: params.run_in_background === true,
+		model: typeof params.model === "string" && params.model.trim() ? params.model.trim() : undefined,
+		maxTurns: typeof params.max_turns === "number" && Number.isFinite(params.max_turns) ? params.max_turns : undefined,
+	};
+}
+
 export function registerPiTeams(pi: ExtensionAPI): void {
 	const globalStore = globalThis as Record<string, unknown>;
 	const runtimeCleanupStoreKey = "__piCrewRuntimeCleanup";
@@ -112,18 +164,37 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	let rpcHandle: PiCrewRpcHandle | undefined;
 	let cleanedUp = false;
 	const widgetState: CrewWidgetState = { frame: 0 };
+	const subagentManager = new SubagentManager(4, (record) => {
+		if (!record.background || record.resultConsumed) return;
+		if (record.status === "completed" || record.status === "failed" || record.status === "cancelled" || record.status === "error") {
+			sendFollowUp(pi, [`pi-crew subagent ${record.id} ${record.status}.`, record.runId ? `Run: ${record.runId}` : undefined, `Use get_subagent_result with agent_id=${record.id} for output.`].filter((line): line is string => Boolean(line)).join("\n"));
+		}
+	});
 	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 stopSessionBoundSubagents = (): void => {
+		for (const controller of foregroundControllers) controller.abort();
+		foregroundControllers.clear();
+		subagentManager.abortAll();
+		terminateActiveChildPiProcesses();
+		if (liveSidebarTimer) clearInterval(liveSidebarTimer);
+		liveSidebarTimer = undefined;
+		liveSidebarRunId = undefined;
+		if (currentCtx) stopCrewWidget(currentCtx, widgetState, loadConfig(currentCtx.cwd).config.ui);
+		clearPiCrewPowerbar(pi.events);
+	};
 	const openLiveSidebar = (ctx: ExtensionContext, runId: string): void => {
 		const uiConfig = loadConfig(ctx.cwd).config.ui;
-		const autoOpen = uiConfig?.autoOpenDashboard ?? true;
-		const foregroundAutoOpen = uiConfig?.autoOpenDashboardForForegroundRuns ?? true;
+		const autoOpen = uiConfig?.autoOpenDashboard === true;
+		const foregroundAutoOpen = uiConfig?.autoOpenDashboardForForegroundRuns !== false;
 		if (!ctx.hasUI || !autoOpen || !foregroundAutoOpen || (uiConfig?.dashboardPlacement ?? "right") !== "right") return;
 		if (liveSidebarRunId === runId) return;
 		if (liveSidebarTimer) clearInterval(liveSidebarTimer);
 		liveSidebarRunId = runId;
+		ctx.ui.setWidget("pi-crew", undefined, { placement: uiConfig?.widgetPlacement ?? "aboveEditor" });
+		ctx.ui.setWidget("pi-crew-active", undefined, { placement: uiConfig?.widgetPlacement ?? "aboveEditor" });
 		const width = Math.min(90, Math.max(40, uiConfig?.dashboardWidth ?? 56));
 		liveSidebarTimer = setInterval(() => requestRender(ctx), uiConfig?.dashboardLiveRefreshMs ?? 1000);
 		liveSidebarTimer.unref?.();
@@ -134,19 +205,32 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			if (liveSidebarRunId === runId) liveSidebarRunId = undefined;
 			if (liveSidebarTimer) clearInterval(liveSidebarTimer);
 			liveSidebarTimer = undefined;
+			updateCrewWidget(ctx, widgetState, loadConfig(ctx.cwd).config.ui);
 		});
 	};
-	const startForegroundRun = (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>): void => {
+	const startForegroundRun = (ctx: ExtensionContext, runner: (signal?: AbortSignal) => Promise<void>, runId?: string): void => {
 		const controller = new AbortController();
 		foregroundControllers.add(controller);
 		setImmediate(() => {
 			void runner(controller.signal)
 				.catch((error) => {
 					const message = error instanceof Error ? error.message : String(error);
+					if (runId) {
+						try {
+							const loaded = loadRunManifestById(ctx.cwd, runId);
+							if (loaded && loaded.manifest.status !== "completed" && loaded.manifest.status !== "failed" && loaded.manifest.status !== "cancelled" && loaded.manifest.status !== "blocked") updateRunStatus(loaded.manifest, "failed", message);
+						} catch {}
+					}
 					ctx.ui.notify(`pi-crew foreground run failed: ${message}`, "error");
 				})
 				.finally(() => {
 					foregroundControllers.delete(controller);
+					if (runId) {
+						const loaded = loadRunManifestById(ctx.cwd, runId);
+						const status = loaded?.manifest.status ?? "finished";
+						const level = status === "failed" || status === "blocked" ? "error" : status === "cancelled" ? "warning" : "info";
+						ctx.ui.notify(`pi-crew run ${runId} ${status}. Use /team-summary ${runId} or /team-status ${runId}.`, level as "info" | "warning" | "error");
+					}
 					if (currentCtx) {
 						const config = loadConfig(currentCtx.cwd).config.ui;
 						updateCrewWidget(currentCtx, widgetState, config);
@@ -160,14 +244,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	const cleanupRuntime = (): void => {
 		if (cleanedUp) return;
 		cleanedUp = true;
-		for (const controller of foregroundControllers) controller.abort();
-		foregroundControllers.clear();
-		terminateActiveChildPiProcesses();
+		stopSessionBoundSubagents();
 		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;
@@ -179,6 +258,8 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	pi.on("session_start", (_event, ctx) => {
 		cleanedUp = false;
 		currentCtx = ctx;
+		if (widgetState.interval) clearInterval(widgetState.interval);
+		widgetState.interval = undefined;
 		notifyActiveRuns(ctx);
 		const loadedConfig = loadConfig(ctx.cwd);
 		registerPiCrewPowerbarSegments(pi.events, loadedConfig.config.ui);
@@ -188,11 +269,19 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		widgetState.interval = setInterval(() => {
 			if (!currentCtx) return;
 			const config = loadConfig(currentCtx.cwd).config.ui;
-			updateCrewWidget(currentCtx, widgetState, config);
+			if (liveSidebarRunId) {
+				currentCtx.ui.setWidget("pi-crew", undefined, { placement: config?.widgetPlacement ?? "aboveEditor" });
+				currentCtx.ui.setWidget("pi-crew-active", undefined, { placement: config?.widgetPlacement ?? "aboveEditor" });
+			} else {
+				updateCrewWidget(currentCtx, widgetState, config);
+			}
 			updatePiCrewPowerbar(pi.events, currentCtx.cwd, config);
 		}, 1000);
 		widgetState.interval.unref?.();
 	});
+	pi.on("session_before_switch", () => {
+		stopSessionBoundSubagents();
+	});
 	pi.on("session_shutdown", () => {
 		cleanupRuntime();
 	});
@@ -209,7 +298,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), onRunStarted: (runId) => openLiveSidebar(ctx, runId) });
+				const output = await handleTeamTool(params as TeamToolParamsValue, { ...ctx, signal: controller.signal, startForegroundRun: (runner, runId) => startForegroundRun(ctx, runner, runId), onRunStarted: (runId) => openLiveSidebar(ctx, runId) });
 				const config = loadConfig(ctx.cwd).config.ui;
 				updateCrewWidget(ctx, widgetState, config);
 				updatePiCrewPowerbar(pi.events, ctx.cwd, config);
@@ -223,6 +312,108 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 
 	pi.registerTool(tool);
 
+	const agentTool: ToolDefinition = {
+		name: "Agent",
+		label: "Agent",
+		description: "Launch a real pi-crew subagent. Uses pi-crew's durable child-process runtime by default; set run_in_background=true for parallel/background work, then use get_subagent_result.",
+		promptSnippet: "Use Agent to delegate focused work to a real pi-crew subagent. Use run_in_background=true for parallel work and get_subagent_result to join results.",
+		promptGuidelines: [
+			"Use Agent for independent exploration, review, verification, or implementation subtasks instead of doing all work in the parent turn.",
+			"For parallel work, launch multiple Agent calls with run_in_background=true, then call get_subagent_result for each result.",
+			"Available pi-crew subagent types include explorer, planner, analyst, executor, reviewer, verifier, writer, security-reviewer, and test-engineer.",
+		],
+		parameters: Type.Object({
+			prompt: Type.String({ description: "The task for the subagent to perform." }),
+			description: Type.String({ description: "Short 3-5 word task description." }),
+			subagent_type: Type.String({ description: "pi-crew agent name, e.g. explorer, planner, executor, reviewer, verifier, writer, security-reviewer, test-engineer." }),
+			model: Type.Optional(Type.String({ description: "Optional model override. If omitted, pi-crew uses Pi-configured model fallback." })),
+			max_turns: Type.Optional(Type.Number({ description: "Reserved for live-session subagents; child-process runtime may ignore this." })),
+			run_in_background: Type.Optional(Type.Boolean({ description: "Run in background and return an agent ID immediately." })),
+		}) as never,
+		async execute(_id, params, signal, _onUpdate, ctx) {
+			const options = __test__subagentSpawnParams(params as Record<string, unknown>, ctx);
+			if (!options.prompt.trim()) return subagentToolResult("Agent requires prompt.", {}, true);
+			const runner = async (spawnOptions: SubagentSpawnOptions, childSignal?: AbortSignal) => handleTeamTool({
+				action: "run",
+				agent: spawnOptions.type,
+				goal: spawnOptions.prompt,
+				model: spawnOptions.model,
+				async: false,
+				config: spawnOptions.maxTurns ? { runtime: { maxTurns: spawnOptions.maxTurns } } : undefined,
+			}, spawnOptions.background ? { ...ctx, signal: childSignal, startForegroundRun: (run, runId) => startForegroundRun(ctx, run, runId), onRunStarted: (runId) => openLiveSidebar(ctx, runId) } : { ...ctx, signal: childSignal });
+			const record = subagentManager.spawn(options, runner, options.background ? undefined : signal);
+			if (options.background || record.status === "queued") {
+				return subagentToolResult([`Agent ${record.status === "queued" ? "queued" : "started"}.`, `Agent ID: ${record.id}`, `Type: ${record.type}`, `Description: ${record.description}`, "Use get_subagent_result to retrieve output. Do not duplicate this agent's work."].join("\n"), { agentId: record.id, status: record.status });
+			}
+			await record.promise;
+			const output = readSubagentRunResult(ctx, record) ?? record.result ?? "No output.";
+			return subagentToolResult([`Agent ${record.id} ${record.status}.`, "", output].join("\n"), { agentId: record.id, runId: record.runId, status: record.status }, record.status === "failed" || record.status === "error");
+		},
+	};
+
+	const getSubagentResultTool: ToolDefinition = {
+		name: "get_subagent_result",
+		label: "Get Agent Result",
+		description: "Check status and retrieve results from a pi-crew background subagent.",
+		parameters: Type.Object({
+			agent_id: Type.String({ description: "Agent ID returned by Agent." }),
+			wait: Type.Optional(Type.Boolean({ description: "Wait for completion before returning." })),
+			verbose: Type.Optional(Type.Boolean({ description: "Include status metadata before output." })),
+		}) as never,
+		async execute(_id, params, _signal, _onUpdate, ctx) {
+			const p = params as { agent_id?: string; wait?: boolean; verbose?: boolean };
+			if (!p.agent_id) return subagentToolResult("get_subagent_result requires agent_id.", {}, true);
+			const record = subagentManager.getRecord(p.agent_id);
+			if (!record) return subagentToolResult(`Agent not found: ${p.agent_id}`, {}, true);
+			let current = record;
+			if (p.wait && (current.status === "running" || current.status === "queued")) {
+				current.resultConsumed = true;
+				current = await subagentManager.waitForRecord(current.id) ?? current;
+			}
+			const output = readSubagentRunResult(ctx, current);
+			if (current.status !== "running" && current.status !== "queued") current.resultConsumed = true;
+			const text = [p.verbose ? formatSubagentRecord(current) : undefined, output ? `${p.verbose ? "\n" : ""}${output}` : current.status === "running" || current.status === "queued" ? "Agent is still running. Use wait=true or check again later." : current.error ?? "No output."].filter((line): line is string => Boolean(line)).join("\n");
+			return subagentToolResult(text, { agentId: current.id, runId: current.runId, status: current.status }, current.status === "failed" || current.status === "error");
+		},
+	};
+
+	const steerSubagentTool: ToolDefinition = {
+		name: "steer_subagent",
+		label: "Steer Agent",
+		description: "Send a steering note to a running pi-crew subagent. Live-session steering is planned; child-process runs expose durable status and can be cancelled if needed.",
+		parameters: Type.Object({ agent_id: Type.String(), message: Type.String() }) as never,
+		async execute(_id, params) {
+			const p = params as { agent_id?: string; message?: string };
+			const record = p.agent_id ? subagentManager.getRecord(p.agent_id) : undefined;
+			if (!record) return subagentToolResult(`Agent not found: ${p.agent_id ?? ""}`, {}, true);
+			return subagentToolResult([`Steering request noted for ${record.id}.`, "Current default pi-crew backend is child-process, so mid-turn session.steer is not available yet.", record.runId ? `Use team cancel runId=${record.runId} if the agent must be interrupted.` : undefined].filter((line): line is string => Boolean(line)).join("\n"), { agentId: record.id, runId: record.runId, status: record.status });
+		},
+	};
+
+	const crewAgentTool: ToolDefinition = {
+		...agentTool,
+		name: "crew_agent",
+		label: "Crew Agent",
+		description: "Launch a real pi-crew subagent using a conflict-safe pi-crew-specific tool name.",
+		promptSnippet: "Use crew_agent when you need pi-crew subagents and another extension may own the generic Agent tool.",
+	};
+	const crewAgentResultTool: ToolDefinition = {
+		...getSubagentResultTool,
+		name: "crew_agent_result",
+		label: "Get Crew Agent Result",
+		description: "Check status and retrieve results from a pi-crew subagent using the conflict-safe tool name.",
+	};
+	const crewAgentSteerTool: ToolDefinition = {
+		...steerSubagentTool,
+		name: "crew_agent_steer",
+		label: "Steer Crew Agent",
+		description: "Send a steering note to a pi-crew subagent using the conflict-safe tool name.",
+	};
+	for (const extraTool of [crewAgentTool, crewAgentResultTool, crewAgentSteerTool]) pi.registerTool(extraTool);
+	for (const extraTool of [agentTool, getSubagentResultTool, steerSubagentTool]) {
+		try { pi.registerTool(extraTool); } catch {}
+	}
+
 	pi.registerCommand("teams", {
 		description: "List pi-crew teams, workflows, and agents",
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
@@ -234,7 +425,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), onRunStarted: (runId) => openLiveSidebar(ctx as ExtensionContext, runId) });
+			const result = await handleTeamTool(parseRunArgs(args), { ...ctx, startForegroundRun: (runner, runId) => startForegroundRun(ctx as ExtensionContext, runner, runId), onRunStarted: (runId) => openLiveSidebar(ctx as ExtensionContext, runId) });
 			await notifyCommandResult(ctx, commandText(result));
 		},
 	});

package/src/extension/team-tool.ts

@@ -59,7 +59,7 @@ type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext
 	sessionManager?: { getBranch?: () => unknown[] };
 	events?: { emit?: (event: string, data: unknown) => void };
 	signal?: AbortSignal;
-	startForegroundRun?: (runner: (signal?: AbortSignal) => Promise<void>) => void;
+	startForegroundRun?: (runner: (signal?: AbortSignal) => Promise<void>, runId?: string) => void;
 	onRunStarted?: (runId: string) => void;
 };
 
@@ -300,13 +300,29 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	const teams = allTeams(discoverTeams(ctx.cwd));
 	const workflows = allWorkflows(discoverWorkflows(ctx.cwd));
 	const agents = allAgents(discoverAgents(ctx.cwd));
+	const directAgent = params.agent ? agents.find((item) => item.name === params.agent) : undefined;
+	if (params.agent && !directAgent) return result(`Agent '${params.agent}' not found.`, { action: "run", status: "error" }, true);
 	const teamName = params.team ?? "default";
-	const team = teams.find((item) => item.name === teamName);
+	const team = directAgent ? {
+		name: `direct-${directAgent.name}`,
+		description: `Direct subagent run for ${directAgent.name}`,
+		source: "builtin" as const,
+		filePath: "<generated>",
+		roles: [{ name: params.role ?? "agent", agent: directAgent.name, description: directAgent.description }],
+		defaultWorkflow: "direct-agent",
+		workspaceMode: params.workspaceMode,
+	} : 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 baseWorkflow = workflows.find((item) => item.name === workflowName);
+	const workflowName = directAgent ? "direct-agent" : params.workflow ?? team.defaultWorkflow ?? "default";
+	const baseWorkflow = directAgent ? {
+		name: "direct-agent",
+		description: `Direct task for ${directAgent.name}`,
+		source: "builtin" as const,
+		filePath: "<generated>",
+		steps: [{ id: "01_agent", role: params.role ?? "agent", task: "{goal}", model: params.model }],
+	} : 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 workflow = directAgent ? baseWorkflow : expandParallelResearchWorkflow(baseWorkflow, ctx.cwd);
 
 	const validationErrors = validateWorkflowForTeam(workflow, team);
 	if (validationErrors.length > 0) {
@@ -352,13 +368,13 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	}
 
 	const runtime = await resolveCrewRuntime(effectiveRunConfig(loadedConfig.config, params.config));
-	const executeWorkers = runtime.kind === "child-process";
+	const executeWorkers = runtime.kind !== "scaffold";
 	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 });
-		});
+		}, updatedManifest.runId);
 		const text = [
 			`Started foreground pi-crew run ${updatedManifest.runId}.`,
 			`Team: ${team.name}`,
@@ -507,7 +523,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		appendEvent(loaded.manifest.eventsPath, { type: "run.resume_requested", runId: loaded.manifest.runId });
 		const loadedConfig = loadConfig(ctx.cwd);
 		const runtime = await resolveCrewRuntime(loadedConfig.config);
-		const executeWorkers = runtime.kind === "child-process";
+		const executeWorkers = runtime.kind !== "scaffold";
 		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents: allAgents(discoverAgents(ctx.cwd)), executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, signal: ctx.signal });
 		return result([`Resumed run ${executed.manifest.runId}.`, `Status: ${executed.manifest.status}`, `Tasks: ${executed.tasks.length}`, `Artifacts: ${executed.manifest.artifactsRoot}`].join("\n"), { action: "resume", status: executed.manifest.status === "failed" ? "error" : "ok", runId: executed.manifest.runId, artifactsRoot: executed.manifest.artifactsRoot }, executed.manifest.status === "failed");
 	});

package/src/runtime/child-pi.ts

@@ -210,8 +210,11 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			observeStdoutChunk(input, stdout);
 			return { exitCode: 0, stdout, stderr: "" };
 		}
-		if (mock === "json-success") {
-			const stdout = `${JSON.stringify({ type: "message", message: { role: "assistant", content: [{ type: "text", text: `Mock JSON success for ${input.agent.name}` }] } })}\n${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 0.001, turns: 1 } })}\n`;
+		if (mock === "json-success" || mock === "adaptive-plan") {
+			const text = mock === "adaptive-plan" && input.task.includes("ADAPTIVE_PLAN_JSON_START")
+				? `Adaptive mock plan\nADAPTIVE_PLAN_JSON_START\n${JSON.stringify({ phases: [{ name: "research", tasks: [{ role: "explorer", task: "Explore adaptive target" }, { role: "analyst", task: "Analyze adaptive target" }, { role: "planner", task: "Plan adaptive target" }] }, { name: "build", tasks: [{ role: "executor", task: "Implement adaptive target" }] }, { name: "check", tasks: [{ role: "reviewer", task: "Review adaptive target" }, { role: "test-engineer", task: "Test adaptive target" }, { role: "writer", task: "Summarize adaptive target" }] }] })}\nADAPTIVE_PLAN_JSON_END`
+				: `Mock JSON success for ${input.agent.name}`;
+			const stdout = `${JSON.stringify({ type: "message", message: { role: "assistant", content: [{ type: "text", text }] } })}\n${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 0.001, turns: 1 } })}\n`;
 			observeStdoutChunk(input, stdout);
 			return { exitCode: 0, stdout, stderr: "" };
 		}

package/src/runtime/concurrency.ts

@@ -0,0 +1,42 @@
+export interface ResolveBatchConcurrencyInput {
+	workflowName: string;
+	teamMaxConcurrency?: number;
+	limitMaxConcurrentWorkers?: number;
+	readyCount: number;
+	workspaceMode?: "single" | "worktree";
+	readyRoles?: string[];
+}
+
+export interface BatchConcurrencyDecision {
+	maxConcurrent: number;
+	selectedCount: number;
+	defaultConcurrency: number;
+	reason: string;
+}
+
+export function defaultWorkflowConcurrency(workflowName: string): number {
+	if (workflowName === "parallel-research") return 4;
+	if (workflowName === "research") return 2;
+	if (workflowName === "implementation" || workflowName === "review" || workflowName === "default") return 2;
+	return 1;
+}
+
+function positiveInteger(value: number | undefined): number | undefined {
+	if (value === undefined || !Number.isFinite(value)) return undefined;
+	return Math.max(1, Math.trunc(value));
+}
+
+export function resolveBatchConcurrency(input: ResolveBatchConcurrencyInput): BatchConcurrencyDecision {
+	const defaultConcurrency = defaultWorkflowConcurrency(input.workflowName);
+	const limitMax = positiveInteger(input.limitMaxConcurrentWorkers);
+	const teamMax = positiveInteger(input.teamMaxConcurrency);
+	const requested = limitMax ?? teamMax ?? defaultConcurrency;
+	const source = limitMax !== undefined ? "limit" : teamMax !== undefined ? "team" : "workflow";
+	const readyCount = Math.max(0, Math.trunc(input.readyCount));
+	return {
+		maxConcurrent: requested,
+		selectedCount: readyCount === 0 ? 0 : Math.min(readyCount, requested),
+		defaultConcurrency,
+		reason: `${source}:${requested};ready:${readyCount}`,
+	};
+}

package/src/runtime/pi-args.ts

@@ -15,6 +15,7 @@ export interface BuildPiWorkerArgsInput {
 	model?: string;
 	sessionEnabled?: boolean;
 	maxDepth?: number;
+	env?: NodeJS.ProcessEnv;
 }
 
 export interface BuildPiWorkerArgsResult {
@@ -82,8 +83,9 @@ export function buildPiWorkerArgs(input: BuildPiWorkerArgsInput): BuildPiWorkerA
 		args.push(`Task: ${input.task}`);
 	}
 
-	const parentDepth = currentCrewDepth();
-	const maxDepth = resolveCrewMaxDepth(input.maxDepth);
+	const env = input.env ?? process.env;
+	const parentDepth = currentCrewDepth(env);
+	const maxDepth = resolveCrewMaxDepth(input.maxDepth, env);
 	return {
 		args,
 		env: {

package/src/runtime/progress-event-coalescer.ts

@@ -0,0 +1,43 @@
+export interface ProgressEventSummary {
+	eventType: string;
+	currentTool?: string;
+	toolCount?: number;
+	tokens?: number;
+	turns?: number;
+	activityState?: string;
+	lastActivityAt?: string;
+}
+
+export interface ProgressEventCoalesceDecision {
+	shouldAppend: boolean;
+	reason: string;
+}
+
+export interface ProgressEventCoalesceInput {
+	previous?: ProgressEventSummary;
+	next: ProgressEventSummary;
+	nowMs: number;
+	lastAppendMs?: number;
+	minIntervalMs: number;
+	force?: boolean;
+	tokenThreshold?: number;
+}
+
+const DEFAULT_TOKEN_THRESHOLD = 256;
+
+function numericIncrease(previous: number | undefined, next: number | undefined): number {
+	return next !== undefined && previous !== undefined ? next - previous : next !== undefined ? next : 0;
+}
+
+export function shouldAppendProgressEventUpdate(input: ProgressEventCoalesceInput): ProgressEventCoalesceDecision {
+	if (input.force) return { shouldAppend: true, reason: "force" };
+	if (!input.previous) return { shouldAppend: true, reason: "first" };
+	if (input.previous.activityState !== input.next.activityState) return { shouldAppend: true, reason: "activity_changed" };
+	if (input.previous.currentTool !== input.next.currentTool) return { shouldAppend: true, reason: "tool_changed" };
+	if (numericIncrease(input.previous.toolCount, input.next.toolCount) > 0) return { shouldAppend: true, reason: "tool_count_increased" };
+	if (numericIncrease(input.previous.turns, input.next.turns) > 0) return { shouldAppend: true, reason: "turns_increased" };
+	const tokenIncrease = numericIncrease(input.previous.tokens, input.next.tokens);
+	if (tokenIncrease >= (input.tokenThreshold ?? DEFAULT_TOKEN_THRESHOLD)) return { shouldAppend: true, reason: "tokens_increased" };
+	if (input.lastAppendMs === undefined || input.nowMs - input.lastAppendMs >= input.minIntervalMs) return { shouldAppend: true, reason: "interval" };
+	return { shouldAppend: false, reason: "coalesced" };
+}

package/src/runtime/subagent-manager.ts

@@ -0,0 +1,202 @@
+import { loadRunManifestById } from "../state/state-store.ts";
+import type { PiTeamsToolResult } from "../extension/tool-result.ts";
+
+export type SubagentStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "error" | "stopped";
+
+export interface SubagentSpawnOptions {
+	cwd: string;
+	type: string;
+	description: string;
+	prompt: string;
+	background: boolean;
+	model?: string;
+	maxTurns?: number;
+}
+
+export interface SubagentRecord {
+	id: string;
+	runId?: string;
+	type: string;
+	description: string;
+	prompt: string;
+	status: SubagentStatus;
+	startedAt: number;
+	completedAt?: number;
+	result?: string;
+	error?: string;
+	resultConsumed?: boolean;
+	model?: string;
+	background: boolean;
+	promise?: Promise<void>;
+}
+
+type SpawnRunner = (options: SubagentSpawnOptions, signal?: AbortSignal) => Promise<PiTeamsToolResult>;
+type Notify = (record: SubagentRecord) => void;
+
+interface QueuedSpawn {
+	record: SubagentRecord;
+	options: SubagentSpawnOptions;
+	runner: SpawnRunner;
+	signal?: AbortSignal;
+}
+
+const TERMINAL_RUN_STATUS = new Set(["completed", "failed", "cancelled", "blocked"]);
+
+function resultText(result: PiTeamsToolResult): string {
+	return result.content?.map((item) => item.type === "text" ? item.text : "").filter(Boolean).join("\n") ?? "";
+}
+
+function detailsRunId(result: PiTeamsToolResult): string | undefined {
+	const details = result.details as { runId?: unknown } | undefined;
+	return typeof details?.runId === "string" ? details.runId : undefined;
+}
+
+export class SubagentManager {
+	private readonly records = new Map<string, SubagentRecord>();
+	private queue: QueuedSpawn[] = [];
+	private runningBackground = 0;
+	private counter = 0;
+	private maxConcurrent: number;
+	private readonly onComplete?: Notify;
+	private readonly pollIntervalMs: number;
+
+	constructor(maxConcurrent = 4, onComplete?: Notify, pollIntervalMs = 1000) {
+		this.maxConcurrent = maxConcurrent;
+		this.onComplete = onComplete;
+		this.pollIntervalMs = pollIntervalMs;
+	}
+
+	spawn(options: SubagentSpawnOptions, runner: SpawnRunner, signal?: AbortSignal): SubagentRecord {
+		const record: SubagentRecord = {
+			id: `agent_${Date.now().toString(36)}_${(++this.counter).toString(36)}`,
+			type: options.type,
+			description: options.description,
+			prompt: options.prompt,
+			status: options.background && this.runningBackground >= this.maxConcurrent ? "queued" : "running",
+			startedAt: Date.now(),
+			model: options.model,
+			background: options.background,
+		};
+		this.records.set(record.id, record);
+		if (record.status === "queued") {
+			this.queue.push({ record, options, runner, signal });
+			return record;
+		}
+		this.start(record, options, runner, signal);
+		return record;
+	}
+
+	getRecord(id: string): SubagentRecord | undefined {
+		return this.records.get(id);
+	}
+
+	listAgents(): SubagentRecord[] {
+		return [...this.records.values()].sort((a, b) => b.startedAt - a.startedAt);
+	}
+
+	abort(id: string): boolean {
+		const record = this.records.get(id);
+		if (!record) return false;
+		if (record.status === "queued") {
+			this.queue = this.queue.filter((entry) => entry.record.id !== id);
+			record.status = "stopped";
+			record.completedAt = Date.now();
+			return true;
+		}
+		if (record.status !== "running") return false;
+		record.status = "stopped";
+		record.completedAt = Date.now();
+		return true;
+	}
+
+	abortAll(): number {
+		let count = 0;
+		for (const entry of this.queue) {
+			entry.record.status = "stopped";
+			entry.record.completedAt = Date.now();
+			count++;
+		}
+		this.queue = [];
+		for (const record of this.records.values()) {
+			if (record.status === "running") {
+				record.status = "stopped";
+				record.completedAt = Date.now();
+				count++;
+			}
+		}
+		return count;
+	}
+
+	async waitForAll(): Promise<void> {
+		while (true) {
+			this.drainQueue();
+			const pending = this.listAgents().filter((record) => record.status === "running" || record.status === "queued").map((record) => record.promise).filter((promise): promise is Promise<void> => Boolean(promise));
+			if (!pending.length) break;
+			await Promise.allSettled(pending);
+		}
+	}
+
+	async waitForRecord(id: string): Promise<SubagentRecord | undefined> {
+		while (true) {
+			const record = this.records.get(id);
+			if (!record) return undefined;
+			if (record.status !== "running" && record.status !== "queued") return record;
+			if (record.promise) await record.promise;
+			else await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+	}
+
+	setMaxConcurrent(value: number): void {
+		this.maxConcurrent = Math.max(1, Math.floor(value));
+		this.drainQueue();
+	}
+
+	private start(record: SubagentRecord, options: SubagentSpawnOptions, runner: SpawnRunner, signal?: AbortSignal): void {
+		if (options.background) this.runningBackground++;
+		record.status = "running";
+		record.startedAt = Date.now();
+		record.promise = (async () => {
+			try {
+				const result = await runner(options, signal);
+				record.runId = detailsRunId(result);
+				record.result = resultText(result);
+				if (result.isError) {
+					record.status = "error";
+					record.error = record.result;
+					return;
+				}
+				if (record.runId) await this.pollRunToTerminal(options.cwd, record);
+				else record.status = "completed";
+			} catch (error) {
+				record.status = "error";
+				record.error = error instanceof Error ? error.message : String(error);
+			} finally {
+				if (options.background) this.runningBackground = Math.max(0, this.runningBackground - 1);
+				record.completedAt = record.completedAt ?? Date.now();
+				this.onComplete?.(record);
+				this.drainQueue();
+			}
+		})();
+	}
+
+	private drainQueue(): void {
+		while (this.queue.length > 0 && this.runningBackground < this.maxConcurrent) {
+			const next = this.queue.shift();
+			if (!next || next.record.status !== "queued") continue;
+			this.start(next.record, next.options, next.runner, next.signal);
+		}
+	}
+
+	private async pollRunToTerminal(cwd: string, record: SubagentRecord): Promise<void> {
+		while (record.runId && record.status === "running") {
+			const loaded = loadRunManifestById(cwd, record.runId);
+			if (loaded && TERMINAL_RUN_STATUS.has(loaded.manifest.status)) {
+				record.status = loaded.manifest.status === "completed" ? "completed" : loaded.manifest.status === "cancelled" ? "cancelled" : "failed";
+				record.error = record.status === "completed" ? undefined : loaded.manifest.summary;
+				record.completedAt = Date.now();
+				return;
+			}
+			await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+		}
+	}
+}

package/src/runtime/task-runner.ts

@@ -22,6 +22,7 @@ import { parseSessionUsage } from "./session-usage.ts";
 import type { CrewAgentProgress, CrewRuntimeKind } from "./crew-agent-runtime.ts";
 import { buildMemoryBlock } from "./agent-memory.ts";
 import { runLiveSessionTask } from "./live-session-runtime.ts";
+import { shouldAppendProgressEventUpdate, type ProgressEventSummary } from "./progress-event-coalescer.ts";
 
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
@@ -201,7 +202,7 @@ function cleanResultText(text: string | undefined): string | undefined {
 	return trimmed;
 }
 
-function progressEventSummary(task: TeamTaskState, event: unknown): Record<string, unknown> {
+function progressEventSummary(task: TeamTaskState, event: unknown): ProgressEventSummary {
 	const type = asRecord(event)?.type;
 	return {
 		eventType: typeof type === "string" ? type : "event",
@@ -306,14 +307,18 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
 		let lastAgentRecordPersistedAt = 0;
 		let lastRunProgressPersistedAt = 0;
+		let lastRunProgressSummary: ProgressEventSummary | undefined;
 		const persistChildProgress = (event: unknown, force = false): void => {
 			const now = Date.now();
 			if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
 				upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
 				lastAgentRecordPersistedAt = now;
 			}
-			if (force || shouldFlushProgressEvent(event) || now - lastRunProgressPersistedAt >= 1000) {
-				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: progressEventSummary(task, event) });
+			const summary = progressEventSummary(task, event);
+			const decision = shouldAppendProgressEventUpdate({ previous: lastRunProgressSummary, next: summary, nowMs: now, lastAppendMs: lastRunProgressPersistedAt || undefined, minIntervalMs: 1000, force });
+			if (decision.shouldAppend) {
+				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { ...summary, coalesceReason: decision.reason } });
+				lastRunProgressSummary = summary;
 				lastRunProgressPersistedAt = now;
 			}
 		};
@@ -389,14 +394,18 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		const transcriptPath = `${manifest.artifactsRoot}/transcripts/${task.id}.jsonl`;
 		let lastAgentRecordPersistedAt = 0;
 		let lastRunProgressPersistedAt = 0;
+		let lastRunProgressSummary: ProgressEventSummary | undefined;
 		const persistLiveProgress = (event: unknown, force = false): void => {
 			const now = Date.now();
 			if (force || shouldFlushProgressEvent(event) || now - lastAgentRecordPersistedAt >= 500) {
 				upsertCrewAgent(manifest, recordFromTask(manifest, task, "live-session"));
 				lastAgentRecordPersistedAt = now;
 			}
-			if (force || shouldFlushProgressEvent(event) || now - lastRunProgressPersistedAt >= 1000) {
-				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: progressEventSummary(task, event) });
+			const summary = progressEventSummary(task, event);
+			const decision = shouldAppendProgressEventUpdate({ previous: lastRunProgressSummary, next: summary, nowMs: now, lastAppendMs: lastRunProgressPersistedAt || undefined, minIntervalMs: 1000, force });
+			if (decision.shouldAppend) {
+				appendEvent(manifest.eventsPath, { type: "task.progress", runId: manifest.runId, taskId: task.id, data: { ...summary, coalesceReason: decision.reason } });
+				lastRunProgressSummary = summary;
 				lastRunProgressPersistedAt = now;
 			}
 		};

package/src/runtime/team-runner.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
 import type { CrewRuntimeCapabilities } from "./runtime-resolver.ts";
@@ -17,6 +18,7 @@ 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";
+import { resolveBatchConcurrency } from "./concurrency.ts";
 
 export interface ExecuteTeamRunInput {
 	manifest: TeamRunManifest;
@@ -75,6 +77,129 @@ function mergeTaskUpdates(base: TeamTaskState[], results: Array<{ tasks: TeamTas
 	return refreshTaskGraphQueues(merged);
 }
 
+interface AdaptivePlanTask {
+	role: string;
+	title?: string;
+	task: string;
+}
+
+interface AdaptivePlanPhase {
+	name: string;
+	tasks: AdaptivePlanTask[];
+}
+
+interface AdaptivePlan {
+	phases: AdaptivePlanPhase[];
+}
+
+const MAX_ADAPTIVE_TASKS = 12;
+
+function slug(value: string): string {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "task";
+}
+
+export function __test__parseAdaptivePlan(text: string, allowedRoles: string[]): AdaptivePlan | undefined {
+	const markerMatch = text.match(/ADAPTIVE_PLAN_JSON_START\s*([\s\S]*?)\s*ADAPTIVE_PLAN_JSON_END/);
+	const fencedMatch = markerMatch ? undefined : text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+	const raw = markerMatch?.[1] ?? fencedMatch?.[1];
+	if (!raw) return undefined;
+	let parsed: unknown;
+	try { parsed = JSON.parse(raw); } catch { return undefined; }
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+	const phasesRaw = Array.isArray((parsed as { phases?: unknown }).phases) ? (parsed as { phases: unknown[] }).phases : Array.isArray((parsed as { tasks?: unknown }).tasks) ? [{ name: "adaptive", tasks: (parsed as { tasks: unknown[] }).tasks }] : undefined;
+	if (!phasesRaw) return undefined;
+	const allowed = new Set(allowedRoles);
+	const phases: AdaptivePlanPhase[] = [];
+	let total = 0;
+	for (const [phaseIndex, phaseRaw] of phasesRaw.entries()) {
+		if (!phaseRaw || typeof phaseRaw !== "object" || Array.isArray(phaseRaw)) return undefined;
+		const phaseObj = phaseRaw as { name?: unknown; tasks?: unknown };
+		if (!Array.isArray(phaseObj.tasks) || phaseObj.tasks.length === 0) return undefined;
+		const tasks: AdaptivePlanTask[] = [];
+		for (const taskRaw of phaseObj.tasks) {
+			if (!taskRaw || typeof taskRaw !== "object" || Array.isArray(taskRaw)) return undefined;
+			const taskObj = taskRaw as { role?: unknown; title?: unknown; task?: unknown };
+			if (typeof taskObj.role !== "string" || !allowed.has(taskObj.role)) return undefined;
+			if (typeof taskObj.task !== "string" || !taskObj.task.trim()) return undefined;
+			if (total >= MAX_ADAPTIVE_TASKS) return undefined;
+			tasks.push({ role: taskObj.role, title: typeof taskObj.title === "string" ? taskObj.title : undefined, task: taskObj.task.trim() });
+			total++;
+		}
+		phases.push({ name: typeof phaseObj.name === "string" && phaseObj.name.trim() ? phaseObj.name.trim() : `phase-${phaseIndex + 1}`, tasks });
+	}
+	return phases.length ? { phases } : undefined;
+}
+
+function reconstructAdaptiveWorkflow(workflow: WorkflowConfig, tasks: TeamTaskState[]): WorkflowConfig {
+	const existing = new Set(workflow.steps.map((step) => step.id));
+	const steps: WorkflowStep[] = [];
+	for (const task of tasks) {
+		if (!task.stepId?.startsWith("adaptive-") || !task.adaptive?.task || existing.has(task.stepId)) continue;
+		steps.push({ id: task.stepId, role: task.role, dependsOn: task.graph?.dependencies ?? task.dependsOn, parallelGroup: `adaptive-${slug(task.adaptive.phase)}`, task: task.adaptive.task });
+	}
+	return steps.length ? { ...workflow, steps: [...workflow.steps, ...steps] } : workflow;
+}
+
+function injectAdaptivePlanIfReady(input: { manifest: TeamRunManifest; tasks: TeamTaskState[]; workflow: WorkflowConfig; team: TeamConfig }): { tasks: TeamTaskState[]; workflow: WorkflowConfig; injected: boolean; missingPlan: boolean } {
+	if (input.workflow.name !== "implementation") return { tasks: input.tasks, workflow: input.workflow, injected: false, missingPlan: false };
+	if (input.tasks.some((task) => task.stepId?.startsWith("adaptive-"))) return { tasks: input.tasks, workflow: reconstructAdaptiveWorkflow(input.workflow, input.tasks), injected: false, missingPlan: false };
+	const completedAssess = input.tasks.find((task) => task.stepId === "assess" && task.status === "completed");
+	if (!completedAssess) return { tasks: input.tasks, workflow: input.workflow, injected: false, missingPlan: false };
+	if (!completedAssess.resultArtifact?.path) {
+		appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_missing", runId: input.manifest.runId, taskId: completedAssess.id, message: "Adaptive planner result artifact is missing." });
+		return { tasks: input.tasks, workflow: input.workflow, injected: false, missingPlan: true };
+	}
+	const assessTask = completedAssess;
+	const resultPath = completedAssess.resultArtifact.path;
+	let text = "";
+	try { text = fs.readFileSync(resultPath, "utf-8"); } catch {
+		appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_missing", runId: input.manifest.runId, taskId: assessTask.id, message: "Adaptive planner result artifact could not be read." });
+		return { tasks: input.tasks, workflow: input.workflow, injected: false, missingPlan: true };
+	}
+	const plan = __test__parseAdaptivePlan(text, input.team.roles.map((role) => role.name));
+	if (!plan) {
+		appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_missing", runId: input.manifest.runId, taskId: assessTask.id, message: "Adaptive planner did not produce a valid plan; no dynamic subagents were spawned." });
+		return { tasks: input.tasks, workflow: input.workflow, injected: false, missingPlan: true };
+	}
+	const steps: WorkflowStep[] = [];
+	const tasks: TeamTaskState[] = [];
+	let previousStepIds = ["assess"];
+	let counter = 0;
+	for (const [phaseIndex, phase] of plan.phases.entries()) {
+		const currentStepIds: string[] = [];
+		for (const [taskIndex, planned] of phase.tasks.entries()) {
+			counter++;
+			const stepId = `adaptive-${phaseIndex + 1}-${taskIndex + 1}-${slug(planned.role)}`;
+			const taskId = `adaptive-${String(counter).padStart(2, "0")}-${slug(planned.role)}`;
+			steps.push({ id: stepId, role: planned.role, dependsOn: previousStepIds, parallelGroup: `adaptive-${slug(phase.name)}`, task: planned.task });
+			tasks.push({
+				id: taskId,
+				runId: input.manifest.runId,
+				stepId,
+				role: planned.role,
+				agent: input.team.roles.find((role) => role.name === planned.role)?.agent ?? planned.role,
+				title: planned.title ?? stepId,
+				status: "queued",
+				dependsOn: previousStepIds,
+				cwd: input.manifest.cwd,
+				adaptive: { phase: phase.name, task: planned.task },
+				graph: { taskId, dependencies: previousStepIds, children: [], queue: "blocked" },
+			});
+			currentStepIds.push(stepId);
+		}
+		previousStepIds = currentStepIds;
+	}
+	const dependencyTaskIdByStep = new Map<string, string>([["assess", assessTask.id], ...tasks.map((task) => [task.stepId ?? task.id, task.id] as const)]);
+	const withGraph = tasks.map((task) => ({
+		...task,
+		dependsOn: task.dependsOn.map((dep) => dependencyTaskIdByStep.get(dep) ?? dep),
+		graph: task.graph ? { ...task.graph, dependencies: task.dependsOn.map((dep) => dependencyTaskIdByStep.get(dep) ?? dep), queue: "blocked" as const } : task.graph,
+	}));
+	const allTasks = refreshTaskGraphQueues([...input.tasks, ...withGraph]);
+	appendEvent(input.manifest.eventsPath, { type: "adaptive.plan_injected", runId: input.manifest.runId, taskId: assessTask.id, message: `Injected ${withGraph.length} adaptive subagent task(s) across ${plan.phases.length} phase(s).`, data: { phases: plan.phases.map((phase) => ({ name: phase.name, count: phase.tasks.length, roles: phase.tasks.map((task) => task.role) })) } });
+	return { tasks: allTasks, workflow: { ...input.workflow, steps: [...input.workflow.steps, ...steps] }, injected: true, missingPlan: false };
+}
+
 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}` : ""}`;
 }
@@ -143,8 +268,22 @@ function applyPolicy(manifest: TeamRunManifest, tasks: TeamTaskState[], limits?:
 }
 
 export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ manifest: TeamRunManifest; tasks: TeamTaskState[] }> {
+	let workflow = input.workflow;
 	let manifest = updateRunStatus(input.manifest, "running", input.executeWorkers ? "Executing team workflow." : "Creating workflow prompts and placeholder results.");
 	let tasks = refreshTaskGraphQueues(input.tasks);
+	const initialAdaptive = injectAdaptivePlanIfReady({ manifest, tasks, workflow, team: input.team });
+	if (initialAdaptive.missingPlan) {
+		tasks = markBlocked(tasks, "Adaptive planner did not produce a valid subagent plan.");
+		saveRunTasks(manifest, tasks);
+		manifest = updateRunStatus(manifest, "blocked", "Adaptive planner did not produce a valid subagent plan.");
+		return { manifest, tasks };
+	}
+	if (initialAdaptive.injected) {
+		tasks = initialAdaptive.tasks;
+		workflow = initialAdaptive.workflow;
+	} else {
+		workflow = initialAdaptive.workflow;
+	}
 	manifest = writeProgress(manifest, tasks, "team-runner");
 	saveRunManifest(manifest);
 	const runtimeKind = input.runtime?.kind ?? (input.executeWorkers ? "child-process" : "scaffold");
@@ -167,9 +306,26 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 			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);
+		const injectedPlan = injectAdaptivePlanIfReady({ manifest, tasks, workflow, team: input.team });
+		if (injectedPlan.missingPlan) {
+			tasks = markBlocked(tasks, "Adaptive planner did not produce a valid subagent plan.");
+			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "blocked", "Adaptive planner did not produce a valid subagent plan.");
+			return { manifest, tasks };
+		}
+		if (injectedPlan.injected) {
+			tasks = injectedPlan.tasks;
+			workflow = injectedPlan.workflow;
+			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+		} else {
+			workflow = injectedPlan.workflow;
+		}
+		const snapshot = taskGraphSnapshot(tasks);
+		const readyRoles = snapshot.ready.map((taskId) => tasks.find((task) => task.id === taskId)?.role).filter((role): role is string => Boolean(role));
+		const concurrency = resolveBatchConcurrency({ workflowName: workflow.name, teamMaxConcurrency: input.team.maxConcurrency, limitMaxConcurrentWorkers: input.limits?.maxConcurrentWorkers, readyCount: snapshot.ready.length, workspaceMode: manifest.workspaceMode, readyRoles });
+		const readyBatch = getReadyTasks(tasks, concurrency.selectedCount);
 		if (readyBatch.length === 0) {
 			tasks = markBlocked(tasks, "No ready queued task; dependency graph may be invalid.");
 			saveRunTasks(manifest, tasks);
@@ -178,14 +334,28 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 			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 } });
+		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), readyCount: snapshot.ready.length, blockedCount: snapshot.blocked.length, runningCount: snapshot.running.length, doneCount: snapshot.done.length, selectedCount: readyBatch.length, maxConcurrent: concurrency.maxConcurrent, defaultConcurrency: concurrency.defaultConcurrency, concurrencyReason: concurrency.reason } });
 		const results = await Promise.all(readyBatch.map((task) => {
-			const step = findStep(input.workflow, task);
+			const step = findStep(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);
+		const injectedAfterBatch = injectAdaptivePlanIfReady({ manifest, tasks, workflow, team: input.team });
+		if (injectedAfterBatch.missingPlan) {
+			tasks = markBlocked(tasks, "Adaptive planner did not produce a valid subagent plan.");
+			saveRunTasks(manifest, tasks);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			manifest = updateRunStatus(manifest, "blocked", "Adaptive planner did not produce a valid subagent plan.");
+			return { manifest, tasks };
+		}
+		if (injectedAfterBatch.injected) {
+			tasks = injectedAfterBatch.tasks;
+			workflow = injectedAfterBatch.workflow;
+		} else {
+			workflow = injectedAfterBatch.workflow;
+		}
 		saveRunTasks(manifest, tasks);
 		saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
 		const completedBatch = readyBatch.map((task) => tasks.find((item) => item.id === task.id) ?? task);

package/src/state/types.ts

@@ -152,6 +152,10 @@ export interface TeamTaskState {
 	taskPacket?: TaskPacket;
 	verification?: VerificationEvidence;
 	graph?: TaskGraphNode;
+	adaptive?: {
+		phase: string;
+		task: string;
+	};
 	policy?: {
 		retryCount?: number;
 		lastDecision?: PolicyDecision;

package/src/ui/powerbar-publisher.ts

@@ -16,7 +16,7 @@ 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 {
+export function compactTokens(total: number): string {
 	return total >= 1000 ? `${Math.round(total / 1000)}k` : `${total}`;
 }
 
@@ -42,23 +42,24 @@ export function updatePiCrewPowerbar(events: EventBus, cwd: string, config?: Cre
 	const tasks = active.flatMap((item) => readTasks(item.run.tasksPath));
 	const running = agents.filter((agent) => agent.status === "running").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 + waiting);
+	const completed = tasks.filter((task) => task.status === "completed").length;
+	const total = Math.max(1, tasks.length || agents.length);
 	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);
+	const model = config?.showModel === false ? undefined : agents.find((agent) => agent.model)?.model?.split("/").at(-1);
+	const tokenText = config?.showTokens === false || !tokenTotal ? undefined : compactTokens(tokenTotal);
 	safeEmit(events, "powerbar:update", {
 		id: "pi-crew-active",
 		icon: "⚙",
 		text: `crew ${running}a/${waiting}w`,
-		suffix: [model, tokenTotal ? compactTokens(tokenTotal) : undefined].filter(Boolean).join(" · ") || undefined,
+		suffix: [model, tokenText].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}${tokenTotal ? ` · ${compactTokens(tokenTotal)}` : ""}`,
+		suffix: `${completed}/${total}${tokenText ? ` · ${tokenText}` : ""}`,
 		color: completed === total ? "success" : "accent",
 		barSegments: 8,
 	});

package/teams/implementation.team.md

@@ -1,6 +1,6 @@
 ---
 name: implementation
-description: Full implementation team with analysis, critique, execution, review, and verification
+description: Full implementation team with parallel specialists, critique, execution, review, and verification
 defaultWorkflow: implementation
 workspaceMode: single
 maxConcurrency: 3
@@ -9,7 +9,10 @@ maxConcurrency: 3
 - explorer: agent=explorer map the codebase
 - analyst: agent=analyst clarify requirements and constraints
 - planner: agent=planner create execution plan
-- critic: agent=critic challenge the plan
+- critic: agent=critic challenge and synthesize specialist findings
 - executor: agent=executor implement the plan
 - reviewer: agent=reviewer review the implementation
+- security-reviewer: agent=security-reviewer review security and trust boundaries
+- test-engineer: agent=test-engineer design and run verification
 - verifier: agent=verifier verify done
+- writer: agent=writer summarize documentation or release notes when needed

package/workflows/implementation.workflow.md

@@ -1,47 +1,38 @@
 ---
 name: implementation
-description: Full implementation workflow with critique and review gates
+description: Adaptive implementation workflow where a planner agent decides the subagent fanout
 ---
 
-## explore
-role: explorer
-
-Map relevant files, APIs, and constraints for: {goal}
-
-## analyze
-role: analyst
-dependsOn: explore
-
-Analyze requirements, ambiguities, risks, and acceptance criteria for: {goal}
-
-## plan
+## assess
 role: planner
-dependsOn: analyze
-output: plan.md
-
-Create an execution plan for: {goal}
-
-## critique
-role: critic
-dependsOn: plan
-
-Critique the plan and identify required improvements.
-
-## execute
-role: executor
-dependsOn: critique
-
-Implement the improved plan for: {goal}
-
-## review
-role: reviewer
-dependsOn: execute
-
-Review the implementation.
-
-## verify
-role: verifier
-dependsOn: review
-verify: true
-
-Verify the final result.
+output: adaptive-plan.json
+
+Assess this task and decide how many subagents are actually needed for: {goal}
+
+You are the orchestration planner. Inspect the repository enough to choose an efficient crew; do not use a fixed template. Small/simple tasks may need one executor plus one verifier. Risky or broad tasks may need parallel explorers, specialists, implementers, reviewers, security reviewers, or test engineers.
+
+Return a concise rationale, then include exactly one JSON block between these markers:
+
+ADAPTIVE_PLAN_JSON_START
+{
+  "phases": [
+    {
+      "name": "short-phase-name",
+      "tasks": [
+        {
+          "role": "explorer|analyst|planner|critic|executor|reviewer|security-reviewer|test-engineer|verifier|writer",
+          "title": "short task title",
+          "task": "specific autonomous task prompt for this subagent"
+        }
+      ]
+    }
+  ]
+}
+ADAPTIVE_PLAN_JSON_END
+
+Rules:
+- Choose the smallest effective number of subagents.
+- Use parallel tasks in the same phase only when their work is independent.
+- Later phases depend on all tasks in the previous phase.
+- Include verification/review tasks when implementation is requested.
+- Do not include more than 12 total subagents unless the user explicitly asks for a large crew.