pi-crew 0.1.41 → 0.1.44

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

@@ -0,0 +1,67 @@
+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 },
+		);
+	});
+}

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

@@ -21,8 +21,10 @@ import { effectiveRunConfig } from "./config-patch.ts";
 
 function tailFile(filePath: string, maxBytes = 4096): string | undefined {
 	try {
+		// Cap at 512KB to prevent OOM from misconfigured callers.
+		const safeMaxBytes = Math.min(maxBytes, 512 * 1024);
 		const stat = fs.statSync(filePath);
-		const start = Math.max(0, stat.size - maxBytes);
+		const start = Math.max(0, stat.size - safeMaxBytes);
 		const fd = fs.openSync(filePath, "r");
 		try {
 			const buffer = Buffer.alloc(stat.size - start);
@@ -50,7 +52,7 @@ function scheduleBackgroundEarlyExitGuard(cwd: string, runId: string, pid: numbe
 		const failed = updateRunStatus(loaded.manifest, "failed", "Background runner exited within 3s; see background.log");
 		appendEvent(failed.eventsPath, { type: "async.failed", runId: failed.runId, message, data: { pid, detail: liveness.detail } });
 	}, 3000);
-	timer.unref?.();
+	timer.unref();
 }
 
 export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
@@ -134,7 +136,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 	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 });
+			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 });
 		}, updatedManifest.runId);
 		const text = [
 			`Started foreground pi-crew run ${updatedManifest.runId}.`,
@@ -150,7 +152,7 @@ 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 });
+	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

