pi-crew 0.1.45 → 0.1.46

package/src/runtime/task-runner.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewLimitsConfig, CrewRuntimeConfig } from "../config/config.ts";
-import type { ArtifactDescriptor, TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
+import type { ArtifactDescriptor, OperationTerminalEvidence, TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { writeArtifact } from "../state/artifact-store.ts";
 import { appendEvent } from "../state/event-log.ts";
 import { saveRunManifest } from "../state/state-store.ts";
@@ -22,12 +22,16 @@ import { parseSessionUsage } from "./session-usage.ts";
 import type { CrewAgentProgress, CrewRuntimeKind } from "./crew-agent-runtime.ts";
 import { shouldAppendProgressEventUpdate, type ProgressEventSummary } from "./progress-event-coalescer.ts";
 import { coordinationBridgeInstructions, renderTaskPrompt } from "./task-runner/prompt-builder.ts";
+import { buildWorkerPromptPipeline } from "./task-runner/prompt-pipeline.ts";
+import { buildWorkerCapabilityInventory } from "./task-runner/capabilities.ts";
 import { applyAgentProgressEvent, applyUsageToProgress, progressEventSummary, shouldFlushProgressEvent } from "./task-runner/progress.ts";
 import { checkpointTask, persistSingleTaskUpdate, updateTask } from "./task-runner/state-helpers.ts";
 import { cleanResultText, isFinalChildEvent } from "./task-runner/result-utils.ts";
 import { evaluateCompletionMutationGuard } from "./completion-guard.ts";
+import { cancellationReasonFromSignal } from "./cancellation.ts";
 import { appendTaskAttentionEvent } from "./attention-events.ts";
 import { parseSupervisorContactFromLine, recordSupervisorContact } from "./supervisor-contact.ts";
+import { renderSkillInstructions } from "./skill-instructions.ts";
 
 export interface TaskRunnerInput {
 	manifest: TeamRunManifest;
@@ -43,8 +47,14 @@ export interface TaskRunnerInput {
 	parentModel?: unknown;
 	modelRegistry?: unknown;
 	modelOverride?: string;
+	teamRoleModel?: string;
+	teamRoleSkills?: string[] | false;
+	skillOverride?: string[] | false;
 	limits?: CrewLimitsConfig;
 	dependencyContextText?: string;
+	skillBlock?: string;
+	skillNames?: string[];
+	skillPaths?: string[];
 	/** Optional callback for JSON events from child Pi. Used for overflow recovery tracking. */
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 }
@@ -75,8 +85,12 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 	upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));
 	appendEvent(manifest.eventsPath, { type: "task.started", runId: manifest.runId, taskId: task.id, data: { role: task.role, agent: task.agent, runtime: runtimeKind, cwd: task.cwd, worktreePath: workspace.worktreePath, worktreeBranch: workspace.branch, worktreeReused: workspace.reused } });
 	const permissionMode = permissionForRole(task.role);
+	const renderedSkills = input.skillBlock === undefined ? renderSkillInstructions({ cwd: task.cwd, role: task.role, agent: input.agent, teamRole: { skills: input.teamRoleSkills }, step: input.step, override: input.skillOverride }) : undefined;
+	const skillBlock = input.skillBlock ?? renderedSkills?.block;
+	const skillNames = input.skillNames ?? renderedSkills?.names;
+	const skillPaths = input.skillPaths ?? renderedSkills?.paths;
 
-	const prompt = renderTaskPrompt(manifest, input.step, task, input.agent);
+	const prompt = renderTaskPrompt(manifest, input.step, task, input.agent, skillBlock);
 	const promptArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "prompt",
 		relativePath: `prompts/${task.id}.md`,
@@ -93,9 +107,16 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 	let parsedOutput: ParsedPiJsonOutput | undefined;
 	let finalStdout = "";
 	let transcriptPath: string | undefined;
+	let terminalEvidence: OperationTerminalEvidence[] = [];
 
 	let startupEvidence = createStartupEvidence({ command: runtimeKind === "child-process" ? "pi" : runtimeKind === "live-session" ? "live-session" : "safe-scaffold", startedAt: new Date(task.startedAt ?? new Date().toISOString()), finishedAt: new Date(), promptSentAt: new Date(task.startedAt ?? new Date().toISOString()), promptAccepted: true, exitCode: 0 });
 	const inputsArtifact = writeTaskInputsArtifact(manifest, task, dependencyContext);
+	const skillArtifact = skillBlock ? writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.skills.md`,
+		content: [`Selected skills: ${skillNames?.join(", ") ?? "(none)"}`, `Skill paths passed to child Pi: ${(skillPaths ?? []).length}`, "", skillBlock, ""].join("\n"),
+		producer: task.id,
+	}) : undefined;
 	const coordinationArtifact = writeArtifact(manifest.artifactsRoot, {
 		kind: "metadata",
 		relativePath: `metadata/${task.id}.coordination-bridge.md`,
@@ -103,7 +124,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		producer: task.id,
 	});
 	if (runtimeKind === "child-process") {
-		const modelRoutingPlan = buildConfiguredModelRouting({ overrideModel: input.modelOverride, stepModel: input.step.model, agentModel: input.agent.model, fallbackModels: input.agent.fallbackModels, parentModel: input.parentModel, modelRegistry: input.modelRegistry, cwd: manifest.cwd });
+		const modelRoutingPlan = buildConfiguredModelRouting({ overrideModel: input.modelOverride, stepModel: input.step.model, teamRoleModel: input.teamRoleModel, agentModel: input.agent.model, fallbackModels: input.agent.fallbackModels, parentModel: input.parentModel, modelRegistry: input.modelRegistry, cwd: task.cwd });
 		const candidates = modelRoutingPlan.candidates;
 		const attemptModels = candidates.length > 0 ? candidates : [undefined];
 		const logs: string[] = [];
@@ -151,6 +172,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 				signal: input.signal,
 				transcriptPath,
 				maxDepth: input.limits?.maxTaskDepth,
+				skillPaths,
 				onSpawn: (pid) => {
 					({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));
 				},
@@ -181,6 +203,9 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 					persistChildProgress(event);
 				},
 			});
+			const evidenceStatus = childResult.exitStatus?.cancelled ? "cancelled" : childResult.error || (childResult.exitCode && childResult.exitCode !== 0) ? "failed" : "completed";
+			terminalEvidence = [...terminalEvidence, { operation: "worker", status: evidenceStatus, startedAt: attemptStartedAt.toISOString(), finishedAt: new Date().toISOString(), ...(input.signal?.aborted ? { reason: cancellationReasonFromSignal(input.signal) } : {}), ...(childResult.exitStatus ? { exitStatus: childResult.exitStatus } : {}) }];
+			if (evidenceStatus === "cancelled") appendEvent(manifest.eventsPath, { type: "worker.cancelled", runId: manifest.runId, taskId: task.id, message: input.signal?.aborted ? cancellationReasonFromSignal(input.signal).message : "Worker cancelled.", data: { terminalEvidence: terminalEvidence.at(-1) } });
 			startupEvidence = createStartupEvidence({ command: "pi", startedAt: attemptStartedAt, finishedAt: new Date(), promptSentAt: attemptStartedAt, promptAccepted: childResult.exitCode === 0 && !childResult.error, stderr: childResult.stderr, error: childResult.error, exitCode: childResult.exitCode });
 			exitCode = childResult.exitCode;
 			finalStdout = childResult.stdout;
@@ -238,7 +263,7 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		({ task, tasks } = checkpointTask(manifest, tasks, task, "artifact-written"));
 	} else if (runtimeKind === "live-session") {
 		const { runLiveTask } = await import("./task-runner/live-executor.ts");
-		const live = await runLiveTask({ manifest, tasks, task, step: input.step, agent: input.agent, prompt, signal: input.signal, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry });
+		const live = await runLiveTask({ manifest, tasks, task, step: input.step, agent: input.agent, prompt, signal: input.signal, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, modelOverride: input.modelOverride, teamRoleModel: input.teamRoleModel });
 		task = live.task;
 		tasks = live.tasks;
 		startupEvidence = live.startupEvidence;
@@ -310,6 +335,8 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		resultArtifact,
 		claim: undefined,
 		heartbeat: touchWorkerHeartbeat(task.heartbeat ?? createWorkerHeartbeat(task.id), { alive: false }),
+		workerExitStatus: terminalEvidence.at(-1)?.exitStatus,
+		terminalEvidence: terminalEvidence.length ? [...(task.terminalEvidence ?? []), ...terminalEvidence] : task.terminalEvidence,
 		...(logArtifact ? { logArtifact } : {}),
 		...(transcriptArtifact ? { transcriptArtifact } : {}),
 	};
@@ -339,7 +366,19 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 		content: `${JSON.stringify({ role: task.role, permissionMode }, null, 2)}\n`,
 		producer: task.id,
 	});
-	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : []), ...(diffStatArtifact ? [diffStatArtifact] : [])] };
+	const capabilityArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.capabilities.json`,
+		content: `${JSON.stringify(buildWorkerCapabilityInventory({ taskId: task.id, role: task.role, agent: input.agent, runtime: runtimeKind, permissionMode, skillNames, skillPaths, skillsDisabled: input.skillOverride === false || input.teamRoleSkills === false, modelOverride: input.modelOverride, teamRoleModel: input.teamRoleModel, stepModel: input.step.model }), null, 2)}\n`,
+		producer: task.id,
+	});
+	const promptPipelineArtifact = writeArtifact(manifest.artifactsRoot, {
+		kind: "metadata",
+		relativePath: `metadata/${task.id}.prompt-pipeline.json`,
+		content: `${JSON.stringify(buildWorkerPromptPipeline({ artifactsRoot: manifest.artifactsRoot, taskId: task.id, promptArtifact, inputsArtifact, skillArtifact, capabilityArtifact, coordinationArtifact, skillInstructionCount: skillNames?.length ?? 0, skillsDisabled: input.skillOverride === false || input.teamRoleSkills === false }), null, 2)}\n`,
+		producer: task.id,
+	});
+	manifest = { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts, promptArtifact, resultArtifact, inputsArtifact, coordinationArtifact, ...(skillArtifact ? [skillArtifact] : []), packetArtifact, verificationArtifact, startupArtifact, permissionArtifact, capabilityArtifact, promptPipelineArtifact, ...(sharedOutputArtifact ? [sharedOutputArtifact] : []), ...(logArtifact ? [logArtifact] : []), ...(transcriptArtifact ? [transcriptArtifact] : []), ...(diffArtifact ? [diffArtifact] : []), ...(diffStatArtifact ? [diffStatArtifact] : [])] };
 	saveRunManifest(manifest);
 	tasks = persistSingleTaskUpdate(manifest, tasks, task);
 	upsertCrewAgent(manifest, recordFromTask(manifest, task, runtimeKind));

