pi-crew 0.1.46 → 0.1.49

package/src/extension/team-tool/parallel-dispatch.ts

@@ -0,0 +1,156 @@
+/**
+ * Parallel dispatch handler — accepts an array of independent tasks
+ * and spawns them as concurrent background agents.
+ *
+ * Solves the host-agent limitation of only being able to emit
+ * one Agent() call per response turn. By calling `action=parallel`
+ * once with multiple tasks, the system handles fanout automatically.
+ */
+import { discoverAgents } from "../../agents/discover-agents.ts";
+import { loadConfig } from "../../config/config.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { createRunManifest } from "../../state/state-store.ts";
+import { appendEvent } from "../../state/event-log.ts";
+import { spawnBackgroundTeamRun } from "../../subagents/async-entry.ts";
+import { resolveCrewRuntime } from "../../runtime/runtime-resolver.ts";
+import { resolveCwdOverride } from "../registration/team-tool.ts";
+import { result, type TeamContext } from "./context.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { discoverTeams } from "../../teams/discover-teams.ts";
+import { discoverWorkflows } from "../../workflows/discover-workflows.ts";
+import type { TeamConfig } from "../../teams/team-config.ts";
+import type { WorkflowConfig } from "../../workflows/workflow-config.ts";
+
+const MAX_CONCURRENCY = 8;
+const DEFAULT_CONCURRENCY = 4;
+const DEFAULT_TEAM = "fast-fix";
+const DEFAULT_AGENT = "explorer";
+
+export async function handleParallel(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	const tasksParam = params.config?.tasks;
+	if (!Array.isArray(tasksParam) || tasksParam.length === 0) {
+		return result("parallel action requires config.tasks: [{goal, agent?}]", { action: "parallel", status: "error" }, true);
+	}
+
+	const concurrency = Math.min(
+		Math.max(1, Math.floor((params.config?.concurrency as number) ?? DEFAULT_CONCURRENCY)),
+		MAX_CONCURRENCY,
+	);
+
+	const config = loadConfig(ctx.cwd);
+	const agentsResult = discoverAgents(ctx.cwd);
+	const allAgentsList = [...agentsResult.builtin, ...agentsResult.user, ...agentsResult.project];
+	const teams = discoverTeams(ctx.cwd);
+	const workflows = discoverWorkflows(ctx.cwd);
+
+	const teamName = (params.config?.team as string) ?? DEFAULT_TEAM;
+	const team = teams.builtin.find((t) => t.name === teamName)
+		?? teams.user.find((t) => t.name === teamName)
+		?? teams.project.find((t) => t.name === teamName);
+	if (!team) {
+		return result(`Team '${teamName}' not found`, { action: "parallel", status: "error" }, true);
+	}
+
+	// H2: Use team's defaultWorkflow, fall back to "fast-fix"
+	const workflow = workflows.builtin.find((w) => w.name === team.defaultWorkflow)
+		?? workflows.builtin.find((w) => w.name === "fast-fix");
+	if (!workflow) {
+		return result("No suitable workflow found for parallel dispatch", { action: "parallel", status: "error" }, true);
+	}
+
+	const runtime = await resolveCrewRuntime(config.config);
+
+	const launched: Array<{ runId: string; goal: string; agent: string }> = [];
+	const errors: Array<{ goal: string; error: string }> = [];
+
+	// C1: Enforce concurrency limit with batched spawning
+	for (let batchStart = 0; batchStart < tasksParam.length; batchStart += concurrency) {
+		const batch = tasksParam.slice(batchStart, batchStart + concurrency);
+		const batchPromises = batch.map((task) => spawnSingleTask(task, ctx, allAgentsList, team, workflow, runtime));
+		const batchResults = await Promise.allSettled(batchPromises);
+		for (const res of batchResults) {
+			if (res.status === "fulfilled" && res.value.ok) {
+				launched.push(res.value.value);
+			} else if (res.status === "fulfilled" && !res.value.ok) {
+				errors.push(res.value.error);
+			} else {
+				const reason = (res as PromiseRejectedResult).reason;
+				errors.push({ goal: "(unknown)", error: reason instanceof Error ? reason.message : String(reason) });
+			}
+		}
+	}
+
+	const lines: string[] = [
+		`Parallel dispatch: ${launched.length}/${tasksParam.length} tasks launched (concurrency: ${concurrency})`,
+		"",
+	];
+	for (const l of launched) {
+		lines.push(`  ✅ ${l.runId} — ${l.agent}: ${l.goal.slice(0, 80)}`);
+	}
+	for (const e of errors) {
+		lines.push(`  ❌ ${e.goal.slice(0, 80)}: ${e.error}`);
+	}
+
+	return result(lines.join("\n"), {
+		action: "parallel",
+		status: errors.length === tasksParam.length ? "error" : "ok",
+	}, errors.length === tasksParam.length);
+}
+
+type SpawnOk = { ok: true; value: { runId: string; goal: string; agent: string } };
+type SpawnErr = { ok: false; error: { goal: string; error: string } };
+type SpawnResult = SpawnOk | SpawnErr;
+
+async function spawnSingleTask(
+	task: unknown,
+	ctx: TeamContext,
+	allAgentsList: Array<{ name: string }>,
+	team: TeamConfig,
+	workflow: WorkflowConfig,
+	runtime: { available: boolean; kind: string },
+): Promise<SpawnResult> {
+	try {
+		const taskRec = task as Record<string, unknown>;
+		const goal = taskRec.goal as string;
+		const agentName = (taskRec.agent as string) ?? DEFAULT_AGENT;
+		const rawCwd = (taskRec.cwd as string) ?? undefined;
+
+		if (!goal) {
+			return { ok: false, error: { goal: "(missing)", error: "Each task must have a 'goal' field" } };
+		}
+
+		const agent = allAgentsList.find((a) => a.name === agentName);
+		if (!agent) {
+			return { ok: false, error: { goal, error: `Agent '${agentName}' not found` } };
+		}
+
+		// H1: Validate taskCwd containment against project root
+		const cwdResult = resolveCwdOverride(ctx.cwd, rawCwd);
+		if (!cwdResult.ok) {
+			return { ok: false, error: { goal, error: cwdResult.error } };
+		}
+		const taskCwd = cwdResult.cwd;
+
+		const created = createRunManifest({
+			cwd: taskCwd,
+			team,
+			workflow,
+			goal,
+		});
+
+		appendEvent(created.manifest.eventsPath, {
+			type: "run.started",
+			runId: created.manifest.runId,
+			message: `Parallel task: ${goal}`,
+		});
+
+		if (runtime.available && runtime.kind === "child-process") {
+			spawnBackgroundTeamRun(created.manifest);
+		}
+
+		return { ok: true, value: { runId: created.manifest.runId, goal, agent: agentName } };
+	} catch (error) {
+		const goal = ((task as Record<string, unknown>).goal as string) ?? "(unknown)";
+		return { ok: false, error: { goal, error: error instanceof Error ? error.message : String(error) } };
+	}
+}

