pi-crew 0.1.19 → 0.1.21

package/CHANGELOG.md

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

package/package.json

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

package/src/extension/register.ts

@@ -16,10 +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";
+import { readPersistedSubagentRecord, savePersistedSubagentRecord, 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, "")) ?? [];
@@ -109,6 +109,18 @@ function sendFollowUp(pi: ExtensionAPI, content: string): void {
 	sender.call(pi, { customType: "pi-crew-subagent-notification", content, display: true }, { deliverAs: "followUp", triggerTurn: true });
 }
 
+function refreshPersistedSubagentRecord(ctx: ExtensionContext | ExtensionCommandContext, record: SubagentRecord): SubagentRecord {
+	if (!record.runId) return record;
+	const loaded = loadRunManifestById(ctx.cwd, record.runId);
+	if (!loaded) return record;
+	if (loaded.manifest.status === "completed" || loaded.manifest.status === "failed" || loaded.manifest.status === "cancelled" || loaded.manifest.status === "blocked") {
+		const refreshed = { ...record, status: loaded.manifest.status === "completed" ? "completed" as const : loaded.manifest.status === "cancelled" ? "cancelled" as const : "failed" as const, error: loaded.manifest.status === "completed" ? undefined : loaded.manifest.summary, completedAt: record.completedAt ?? Date.now() };
+		savePersistedSubagentRecord(ctx.cwd, refreshed);
+		return refreshed;
+	}
+	return record;
+}
+
 function formatSubagentRecord(record: SubagentRecord): string {
 	const duration = record.completedAt ? `${Math.round((record.completedAt - record.startedAt) / 1000)}s` : "running";
 	return [
@@ -215,6 +227,12 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			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(() => {
@@ -332,8 +350,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				agent: spawnOptions.type,
 				goal: spawnOptions.prompt,
 				model: spawnOptions.model,
-				async: false,
-			}, spawnOptions.background ? { ...ctx, signal: childSignal, startForegroundRun: (run, runId) => startForegroundRun(ctx, run, runId), onRunStarted: (runId) => openLiveSidebar(ctx, runId) } : { ...ctx, signal: childSignal });
+				async: spawnOptions.background,
+				config: spawnOptions.maxTurns ? { runtime: { maxTurns: spawnOptions.maxTurns } } : undefined,
+			}, spawnOptions.background ? { ...ctx, signal: childSignal } : { ...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 });
@@ -353,18 +372,40 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 			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) {
+		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);
+			const inMemory = subagentManager.getRecord(p.agent_id);
+			const record = inMemory ?? readPersistedSubagentRecord(ctx.cwd, p.agent_id);
 			if (!record) return subagentToolResult(`Agent not found: ${p.agent_id}`, {}, true);
-			let current = record;
+			let current = refreshPersistedSubagentRecord(ctx, record);
+			if (!inMemory && !current.runId && (current.status === "running" || current.status === "queued")) {
+				current = { ...current, status: "error", error: "Subagent was interrupted before its durable run id was recorded; it cannot be recovered after restart.", completedAt: current.completedAt ?? Date.now() };
+				savePersistedSubagentRecord(ctx.cwd, current);
+			}
 			if (p.wait && (current.status === "running" || current.status === "queued")) {
 				current.resultConsumed = true;
-				current = await subagentManager.waitForRecord(current.id) ?? current;
+				savePersistedSubagentRecord(ctx.cwd, current);
+				const waited = await subagentManager.waitForRecord(current.id);
+				if (waited) current = waited;
+				else {
+					while (current.status === "running" || current.status === "queued") {
+						if (signal?.aborted) {
+							current = { ...current, status: "error", error: "Waiting for subagent result was aborted.", completedAt: Date.now() };
+							savePersistedSubagentRecord(ctx.cwd, current);
+							break;
+						}
+						await new Promise((resolve) => setTimeout(resolve, 1000));
+						current = refreshPersistedSubagentRecord(ctx, current);
+						if (!current.runId) break;
+					}
+				}
 			}
 			const output = readSubagentRunResult(ctx, current);