package/src/runtime/team-runner.ts

@@ -25,6 +25,8 @@ import { childCorrelation, withCorrelation } from "../observability/correlation.
 import { resolveBatchConcurrency } from "./concurrency.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 import { permissionForRole } from "./role-permission.ts";
+import { CrewCancellationError, cancellationReasonFromSignal } from "./cancellation.ts";
+import { effectivenessPolicyDecision, evaluateRunEffectiveness, formatRunEffectivenessLines } from "./effectiveness.ts";
 
 export interface ExecuteTeamRunInput {
 	manifest: TeamRunManifest;
@@ -43,6 +45,8 @@ export interface ExecuteTeamRunInput {
 	signal?: AbortSignal;
 	reliability?: CrewReliabilityConfig;
 	metricRegistry?: MetricRegistry;
+	/** Skill override from the team tool. false disables skill injection for this run. */
+	skillOverride?: string[] | false;
 	/** Optional callback for JSON events from child Pi. Used for overflow recovery tracking. */
 	onJsonEvent?: (taskId: string, runId: string, event: unknown) => void;
 }
@@ -380,7 +384,11 @@ function formatTaskProgress(task: TeamTaskState): string {
 	return `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.error ? ` - ${task.error}` : ""}`;
 }
 
-function writeProgress(manifest: TeamRunManifest, tasks: TeamTaskState[], producer: string): TeamRunManifest {
+function runEffectivenessLines(manifest: TeamRunManifest, tasks: TeamTaskState[], executeWorkers: boolean, runtimeConfig?: CrewRuntimeConfig): string[] {
+	return formatRunEffectivenessLines(evaluateRunEffectiveness({ manifest, tasks, executeWorkers, runtimeConfig }));
+}
+
+function writeProgress(manifest: TeamRunManifest, tasks: TeamTaskState[], producer: string, executeWorkers = true, runtimeConfig?: CrewRuntimeConfig): TeamRunManifest {
 	const counts = new Map<string, number>();
 	for (const task of tasks) counts.set(task.status, (counts.get(task.status) ?? 0) + 1);
 	const queue = taskGraphSnapshot(tasks);
@@ -401,6 +409,9 @@ function writeProgress(manifest: TeamRunManifest, tasks: TeamTaskState[], produc
 			"## Tasks",
 			...tasks.map(formatTaskProgress),
 			"",
+			"## Effectiveness",
+			...runEffectivenessLines(manifest, tasks, executeWorkers, runtimeConfig),
+			"",
 		].join("\n"),
 	});
 	return { ...manifest, updatedAt: new Date().toISOString(), artifacts: [...manifest.artifacts.filter((artifact) => !(artifact.kind === "progress" && artifact.path === progress.path)), progress] };
@@ -528,16 +539,24 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		manifest = updateRunStatus(manifest, "cancelled", "Plan approval was cancelled.");
 		return { manifest, tasks };
 	}
