pi-crew 0.1.45 → 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/respond.ts

@@ -1,7 +1,8 @@
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { withRunLockSync } from "../../state/locks.ts";
-import { loadRunManifestById, saveRunTasks } from "../../state/state-store.ts";
-import { appendMailboxMessage } from "../../state/mailbox.ts";
+import { loadRunManifestById, saveRunTasks, updateRunStatus } from "../../state/state-store.ts";
+import { appendEvent } from "../../state/event-log.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";
@@ -10,7 +11,7 @@ import { result, type TeamContext } from "./context.ts";
 /**
  * Handle `respond` action: send a message to a waiting (interactive) task.
  * The task must be in "waiting" status. The message is stored in the task's
- * mailbox and the task is transitioned back to "running".
+ * mailbox and the task is re-queued for durable scheduler resume.
  */
 export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	if (!params.runId) return result("Respond requires runId.", { action: "respond", status: "error" }, true);
@@ -20,22 +21,28 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "respond", status: "error" }, true);
 
 	return withRunLockSync(loaded.manifest, () => {
+		const fresh = loadRunManifestById(ctx.cwd, params.runId!);
+		if (!fresh) return result(`Run '${params.runId}' not found.`, { action: "respond", status: "error" }, true);
+		const foreignRun = typeof fresh.manifest.ownerSessionId === "string" && fresh.manifest.ownerSessionId !== ctx.sessionId;
+		if (foreignRun) return result(`Run ${fresh.manifest.runId} belongs to another session; not responding.`, { action: "respond", status: "error", runId: fresh.manifest.runId }, true);
+
 		const taskId = params.taskId;
 		const message = params.message ?? "";
 
 		const targetTasks = taskId
-			? loaded.tasks.filter((t) => t.id === taskId && t.status === "waiting")
-			: loaded.tasks.filter((t) => t.status === "waiting");
+			? fresh.tasks.filter((t) => t.id === taskId && t.status === "waiting")
+			: fresh.tasks.filter((t) => t.status === "waiting");
 
 		if (targetTasks.length === 0) {
-			const existing = taskId ? loaded.tasks.find((t) => t.id === taskId) : undefined;
+			const existing = taskId ? fresh.tasks.find((t) => t.id === taskId) : undefined;
+			const hint = " Use api operation=follow-up-agent for continuation prompts or api operation=steer-agent to interrupt active work.";
 			return result(
-				taskId
+				(taskId
 					? existing
 						? `Task '${taskId}' is ${existing.status}, not waiting.`
 						: `Task '${taskId}' not found.`
-					: `No waiting tasks in run ${loaded.manifest.runId}.`,
-				{ action: "respond", status: "error", runId: loaded.manifest.runId },
+					: `No waiting tasks in run ${fresh.manifest.runId}.`) + hint,
+				{ action: "respond", status: "error", runId: fresh.manifest.runId },
 				true,
 			);
 		}
@@ -43,23 +50,37 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 		const resumed = new Set(targetTasks.map((t) => t.id));
 		const mailboxIds: string[] = [];
 		for (const task of targetTasks) {
-			const mailbox = appendMailboxMessage(loaded.manifest, {
+			const mailbox = appendMailboxMessage(fresh.manifest, {
 				direction: "inbox",
 				from: "leader",
 				to: task.id,
 				taskId: task.id,
 				body: message || "(resume)",
-				data: { action: "respond" },
+				kind: "response",
+				priority: "normal",
+				deliveryMode: "next_turn",
+				data: { action: "respond", kind: "response" },
+				replyTo: params.replyTo,
+				replyFrom: params.replyFrom,
+				replyDeadline: params.replyDeadline,
 			});
 			mailboxIds.push(mailbox.id);
 		}
 
-		// Transition waiting tasks back to running
-		const updatedTasks = loaded.tasks.map((task) => {
+		// 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;
 			return {
 				...task,
-				status: "running" as const,
+				status: "queued" as const,
+				startedAt: undefined,
+				finishedAt: undefined,
+				error: undefined,
 				adaptive: {
 					...task.adaptive,
 					phase: "resumed",
@@ -68,17 +89,24 @@ export function handleRespond(params: TeamToolParamsValue, ctx: TeamContext): Pi
 			};
 		});
 
-		saveRunTasks(loaded.manifest, updatedTasks);
+		saveRunTasks(fresh.manifest, updatedTasks);
+		let manifest = fresh.manifest;
+		if (manifest.status === "blocked" || manifest.status === "completed" || manifest.status === "failed" || manifest.status === "cancelled") {
+			manifest = updateRunStatus(manifest, "running", `Resumed ${resumed.size} waiting task(s).`);
+		}
+		for (const taskId of resumed) {
+			appendEvent(manifest.eventsPath, { type: "task.resumed", runId: manifest.runId, taskId, message: message || "Task re-queued after respond.", data: { mailboxIds } });
+		}
 		try {
-			saveCrewAgents(loaded.manifest, updatedTasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
+			saveCrewAgents(fresh.manifest, updatedTasks.map((task) => recordFromTask(fresh.manifest, task, "child-process")));
 		} catch (error) {
-			logInternalError("team-tool.handleRespond.crewAgents", error, `runId=${loaded.manifest.runId}`);
+			logInternalError("team-tool.handleRespond.crewAgents", error, `runId=${fresh.manifest.runId}`);
 		}
 
 		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: loaded.manifest.runId, resumedIds, mailboxIds } as never,
+			{ 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

@@ -4,13 +4,15 @@ import { allWorkflows, discoverWorkflows } from "../../workflows/discover-workfl
 import { loadConfig } from "../../config/config.ts";
 import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
 import { writeArtifact } from "../../state/artifact-store.ts";
+import { registerActiveRun, unregisterActiveRun } from "../../state/active-run-registry.ts";
 import { createRunManifest, loadRunManifestById, updateRunStatus } from "../../state/state-store.ts";
 import { atomicWriteJson } from "../../state/atomic-write.ts";
 import { validateWorkflowForTeam } from "../../workflows/validate-workflow.ts";
 import { executeTeamRun } from "../../runtime/team-runner.ts";
 import { spawnBackgroundTeamRun } from "../../subagents/async-entry.ts";
 import { appendEvent, readEvents } from "../../state/event-log.ts";
-import { resolveCrewRuntime } from "../../runtime/runtime-resolver.ts";
+import { resolveCrewRuntime, runtimeResolutionState } from "../../runtime/runtime-resolver.ts";
+import { normalizeSkillOverride } from "../../runtime/skill-instructions.ts";
 import { expandParallelResearchWorkflow } from "../../runtime/parallel-research.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
 import { hasAsyncStartMarker } from "../../runtime/async-marker.ts";
@@ -58,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));
@@ -91,6 +94,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		return result([`Workflow '${workflow.name}' is not valid for team '${team.name}':`, ...validationErrors.map((error) => `- ${error}`)].join("\n"), { action: "run", status: "error" }, true);
 	}
 
+	const skillOverride = normalizeSkillOverride(params.skill);
 	const { manifest, tasks, paths } = createRunManifest({
 		cwd: ctx.cwd,
 		team,
@@ -105,17 +109,35 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		content: `${goal}\n`,
 		producer: "team-tool",
 	});
-	const updatedManifest = { ...manifest, artifacts: [goalArtifact], summary: "Run manifest created; worker execution is not implemented yet." };
+	const updatedManifest = { ...manifest, ...(skillOverride !== undefined ? { skillOverride } : {}), artifacts: [goalArtifact], summary: "Run manifest created; worker execution is not implemented yet." };
 	atomicWriteJson(paths.manifestPath, updatedManifest);
+	registerActiveRun(updatedManifest);
 
 	const loadedConfig = loadConfig(ctx.cwd);
+	const executedConfig = effectiveRunConfig(loadedConfig.config, params.config);
+	const runtime = await resolveCrewRuntime(executedConfig);
+	const runtimeResolution = runtimeResolutionState(runtime);
+	const executionManifest = { ...updatedManifest, runtimeResolution, runConfig: executedConfig, updatedAt: new Date().toISOString() };
+	atomicWriteJson(paths.manifestPath, executionManifest);
+	appendEvent(executionManifest.eventsPath, { type: "runtime.resolved", runId: executionManifest.runId, message: `Runtime resolved: ${runtime.kind} safety=${runtime.safety}`, data: { runtimeResolution } });
 	const runAsync = params.async ?? loadedConfig.config.asyncByDefault ?? false;
 	if (runAsync) {
-		const spawned = spawnBackgroundTeamRun(updatedManifest);
-		const asyncManifest = { ...updatedManifest, async: { pid: spawned.pid, logPath: spawned.logPath, spawnedAt: new Date().toISOString() } };
+		if (runtime.safety === "blocked") {
+			const runningManifest = updateRunStatus(executionManifest, "running", "Checking worker runtime availability.");
+			const blocked = updateRunStatus(runningManifest, "blocked", runtime.reason ?? "Child worker execution is disabled; refusing to create no-op scaffold subagents.");
+			appendEvent(blocked.eventsPath, { type: "run.blocked", runId: blocked.runId, message: blocked.summary, data: { runtime, runtimeResolution, async: true } });
+			unregisterActiveRun(blocked.runId);
+			return result([
+				`Blocked pi-crew run ${blocked.runId}: real subagent workers are disabled.`,
+				`Runtime: ${runtime.kind} (requested ${runtime.requestedMode})`,
+				runtime.reason ?? "Child worker execution is disabled.",
+			].join("\n"), { action: "run", status: "error", runId: blocked.runId, artifactsRoot: blocked.artifactsRoot }, true);
+		}
+		const spawned = spawnBackgroundTeamRun(executionManifest);
+		const asyncManifest = { ...executionManifest, async: { pid: spawned.pid, logPath: spawned.logPath, spawnedAt: new Date().toISOString() } };
 		atomicWriteJson(paths.manifestPath, asyncManifest);
-		appendEvent(updatedManifest.eventsPath, { type: "async.spawned", runId: updatedManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });
-		scheduleBackgroundEarlyExitGuard(ctx.cwd, updatedManifest.runId, spawned.pid, spawned.logPath);
+		appendEvent(executionManifest.eventsPath, { type: "async.spawned", runId: executionManifest.runId, data: { pid: spawned.pid, logPath: spawned.logPath } });
+		scheduleBackgroundEarlyExitGuard(ctx.cwd, executionManifest.runId, spawned.pid, spawned.logPath);
 		const text = [
 			`Started async pi-crew run ${updatedManifest.runId}.`,
 			`Team: ${team.name}`,
@@ -128,16 +150,32 @@ 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}` });
 	}
 
-	const runtime = await resolveCrewRuntime(effectiveRunConfig(loadedConfig.config, params.config));
+	if (runtime.safety === "blocked") {
+		const runningManifest = updateRunStatus(executionManifest, "running", "Checking worker runtime availability.");
+		const blocked = updateRunStatus(runningManifest, "blocked", runtime.reason ?? "Child worker execution is disabled; refusing to create no-op scaffold subagents.");
+		appendEvent(blocked.eventsPath, { type: "run.blocked", runId: blocked.runId, message: blocked.summary, data: { runtime, runtimeResolution } });
+		unregisterActiveRun(blocked.runId);
+		return result([
+			`Blocked pi-crew run ${blocked.runId}: real subagent workers are disabled.`,
+			`Runtime: ${runtime.kind} (requested ${runtime.requestedMode})`,
+			runtime.reason ?? "Child worker execution is disabled.",
+			"",
+			"To run effective subagents, remove executeWorkers=false / PI_CREW_EXECUTE_WORKERS=0 / PI_TEAMS_EXECUTE_WORKERS=0 or set runtime.mode=child-process.",
+			"Use runtime.mode=scaffold only for explicit dry-run prompt/artifact generation.",
+		].join("\n"), { action: "run", status: "error", runId: blocked.runId, artifactsRoot: blocked.artifactsRoot }, true);
+	}
 	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, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry, onJsonEvent: ctx.onJsonEvent });
+			try {
+				await executeTeamRun({ manifest: executionManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, skillOverride, signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry, onJsonEvent: ctx.onJsonEvent });
+			} finally {
+				unregisterActiveRun(updatedManifest.runId);
+			}
 		}, updatedManifest.runId);
 		const text = [
 			`Started foreground pi-crew run ${updatedManifest.runId}.`,
@@ -151,9 +189,14 @@ 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 {
+		executed = await executeTeamRun({ manifest: executionManifest, tasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, skillOverride, signal: ctx.signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry, onJsonEvent: ctx.onJsonEvent });
+	} finally {
+		unregisterActiveRun(updatedManifest.runId);
 	}
-	const executed = 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: ctx.signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry, onJsonEvent: ctx.onJsonEvent });
 	const text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
 		`Team: ${team.name}`,

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

@@ -9,6 +9,7 @@ import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../../runtime/process-status.ts";
 import { formatTaskGraphLines, waitingReason } from "../../runtime/task-display.ts";
 import { verifyTaskCompletion, formatOutputPreview } from "../../runtime/completion-guard.ts";
+import { evaluateRunEffectiveness } from "../../runtime/effectiveness.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { result, type TeamContext } from "./context.ts";
 
@@ -51,6 +52,10 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		groupJoinLines.push(`- ${String(message.data?.partial) === "true" ? "partial" : "completed"} request=${requestId} message=${message.id} ack=${timedOut ? "timeout" : ack}`);
 	}
 	const totalUsage = aggregateUsage(tasks);
+	const completedTasks = tasks.filter((task) => task.status === "completed");
+	const effectiveness = evaluateRunEffectiveness({ manifest, tasks, executeWorkers: manifest.runtimeResolution?.kind !== "scaffold", runtimeConfig: loadConfig(ctx.cwd).config.runtime });
+	const noObservedWorkTasks = effectiveness.noObservedWorkTaskIds.map((id) => tasks.find((task) => task.id === id)).filter((task): task is typeof tasks[number] => task !== undefined);
+	const attentionTasks = effectiveness.needsAttentionTaskIds.map((id) => tasks.find((task) => task.id === id)).filter((task): task is typeof tasks[number] => task !== undefined);
 	const activeAgents = crewAgents.filter((agent) => agent.status === "running");
 	const completedAgents = crewAgents.filter((agent) => agent.status !== "running");
 	const waitingTasks = tasks.filter((task) => task.status === "queued" || task.status === "waiting");
@@ -61,6 +66,7 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		`Workflow: ${manifest.workflow ?? "(none)"}`,
 		`Status: ${manifest.status}`,
 		`Workspace mode: ${manifest.workspaceMode}`,
+		...(manifest.runtimeResolution ? [`Runtime: ${manifest.runtimeResolution.kind}`, `Runtime safety: ${manifest.runtimeResolution.safety}`, `Runtime requested: ${manifest.runtimeResolution.requestedMode}${manifest.runtimeResolution.reason ? ` (${manifest.runtimeResolution.reason})` : ""}`] : []),
 		`Goal: ${manifest.goal}`,
 		`Created: ${manifest.createdAt}`,
 		`Updated: ${manifest.updatedAt}`,
@@ -72,7 +78,12 @@ export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiT
 		"Tasks:",
 		...(tasks.length ? tasks.map((task) => `- ${task.id} [${task.status}] ${task.role} -> ${task.agent}${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.modelAttempts?.length ? ` attempts=${task.modelAttempts.length}` : ""}${task.modelRouting ? ` modelRouting=${task.modelRouting.requested ? `${task.modelRouting.requested}->` : ""}${task.modelRouting.resolved}${task.modelRouting.usedAttempt ? ` attempt=${task.modelRouting.usedAttempt + 1}` : ""}` : ""}${task.agentProgress?.activityState ? ` activityState=${task.agentProgress.activityState}` : ""}${attentionByTask.get(task.id)?.data?.reason ? ` attention=${String(attentionByTask.get(task.id)?.data?.reason)}` : ""}${task.jsonEvents !== undefined ? ` jsonEvents=${task.jsonEvents}` : ""}${task.usage ? ` usage=${JSON.stringify(task.usage)}` : ""}${task.resultArtifact ? ` result=${task.resultArtifact.path}` : ""}${task.transcriptArtifact ? ` transcript=${task.transcriptArtifact.path}` : ""}${task.worktree ? ` worktree=${task.worktree.path}` : ""}${task.error ? ` error=${task.error}` : ""}`) : ["- (none)"]),
 		`Task counts: ${[...counts.entries()].map(([status, count]) => `${status}=${count}`).join(", ") || "none"}`,
-		"Completion verification:",
+		"Effectiveness:",
+		`- observable=${effectiveness.observable}/${Math.max(1, effectiveness.completed)} completed tasks`,
+		`- workerExecution=${effectiveness.workerExecution} guard=${effectiveness.guardMode} severity=${effectiveness.severity}`,
+		`- noObservedWork=${effectiveness.noObservedWorkTaskIds.length ? effectiveness.noObservedWorkTaskIds.join(",") : "none"}`,
+		`- needsAttention=${effectiveness.needsAttentionTaskIds.length ? effectiveness.needsAttentionTaskIds.join(",") : "none"}`,
+		"Completion verification",
 		...(tasks.filter((t) => t.status === "completed").length ? tasks.filter((t) => t.status === "completed").map((t) => {
 			const guard = verifyTaskCompletion(t, manifest);
 			return `- ${t.id} green=${guard.greenLevel}/3${guard.warnings.length ? ` warnings=[${guard.warnings.join(", ")}]` : ""}`;
@@ -95,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

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

package/src/extension/team-tool.ts

@@ -29,24 +29,26 @@ import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState } from "../stat
 import { executeTeamRun } from "../runtime/team-runner.ts";
 import { checkProcessLiveness, isActiveRunStatus } from "../runtime/process-status.ts";
 import { saveCrewAgents, readCrewAgents, recordFromTask } from "../runtime/crew-agent-records.ts";
-import { resolveCrewRuntime } from "../runtime/runtime-resolver.ts";
+import { resolveCrewRuntime, runtimeResolutionState } from "../runtime/runtime-resolver.ts";
 import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../runtime/agent-control.ts";
 import { writeForegroundInterruptRequest } from "../runtime/foreground-control.ts";
 import { formatTaskGraphLines, waitingReason } from "../runtime/task-display.ts";
 import { directTeamAndWorkflowFromRun } from "../runtime/direct-run.ts";
 import { parsePiJsonOutput } from "../runtime/pi-json-output.ts";
 import { buildParentContext, configRecord, formatScoped, result, type TeamContext } from "./team-tool/context.ts";
-import { autonomousPatchFromConfig, configPatchFromConfig, formatAutonomyStatus } from "./team-tool/config-patch.ts";
+import { autonomousPatchFromConfig, configPatchFromConfig, effectiveRunConfig, formatAutonomyStatus } from "./team-tool/config-patch.ts";
 import { handleApi } from "./team-tool/api.ts";
 import { handleRun } from "./team-tool/run.ts";
 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";
+import { normalizeSkillOverride } from "../runtime/skill-instructions.ts";
 
 export type { TeamToolDetails } from "./team-tool-types.ts";
 export type { TeamContext } from "./team-tool/context.ts";
@@ -55,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";
 
@@ -176,18 +178,44 @@ export async function handleResume(params: TeamToolParamsValue, ctx: TeamContext
 	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 loadedConfig = loadConfig(ctx.cwd);
 		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() };
+		saveRunManifest(runtimeManifest);
+		appendEvent(runtimeManifest.eventsPath, { type: "runtime.resolved", runId: runtimeManifest.runId, message: `Runtime resolved for resume: ${runtime.kind} safety=${runtime.safety}`, data: { runtimeResolution, action: "resume" } });
+		if (runtime.safety === "blocked") {
+			const runningManifest = updateRunStatus(runtimeManifest, "running", "Checking worker runtime availability before resume.");
+			const blocked = updateRunStatus(runningManifest, "blocked", runtime.reason ?? "Child worker execution is disabled; refusing to resume with no-op scaffold subagents.");
+			appendEvent(blocked.eventsPath, { type: "run.blocked", runId: blocked.runId, message: blocked.summary, data: { runtime, action: "resume" } });
+			return result([
+				`Blocked resume for pi-crew run ${blocked.runId}: real subagent workers are disabled.`,
+				`Runtime: ${runtime.kind} (requested ${runtime.requestedMode})`,
+				runtime.reason ?? "Child worker execution is disabled.",
+				"",
+				"To resume effective subagents, remove executeWorkers=false / PI_CREW_EXECUTE_WORKERS=0 / PI_TEAMS_EXECUTE_WORKERS=0 or set runtime.mode=child-process.",
+				"Use runtime.mode=scaffold only for explicit dry-run prompt/artifact generation.",
+			].join("\n"), { action: "resume", status: "error", runId: blocked.runId, artifactsRoot: blocked.artifactsRoot }, true);
+		}
 		const resetTasks = recovered.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);
-		saveRunTasks(resumeManifest, resetTasks);
-		const replay = replayPendingMailboxMessages(resumeManifest);
-		appendEvent(resumeManifest.eventsPath, { type: "run.resume_requested", runId: resumeManifest.runId, data: { replayedMailboxMessages: replay.messages.length, recoveredCheckpointTasks: recovered.recovered } });
-		if (recovered.recovered.length) appendEvent(resumeManifest.eventsPath, { type: "task.checkpoint_recovered", runId: resumeManifest.runId, message: `Recovered ${recovered.recovered.length} task(s) from artifact-written checkpoints.`, data: { taskIds: recovered.recovered } });
-		if (replay.messages.length) appendEvent(resumeManifest.eventsPath, { type: "mailbox.replayed", runId: resumeManifest.runId, message: `Replayed ${replay.messages.length} pending inbox message(s).`, data: { messageIds: replay.messages.map((message) => message.id), taskIds: replay.messages.map((message) => message.taskId).filter(Boolean) } });
-		const loadedConfig = loadConfig(ctx.cwd);
-		const runtime = await resolveCrewRuntime(loadedConfig.config);
+		saveRunTasks(runtimeManifest, resetTasks);
+		const replay = replayPendingMailboxMessages(runtimeManifest);
+		appendEvent(runtimeManifest.eventsPath, { type: "run.resume_requested", runId: runtimeManifest.runId, data: { replayedMailboxMessages: replay.messages.length, recoveredCheckpointTasks: recovered.recovered } });
+		if (recovered.recovered.length) appendEvent(runtimeManifest.eventsPath, { type: "task.checkpoint_recovered", runId: runtimeManifest.runId, message: `Recovered ${recovered.recovered.length} task(s) from artifact-written checkpoints.`, data: { taskIds: recovered.recovered } });
+		if (replay.messages.length) appendEvent(runtimeManifest.eventsPath, { type: "mailbox.replayed", runId: runtimeManifest.runId, message: `Replayed ${replay.messages.length} pending inbox message(s).`, data: { messageIds: replay.messages.map((message) => message.id), taskIds: replay.messages.map((message) => message.taskId).filter(Boolean) } });
 		const executeWorkers = runtime.kind !== "scaffold";
-		const executed = await executeTeamRun({ manifest: resumeManifest, 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, reliability: loadedConfig.config.reliability, metricRegistry: ctx.metricRegistry });
+		const resumeSkillOverride = normalizeSkillOverride(params.skill) ?? runtimeManifest.skillOverride;
+		const executed = await executeTeamRun({ manifest: runtimeManifest, tasks: resetTasks, team, workflow, agents, executeWorkers, limits: executedConfig.limits, runtime, runtimeConfig: executedConfig.runtime, parentContext: buildParentContext(ctx), parentModel: ctx.model, modelRegistry: ctx.modelRegistry, modelOverride: params.model, skillOverride: resumeSkillOverride, signal: ctx.signal, reliability: executedConfig.reliability, metricRegistry: ctx.metricRegistry });
 		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");
 	});
 }
@@ -199,7 +227,7 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 		case "get": return handleGet(params, ctx);
 		case "init": {
 			const cfg = configRecord(params.config);
-			const initialized = initializeProject(ctx.cwd, { copyBuiltins: cfg.copyBuiltins === true, overwrite: cfg.overwrite === true });
+			const initialized = initializeProject(ctx.cwd, { copyBuiltins: cfg.copyBuiltins === true, overwrite: cfg.overwrite === true, configScope: cfg.configScope === "project" || cfg.scope === "project" ? "project" : cfg.configScope === "none" || cfg.scope === "none" ? "none" : "global" });
 			return result([
 				"Initialized pi-crew project layout.",
 				"Directories:",
@@ -207,6 +235,7 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 				"Copied builtin files:",
 				...(initialized.copiedFiles.length ? initialized.copiedFiles.map((file) => `- ${file}`) : ["- (none)"]),
 				...(initialized.skippedFiles.length ? ["Skipped existing files:", ...initialized.skippedFiles.map((file) => `- ${file}`)] : []),
+				`Config: ${initialized.configPath || "(none)"} (${initialized.configScope}${initialized.configCreated ? "; created" : initialized.configSkipped ? "; already existed" : "; unchanged"})`,
 				`Gitignore: ${initialized.gitignorePath} (${initialized.gitignoreUpdated ? "updated" : "already configured"})`,
 			].join("\n"), { action: "init", status: "ok" });
 		}
@@ -274,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);