pi-crew 0.1.20 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.1.20",
+  "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

@@ -19,7 +19,7 @@ import { DurableTextViewer, DurableTranscriptViewer } from "../ui/transcript-vie
 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 [
@@ -338,9 +350,9 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 				agent: spawnOptions.type,
 				goal: spawnOptions.prompt,
 				model: spawnOptions.model,
-				async: false,
+				async: spawnOptions.background,
 				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 });
+			}, 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 });
@@ -360,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");
 		},
@@ -382,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 });
 		},

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/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/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/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;

package/workflows/implementation.workflow.md

@@ -35,4 +35,4 @@ Rules:
 - 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.
+- Do not include more than 12 total subagents; split or summarize oversized plans instead.