package/src/extension/team-tool/plan.ts

@@ -1,19 +1,19 @@
-import { allTeams, discoverTeams } from "../../teams/discover-teams.ts";
-import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workflows.ts";
-import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
-import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
-import { result, type TeamContext } from "./context.ts";
-
-export function handlePlan(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	const teamName = params.team ?? "default";
-	const team = allTeams(discoverTeams(ctx.cwd)).find((item) => item.name === teamName);
-	if (!team) return result(`Team '${teamName}' not found.`, { action: "plan", status: "error" }, true);
-	const workflowName = params.workflow ?? team.defaultWorkflow ?? "default";
-	const workflow = allWorkflows(discoverWorkflows(ctx.cwd)).find((item) => item.name === workflowName);
-	if (!workflow) return result(`Workflow '${workflowName}' not found.`, { action: "plan", status: "error" }, true);
-	const errors = validateWorkflowForTeam(workflow, team);
-	if (errors.length > 0) return result([`Workflow '${workflow.name}' is not valid for team '${team.name}':`, ...errors.map((error) => `- ${error}`)].join("\n"), { action: "plan", status: "error" }, true);
-	const lines = [`Team plan: ${team.name}`, `Workflow: ${workflow.name}`, `Goal: ${params.goal ?? params.task ?? "(not provided)"}`, "", "Steps:", ...workflow.steps.map((step, index) => `${index + 1}. ${step.id} [${step.role}]${step.dependsOn?.length ? ` after ${step.dependsOn.join(", ")}` : ""}`)];
-	return result(lines.join("\n"), { action: "plan", status: "ok" });
-}
+import { allTeams, discoverTeams } from "../../teams/discover-teams.ts";
+import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workflows.ts";
+import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+
+export function handlePlan(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	const teamName = params.team ?? "default";
+	const team = allTeams(discoverTeams(ctx.cwd)).find((item) => item.name === teamName);
+	if (!team) return result(`Team '${teamName}' not found.`, { action: "plan", status: "error" }, true);
+	const workflowName = params.workflow ?? team.defaultWorkflow ?? "default";
+	const workflow = allWorkflows(discoverWorkflows(ctx.cwd)).find((item) => item.name === workflowName);
+	if (!workflow) return result(`Workflow '${workflowName}' not found.`, { action: "plan", status: "error" }, true);
+	const errors = validateWorkflowForTeam(workflow, team);
+	if (errors.length > 0) return result([`Workflow '${workflow.name}' is not valid for team '${team.name}':`, ...errors.map((error) => `- ${error}`)].join("\n"), { action: "plan", status: "error" }, true);
+	const lines = [`Team plan: ${team.name}`, `Workflow: ${workflow.name}`, `Goal: ${params.goal ?? params.task ?? "(not provided)"}`, "", "Steps:", ...workflow.steps.map((step, index) => `${index + 1}. ${step.id} [${step.role}]${step.dependsOn?.length ? ` after ${step.dependsOn.join(", ")}` : ""}`)];
+	return result(lines.join("\n"), { action: "plan", status: "ok" });
+}