-			if (current.status !== "running" && current.status !== "queued") current.resultConsumed = true;
+			if (current.status !== "running" && current.status !== "queued") {
+				current.resultConsumed = true;
+				savePersistedSubagentRecord(ctx.cwd, current);
+			}
 			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");
 		},
@@ -375,9 +416,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		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) {
+		async execute(_id, params, _signal, _onUpdate, ctx) {
 			const p = params as { agent_id?: string; message?: string };
-			const record = p.agent_id ? subagentManager.getRecord(p.agent_id) : undefined;
+			const record = p.agent_id ? subagentManager.getRecord(p.agent_id) ?? readPersistedSubagentRecord(ctx.cwd, 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 });
 		},
@@ -402,8 +443,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 		label: "Steer Crew Agent",
 		description: "Send a steering note to a pi-crew subagent using the conflict-safe tool name.",
 	};
-	for (const extraTool of [agentTool, getSubagentResultTool, steerSubagentTool, crewAgentTool, crewAgentResultTool, crewAgentSteerTool]) {
-		pi.registerTool(extraTool);
+	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", {

package/src/extension/team-tool.ts

@@ -46,6 +46,7 @@ import { listLiveAgents, resumeLiveAgent, steerLiveAgent, stopLiveAgent } from "
 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";
+import { directTeamAndWorkflowFromRun } from "../runtime/direct-run.ts";
 
 export interface TeamToolDetails {
 	action: string;
@@ -513,9 +514,11 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 	const loaded = loadRunManifestById(ctx.cwd, params.runId);
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "resume", status: "error" }, true);
 	if (!loaded.manifest.workflow) return result(`Run '${params.runId}' has no workflow to resume.`, { action: "resume", status: "error" }, true);
-	const team = allTeams(discoverTeams(ctx.cwd)).find((candidate) => candidate.name === loaded.manifest.team);
+	const agents = allAgents(discoverAgents(ctx.cwd));
+	const direct = directTeamAndWorkflowFromRun(loaded.manifest, loaded.tasks, agents);
+	const team = direct?.team ?? allTeams(discoverTeams(ctx.cwd)).find((candidate) => candidate.name === loaded.manifest.team);
 	if (!team) return result(`Team '${loaded.manifest.team}' not found.`, { action: "resume", status: "error" }, true);
-	const workflow = allWorkflows(discoverWorkflows(ctx.cwd)).find((candidate) => candidate.name === loaded.manifest.workflow);
+	const workflow = direct?.workflow ?? allWorkflows(discoverWorkflows(ctx.cwd)).find((candidate) => candidate.name === loaded.manifest.workflow);
 	if (!workflow) return result(`Workflow '${loaded.manifest.workflow}' not found.`, { action: "resume", status: "error" }, true);
 	return await withRunLock(loaded.manifest, async () => {
 		const resetTasks = loaded.tasks.map((task) => task.status === "failed" || task.status === "cancelled" || task.status === "skipped" || task.status === "running" ? { ...task, status: "queued" as const, error: undefined, startedAt: undefined, finishedAt: undefined, claim: undefined } : task);
@@ -524,7 +527,7 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		const loadedConfig = loadConfig(ctx.cwd);
 		const runtime = await resolveCrewRuntime(loadedConfig.config);
 		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 });
