pi-crew 0.2.2 → 0.2.4

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

@@ -1,156 +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) } };
-	}
-}
+/**
+ * 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

@@ -1,112 +1,113 @@
-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, 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";
-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 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);
-	if (!params.message && !params.taskId) return result("Respond requires taskId and/or message.", { action: "respond", status: "error" }, true);
-
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	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
-			? fresh.tasks.filter((t) => t.id === taskId && t.status === "waiting")
-			: fresh.tasks.filter((t) => t.status === "waiting");
-
-		if (targetTasks.length === 0) {
-			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
-					? existing
-						? `Task '${taskId}' is ${existing.status}, not waiting.`
-						: `Task '${taskId}' not found.`
-					: `No waiting tasks in run ${fresh.manifest.runId}.`) + hint,
-				{ action: "respond", status: "error", runId: fresh.manifest.runId },
-				true,
-			);
-		}
-
-		const resumed = new Set(targetTasks.map((t) => t.id));
-		const mailboxIds: string[] = [];
-		for (const task of targetTasks) {
-			const mailbox = appendMailboxMessage(fresh.manifest, {
-				direction: "inbox",
-				from: "leader",
-				to: task.id,
-				taskId: task.id,
-				body: message || "(resume)",
-				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);
-		}
-
-		// 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: "queued" as const,
-				startedAt: undefined,
-				finishedAt: undefined,
-				error: undefined,
-				adaptive: {
-					...task.adaptive,
-					phase: "resumed",
-					task: message || task.adaptive?.task || "",
-				},
-			};
-		});
-
-		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(fresh.manifest, updatedTasks.map((task) => recordFromTask(fresh.manifest, task, "child-process")));
-		} catch (error) {
-			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: fresh.manifest.runId, resumedIds, mailboxIds, intent: `responding to ${resumedIds.join(", ")} in ${fresh.manifest.runId}` },
-		);
-	});
+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, updateMailboxMessageReply } from "../../state/mailbox.ts";
+import { readCrewAgents, saveCrewAgents, recordFromTask } from "../../runtime/crew-agent-records.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+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 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);
+	if (!params.message && !params.taskId) return result("Respond requires taskId and/or message.", { action: "respond", status: "error" }, true);
+
+	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	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
+			? fresh.tasks.filter((t) => t.id === taskId && t.status === "waiting")
+			: fresh.tasks.filter((t) => t.status === "waiting");
+
+		if (targetTasks.length === 0) {
+			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
+					? existing
+						? `Task '${taskId}' is ${existing.status}, not waiting.`
+						: `Task '${taskId}' not found.`
+					: `No waiting tasks in run ${fresh.manifest.runId}.`) + hint,
+				{ action: "respond", status: "error", runId: fresh.manifest.runId },
+				true,
+			);
+		}
+
+		const resumed = new Set(targetTasks.map((t) => t.id));
+		const mailboxIds: string[] = [];
+		for (const task of targetTasks) {
+			const mailbox = appendMailboxMessage(fresh.manifest, {
+				direction: "inbox",
+				from: "leader",
+				to: task.id,
+				taskId: task.id,
+				body: message || "(resume)",
+				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);
+		}
+
+		// 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: "queued" as const,
+				startedAt: undefined,
+				finishedAt: undefined,
+				error: undefined,
+				adaptive: {
+					...task.adaptive,
+					phase: "resumed",
+					task: message || task.adaptive?.task || "",
+				},
+			};
+		});
+
+		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 {
+			const existingRuntimes = new Map(readCrewAgents(fresh.manifest).map((a) => [a.taskId, a.runtime]));
+			saveCrewAgents(fresh.manifest, updatedTasks.map((task) => recordFromTask(fresh.manifest, task, existingRuntimes.get(task.id) ?? "child-process")));
+		} catch (error) {
+			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: fresh.manifest.runId, resumedIds, mailboxIds, intent: `responding to ${resumedIds.join(", ")} in ${fresh.manifest.runId}` },
+		);
+	});
 }