pi-crew 0.1.44 → 0.1.46

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

@@ -1,103 +1,135 @@
-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 { saveCrewAgents, recordFromTask } from "../../runtime/crew-agent-records.ts";
-import { writeForegroundInterruptRequest } from "../../runtime/foreground-control.ts";
-import { logInternalError } from "../../utils/internal-error.ts";
-import type { PiTeamsToolResult } from "../tool-result.ts";
-import { result, type TeamContext } from "./context.ts";
-
-export interface AbortOwnedResult {
-	abortedIds: string[];
-	missingIds: string[];
-	foreignIds: string[];
-}
-
-/**
- * Classify task IDs by ownership.
- * - Tasks with status "queued" or "running" that belong to the current session → abortedIds
- * - Task IDs not found in the run → missingIds
- * - Tasks with status "queued" or "running" that belong to a different session → foreignIds
- * - Tasks already completed/failed/cancelled → neither (not included in any list)
- *
- * Currently, task ownership is determined by the manifest's run-level ownership.
- * Since tasks in a single run are all owned by the session that created the run,
- * the ownerSessionId comes from the context. Foreign detection compares
- * the requesting session against the run's creating session.
- */
-export function abortOwned(
-	runId: string,
-	taskIds: string[] | undefined,
-	ctx: TeamContext,
-): AbortOwnedResult {
-	const loaded = loadRunManifestById(ctx.cwd, runId);
-	if (!loaded) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
-
-	const result: AbortOwnedResult = { abortedIds: [], missingIds: [], foreignIds: [] };
-	const taskMap = new Map(loaded.tasks.map((t) => [t.id, t] as const));
-	const targetIds = taskIds ?? loaded.tasks.map((t) => t.id);
-
-	for (const id of targetIds) {
-		const task = taskMap.get(id);
-		if (!task) {
-			result.missingIds.push(id);
-			continue;
-		}
-		if (task.status !== "queued" && task.status !== "running" && task.status !== "waiting") continue;
-		// All tasks in a run are owned by the session that created the run.
-		// Since cancel is always called within the session that created it,
-		// all cancellable tasks are abortable.
-		// Foreign detection is a placeholder for when tasks can be owned
-		// by different sessions (e.g., shared runs with session-scoped tasks).
-		result.abortedIds.push(id);
-	}
-
-	return result;
-}
-
-export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
-	return withRunLockSync(loaded.manifest, () => {
-		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && !params.force) return result(`Run ${loaded.manifest.runId} is already ${loaded.manifest.status}; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
-
-		// Classify tasks for foreign-aware cancellation
-		const abortResult = abortOwned(loaded.manifest.runId, undefined, ctx);
-		const cancellableIds = new Set(abortResult.abortedIds);
-
-		const tasks = loaded.tasks.map((task) => {
-			if (cancellableIds.has(task.id) && (task.status === "queued" || task.status === "running" || task.status === "waiting")) {
-				return { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: "Run cancelled by user request." };
-			}
-			return task;
-		});
-		saveRunTasks(loaded.manifest, tasks);
-		try {
-			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
-		} catch (error) {
-			logInternalError("team-tool.handleCancel.crewAgents", error, `runId=${loaded.manifest.runId}`);
-		}
-		try {
-			writeForegroundInterruptRequest(loaded.manifest, "Run cancelled by user request.");
-		} catch (error) {
-			logInternalError("team-tool.handleCancel.interruptRequest", error, `runId=${loaded.manifest.runId}`);
-		}
-		const updated = updateRunStatus(loaded.manifest, "cancelled", "Run cancelled by user request. Already-finished worker processes are not retroactively changed.");
-
-		// Build descriptive message including foreign/missing info
-		const parts = [`Cancelled run ${updated.runId}.`];
-		if (abortResult.foreignIds.length > 0) parts.push(` ${abortResult.foreignIds.length} task(s) belong to another session and were not cancelled: ${abortResult.foreignIds.join(", ")}.`);
-		if (abortResult.missingIds.length > 0) parts.push(` ${abortResult.missingIds.length} task ID(s) not found: ${abortResult.missingIds.join(", ")}.`);
-
-		return result(parts.join(""), {
-			action: "cancel",
-			status: "ok",
-			runId: updated.runId,
-			artifactsRoot: updated.artifactsRoot,
-			abortedIds: abortResult.abortedIds,
-			missingIds: abortResult.missingIds,
-			foreignIds: abortResult.foreignIds,
-		});
-	});
+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 { saveCrewAgents, recordFromTask } from "../../runtime/crew-agent-records.ts";
+import { writeForegroundInterruptRequest } from "../../runtime/foreground-control.ts";
+import { cancellationReasonFromUnknown } from "../../runtime/cancellation.ts";
+import { appendEvent } from "../../state/event-log.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+
+export interface AbortOwnedResult {
+	abortedIds: string[];
+	missingIds: string[];
+	foreignIds: string[];
+}
+
+/**
+ * Classify task IDs by ownership.
+ * - Tasks with status "queued" or "running" that belong to the current session → abortedIds
+ * - Task IDs not found in the run → missingIds
+ * - Tasks with status "queued" or "running" that belong to a different session → foreignIds
+ * - Tasks already completed/failed/cancelled → neither (not included in any list)
+ *
+ * Currently, task ownership is determined by the manifest's run-level ownership.
+ * Since tasks in a single run are all owned by the session that created the run,
+ * the ownerSessionId comes from the context. Foreign detection compares
+ * the requesting session against the run's creating session.
+ */
+export function abortOwned(
+	runId: string,
+	taskIds: string[] | undefined,
+	ctx: TeamContext,
+): AbortOwnedResult {
+	const loaded = loadRunManifestById(ctx.cwd, runId);
+	if (!loaded) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
+
+	const result: AbortOwnedResult = { abortedIds: [], missingIds: [], foreignIds: [] };
+	const taskMap = new Map(loaded.tasks.map((t) => [t.id, t] as const));
+	const targetIds = taskIds ?? loaded.tasks.map((t) => t.id);
+	const foreignRun = typeof loaded.manifest.ownerSessionId === "string" && loaded.manifest.ownerSessionId !== ctx.sessionId;
+
+	for (const id of targetIds) {
+		const task = taskMap.get(id);
+		if (!task) {
+			result.missingIds.push(id);
+			continue;
+		}
+		if (task.status !== "queued" && task.status !== "running" && task.status !== "waiting") continue;
+		if (foreignRun) {
+			result.foreignIds.push(id);
+			continue;
+		}
+		result.abortedIds.push(id);
+	}
+
+	return result;
+}
+
+function configFromParams(params: TeamToolParamsValue): Record<string, unknown> | undefined {
+	return params.config && typeof params.config === "object" && !Array.isArray(params.config) ? params.config : undefined;
+}
+
+function cancelReasonFromParams(params: TeamToolParamsValue): { code: string; message: string } {
+	const config = configFromParams(params);
+	const rawReason = config?.reason ?? config?.cancelReason;
+	const reason = rawReason === undefined ? { code: "caller_cancelled" as const, message: "Run cancelled by user request." } : cancellationReasonFromUnknown(rawReason);
+	return { code: reason.code, message: reason.message };
+}
+
+function intentFromParams(params: TeamToolParamsValue): string | undefined {
+	const config = configFromParams(params);
+	const rawIntent = config?.intent ?? config?._intent;
+	if (typeof rawIntent !== "string") return undefined;
+	const intent = rawIntent.replace(/\s+/g, " ").trim();
+	return intent ? intent.slice(0, 500) : undefined;
+}
+
+export function handleCancel(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	if (!params.runId) return result("Cancel requires runId.", { action: "cancel", status: "error" }, true);
+	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cancel", status: "error" }, true);
+	return withRunLockSync(loaded.manifest, () => {
+		if ((loaded.manifest.status === "completed" || loaded.manifest.status === "cancelled") && !params.force) return result(`Run ${loaded.manifest.runId} is already ${loaded.manifest.status}; nothing to cancel. Use force: true to mark it cancelled anyway.`, { action: "cancel", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+
+		// Classify tasks for foreign-aware cancellation
+		const abortResult = abortOwned(loaded.manifest.runId, undefined, ctx);
+		if (abortResult.abortedIds.length === 0 && abortResult.foreignIds.length > 0) {
+			return result(`Run ${loaded.manifest.runId} belongs to another session; not cancelled.`, { action: "cancel", status: "error", runId: loaded.manifest.runId, foreignIds: abortResult.foreignIds }, true);
+		}
+		const cancellableIds = new Set(abortResult.abortedIds);
+		const cancelReason = cancelReasonFromParams(params);
+		const cancelIntent = intentFromParams(params);
+		const cancelData = cancelIntent ? { reason: cancelReason.code, intent: cancelIntent } : { reason: cancelReason.code };
+		const cancelMessage = `${cancelReason.message} (${cancelReason.code})`;
+
+		const tasks = loaded.tasks.map((task) => {
+			if (cancellableIds.has(task.id) && (task.status === "queued" || task.status === "running" || task.status === "waiting")) {
+				return { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: cancelMessage };
+			}
+			return task;
+		});
+		saveRunTasks(loaded.manifest, tasks);
+		try {
+			saveCrewAgents(loaded.manifest, tasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
+		} catch (error) {
+			logInternalError("team-tool.handleCancel.crewAgents", error, `runId=${loaded.manifest.runId}`);
+		}
+		try {
+			writeForegroundInterruptRequest(loaded.manifest, cancelMessage);
+		} catch (error) {
+			logInternalError("team-tool.handleCancel.interruptRequest", error, `runId=${loaded.manifest.runId}`);
+		}
+		for (const taskId of abortResult.abortedIds) {
+			appendEvent(loaded.manifest.eventsPath, { type: "task.cancelled", runId: loaded.manifest.runId, taskId, message: cancelMessage, data: cancelData });
+		}
+		const updated = updateRunStatus(loaded.manifest, "cancelled", `${cancelMessage} Already-finished worker processes are not retroactively changed.`, { data: cancelData });
+
+		// Build descriptive message including foreign/missing info
+		const parts = [`Cancelled run ${updated.runId}.`];
+		if (abortResult.foreignIds.length > 0) parts.push(` ${abortResult.foreignIds.length} task(s) belong to another session and were not cancelled: ${abortResult.foreignIds.join(", ")}.`);
+		if (abortResult.missingIds.length > 0) parts.push(` ${abortResult.missingIds.length} task ID(s) not found: ${abortResult.missingIds.join(", ")}.`);
+
+		return result(parts.join(""), {
+			action: "cancel",
+			status: "ok",
+			runId: updated.runId,
+			artifactsRoot: updated.artifactsRoot,
+			abortedIds: abortResult.abortedIds,
+			missingIds: abortResult.missingIds,
+			foreignIds: abortResult.foreignIds,
+			intent: cancelIntent,
+		});
+	});
 }

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

@@ -4,6 +4,7 @@ import type { TeamToolDetails } from "../team-tool-types.ts";
 import { toolResult, type PiTeamsToolResult } from "../tool-result.ts";
 
 export type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext, "model">> & {
+	sessionId?: string;
 	modelRegistry?: unknown;
 	sessionManager?: { getBranch?: () => unknown[] };
 	events?: { emit?: (event: string, data: unknown) => void };
@@ -14,6 +15,11 @@ export type TeamContext = Pick<ExtensionContext, "cwd"> & Partial<Pick<Extension
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 };
 
+export function withSessionId<T extends Pick<ExtensionContext, "sessionManager">>(ctx: T): T & { sessionId?: string } {
+	const sessionId = ctx.sessionManager.getSessionId();
+	return sessionId ? { ...ctx, sessionId } : { ...ctx };
+}
+
 export function result(text: string, details: TeamToolDetails, isError = false): PiTeamsToolResult {
 	return toolResult(text, details, isError);
 }

package/src/extension/team-tool/lifecycle-actions.ts

@@ -10,6 +10,14 @@ import { pruneFinishedRuns } from "../run-maintenance.ts";
 import type { PiTeamsToolResult } from "../tool-result.ts";
 import { configRecord, result, type TeamContext } from "./context.ts";
 
+function intentFromParams(params: TeamToolParamsValue): string | undefined {
+	const cfg = configRecord(params.config);
+	const rawIntent = cfg.intent ?? cfg._intent;
+	if (typeof rawIntent !== "string") return undefined;
+	const intent = rawIntent.replace(/\s+/g, " ").trim();
+	return intent ? intent.slice(0, 500) : undefined;
+}
+
 export function handleWorktrees(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
 	if (!params.runId) return result("Worktrees requires runId.", { action: "worktrees", status: "error" }, true);
 	const loaded = loadRunManifestById(ctx.cwd, params.runId);
@@ -52,8 +60,9 @@ export function handlePrune(params: TeamToolParamsValue, ctx: TeamContext): PiTe
 	const keep = params.keep ?? 20;
 	if (!params.confirm) return result("prune requires confirm: true.", { action: "prune", status: "error" }, true);
 	if (keep < 0 || !Number.isInteger(keep)) return result("keep must be an integer >= 0.", { action: "prune", status: "error" }, true);
-	const pruned = pruneFinishedRuns(ctx.cwd, keep);
-	return result([`Pruned finished pi-crew runs.`, `Kept: ${pruned.kept.length}`, `Removed: ${pruned.removed.length}`, ...(pruned.removed.length ? ["Removed runs:", ...pruned.removed.map((runId) => `- ${runId}`)] : [])].join("\n"), { action: "prune", status: "ok" });
+	const intent = intentFromParams(params);
+	const pruned = pruneFinishedRuns(ctx.cwd, keep, { intent });
+	return result([`Pruned finished pi-crew runs.`, `Kept: ${pruned.kept.length}`, `Removed: ${pruned.removed.length}`, ...(pruned.auditPath ? [`Audit: ${pruned.auditPath}`] : []), ...(pruned.removed.length ? ["Removed runs:", ...pruned.removed.map((runId) => `- ${runId}`)] : [])].join("\n"), { action: "prune", status: "ok", intent });
 }
 
 export function handleForget(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
@@ -63,9 +72,11 @@ export function handleForget(params: TeamToolParamsValue, ctx: TeamContext): PiT
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "forget", status: "error" }, true);
 	const cleanup = cleanupRunWorktrees(loaded.manifest, { force: params.force });
 	if (cleanup.preserved.length > 0 && !params.force) return result([`Run '${params.runId}' has preserved worktrees. Use force: true to forget anyway.`, ...cleanup.preserved.map((item) => `- ${item.path}: ${item.reason}`)].join("\n"), { action: "forget", status: "error", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot }, true);
+	const intent = intentFromParams(params);
+	appendEvent(loaded.manifest.eventsPath, { type: "run.forget_requested", runId: loaded.manifest.runId, message: "Run state and artifacts are being forgotten.", data: { force: params.force === true, removedWorktrees: cleanup.removed, preservedWorktrees: cleanup.preserved, intent } });
 	fs.rmSync(loaded.manifest.stateRoot, { recursive: true, force: true });
 	fs.rmSync(loaded.manifest.artifactsRoot, { recursive: true, force: true });
-	return result([`Forgot run ${loaded.manifest.runId}.`, `Removed state: ${loaded.manifest.stateRoot}`, `Removed artifacts: ${loaded.manifest.artifactsRoot}`, ...(cleanup.removed.length ? ["Removed worktrees:", ...cleanup.removed.map((item) => `- ${item}`)] : [])].join("\n"), { action: "forget", status: "ok", runId: loaded.manifest.runId });
+	return result([`Forgot run ${loaded.manifest.runId}.`, `Removed state: ${loaded.manifest.stateRoot}`, `Removed artifacts: ${loaded.manifest.artifactsRoot}`, ...(cleanup.removed.length ? ["Removed worktrees:", ...cleanup.removed.map((item) => `- ${item}`)] : [])].join("\n"), { action: "forget", status: "ok", runId: loaded.manifest.runId, intent });
 }
 
 export function handleCleanup(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
@@ -73,7 +84,8 @@ export function handleCleanup(params: TeamToolParamsValue, ctx: TeamContext): Pi
 	const loaded = loadRunManifestById(ctx.cwd, params.runId);
 	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "cleanup", status: "error" }, true);
 	const cleanup = cleanupRunWorktrees(loaded.manifest, { force: params.force });
-	appendEvent(loaded.manifest.eventsPath, { type: "worktree.cleanup", runId: loaded.manifest.runId, data: { removed: cleanup.removed, preserved: cleanup.preserved, artifacts: cleanup.artifactPaths } });
+	const intent = intentFromParams(params);
+	appendEvent(loaded.manifest.eventsPath, { type: "worktree.cleanup", runId: loaded.manifest.runId, data: { removed: cleanup.removed, preserved: cleanup.preserved, artifacts: cleanup.artifactPaths, intent } });
 	const lines = [`Worktree cleanup for ${loaded.manifest.runId}:`, "Removed:", ...(cleanup.removed.length ? cleanup.removed.map((item) => `- ${item}`) : ["- (none)"]), "Preserved:", ...(cleanup.preserved.length ? cleanup.preserved.map((item) => `- ${item.path}: ${item.reason}`) : ["- (none)"]), "Artifacts:", ...(cleanup.artifactPaths.length ? cleanup.artifactPaths.map((item) => `- ${item}`) : ["- (none)"])];
-	return result(lines.join("\n"), { action: "cleanup", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot });
+	return result(lines.join("\n"), { action: "cleanup", status: "ok", runId: loaded.manifest.runId, artifactsRoot: loaded.manifest.artifactsRoot, intent });
 }

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

@@ -1,67 +1,104 @@
-import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { withRunLockSync } from "../../state/locks.ts";
-import { loadRunManifestById, saveRunTasks } from "../../state/state-store.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 transitioned back to "running".
- */
-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 taskId = params.taskId;
-		const message = params.message ?? "";
-
-		// Find the waiting task(s)
-		const targetTasks = taskId
-			? loaded.tasks.filter((t) => t.id === taskId)
-			: loaded.tasks.filter((t) => t.status === "waiting");
-
-		if (targetTasks.length === 0) {
-			return result(
-				taskId ? `Task '${taskId}' not found or not in waiting state.` : `No waiting tasks in run ${loaded.manifest.runId}.`,
-				{ action: "respond", status: "error" },
-				true,
-			);
-		}
-
-		// Transition waiting tasks back to running
-		const updatedTasks = loaded.tasks.map((task) => {
-			if (task.status !== "waiting") return task;
-			if (taskId && task.id !== taskId) return task;
-			return {
-				...task,
-				status: "running" as const,
-				// Store the response in the task's adaptive field
-				adaptive: {
-					...task.adaptive,
-					phase: "resumed",
-					task: message || task.adaptive?.task || "",
-				},
-			};
-		});
-
-		saveRunTasks(loaded.manifest, updatedTasks);
-		try {
-			saveCrewAgents(loaded.manifest, updatedTasks.map((task) => recordFromTask(loaded.manifest, task, "child-process")));
-		} catch (error) {
-			logInternalError("team-tool.handleRespond.crewAgents", error, `runId=${loaded.manifest.runId}`);
-		}
-
-		const resumedIds = targetTasks.map((t) => t.id);
-		return result(
-			`Resumed ${resumedIds.length} task(s): ${resumedIds.join(", ")}. Message: ${message || "(no message)"}`,
-			{ action: "respond", status: "ok", runId: loaded.manifest.runId, resumedIds },
-		);
-	});
+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 { 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" },
+			});
+			mailboxIds.push(mailbox.id);
+		}
+
+		// 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 },
+		);
+	});
 }

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";
@@ -91,12 +93,14 @@ 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,
 		workflow,
 		goal,
 		workspaceMode: params.workspaceMode,
+		ownerSessionId: ctx.sessionId,
 	});
 	const goalArtifact = writeArtifact(paths.artifactsRoot, {
 		kind: "prompt",
@@ -104,17 +108,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}`,
@@ -130,13 +152,29 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot });
 	}
 
-	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}.`,
@@ -152,7 +190,12 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 		].join("\n");
 		return result(text, { action: "run", status: "ok", runId: updatedManifest.runId, artifactsRoot: updatedManifest.artifactsRoot });
 	}
-	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 });
+	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 text = [
 		`Created pi-crew run ${executed.manifest.runId}.`,
 		`Team: ${team.name}`,