package/src/extension/team-tool/respond.ts

@@ -2,7 +2,7 @@ import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { withRunLockSync } from "../../state/locks.ts";
 import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/state-store.ts";
 import { appendEvent } from "../../state/event-log.ts";
-import { appendMailboxMessage } from "../../state/mailbox.ts";
+import { appendMailboxMessage, updateMailboxMessageReply } from "../../state/mailbox.ts";
 import { saveCrewAgents, recordFromTask } from "../../runtime/crew-agent-records.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
@@ -60,10 +60,18 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 				priority: "normal",
 				deliveryMode: "next_turn",
 				data: { action: "respond", kind: "response" },
+				replyTo: params.replyTo,
+				replyFrom: params.replyFrom,
+				replyDeadline: params.replyDeadline,
 			});
 			mailboxIds.push(mailbox.id);
 		}
 
+		// If this respond includes a replyTo, update the original message with reply metadata.
+		if (params.replyTo) {
+			updateMailboxMessageReply(fresh.manifest, params.replyTo, message || "(resume)");
+		}
+
 		// Re-queue waiting tasks so durable scheduler/resume can pick them up again.
 		const updatedTasks = fresh.tasks.map((task) => {
 			if (!resumed.has(task.id)) return task;
@@ -98,7 +106,7 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 		const resumedIds = targetTasks.map((t) => t.id);
 		return result(
 			`Resumed ${resumedIds.length} waiting task(s): ${resumedIds.join(", ")}. Message: ${message || "(no message)"}`,
-			{ action: "respond", status: "ok", runId: fresh.manifest.runId, resumedIds, mailboxIds },
+			{ action: "respond", status: "ok", runId: fresh.manifest.runId, resumedIds, mailboxIds, intent: `responding to ${resumedIds.join(", ")} in ${fresh.manifest.runId}` },
 		);
 	});
 }

package/src/extension/team-tool/run.ts

@@ -60,6 +60,7 @@ function scheduleBackgroundEarlyExitGuard(cwd: string, runId: string, pid: numbe
 export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
 	const goal = params.goal ?? params.task;
 	if (!goal) return result("Run requires goal or task.", { action: "run", status: "error" }, true);
+	const intentPrefix = goal.length > 60 ? `${goal.slice(0, 57)}...` : goal;
 
 	const teams = allTeams(discoverTeams(ctx.cwd));
 	const workflows = allWorkflows(discoverWorkflows(ctx.cwd));
@@ -149,7 +150,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			"",
 			`Check status with: team status runId=${updatedManifest.runId}`,
 		].join("\n");
-		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot });
+		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot, intent: `running ${team.name}: ${intentPrefix}` });
 	}
 
 	if (runtime.safety === "blocked") {
@@ -188,7 +189,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			"",
 			"The run continues in this Pi session without blocking the chat. It will be interrupted on session shutdown. Use /team-dashboard or /team-status to watch it.",
 		].join("\n");