-	manifest = writeProgress(manifest, tasks, "team-runner");
+	manifest = writeProgress(manifest, tasks, "team-runner", input.executeWorkers, input.runtimeConfig);
 	await saveRunManifestAsync(manifest);
 	const runtimeKind = input.runtime?.kind ?? (input.executeWorkers ? "child-process" : "scaffold");
 	saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
 
 	while (tasks.some((task) => task.status === "queued")) {
 		if (input.signal?.aborted) {
-			tasks = tasks.map((task) => task.status === "queued" || task.status === "running" || task.status === "waiting" ? { ...task, status: "cancelled", finishedAt: new Date().toISOString(), error: "Run cancelled." } : task);
+			const cancelReason = cancellationReasonFromSignal(input.signal);
+			const message = `${cancelReason.message} (${cancelReason.code})`;
+			const cancelledTaskIds: string[] = [];
+			tasks = tasks.map((task) => {
+				if (task.status !== "queued" && task.status !== "running" && task.status !== "waiting") return task;
+				cancelledTaskIds.push(task.id);
+				return { ...task, status: "cancelled", finishedAt: new Date().toISOString(), error: message };
+			});
 			await saveRunTasksAsync(manifest, tasks);
-			manifest = updateRunStatus(manifest, "cancelled", "Run cancelled.");
+			for (const taskId of cancelledTaskIds) appendEvent(manifest.eventsPath, { type: "task.cancelled", runId: manifest.runId, taskId, message, data: { reason: cancelReason.code } });
+			manifest = updateRunStatus(manifest, "cancelled", message, { data: { reason: cancelReason.code, cancelledTaskIds } });
 			return { manifest, tasks };
 		}
 
@@ -581,25 +600,27 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 			async (task) => {
 				const step = findStep(workflow, task);
 				const agent = findAgent(input.agents, task);
-				const baseInput = { manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, modelOverride: input.modelOverride, limits: input.limits, onJsonEvent: input.onJsonEvent };
+				const teamRole = input.team.roles.find((role) => role.name === task.role);
+				const baseInput = { manifest, tasks, task, step, agent, signal: input.signal, executeWorkers: input.executeWorkers, runtimeKind: input.runtime?.kind, runtimeConfig: input.runtimeConfig, parentContext: input.parentContext, parentModel: input.parentModel, modelRegistry: input.modelRegistry, modelOverride: input.modelOverride, teamRoleModel: teamRole?.model, teamRoleSkills: teamRole?.skills, skillOverride: input.skillOverride, limits: input.limits, onJsonEvent: input.onJsonEvent };
 				if (input.reliability?.autoRetry !== true) return withCorrelation(childCorrelation(manifest.runId, task.id), () => runTeamTask(baseInput));
 				let lastFailed: { manifest: TeamRunManifest; tasks: TeamTaskState[] } | undefined;
 				const attemptsSoFar: TaskAttemptState[] = [...(task.attempts ?? [])];
 				const policy = retryPolicyFromConfig(input.reliability);
 				try {
-					return await executeWithRetry(async (attempt) => {
+					return await executeWithRetry(async (attempt, info) => {
 						const startedAt = new Date().toISOString();
-						const inFlightAttempts: TaskAttemptState[] = [...attemptsSoFar, { startedAt }];
+						const inFlightAttempts: TaskAttemptState[] = [...attemptsSoFar, { attemptId: info.attemptId, startedAt }];
 						input.metricRegistry?.counter("crew.task.retry_attempt_total", "Retry attempts by run and task").inc({ runId: manifest.runId, taskId: task.id });
 						const fresh = loadRunManifestById(manifest.cwd, manifest.runId);
 						const freshManifest = fresh?.manifest ?? manifest;
 						const freshTasks = fresh?.tasks ?? tasks;
 						const freshTask = freshTasks.find((item) => item.id === task.id) ?? task;
+						if (freshTask.status !== "queued" && freshTask.status !== "running") return { manifest: freshManifest, tasks: freshTasks };
 						const taskWithAttempt: TeamTaskState = { ...freshTask, attempts: inFlightAttempts };
 						const result = await withCorrelation(childCorrelation(freshManifest.runId, task.id), () => runTeamTask({ ...baseInput, manifest: freshManifest, tasks: freshTasks, task: taskWithAttempt }));
 						const failed = failedTaskFrom(result, task.id);
 						const endedAt = new Date().toISOString();
-						const finishedAttempt: TaskAttemptState = { startedAt, endedAt, ...(failed?.error ? { error: failed.error } : {}) };
+						const finishedAttempt: TaskAttemptState = { attemptId: info.attemptId, startedAt, endedAt, ...(failed?.error ? { error: failed.error } : {}) };
 						attemptsSoFar.push(finishedAttempt);
 						const withAttempt = result.tasks.map((item) => item.id === task.id ? { ...item, attempts: [...attemptsSoFar] } : item);
 						const enriched = { manifest: result.manifest, tasks: withAttempt };
@@ -611,28 +632,51 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 						return enriched;
 					}, policy, {
 						signal: input.signal,
-						onAttemptFailed: (attempt, error, delayMs) => {
-							appendEvent(manifest.eventsPath, { type: "crew.task.retry_attempt", runId: manifest.runId, taskId: task.id, message: error.message, data: { attempt, delayMs } });
+						attemptId: (attempt) => `${manifest.runId}:${task.id}:attempt-${attempt}`,
+						onAttemptFailed: (attempt, error, delayMs, info) => {
+							appendEvent(manifest.eventsPath, { type: "crew.task.retry_attempt", runId: manifest.runId, taskId: task.id, message: error.message, data: { attempt, attemptId: info.attemptId, delayMs } });
 							input.metricRegistry?.histogram("crew.task.retry_delay_ms", "Retry backoff delay, milliseconds").observe({ runId: manifest.runId, taskId: task.id }, delayMs);
 						},
-						onRetryGivenUp: (attempts, error) => {
-							appendDeadletter(manifest, { runId: manifest.runId, taskId: task.id, reason: "max-retries", attempts, lastError: error.message, timestamp: new Date().toISOString() });
+						onRetryGivenUp: (attempts, error, info) => {
+							appendDeadletter(manifest, { runId: manifest.runId, taskId: task.id, reason: "max-retries", attempts, attemptId: info.attemptId, lastError: error.message, timestamp: new Date().toISOString() });
 							input.metricRegistry?.counter("crew.task.deadletter_total", "Deadletter triggers by reason").inc({ reason: "max-retries" });
 							input.metricRegistry?.histogram("crew.task.retry_count", "Retries per task", [0, 1, 2, 3, 5, 10]).observe({ runId: manifest.runId, team: input.team.name }, Math.max(0, attempts - 1));
 						},
 					});
-				} catch {
+				} catch (retryError) {
+					if (retryError instanceof CrewCancellationError || input.signal?.aborted) {
+						const reason = retryError instanceof CrewCancellationError ? retryError.reason : cancellationReasonFromSignal(input.signal);
+						const fresh = loadRunManifestById(manifest.cwd, manifest.runId);
+						const freshManifest = fresh?.manifest ?? manifest;
+						const freshTasks = fresh?.tasks ?? tasks;
+						const cancelledTasks = freshTasks.map((item) => item.id === task.id && (item.status === "queued" || item.status === "running") ? { ...item, status: "cancelled" as const, finishedAt: new Date().toISOString(), error: `${reason.message} (${reason.code})` } : item);
+						appendEvent(freshManifest.eventsPath, { type: "task.cancelled", runId: freshManifest.runId, taskId: task.id, message: reason.message, data: { reason, phase: "retry" } });
+						return { manifest: updateRunStatus(freshManifest, "cancelled", reason.message), tasks: cancelledTasks };
+					}
 					if (lastFailed) return lastFailed;
 					const fresh = loadRunManifestById(manifest.cwd, manifest.runId);
 					const freshManifest = fresh?.manifest ?? manifest;
 					const freshTasks = fresh?.tasks ?? tasks;
 					const freshTask = freshTasks.find((item) => item.id === task.id) ?? task;
+					if (freshTask.status !== "queued" && freshTask.status !== "running") return { manifest: freshManifest, tasks: freshTasks };
 					return withCorrelation(childCorrelation(freshManifest.runId, task.id), () => runTeamTask({ ...baseInput, manifest: freshManifest, tasks: freshTasks, task: freshTask }));
 				}
 			},
 		);
 		manifest = { ...results.at(-1)!.manifest, artifacts: mergeArtifacts([manifest.artifacts, ...results.map((item) => item.manifest.artifacts)].flat()) };
 		tasks = __test__mergeTaskUpdates(tasks, results);
+		const cancelledResult = results.find((item) => item.manifest.status === "cancelled");
+		if (cancelledResult || input.signal?.aborted) {
+			const reason = input.signal?.aborted ? cancellationReasonFromSignal(input.signal) : undefined;
+			const message = reason?.message ?? cancelledResult?.manifest.summary ?? "Run cancelled during task execution.";
+			manifest = { ...manifest, status: "running" };
+			manifest = updateRunStatus(manifest, "cancelled", message);
+			await saveRunTasksAsync(manifest, tasks);
+			saveCrewAgents(manifest, recordsForMaterializedTasks(manifest, tasks, runtimeKind));
+			await saveRunManifestAsync(manifest);
+			appendEvent(manifest.eventsPath, { type: "run.cancelled", runId: manifest.runId, message, data: { reason, phase: "task-batch", cancelledResultRunId: cancelledResult?.manifest.runId } });
+			return { manifest, tasks };
+		}
 		queueIndex = buildTaskGraphIndex(tasks);
 		const injectedAfterBatch = attemptAdaptivePlan();
 		if (injectedAfterBatch.missing) {
@@ -666,21 +710,37 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 		});
 		const groupDelivery = deliverGroupJoin({ manifest, mode: resolveGroupJoinMode(input.runtimeConfig), batch: readyBatch, allTasks: tasks });
 		manifest = { ...manifest, artifacts: mergeArtifacts([...manifest.artifacts, batchArtifact, ...(groupDelivery?.artifact ? [groupDelivery.artifact] : [])]) };
-		manifest = writeProgress(manifest, tasks, "team-runner");
+		manifest = writeProgress(manifest, tasks, "team-runner", input.executeWorkers, input.runtimeConfig);
 		await saveRunManifestAsync(manifest);
 	}
 
 	const failed = tasks.find((task) => task.status === "failed");
+	const waiting = tasks.find((task) => task.status === "waiting");
+	const running = tasks.find((task) => task.status === "running");
 	manifest = applyPolicy(manifest, tasks, input.limits);
+	const effectiveness = evaluateRunEffectiveness({ manifest, tasks, executeWorkers: input.executeWorkers, runtimeConfig: input.runtimeConfig });
+	const effectivenessDecision = effectivenessPolicyDecision(effectiveness);
+	if (effectivenessDecision) {
+		manifest = { ...manifest, policyDecisions: [...(manifest.policyDecisions ?? []), effectivenessDecision], updatedAt: new Date().toISOString() };
+		appendEvent(manifest.eventsPath, { type: "run.effectiveness", runId: manifest.runId, message: effectivenessDecision.message, data: { effectiveness, policyDecision: effectivenessDecision } });
+	}
 	const blockingDecision = manifest.policyDecisions?.find((item) => item.action === "block" || item.action === "escalate");
 	if (failed) {
 		manifest = updateRunStatus(manifest, "failed", `Failed at task '${failed.id}'.`);
+	} else if (waiting) {
+		manifest = updateRunStatus(manifest, "blocked", `Waiting for response to task '${waiting.id}'.`);
+	} else if (running) {
+		manifest = updateRunStatus(manifest, "blocked", `Task '${running.id}' is still running.`);
+	} else if (effectiveness.severity === "failed") {
+		manifest = updateRunStatus(manifest, "failed", effectivenessDecision?.message ?? "Run effectiveness guard failed.");
+	} else if (effectiveness.severity === "blocked") {
+		manifest = updateRunStatus(manifest, "blocked", effectivenessDecision?.message ?? "Run effectiveness guard blocked completion.");
 	} else if (blockingDecision) {
 		manifest = updateRunStatus(manifest, "blocked", blockingDecision.message);
 	} else {
 		manifest = updateRunStatus(manifest, "completed", input.executeWorkers ? "Team workflow completed." : "Team workflow scaffold completed without launching child workers.");
 	}
-	manifest = writeProgress(manifest, tasks, "team-runner");
+	manifest = writeProgress(manifest, tasks, "team-runner", input.executeWorkers, input.runtimeConfig);
 	await saveRunManifestAsync(manifest);
 	const usage = aggregateUsage(tasks);
 	const summaryArtifact = writeArtifact(manifest.artifactsRoot, {
@@ -699,6 +759,9 @@ export async function executeTeamRun(input: ExecuteTeamRunInput): Promise<{ mani
 			"## Tasks",
 			...tasks.map(formatTaskProgress),
 			"",
+			"## Effectiveness",
+			...runEffectivenessLines(manifest, tasks, input.executeWorkers, input.runtimeConfig),
+			"",
 			"## Policy decisions",
 			...(manifest.policyDecisions?.length ? summarizePolicyDecisions(manifest.policyDecisions) : ["- (none)"]),
 			"",

package/src/runtime/worker-heartbeat.ts

@@ -1,21 +1,21 @@
-export interface WorkerHeartbeatState {
-	workerId: string;
-	pid?: number;
-	lastSeenAt: string;
-	lastStdoutAt?: string;
-	lastEventAt?: string;
-	turnCount?: number;
-	alive?: boolean;
-}
-
-export function createWorkerHeartbeat(workerId: string, pid?: number, now = new Date()): WorkerHeartbeatState {
-	return { workerId, pid, lastSeenAt: now.toISOString(), alive: true };
-}
-
-export function touchWorkerHeartbeat(heartbeat: WorkerHeartbeatState, updates: Partial<Omit<WorkerHeartbeatState, "workerId">> = {}, now = new Date()): WorkerHeartbeatState {
-	return { ...heartbeat, ...updates, lastSeenAt: now.toISOString() };
-}
-
-export function isWorkerHeartbeatStale(heartbeat: WorkerHeartbeatState, staleMs: number, now = new Date()): boolean {
-	return now.getTime() - Date.parse(heartbeat.lastSeenAt) > staleMs;
-}
+export interface WorkerHeartbeatState {
+	workerId: string;
+	pid?: number;
+	lastSeenAt: string;
+	lastStdoutAt?: string;
+	lastEventAt?: string;
+	turnCount?: number;
+	alive?: boolean;
+}
+
+export function createWorkerHeartbeat(workerId: string, pid?: number, now = new Date()): WorkerHeartbeatState {
+	return { workerId, pid, lastSeenAt: now.toISOString(), alive: true };
+}
+
+export function touchWorkerHeartbeat(heartbeat: WorkerHeartbeatState, updates: Partial<Omit<WorkerHeartbeatState, "workerId">> = {}, now = new Date()): WorkerHeartbeatState {
+	return { ...heartbeat, ...updates, lastSeenAt: now.toISOString() };
+}
+
+export function isWorkerHeartbeatStale(heartbeat: WorkerHeartbeatState, staleMs: number, now = new Date()): boolean {
+	return now.getTime() - Date.parse(heartbeat.lastSeenAt) > staleMs;
+}

package/src/runtime/worker-startup.ts

@@ -1,57 +1,57 @@
-export type WorkerLifecycleState = "spawning" | "trust_required" | "ready_for_prompt" | "running" | "finished" | "failed";
-export type StartupFailureClassification = "trust_required" | "prompt_misdelivery" | "prompt_acceptance_timeout" | "transport_dead" | "worker_crashed" | "unknown";
-
-export interface WorkerStartupEvidence {
-	lastLifecycleState: WorkerLifecycleState;
-	command: string;
-	promptSentAt?: string;
-	promptAccepted: boolean;
-	trustPromptDetected: boolean;
-	transportHealthy: boolean;
-	childProcessAlive: boolean;
-	elapsedMs: number;
-	classification: StartupFailureClassification;
-	stderrPreview?: string;
-}
-
-export function detectTrustPrompt(text: string): boolean {
-	const lowered = text.toLowerCase();
-	return lowered.includes("do you trust") || lowered.includes("trust this") || lowered.includes("untrusted") || lowered.includes("workspace trust") || lowered.includes("allow this folder");
-}
-
-export function classifyStartupFailure(evidence: Omit<WorkerStartupEvidence, "classification">): StartupFailureClassification {
-	if (!evidence.transportHealthy) return "transport_dead";
-	if (evidence.trustPromptDetected || evidence.lastLifecycleState === "trust_required") return "trust_required";
-	if (evidence.promptSentAt && !evidence.promptAccepted && evidence.childProcessAlive) return "prompt_acceptance_timeout";
-	if (evidence.promptSentAt && !evidence.promptAccepted && !evidence.childProcessAlive) return "worker_crashed";
-	if (evidence.stderrPreview?.toLowerCase().includes("command not found") || evidence.stderrPreview?.toLowerCase().includes("not recognized")) return "prompt_misdelivery";
-	if (!evidence.childProcessAlive && evidence.lastLifecycleState !== "finished") return "worker_crashed";
-	return "unknown";
-}
-
-export function createStartupEvidence(input: {
-	command: string;
-	startedAt: Date;
-	finishedAt?: Date;
-	promptSentAt?: Date;
-	promptAccepted?: boolean;
-	stderr?: string;
-	error?: string;
-	exitCode?: number | null;
-}): WorkerStartupEvidence {
-	const stderrPreview = (input.error || input.stderr || "").slice(0, 500) || undefined;
-	const trustPromptDetected = detectTrustPrompt(stderrPreview ?? "");
-	const childProcessAlive = input.exitCode === undefined || input.exitCode === null ? !input.finishedAt : false;
-	const base: Omit<WorkerStartupEvidence, "classification"> = {
-		lastLifecycleState: input.error || (input.exitCode !== undefined && input.exitCode !== null && input.exitCode !== 0) ? "failed" : input.finishedAt ? "finished" : "running",
-		command: input.command,
-		promptSentAt: input.promptSentAt?.toISOString(),
-		promptAccepted: input.promptAccepted ?? !input.error,
-		trustPromptDetected,
-		transportHealthy: !input.error || !/enoent|spawn|transport/i.test(input.error),
-		childProcessAlive,
-		elapsedMs: Math.max(0, (input.finishedAt ?? new Date()).getTime() - input.startedAt.getTime()),
-		stderrPreview,
-	};
-	return { ...base, classification: classifyStartupFailure(base) };
-}
+export type WorkerLifecycleState = "spawning" | "trust_required" | "ready_for_prompt" | "running" | "finished" | "failed";
+export type StartupFailureClassification = "trust_required" | "prompt_misdelivery" | "prompt_acceptance_timeout" | "transport_dead" | "worker_crashed" | "unknown";
+
+export interface WorkerStartupEvidence {
+	lastLifecycleState: WorkerLifecycleState;
+	command: string;
+	promptSentAt?: string;
+	promptAccepted: boolean;
+	trustPromptDetected: boolean;
+	transportHealthy: boolean;
+	childProcessAlive: boolean;
+	elapsedMs: number;
+	classification: StartupFailureClassification;
+	stderrPreview?: string;
+}
+
+export function detectTrustPrompt(text: string): boolean {
+	const lowered = text.toLowerCase();
+	return lowered.includes("do you trust") || lowered.includes("trust this") || lowered.includes("untrusted") || lowered.includes("workspace trust") || lowered.includes("allow this folder");
+}
+
+export function classifyStartupFailure(evidence: Omit<WorkerStartupEvidence, "classification">): StartupFailureClassification {
+	if (!evidence.transportHealthy) return "transport_dead";
+	if (evidence.trustPromptDetected || evidence.lastLifecycleState === "trust_required") return "trust_required";
+	if (evidence.promptSentAt && !evidence.promptAccepted && evidence.childProcessAlive) return "prompt_acceptance_timeout";
+	if (evidence.promptSentAt && !evidence.promptAccepted && !evidence.childProcessAlive) return "worker_crashed";
+	if (evidence.stderrPreview?.toLowerCase().includes("command not found") || evidence.stderrPreview?.toLowerCase().includes("not recognized")) return "prompt_misdelivery";
+	if (!evidence.childProcessAlive && evidence.lastLifecycleState !== "finished") return "worker_crashed";
+	return "unknown";
+}
+
+export function createStartupEvidence(input: {
+	command: string;
+	startedAt: Date;
+	finishedAt?: Date;
+	promptSentAt?: Date;
+	promptAccepted?: boolean;
+	stderr?: string;
+	error?: string;
+	exitCode?: number | null;
+}): WorkerStartupEvidence {
+	const stderrPreview = (input.error || input.stderr || "").slice(0, 500) || undefined;
+	const trustPromptDetected = detectTrustPrompt(stderrPreview ?? "");
+	const childProcessAlive = input.exitCode === undefined || input.exitCode === null ? !input.finishedAt : false;
+	const base: Omit<WorkerStartupEvidence, "classification"> = {
+		lastLifecycleState: input.error || (input.exitCode !== undefined && input.exitCode !== null && input.exitCode !== 0) ? "failed" : input.finishedAt ? "finished" : "running",
+		command: input.command,
+		promptSentAt: input.promptSentAt?.toISOString(),
+		promptAccepted: input.promptAccepted ?? !input.error,
+		trustPromptDetected,
+		transportHealthy: !input.error || !/enoent|spawn|transport/i.test(input.error),
+		childProcessAlive,
+		elapsedMs: Math.max(0, (input.finishedAt ?? new Date()).getTime() - input.startedAt.getTime()),
+		stderrPreview,
+	};
+	return { ...base, classification: classifyStartupFailure(base) };
+}

package/src/schema/config-schema.ts

@@ -39,6 +39,7 @@ export const PiTeamsRuntimeConfigSchema = Type.Object({
 	groupJoinAckTimeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
 	requirePlanApproval: Type.Optional(Type.Boolean()),
 	completionMutationGuard: Type.Optional(Type.Union([Type.Literal("off"), Type.Literal("warn"), Type.Literal("fail")])),
+	effectivenessGuard: Type.Optional(Type.Union([Type.Literal("off"), Type.Literal("warn"), Type.Literal("block"), Type.Literal("fail")])),
 }, { additionalProperties: false });
 
 export const PiTeamsControlConfigSchema = Type.Object({

package/src/schema/team-tool-schema.ts

@@ -1,10 +1,10 @@
 import { Type } from "typebox";
 
 const SkillOverride = Type.Unsafe({
-	description: "Skill name(s) to inject, array of skill names, or false to disable role defaults.",
+	description: "Skill name(s) to add to role/default skills, an array of skill names, or false to disable all injected skills for this run.",
 	anyOf: [
-		{ type: "string" },
-		{ type: "array", items: { type: "string" } },
+		{ type: "string", maxLength: 2048 },
+		{ type: "array", maxItems: 32, items: { type: "string", maxLength: 80 } },
 		{ type: "boolean" },
 	],
 });