+		const executed = await executeTeamRun({ manifest: loaded.manifest, tasks: resetTasks, team, workflow, agents, 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/background-runner.ts

@@ -6,6 +6,7 @@ import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows
 import { loadConfig } from "../config/config.ts";
 import { executeTeamRun } from "./team-runner.ts";
 import { resolveCrewRuntime } from "./runtime-resolver.ts";
+import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
 
 function argValue(name: string): string | undefined {
 	const index = process.argv.indexOf(name);
@@ -24,14 +25,15 @@ async function main(): Promise<void> {
 	appendEvent(manifest.eventsPath, { type: "async.started", runId: manifest.runId, data: { pid: process.pid } });
 
 	try {
-		const team = allTeams(discoverTeams(cwd)).find((candidate) => candidate.name === manifest.team);
+		const agents = allAgents(discoverAgents(cwd));
+		const direct = directTeamAndWorkflowFromRun(manifest, tasks, agents);
+		const team = direct?.team ?? allTeams(discoverTeams(cwd)).find((candidate) => candidate.name === manifest.team);
 		if (!team) throw new Error(`Team '${manifest.team}' not found.`);
-		const workflow = allWorkflows(discoverWorkflows(cwd)).find((candidate) => candidate.name === manifest.workflow);
+		const workflow = direct?.workflow ?? allWorkflows(discoverWorkflows(cwd)).find((candidate) => candidate.name === manifest.workflow);
 		if (!workflow) throw new Error(`Workflow '${manifest.workflow ?? ""}' not found.`);
-		const agents = allAgents(discoverAgents(cwd));
 		const loadedConfig = loadConfig(cwd);
 		const runtime = await resolveCrewRuntime(loadedConfig.config);
-		const executeWorkers = runtime.kind === "child-process";
+		const executeWorkers = runtime.kind !== "scaffold";
 		const result = await executeTeamRun({ manifest, tasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime });
 		manifest = result.manifest;
 		tasks = result.tasks;

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/direct-run.ts

@@ -0,0 +1,35 @@
+import type { AgentConfig } from "../agents/agent-config.ts";
+import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
+import type { TeamConfig } from "../teams/team-config.ts";
+import type { WorkflowConfig } from "../workflows/workflow-config.ts";
+
+export function isDirectRun(manifest: Pick<TeamRunManifest, "team" | "workflow">): boolean {
+	return manifest.workflow === "direct-agent";
+}
+
+export function directTeamAndWorkflowFromRun(manifest: TeamRunManifest, tasks: TeamTaskState[], agents: AgentConfig[]): { team: TeamConfig; workflow: WorkflowConfig } | undefined {
+	if (!isDirectRun(manifest)) return undefined;
+	const firstTask = tasks[0];
+	const agentName = firstTask?.agent ?? (manifest.team.replace(/^direct-/, "") || "executor");
+	const agent = agents.find((candidate) => candidate.name === agentName);
+	const role = firstTask?.role ?? "agent";
+	const stepId = firstTask?.stepId ?? "01_agent";
+	return {
+		team: {
+			name: manifest.team,
+			description: `Direct subagent run for ${agentName}`,
+			source: "builtin",
+			filePath: "<generated>",
+			roles: [{ name: role, agent: agentName, description: agent?.description }],
+			defaultWorkflow: "direct-agent",
+			workspaceMode: manifest.workspaceMode,
+		},
+		workflow: {
+			name: manifest.workflow ?? "direct-agent",
+			description: `Direct task for ${agentName}`,
+			source: "builtin",
+			filePath: "<generated>",
+			steps: [{ id: stepId, role, task: "{goal}", model: firstTask?.model }],
+		},
+	};
+}

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/subagent-manager.ts

@@ -1,5 +1,8 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { loadRunManifestById } from "../state/state-store.ts";
 import type { PiTeamsToolResult } from "../extension/tool-result.ts";
+import { projectPiRoot } from "../utils/paths.ts";
 
 export type SubagentStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "error" | "stopped";
 
@@ -42,6 +45,32 @@ interface QueuedSpawn {
 
 const TERMINAL_RUN_STATUS = new Set(["completed", "failed", "cancelled", "blocked"]);
 
+function persistedSubagentPath(cwd: string, id: string): string {
+	return path.join(projectPiRoot(cwd), "teams", "state", "subagents", `${id}.json`);
+}
+
+function serializableRecord(record: SubagentRecord): SubagentRecord {
+	const { promise: _promise, ...rest } = record;
+	return rest;
+}
+
+export function savePersistedSubagentRecord(cwd: string, record: SubagentRecord): void {
+	try {
+		const filePath = persistedSubagentPath(cwd, record.id);
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.writeFileSync(filePath, `${JSON.stringify(serializableRecord(record), null, 2)}\n`, "utf-8");
+	} catch {}
+}
+
+export function readPersistedSubagentRecord(cwd: string, id: string): SubagentRecord | undefined {
+	try {
+		const parsed = JSON.parse(fs.readFileSync(persistedSubagentPath(cwd, id), "utf-8"));
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as SubagentRecord : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 function resultText(result: PiTeamsToolResult): string {
 	return result.content?.map((item) => item.type === "text" ? item.text : "").filter(Boolean).join("\n") ?? "";
 }
@@ -78,6 +107,7 @@ export class SubagentManager {
 			background: options.background,
 		};
 		this.records.set(record.id, record);
+		savePersistedSubagentRecord(options.cwd, record);
 		if (record.status === "queued") {
 			this.queue.push({ record, options, runner, signal });
 			return record;
@@ -155,11 +185,13 @@ export class SubagentManager {
 		if (options.background) this.runningBackground++;
 		record.status = "running";
 		record.startedAt = Date.now();
+		savePersistedSubagentRecord(options.cwd, record);
 		record.promise = (async () => {
 			try {
 				const result = await runner(options, signal);
 				record.runId = detailsRunId(result);
 				record.result = resultText(result);
+				savePersistedSubagentRecord(options.cwd, record);
 				if (result.isError) {
 					record.status = "error";
 					record.error = record.result;
@@ -173,6 +205,7 @@ export class SubagentManager {
 			} finally {
 				if (options.background) this.runningBackground = Math.max(0, this.runningBackground - 1);
 				record.completedAt = record.completedAt ?? Date.now();
+				savePersistedSubagentRecord(options.cwd, record);
 				this.onComplete?.(record);
 				this.drainQueue();
 			}
@@ -194,6 +227,7 @@ export class SubagentManager {
 				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();
+				savePersistedSubagentRecord(cwd, record);
 				return;
 			}
 			await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));

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";
@@ -76,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}` : ""}`;
 }
@@ -144,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");
@@ -168,9 +306,25 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 			return { manifest, tasks };
 		}
 
+		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: input.workflow.name, teamMaxConcurrency: input.team.maxConcurrency, limitMaxConcurrentWorkers: input.limits?.maxConcurrentWorkers, readyCount: snapshot.ready.length, workspaceMode: manifest.workspaceMode, readyRoles });
+		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.");
@@ -182,12 +336,26 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 
 		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/state-store.ts

@@ -55,6 +55,7 @@ export function createTasksFromWorkflow(runId: string, workflow: WorkflowConfig,
 			status: "queued",
 			dependsOn: dependencies,
 			cwd,
+			model: step.model,
 			graph: {
 				taskId: id,
 				parentId: dependencies[0] ? stepToTaskId.get(dependencies[0]) : undefined,

package/src/state/types.ts

@@ -142,6 +142,7 @@ export interface TeamTaskState {
 	startedAt?: string;
 	finishedAt?: string;
 	exitCode?: number | null;
+	model?: string;
 	modelAttempts?: ModelAttemptState[];
 	usage?: UsageState;
 	jsonEvents?: number;
@@ -152,6 +153,10 @@ export interface TeamTaskState {
 	taskPacket?: TaskPacket;
 	verification?: VerificationEvidence;
 	graph?: TaskGraphNode;
+	adaptive?: {
+		phase: string;
+		task: string;
+	};
 	policy?: {
 		retryCount?: number;
 		lastDecision?: PolicyDecision;

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; split or summarize oversized plans instead.