-		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot });
+		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot, intent: `running ${team.name}: ${intentPrefix}` });
 	}
 	let executed: Awaited<ReturnType<typeof executeTeamRun>>;
 	try {

package/src/extension/team-tool/status.ts

@@ -106,5 +106,5 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		"Recent events:",
 		...(events.length ? events.map((event) => `- ${event.time} ${event.type}${event.taskId ? ` ${event.taskId}` : ""}${event.message ? `: ${event.message}` : ""}`) : ["- (none)"]),
 	];
-	return result(lines.join("\n"), { action: "status", status: "ok", runId: manifest.runId, artifactsRoot: manifest.artifactsRoot });
+	return result(lines.join("\n"), { action: "status", status: "ok", runId: manifest.runId, artifactsRoot: manifest.artifactsRoot, intent: `status ${manifest.runId}: ${manifest.status}` });
 }

package/src/extension/team-tool-types.ts

@@ -8,5 +8,6 @@ export interface TeamToolDetails {
 	foreignIds?: string[];
 	intent?: string;
 	resumedIds?: string[];
+	retriedTaskIds?: string[];
 	mailboxIds?: string[];
 }

package/src/extension/team-tool.ts

@@ -43,7 +43,8 @@ import { handleDoctor } from "./team-tool/doctor.ts";
 import { handleStatus } from "./team-tool/status.ts";
 import { handleArtifacts, handleEvents, handleSummary } from "./team-tool/inspect.ts";
 import { handleCleanup, handleExport, handleForget, handleImport, handleImports, handlePrune, handleWorktrees } from "./team-tool/lifecycle-actions.ts";
-import { handleCancel } from "./team-tool/cancel.ts";
+import { handleCancel, handleRetry } from "./team-tool/cancel.ts";
+import { handleParallel } from "./team-tool/parallel-dispatch.ts";
 import { handleRespond } from "./team-tool/respond.ts";
 import { handlePlan } from "./team-tool/plan.ts";
 import { logInternalError } from "../utils/internal-error.ts";
@@ -56,7 +57,7 @@ export { handleDoctor } from "./team-tool/doctor.ts";
 export { handleStatus } from "./team-tool/status.ts";
 export { handleArtifacts, handleEvents, handleSummary } from "./team-tool/inspect.ts";
 export { handleCleanup, handleExport, handleForget, handleImport, handleImports, handlePrune, handleWorktrees } from "./team-tool/lifecycle-actions.ts";
-export { handleCancel } from "./team-tool/cancel.ts";
+export { handleRetry } from "./team-tool/cancel.ts";
 export { handlePlan } from "./team-tool/plan.ts";
 export { handleApi } from "./team-tool/api.ts";
 
@@ -181,6 +182,13 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 		const recovered = recoverCheckpointedTasks(loaded.manifest, loaded.tasks);
 		const resumeManifest = recovered.manifest;
 		const executedConfig = effectiveRunConfig(loadedConfig.config, params.config);
+		// Preserve original manifest scaffold mode when resume has no explicit mode override
+		// AND workers are not explicitly disabled. If workers are disabled, let
+		// resolveCrewRuntime detect it and return blocked safety.
+		if (!executedConfig.runtime?.mode && resumeManifest.runtimeResolution?.safety === "explicit_dry_run") {
+			const workersDisabled = executedConfig.executeWorkers === false || process.env.PI_CREW_EXECUTE_WORKERS === "0" || process.env.PI_TEAMS_EXECUTE_WORKERS === "0";
+			if (!workersDisabled) executedConfig.runtime = { ...executedConfig.runtime, mode: "scaffold" };
+		}
 		const runtime = await resolveCrewRuntime(executedConfig);
 		const runtimeResolution = runtimeResolutionState(runtime);
 		const runtimeManifest = { ...resumeManifest, runtimeResolution, updatedAt: new Date().toISOString() };
@@ -295,12 +303,14 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 		case "import": return handleImport(params, ctx);
 		case "imports": return handleImports(params, ctx);
 		case "settings": return handleSettings(params, ctx);
-	case "prune": return handlePrune(params, ctx);
+		case "prune": return handlePrune(params, ctx);
 		case "forget": return handleForget(params, ctx);
 		case "run": return handleRun(params, ctx);
 		case "status": return handleStatus(params, ctx);
 		case "cancel": return handleCancel(params, ctx);