@@ -1,93 +1,99 @@
-import { loadConfig } from "../../config/config.ts";
-import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
-import { appendEvent, readEvents } from "../../state/event-log.ts";
-import { readDeliveryState, readMailbox } from "../../state/mailbox.ts";
-import { loadRunManifestById, updateRunStatus } from "../../state/state-store.ts";
-import { aggregateUsage, formatUsage } from "../../state/usage.ts";
-import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../../runtime/agent-control.ts";
-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 type { PiTeamsToolResult } from "../tool-result.ts";
-import { result, type TeamContext } from "./context.ts";
-
-export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
-	if (!params.runId) return result("Status requires runId.", { action: "status", status: "error" }, true);
-	const loaded = loadRunManifestById(ctx.cwd, params.runId);
-	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "status", status: "error" }, true);
-	let { manifest, tasks } = loaded;
-	let asyncLivenessLine: string | undefined;
-	if (manifest.async) {
-		const asyncState = manifest.async;
-		const liveness = checkProcessLiveness(asyncState.pid);
-		asyncLivenessLine = `Async: pid=${asyncState.pid ?? "unknown"} alive=${liveness.alive ? "true" : "false"} detail=${liveness.detail} log=${asyncState.logPath} spawnedAt=${asyncState.spawnedAt}`;
-		if (!liveness.alive && isActiveRunStatus(manifest.status)) {
-			manifest = updateRunStatus(manifest, "failed", `Async process stale: ${liveness.detail}`);
-			appendEvent(manifest.eventsPath, { type: "async.stale", runId: manifest.runId, message: liveness.detail, data: { pid: asyncState.pid } });
-		}
-	}
-	const counts = new Map<string, number>();
-	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
-	const allEvents = readEvents(manifest.eventsPath);
-	const events = allEvents.slice(-8);
-	const attentionByTask = new Map(allEvents.filter((event) => event.type === "task.attention" && event.taskId).map((event) => [event.taskId!, event]));
-	const controlConfig = resolveCrewControlConfig(loadConfig(ctx.cwd).config);
-	const crewAgents = readCrewAgents(manifest).map((agent) => applyAttentionState(manifest, agent, controlConfig));
-	const artifactLines = manifest.artifacts.slice(-10).map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}`);
-	const deliveryState = readDeliveryState(manifest);
-	const ackTimeoutMs = loadConfig(ctx.cwd).config.runtime?.groupJoinAckTimeoutMs;
-	const groupJoinLines = readMailbox(manifest, "outbox")
-		.filter((message) => message.data?.kind === "group_join")
-		.slice(-5)
-		.map((message) => {
-			const ack = deliveryState.messages[message.id] === "acknowledged" ? "acknowledged" : "pending";
-			const ageMs = Date.now() - new Date(message.createdAt).getTime();
-			const requestId = String(message.data?.requestId ?? "unknown");
-			const timedOut = ack === "pending" && ackTimeoutMs !== undefined && Number.isFinite(ageMs) && ageMs > ackTimeoutMs;
-			if (timedOut && !allEvents.some((event) => event.type === "agent.group_join.ack_timeout" && event.data?.requestId === requestId)) {
-				appendEvent(manifest.eventsPath, { type: "agent.group_join.ack_timeout", runId: manifest.runId, message: "Group join delivery ack timed out; mailbox delivery remains the fallback.", data: { requestId, messageId: message.id, batchId: message.data?.batchId, partial: message.data?.partial, ageMs, ackTimeoutMs } });
-			}
-			return `- ${String(message.data?.partial) === "true" ? "partial" : "completed"} request=${requestId} message=${message.id} ack=${timedOut ? "timeout" : ack}`;
-		});
-	const totalUsage = aggregateUsage(tasks);
-	const activeAgents = crewAgents.filter((agent) => agent.status === "running");
-	const completedAgents = crewAgents.filter((agent) => agent.status !== "running");
-	const waitingTasks = tasks.filter((task) => task.status === "queued");
-	const agentLine = (agent: typeof crewAgents[number]): string => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.model ? ` model=${agent.model}` : ""}${agent.usage ? ` usage=${formatUsage(agent.usage)}` : ""}${agent.progress?.activityState ? ` activityState=${agent.progress.activityState}` : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${!agent.usage && agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.outputPath ? ` output=${agent.outputPath}` : ""}${agent.transcriptPath ? ` transcript=${agent.transcriptPath}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`;
-	const lines = [
-		`Run: ${manifest.runId}`,
-		`Team: ${manifest.team}`,
-		`Workflow: ${manifest.workflow ?? "(none)"}`,
-		`Status: ${manifest.status}`,
-		`Workspace mode: ${manifest.workspaceMode}`,
-		`Goal: ${manifest.goal}`,
-		`Created: ${manifest.createdAt}`,
-		`Updated: ${manifest.updatedAt}`,
-		`State: ${manifest.stateRoot}`,
-		`Artifacts: ${manifest.artifactsRoot}`,
-		...(asyncLivenessLine ? [asyncLivenessLine] : []),
-		"Task graph:",
-		...formatTaskGraphLines(tasks),
-		"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"}`,
-		"Active agents:",
-		...(activeAgents.length ? activeAgents.map(agentLine) : ["- (none)"]),
-		"Waiting tasks:",
-		...(waitingTasks.length ? waitingTasks.map((task) => `- ${task.id} [queued] ${task.role} -> ${task.agent} ${waitingReason(task, tasks) ?? "waiting"}`) : ["- (none)"]),
-		"Completed agents:",
-		...(completedAgents.length ? completedAgents.map(agentLine) : ["- (none)"]),
-		"Policy decisions:",
-		...(manifest.policyDecisions?.length ? manifest.policyDecisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`) : ["- (none)"]),
-		`Total usage: ${formatUsage(totalUsage)}`,
-		"Group joins:",
-		...(groupJoinLines.length ? groupJoinLines : ["- (none)"]),
-		"",
-		"Recent artifacts:",
-		...(artifactLines.length ? artifactLines : ["- (none)"]),
-		"",
-		"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 });
-}
+import { loadConfig } from "../../config/config.ts";
+import type { TeamToolParamsValue } from "../../schema/team-tool-schema.ts";
+import { appendEvent, readEvents } from "../../state/event-log.ts";
+import { readDeliveryState, readMailbox } from "../../state/mailbox.ts";
+import { loadRunManifestById, updateRunStatus, saveRunTasks } from "../../state/state-store.ts";
+import { aggregateUsage, formatUsage } from "../../state/usage.ts";
+import { applyAttentionState, formatActivityAge, resolveCrewControlConfig } from "../../runtime/agent-control.ts";
+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 type { PiTeamsToolResult } from "../tool-result.ts";
+import { result, type TeamContext } from "./context.ts";
+
+export function handleStatus(params: TeamToolParamsValue, ctx: TeamContext): PiTeamsToolResult {
+	if (!params.runId) return result("Status requires runId.", { action: "status", status: "error" }, true);
+	const loaded = loadRunManifestById(ctx.cwd, params.runId);
+	if (!loaded) return result(`Run '${params.runId}' not found.`, { action: "status", status: "error" }, true);
+	let { manifest, tasks } = loaded;
+	let asyncLivenessLine: string | undefined;
+	if (manifest.async) {
+		const asyncState = manifest.async;
+		const liveness = checkProcessLiveness(asyncState.pid);
+		asyncLivenessLine = `Async: pid=${asyncState.pid ?? "unknown"} alive=${liveness.alive ? "true" : "false"} detail=${liveness.detail} log=${asyncState.logPath} spawnedAt=${asyncState.spawnedAt}`;
+		if (!liveness.alive && isActiveRunStatus(manifest.status)) {
+			manifest = updateRunStatus(manifest, "failed", `Async process stale: ${liveness.detail}`);
+			tasks = tasks.map((task) => task.status === "running" ? { ...task, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: "Async process died; task was not completed." } : task);
+			saveRunTasks(manifest, tasks);
+			appendEvent(manifest.eventsPath, { type: "async.stale", runId: manifest.runId, message: liveness.detail, data: { pid: asyncState.pid } });
+		}
+	}
+	const counts = new Map<string, number>();
+	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
+	const allEvents = readEvents(manifest.eventsPath);
+	const events = allEvents.slice(-8);
+	const attentionByTask = new Map(allEvents.filter((event) => event.type === "task.attention" && event.taskId).map((event) => [event.taskId!, event]));
+	const controlConfig = resolveCrewControlConfig(loadConfig(ctx.cwd).config);
+	const crewAgents = readCrewAgents(manifest).map((agent) => applyAttentionState(manifest, agent, controlConfig));
+	const artifactLines = manifest.artifacts.slice(-10).map((artifact) => `- ${artifact.kind}: ${artifact.path}${artifact.sizeBytes !== undefined ? ` (${artifact.sizeBytes} bytes)` : ""}`);
+	const deliveryState = readDeliveryState(manifest);
+	const ackTimeoutMs = loadConfig(ctx.cwd).config.runtime?.groupJoinAckTimeoutMs;
+	const groupJoinLines: string[] = [];
+	for (const message of readMailbox(manifest, "outbox").filter((m) => m.data?.kind === "group_join").slice(-5)) {
+		const ack = deliveryState.messages[message.id] === "acknowledged" ? "acknowledged" : "pending";
+		const ageMs = Date.now() - new Date(message.createdAt).getTime();
+		const requestId = String(message.data?.requestId ?? "unknown");
+		const timedOut = ack === "pending" && ackTimeoutMs !== undefined && Number.isFinite(ageMs) && ageMs > ackTimeoutMs;
+		if (timedOut && !allEvents.some((event) => event.type === "agent.group_join.ack_timeout" && event.data?.requestId === requestId)) {
+			appendEvent(manifest.eventsPath, { type: "agent.group_join.ack_timeout", runId: manifest.runId, message: "Group join delivery ack timed out; mailbox delivery remains the fallback.", data: { requestId, messageId: message.id, batchId: message.data?.batchId, partial: message.data?.partial, ageMs, ackTimeoutMs } });
+		}
+		groupJoinLines.push(`- ${String(message.data?.partial) === "true" ? "partial" : "completed"} request=${requestId} message=${message.id} ack=${timedOut ? "timeout" : ack}`);
+	}
+	const totalUsage = aggregateUsage(tasks);
+	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");
+	const agentLine = (agent: typeof crewAgents[number]): string => `- ${agent.id} [${agent.status}] ${agent.role} -> ${agent.agent} runtime=${agent.runtime}${agent.model ? ` model=${agent.model}` : ""}${agent.usage ? ` usage=${formatUsage(agent.usage)}` : ""}${agent.progress?.activityState ? ` activityState=${agent.progress.activityState}` : ""}${formatActivityAge(agent) ? ` activity=${formatActivityAge(agent)}` : ""}${agent.progress?.currentTool ? ` tool=${agent.progress.currentTool}` : ""}${agent.toolUses ? ` tools=${agent.toolUses}` : ""}${!agent.usage && agent.progress?.tokens ? ` tokens=${agent.progress.tokens}` : ""}${agent.progress?.turns ? ` turns=${agent.progress.turns}` : ""}${agent.jsonEvents !== undefined ? ` jsonEvents=${agent.jsonEvents}` : ""}${agent.outputPath ? ` output=${agent.outputPath}` : ""}${agent.transcriptPath ? ` transcript=${agent.transcriptPath}` : ""}${agent.statusPath ? ` status=${agent.statusPath}` : ""}${agent.error ? ` error=${agent.error}` : ""}`;
+	const lines = [
+		`Run: ${manifest.runId}`,
+		`Team: ${manifest.team}`,
+		`Workflow: ${manifest.workflow ?? "(none)"}`,
+		`Status: ${manifest.status}`,
+		`Workspace mode: ${manifest.workspaceMode}`,
+		`Goal: ${manifest.goal}`,
+		`Created: ${manifest.createdAt}`,
+		`Updated: ${manifest.updatedAt}`,
+		`State: ${manifest.stateRoot}`,
+		`Artifacts: ${manifest.artifactsRoot}`,
+		...(asyncLivenessLine ? [asyncLivenessLine] : []),
+		"Task graph:",
+		...formatTaskGraphLines(tasks),
+		"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:",
+		...(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(", ")}]` : ""}`;
+		}) : ["- (no completed tasks)"]),
+		"Active agents:",
+		...(activeAgents.length ? activeAgents.map(agentLine) : ["- (none)"]),
+		"Waiting tasks:",
+		...(waitingTasks.length ? waitingTasks.map((task) => `- ${task.id} [queued] ${task.role} -> ${task.agent} ${waitingReason(task, tasks) ?? "waiting"}`) : ["- (none)"]),
+		"Completed agents:",
+		...(completedAgents.length ? completedAgents.map(agentLine) : ["- (none)"]),
+		"Policy decisions:",
+		...(manifest.policyDecisions?.length ? manifest.policyDecisions.map((item) => `- ${item.action} (${item.reason})${item.taskId ? ` ${item.taskId}` : ""}: ${item.message}`) : ["- (none)"]),
+		`Total usage: ${formatUsage(totalUsage)}`,
+		"Group joins:",
+		...(groupJoinLines.length ? groupJoinLines : ["- (none)"]),
+		"",
+		"Recent artifacts:",
+		...(artifactLines.length ? artifactLines : ["- (none)"]),
+		"",
+		"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 });
+}

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

@@ -3,4 +3,8 @@ export interface TeamToolDetails {
 	status: "ok" | "error" | "planned";
 	runId?: string;
 	artifactsRoot?: string;
+	abortedIds?: string[];
+	missingIds?: string[];
+	foreignIds?: string[];
+	resumedIds?: string[];
 }

package/src/extension/team-tool.ts

@@ -19,6 +19,7 @@ import { pruneFinishedRuns } from "./run-maintenance.ts";
 import { exportRunBundle } from "./run-export.ts";
 import { importRunBundle } from "./run-import.ts";
 import { listImportedRuns } from "./import-index.ts";
+import { handleSettings } from "./team-tool/handle-settings.ts";
 import { listRuns } from "./run-index.ts";
 import { validateWorkflowForTeam } from "../workflows/validate-workflow.ts";
 import { formatValidationReport, validateResources } from "./validate-resources.ts";
@@ -43,6 +44,7 @@ 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 { handleRespond } from "./team-tool/respond.ts";
 import { handlePlan } from "./team-tool/plan.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 
@@ -271,11 +273,13 @@ export async function handleTeamTool(params: TeamToolParamsValue, ctx: TeamConte
 		case "export": return handleExport(params, ctx);
 		case "import": return handleImport(params, ctx);
 		case "imports": return handleImports(params, ctx);
-		case "prune": return handlePrune(params, ctx);
+		case "settings": return handleSettings(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 "respond": return handleRespond(params, ctx);
 		case "plan": return handlePlan(params, ctx);
 		case "resume": return handleResume(params, ctx);
 		case "create": return handleCreate(params, ctx);

package/src/i18n.ts

@@ -0,0 +1,184 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+type Params = Record<string, string | number>;
+
+const namespace = "pi-crew";
+const TEMPLATE_RE = /\{(\w+)\}/g;
+
+const fallback = {
+	"agent.requiresPrompt": "Agent requires prompt.",
+	"agent.started": "Agent {state}.",
+	"agent.id": "Agent ID: {id}",
+	"agent.type": "Type: {type}",
+	"agent.description": "Description: {description}",
+	"agent.retrieveHint": "Use get_subagent_result to retrieve output. Do not duplicate this agent's work.",
+	"agent.foregroundStatus": "Agent {id} {status}.",
+	"agent.noOutput": "No output.",
+	"result.requiresAgentId": "get_subagent_result requires agent_id.",
+	"result.notFound": "Agent not found: {id}",
+	"result.unrecoverable": "Subagent was interrupted before its durable run id was recorded; it cannot be recovered after restart.",
+	"result.waitAborted": "Waiting for subagent result was aborted.",
+	"result.waitTimeout": "Timed out waiting for subagent result.",
+	"result.stillRunning": "Agent is still running. Use wait=true or check again later.",
+	"steer.noted": "Steering request noted for {id}.",
+	"steer.unavailable": "Current default pi-crew backend is child-process, so mid-turn session.steer is not available yet.",
+	"steer.cancelHint": "Use team cancel runId={runId} if the agent must be interrupted.",
+} as const;
+
+type Key = keyof typeof fallback;
+
+/** Map of locale → partial translations. Keys not present fall back to English. */
+const translations: Record<string, Partial<Record<Key, string>>> = {
+	es: {
+		"agent.requiresPrompt": "Agent requiere prompt.",
+		"agent.started": "Agent {state}.",
+		"agent.id": "ID del agente: {id}",
+		"agent.type": "Tipo: {type}",
+		"agent.description": "Descripción: {description}",
+		"agent.retrieveHint": "Usa get_subagent_result para recuperar la salida. No dupliques el trabajo de este agente.",
+		"agent.foregroundStatus": "Agent {id} {status}.",
+		"agent.noOutput": "Sin salida.",
+		"result.requiresAgentId": "get_subagent_result requiere agent_id.",
+		"result.notFound": "Agente no encontrado: {id}",
+		"result.unrecoverable": "El subagente fue interrumpido antes de registrar su ID de ejecución duradero; no se puede recuperar tras reiniciar.",
+		"result.waitAborted": "Se canceló la espera del resultado del subagente.",
+		"result.waitTimeout": "Se agotó el tiempo de espera del resultado del subagente.",
+		"result.stillRunning": "El agente sigue ejecutándose. Usa wait=true o vuelve a comprobar más tarde.",
+		"steer.noted": "Solicitud de dirección registrada para {id}.",
+		"steer.unavailable": "El backend predeterminado actual de pi-crew es child-process, así que session.steer a mitad de turno aún no está disponible.",
+		"steer.cancelHint": "Usa team cancel runId={runId} si hay que interrumpir el agente.",
+	},
+	fr: {
+		"agent.requiresPrompt": "Agent nécessite un prompt.",
+		"agent.started": "Agent {state}.",
+		"agent.id": "ID de l'agent : {id}",
+		"agent.type": "Type : {type}",
+		"agent.description": "Description : {description}",
+		"agent.retrieveHint": "Utilisez get_subagent_result pour récupérer la sortie. Ne dupliquez pas le travail de cet agent.",
+		"agent.foregroundStatus": "Agent {id} {status}.",
+		"agent.noOutput": "Aucune sortie.",
+		"result.requiresAgentId": "get_subagent_result nécessite agent_id.",
+		"result.notFound": "Agent introuvable : {id}",
+		"result.unrecoverable": "Le sous-agent a été interrompu avant l'enregistrement de son ID d'exécution durable ; il ne peut pas être récupéré après redémarrage.",
+		"result.waitAborted": "L'attente du résultat du sous-agent a été annulée.",
+		"result.waitTimeout": "Délai d'attente du résultat du sous-agent dépassé.",
+		"result.stillRunning": "L'agent est toujours en cours d'exécution. Utilisez wait=true ou réessayez plus tard.",
+		"steer.noted": "Demande de pilotage enregistrée pour {id}.",
+		"steer.unavailable": "Le backend pi-crew par défaut actuel est child-process, donc session.steer en milieu de tour n'est pas encore disponible.",
+		"steer.cancelHint": "Utilisez team cancel runId={runId} si l'agent doit être interrompu.",
+	},
+	"pt-BR": {
+		"agent.requiresPrompt": "Agent requer prompt.",
+		"agent.started": "Agent {state}.",
+		"agent.id": "ID do agente: {id}",
+		"agent.type": "Tipo: {type}",
+		"agent.description": "Descrição: {description}",
+		"agent.retrieveHint": "Use get_subagent_result para recuperar a saída. Não duplique o trabalho deste agente.",
+		"agent.foregroundStatus": "Agent {id} {status}.",
+		"agent.noOutput": "Sem saída.",
+		"result.requiresAgentId": "get_subagent_result requer agent_id.",
+		"result.notFound": "Agente não encontrado: {id}",
+		"result.unrecoverable": "O subagente foi interrompido antes que seu ID de execução durável fosse registrado; ele não pode ser recuperado após reiniciar.",
+		"result.waitAborted": "A espera pelo resultado do subagente foi abortada.",
+		"result.waitTimeout": "Tempo limite de espera pelo resultado do subagente esgotado.",
+		"result.stillRunning": "O agente ainda está em execução. Use wait=true ou verifique novamente mais tarde.",
+		"steer.noted": "Solicitação de orientação registrada para {id}.",
+		"steer.unavailable": "O backend padrão atual do pi-crew é child-process, então session.steer no meio do turno ainda não está disponível.",
+		"steer.cancelHint": "Use team cancel runId={runId} se o agente precisar ser interrompido.",
+	},
+};
+
+// --- Runtime state ---
+
+let currentLocale: string | undefined;
+const warnedMissing = new Set<string>();
+
+// --- Helpers ---
+
+function format(template: string, params: Params = {}): string {
+	return template.replace(TEMPLATE_RE, (_match, key) => String(params[key] ?? `{${key}}`));
+}
+
+function warnOnce(key: string): void {
+	const tag = `${currentLocale}:${key}`;
+	if (warnedMissing.has(tag)) return;
+	warnedMissing.add(tag);
+	process.stderr.write(`[pi-crew] i18n: missing "${key}" in locale "${currentLocale}" — using English\n`);
+}
+
+// --- Public API ---
+
+/**
+ * Translate a key for the currently active locale.
+ * Falls back to English, then to the raw key as a last resort.
+ */
+export function t(key: Key, params?: Params): string {
+	if (currentLocale && translations[currentLocale]) {
+		const template = translations[currentLocale]?.[key];
+		if (template) return format(template, params);
+		warnOnce(key);
+	}
+	return format(fallback[key] ?? key, params);
+}
+
+/**
+ * Register or extend translations for a locale at runtime.
+ * Useful for contributors adding new language bundles without modifying i18n.ts.
+ *
+ * @example
+ * addTranslations("vi", { "agent.requiresPrompt": "Agent cần prompt." })
+ */
+export function addTranslations(locale: string, bundle: Partial<Record<Key, string>>): void {
+	if (!locale) return;
+	const existing = translations[locale];
+	if (existing) {
+		Object.assign(existing, bundle);
+	} else {
+		translations[locale] = { ...bundle };
+	}
+}
+
+/**
+ * Returns the list of currently registered locales (excluding English, which is always available).
+ */
+export function listLocales(): string[] {
+	return Object.keys(translations);
+}
+
+// --- Initialization ---
+
+export function initI18n(pi: ExtensionAPI): () => void {
+	try {
+		pi.events?.emit?.("pi-core/i18n/registerBundle", { namespace, defaultLocale: "en", fallback, translations });
+	} catch {
+		// Non-critical.
+	}
+	const unsubscribe = pi.events?.on?.("pi-core/i18n/localeChanged", (event: unknown) => {
+		if (!event || typeof event !== "object") return;
+		const raw = String((event as { locale?: unknown }).locale ?? "").trim();
+		currentLocale = raw && translations[raw] ? raw : undefined;
+	});
+	try {
+		pi.events?.emit?.("pi-core/i18n/requestApi", { namespace, onApi(api: { getLocale?: () => string | undefined }) {
+			const raw = api.getLocale?.()?.trim();
+			if (raw && translations[raw]) currentLocale = raw;
+		} });
+	} catch {
+		// Non-critical.
+	}
+	return () => {
+		currentLocale = undefined;
+		unsubscribe?.();
+	};
+}
+
+// --- Test helpers ---
+
+export function __test__resetI18n(): void {
+	currentLocale = undefined;
+	warnedMissing.clear();
+	// Clear runtime-added translations but keep built-in ones.
+	for (const key of Object.keys(translations)) {
+		if (!["es", "fr", "pt-BR"].includes(key)) delete translations[key];
+	}
+}

package/src/observability/correlation.ts

@@ -28,8 +28,8 @@ export function childCorrelation(runId: string, taskId: string): CorrelationCont
 	return { traceId: parent?.traceId ?? spanId, parentSpanId: parent?.spanId, spanId };
 }
 
-export function correlatedEvent<T extends { runId?: string; data?: Record<string, unknown> }>(event: T): T {
+export function correlatedEvent<T extends { runId?: string; data?: Record<string, unknown> }>(event: T): T & { data: Record<string, unknown> } {
 	const ctx = getCurrentContext();
-	if (!ctx) return event;
+	if (!ctx) return event as T & { data: Record<string, unknown> };
 	return { ...event, data: { ...(event.data ?? {}), traceId: ctx.traceId, spanId: ctx.spanId, parentSpanId: ctx.parentSpanId } };
 }

package/src/observability/event-to-metric.ts

@@ -22,7 +22,11 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 	const taskCount = registry.counter("crew.task.count", "Total tasks by status");
 	const subagentCount = registry.counter("crew.subagent.count", "Total subagent records by status");
 	const mailboxCount = registry.counter("crew.mailbox.count", "Total mailbox messages by direction");
-	registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
+	const retryAttemptCount = registry.counter("crew.task.retry_attempt_total", "Retry attempts by run and task");
+	const deadletterCount = registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
+	const overflowCount = registry.counter("crew.task.overflow_phase_total", "Overflow recovery phase transitions");
+	const waitingCount = registry.counter("crew.task.waiting_total", "Tasks entering waiting state");
+	const supervisorContactCount = registry.counter("crew.task.supervisor_contact_total", "Supervisor contact requests by reason");
 	registry.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds");
 	const runDuration = registry.histogram("crew.run.duration_ms", "Run end-to-end duration, milliseconds");
 	const taskDuration = registry.histogram("crew.task.duration_ms", "Task duration, milliseconds");
@@ -35,8 +39,11 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 		["crew.run.cancelled", () => runCount.inc({ status: "cancelled" })],
 		["crew.task.completed", (data) => { const item = recordValue(data); taskCount.inc({ status: "completed" }); taskDuration.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.durationMs)); tokenUsage.observe({ role: stringValue(item.role, "unknown") }, numberValue(item.tokens)); }],
 		["crew.task.failed", () => taskCount.inc({ status: "failed" })],
-		["crew.task.retry_attempt", (data) => { const item = recordValue(data); taskCount.inc({ status: "retry" }); registry.counter("crew.task.retry_attempt_total", "Retry attempts by run and task").inc({ runId: stringValue(item.runId, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
-		["crew.task.deadletter", (data) => { const item = recordValue(data); registry.counter("crew.task.deadletter_total", "Deadletter triggers by reason").inc({ reason: stringValue(item.reason, "unknown") }); }],
+		["crew.task.retry_attempt", (data) => { const item = recordValue(data); taskCount.inc({ status: "retry" }); retryAttemptCount.inc({ runId: stringValue(item.runId, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
+		["crew.task.deadletter", (data) => { const item = recordValue(data); deadletterCount.inc({ reason: stringValue(item.reason, "unknown") }); }],
+		["crew.task.overflow", (data) => { const item = recordValue(data); overflowCount.inc({ phase: stringValue(item.phase, "unknown"), previous_phase: stringValue(item.previousPhase, "none") }); }],
+		["task.waiting", (data) => { const item = recordValue(data); waitingCount.inc({ taskId: stringValue(item.taskId, "unknown"), runId: stringValue(item.runId, "unknown") }); }],
+		["supervisor.contact", (data) => { const item = recordValue(data); supervisorContactCount.inc({ reason: stringValue(item.reason, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],
 		["crew.subagent.completed", (data) => { const item = recordValue(data); subagentCount.inc({ status: stringValue(item.status, "completed") }); }],
 		["crew.subagent.failed", () => subagentCount.inc({ status: "failed" })],
 		["crew.mailbox.message", (data) => { const item = recordValue(data); mailboxCount.inc({ direction: stringValue(item.direction, "unknown") }); }],

package/src/observability/exporters/adapter.ts

@@ -19,6 +19,12 @@ export class CompositeExporter implements MetricExporter {
 	}
 
 	dispose(): void {
-		for (const exporter of this.exporters) exporter.dispose();
+		for (const exporter of this.exporters) {
+			try {
+				exporter.dispose();
+			} catch {
+				// Best-effort cleanup; one exporter failing shouldn't prevent others.
+			}
+		}
 	}
 }