+		case "retry": return handleRetry(params, ctx);
 		case "respond": return handleRespond(params, ctx);
+		case "parallel": return await handleParallel(params, ctx);
 		case "plan": return handlePlan(params, ctx);
 		case "resume": return handleResume(params, ctx);
 		case "create": return handleCreate(params, ctx);

package/src/hooks/registry.ts

@@ -0,0 +1,61 @@
+import type { HookDefinition, HookName, HookContext, HookResult, HookExecutionReport } from "./types.ts";
+import { appendEvent } from "../state/event-log.ts";
+import type { TeamRunManifest } from "../state/types.ts";
+import { runEventBus } from "../ui/run-event-bus.ts";
+
+const registry = new Map<HookName, HookDefinition[]>();
+
+export function registerHook(definition: HookDefinition): void {
+	const hooks = registry.get(definition.name) ?? [];
+	hooks.push(definition);
+	registry.set(definition.name, hooks);
+}
+
+export function clearHooks(): void {
+	registry.clear();
+}
+
+export function getHooks(name: HookName): HookDefinition[] {
+	return registry.get(name) ?? [];
+}
+
+export async function executeHook(name: HookName, ctx: HookContext): Promise<HookExecutionReport> {
+	const hooks = getHooks(name);
+	if (hooks.length === 0) return { hookName: name, outcome: "allow", durationMs: 0 };
+	const start = Date.now();
+	const diagnostics: string[] = [];
+	let capturedModifications: Record<string, unknown> | undefined;
+	for (const hook of hooks) {
+		try {
+			const result: HookResult = await hook.handler(ctx);
+			if (hook.mode === "blocking" && result.outcome === "block") {
+				return { hookName: name, outcome: "block", durationMs: Date.now() - start, reason: result.reason };
+			}
+			if (result.outcome === "modify" && result.data) {
+				Object.assign(ctx, result.data);
+				capturedModifications = { ...result.data };
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (hook.mode === "blocking") {
+				return { hookName: name, outcome: "block", durationMs: Date.now() - start, reason: `Hook error: ${message}` };
+			}
+			// Non-blocking hook errors are accumulated as diagnostics; continue to next hook
+			diagnostics.push(message);
+			}
+	}
+	if (diagnostics.length > 0) {
+		return { hookName: name, outcome: "diagnostic", durationMs: Date.now() - start, reason: diagnostics.join("; "), modifiedData: capturedModifications };
+	}
+	return { hookName: name, outcome: "allow", durationMs: Date.now() - start, modifiedData: capturedModifications };
+}
+
+export function appendHookEvent(manifest: TeamRunManifest, report: HookExecutionReport): void {
+	appendEvent(manifest.eventsPath, {
+		type: "hook.executed",
+		runId: manifest.runId,
+		message: `Hook ${report.hookName} completed with outcome=${report.outcome}${report.reason ? `: ${report.reason}` : ""}`,
+		data: { hookName: report.hookName, outcome: report.outcome, durationMs: report.durationMs, reason: report.reason },
+	});
+	runEventBus.emit({ type: "effectiveness_changed", runId: manifest.runId, data: { hookName: report.hookName, outcome: report.outcome } });
+}

package/src/hooks/types.ts

@@ -0,0 +1,41 @@
+export type HookName =
+	| "before_run_start"
+	| "before_task_start"
+	| "task_result"
+	| "before_cancel"
+	| "before_retry"
+	| "before_forget"
+	| "before_cleanup"
+	| "before_publish"
+	| "session_before_switch"
+	| "run_recovery";
+
+export type HookMode = "blocking" | "non_blocking";
+export type HookOutcome = "allow" | "block" | "modify" | "diagnostic";
+
+export interface HookContext {
+	runId: string;
+	taskId?: string;
+	cwd: string;
+	[key: string]: unknown;
+}
+
+export interface HookResult {
+	outcome: HookOutcome;
+	reason?: string;
+	data?: Record<string, unknown>;
+}
+
+export interface HookDefinition {
+	name: HookName;
+	mode: HookMode;
+	handler: (ctx: HookContext) => HookResult | Promise<HookResult>;
+}
+
+export interface HookExecutionReport {
+	hookName: HookName;
+	outcome: HookOutcome;
+	durationMs: number;
+	reason?: string;
+	modifiedData?: Record<string, unknown>;
+}