pi-crew 0.1.44 → 0.1.46

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

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

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

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

package/src/extension/team-tool.ts

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

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

@@ -13,6 +13,13 @@ function numberValue(value: unknown, fallback = 0): number {
 	return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 
+const CANCELLATION_REASON_LABELS = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
+
+function cancellationReasonLabel(value: unknown): string {
+	const raw = stringValue(value, "unknown");
+	return CANCELLATION_REASON_LABELS.has(raw) ? raw : "unknown";
+}
+
 export interface EventToMetricSubscription {
 	dispose(): void;
 }
@@ -36,7 +43,7 @@ export function wireEventToMetrics(events: ExtensionAPI["events"] | undefined, r
 	const handlers: Array<[string, (data: unknown) => void]> = [
 		["crew.run.completed", (data) => { const item = recordValue(data); runCount.inc({ status: "completed" }); runDuration.observe({ team: stringValue(item.team, "unknown") }, numberValue(item.durationMs)); }],
 		["crew.run.failed", () => runCount.inc({ status: "failed" })],
-		["crew.run.cancelled", () => runCount.inc({ status: "cancelled" })],
+		["crew.run.cancelled", (data) => { const item = recordValue(data); runCount.inc({ status: "cancelled", reason: cancellationReasonLabel(item.reason) }); }],
 		["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" }); retryAttemptCount.inc({ runId: stringValue(item.runId, "unknown"), taskId: stringValue(item.taskId, "unknown") }); }],

package/src/runtime/background-runner.ts

@@ -1,11 +1,11 @@
 import { allAgents, discoverAgents } from "../agents/discover-agents.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
 import { appendEvent } from "../state/event-log.ts";
-import { loadRunManifestById, updateRunStatus } from "../state/state-store.ts";
+import { loadRunManifestById, saveRunManifest, updateRunStatus } from "../state/state-store.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 import { loadConfig } from "../config/config.ts";
 import { executeTeamRun } from "./team-runner.ts";
-import { resolveCrewRuntime } from "./runtime-resolver.ts";
+import { resolveCrewRuntime, runtimeResolutionState } from "./runtime-resolver.ts";
 import { directTeamAndWorkflowFromRun } from "./direct-run.ts";
 import { expandParallelResearchWorkflow } from "./parallel-research.ts";
 import { writeAsyncStartMarker } from "./async-marker.ts";
@@ -36,9 +36,15 @@ async function main(): Promise<void> {
 		if (!baseWorkflow) throw new Error(`Workflow '${manifest.workflow ?? ""}' not found.`);
 		const workflow = expandParallelResearchWorkflow(baseWorkflow, cwd);
 		const loadedConfig = loadConfig(cwd);
-		const runtime = await resolveCrewRuntime(loadedConfig.config);
+		const runConfig = manifest.runConfig && typeof manifest.runConfig === "object" && !Array.isArray(manifest.runConfig) ? manifest.runConfig as typeof loadedConfig.config : loadedConfig.config;
+		const runtime = manifest.runtimeResolution ? { kind: manifest.runtimeResolution.kind, requestedMode: manifest.runtimeResolution.requestedMode, available: manifest.runtimeResolution.available, fallback: manifest.runtimeResolution.fallback, steer: manifest.runtimeResolution.kind === "live-session", resume: manifest.runtimeResolution.kind === "live-session", liveToolActivity: manifest.runtimeResolution.kind === "live-session", transcript: manifest.runtimeResolution.kind !== "scaffold", reason: manifest.runtimeResolution.reason, safety: manifest.runtimeResolution.safety } : await resolveCrewRuntime(runConfig);
+		const runtimeResolution = manifest.runtimeResolution ?? runtimeResolutionState(runtime);
+		manifest = { ...manifest, runtimeResolution, runConfig, updatedAt: new Date().toISOString() };
+		saveRunManifest(manifest);
+		appendEvent(manifest.eventsPath, { type: "runtime.resolved", runId: manifest.runId, message: `Runtime resolved: ${runtime.kind} safety=${runtime.safety}`, data: { runtimeResolution, async: true } });
+		if (runtime.safety === "blocked") throw new Error(runtime.reason ?? "Child worker execution is disabled; refusing to create no-op scaffold subagents.");
 		const executeWorkers = runtime.kind !== "scaffold";
-		const result = await executeTeamRun({ manifest, tasks, team, workflow, agents, executeWorkers, limits: loadedConfig.config.limits, runtime, runtimeConfig: loadedConfig.config.runtime });
+		const result = await executeTeamRun({ manifest, tasks, team, workflow, agents, executeWorkers, limits: runConfig.limits, runtime, runtimeConfig: runConfig.runtime, skillOverride: manifest.skillOverride, reliability: runConfig.reliability });
 		manifest = result.manifest;
 		tasks = result.tasks;
 		appendEvent(manifest.eventsPath, { type: "async.completed", runId: manifest.runId, data: { status: manifest.status, tasks: tasks.length } });

package/src/runtime/cancellation.ts

@@ -0,0 +1,51 @@
+export type CancellationReasonCode = "caller_cancelled" | "leader_interrupted" | "provider_timeout" | "worker_timeout" | "tool_timeout" | "shutdown" | "unknown";
+
+export interface CancellationReason {
+	code: CancellationReasonCode;
+	message: string;
+	cause?: unknown;
+}
+
+const KNOWN_CODES: ReadonlySet<string> = new Set(["caller_cancelled", "leader_interrupted", "provider_timeout", "worker_timeout", "tool_timeout", "shutdown", "unknown"]);
+
+export class CrewCancellationError extends Error {
+	readonly reason: CancellationReason;
+
+	constructor(reason: CancellationReason) {
+		super(reason.message);
+		this.name = "CrewCancellationError";
+		this.reason = reason;
+	}
+}
+
+function reasonFromString(value: string): CancellationReason {
+	const trimmed = value.trim();
+	if (KNOWN_CODES.has(trimmed)) return { code: trimmed as CancellationReasonCode, message: `Cancelled: ${trimmed}` };
+	return { code: "caller_cancelled", message: trimmed || "Cancelled by caller." };
+}
+
+export function cancellationReasonFromUnknown(value: unknown): CancellationReason {
+	if (value instanceof CrewCancellationError) return value.reason;
+	if (value instanceof Error) return { code: "caller_cancelled", message: value.message || "Cancelled by caller.", cause: value };
+	if (typeof value === "string") return reasonFromString(value);
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const record = value as { code?: unknown; reason?: unknown; message?: unknown; cause?: unknown };
+		const rawCode = typeof record.code === "string" ? record.code : typeof record.reason === "string" ? record.reason : undefined;
+		const code = rawCode && KNOWN_CODES.has(rawCode) ? rawCode as CancellationReasonCode : "caller_cancelled";
+		const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : `Cancelled: ${code}`;
+		return { code, message, cause: record.cause ?? value };
+	}
+	return { code: "caller_cancelled", message: "Cancelled by caller." };
+}
+
+export function cancellationReasonFromSignal(signal: AbortSignal | undefined): CancellationReason {
+	return cancellationReasonFromUnknown(signal?.reason);
+}
+
+export function cancellationErrorFromSignal(signal: AbortSignal | undefined): CrewCancellationError {
+	return new CrewCancellationError(cancellationReasonFromSignal(signal));
+}
+
+export function throwIfCancelled(signal: AbortSignal | undefined): void {
+	if (signal?.aborted) throw cancellationErrorFromSignal(signal);
+}

package/src/runtime/child-pi.ts

@@ -2,6 +2,7 @@ import { spawn, type ChildProcess, type SpawnOptions } from "node:child_process"
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig } from "../agents/agent-config.ts";
+import type { WorkerExitStatus } from "../state/types.ts";
 import { buildPiWorkerArgs, checkCrewDepth, cleanupTempDir } from "./pi-args.ts";
 import { getPiSpawnCommand } from "./pi-spawn.ts";
 import { DEFAULT_CHILD_PI } from "../config/defaults.ts";
@@ -88,6 +89,7 @@ export interface ChildPiRunInput {
 	task: string;
 	agent: AgentConfig;
 	model?: string;
+	skillPaths?: string[];
 	signal?: AbortSignal;
 	transcriptPath?: string;
 	onStdoutLine?: (line: string) => void;
@@ -104,6 +106,7 @@ export interface ChildPiRunResult {
 	stdout: string;
 	stderr: string;
 	error?: string;
+	exitStatus?: WorkerExitStatus;
 }
 
 export function buildChildPiSpawnOptions(cwd: string, env: NodeJS.ProcessEnv): SpawnOptions {
@@ -283,7 +286,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 		if (mock === "retryable-failure") return { exitCode: 1, stdout: "", stderr: "rate limit: mock failure" };
 		return { exitCode: 1, stdout: "", stderr: `mock failure: ${mock}` };
 	}
-	const built = buildPiWorkerArgs({ task: input.task, agent: input.agent, model: input.model, sessionEnabled: false, maxDepth: input.maxDepth });
+	const built = buildPiWorkerArgs({ task: input.task, agent: input.agent, model: input.model, sessionEnabled: false, maxDepth: input.maxDepth, skillPaths: input.skillPaths });
 	const spawnSpec = getPiSpawnCommand(built.args);
 	try {
 		return await new Promise<ChildPiRunResult>((resolve) => {
@@ -306,6 +309,9 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 			const responseTimeoutMs = Number.isFinite(responseTimeoutEnv) && responseTimeoutEnv >= 0 ? responseTimeoutEnv : input.responseTimeoutMs ?? RESPONSE_TIMEOUT_MS;
 			let responseTimeoutHit = false;
 			let forcedFinalDrain = false;
+			let abortRequested = input.signal?.aborted === true;
+			let hardKilled = false;
+			const cleanupErrors: string[] = [];
 			const restartNoResponseTimer = (): void => {
 				if (responseTimeoutMs <= 0) return;
 				if (noResponseTimer) clearTimeout(noResponseTimer);
@@ -347,6 +353,7 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 						hardKillTimer = setTimeout(() => {
 							if (settled || childExited) return;
 							try {
+								hardKilled = true;
 								child.kill(process.platform === "win32" ? undefined : "SIGKILL");
 							} catch (error) {
 								logInternalError("child-pi.final-drain-kill", error, `pid=${child.pid}`);
@@ -382,11 +389,16 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 				clearChildPiTimeouts();
 				lineObserver.flush();
 				input.signal?.removeEventListener("abort", abort);
-				cleanupTempDir(built.tempDir);
-				resolve(result);
+				try {
+					cleanupTempDir(built.tempDir);
+				} catch (error) {
+					cleanupErrors.push(error instanceof Error ? error.message : String(error));
+				}
+				resolve({ ...result, exitStatus: result.exitStatus ?? { exitCode: result.exitCode, cancelled: abortRequested, timedOut: responseTimeoutHit, killed: hardKilled, cleanupErrors, finalDrainMs } });
 			};
 
 			const abort = (): void => {
+				abortRequested = true;
 				killProcessTree(child.pid, child);
 				if (process.platform !== "win32") {
 					trySignalChild(child, "SIGTERM");
@@ -431,11 +443,12 @@ export async function runChildPi(input: ChildPiRunInput): Promise<ChildPiRunResu
 					clearHardKillTimer(child.pid);
 				}
 				const timeoutError = responseTimeoutHit && !stderr.trim() ? { error: `Child Pi produced no new output for ${responseTimeoutMs}ms; process was terminated as unresponsive.` } : undefined;
+				const finalExitCode = forcedFinalDrain && !timeoutError ? 0 : exitCode;
 				// A final assistant event is the child Pi contract for "the worker produced its answer".
 				// Some Pi processes can linger during post-final cleanup/stdio shutdown; finalDrain terminates
 				// that lingering process so the parent can continue, but it must not turn a completed
 				// subagent answer into a failed task. Real pre-final response timeouts still report errors.
-				settle({ exitCode: forcedFinalDrain && !timeoutError ? 0 : exitCode, stdout, stderr, ...(timeoutError ? { error: timeoutError.error } : {}) });
+				settle({ exitCode: finalExitCode, stdout, stderr, ...(timeoutError ? { error: timeoutError.error } : {}), exitStatus: { exitCode: finalExitCode, cancelled: abortRequested, timedOut: responseTimeoutHit, killed: hardKilled, cleanupErrors, finalDrainMs } });
 			});
 		});
 	} finally {

package/src/runtime/crash-recovery.ts

@@ -75,6 +75,7 @@ export function reconcileAllStaleRuns(cwd: string, manifestCache: ManifestCache,
 			if (!fresh || fresh.manifest.status !== "running") return;
 			const result = reconcileStaleRun(fresh.manifest, fresh.tasks, now);
 			if (result.repaired) {
+				if (result.repairedTasks) saveRunTasks(fresh.manifest, result.repairedTasks);
 				updateRunStatus(fresh.manifest, "failed", `Stale run reconciled: ${result.detail}`);
 				appendEvent(fresh.manifest.eventsPath, { type: "crew.run.reconciled_stale", runId: manifest.runId, message: result.detail, data: { verdict: result.verdict } });
 			}

package/src/runtime/crew-agent-records.ts

@@ -61,6 +61,23 @@ export function agentOutputPath(manifest: TeamRunManifest, taskId: string): stri
 }
 
 const AGENT_READER_TTL_MS = 200;
+const ASYNC_AGENT_READER_CACHE_MAX_ENTRIES = 128;
+
+const asyncAgentReaderCache = new Map<string, { expiresAt: number; records: CrewAgentRecord[]; inFlight?: Promise<CrewAgentRecord[]> }>();
+
+function setAsyncAgentReaderCache(filePath: string, entry: { expiresAt: number; records: CrewAgentRecord[]; inFlight?: Promise<CrewAgentRecord[]> }): void {
+	const now = Date.now();
+	for (const [key, cached] of asyncAgentReaderCache) {
+		if (cached.expiresAt <= now && !cached.inFlight) asyncAgentReaderCache.delete(key);
+	}
+	if (asyncAgentReaderCache.has(filePath)) asyncAgentReaderCache.delete(filePath);
+	asyncAgentReaderCache.set(filePath, entry);
+	while (asyncAgentReaderCache.size > ASYNC_AGENT_READER_CACHE_MAX_ENTRIES) {
+		const oldest = asyncAgentReaderCache.keys().next().value;
+		if (!oldest) break;
+		asyncAgentReaderCache.delete(oldest);
+	}
+}
 
 export function readCrewAgents(manifest: TeamRunManifest): CrewAgentRecord[] {
 	try {
@@ -70,9 +87,32 @@ export function readCrewAgents(manifest: TeamRunManifest): CrewAgentRecord[] {
 	}
 }
 
+export async function readCrewAgentsAsync(manifest: TeamRunManifest): Promise<CrewAgentRecord[]> {
+	const filePath = agentsPath(manifest);
+	const now = Date.now();
+	const cached = asyncAgentReaderCache.get(filePath);
+	if (cached && cached.expiresAt > now) return cached.records;
+	if (cached?.inFlight) return cached.inFlight;
+	const inFlight = (async (): Promise<CrewAgentRecord[]> => {
+		try {
+			const parsed = JSON.parse(await fs.promises.readFile(filePath, "utf-8")) as unknown;
+			const records = Array.isArray(parsed) ? redactSecrets(parsed) as CrewAgentRecord[] : [];
+			setAsyncAgentReaderCache(filePath, { expiresAt: Date.now() + AGENT_READER_TTL_MS, records });
+			return records;
+		} catch {
+			setAsyncAgentReaderCache(filePath, { expiresAt: Date.now() + AGENT_READER_TTL_MS, records: [] });
+			return [];
+		}
+	})();
+	setAsyncAgentReaderCache(filePath, { expiresAt: now + AGENT_READER_TTL_MS, records: cached?.records ?? [], inFlight });
+	return inFlight;
+}
+
 export function saveCrewAgents(manifest: TeamRunManifest, records: CrewAgentRecord[]): void {
 	fs.mkdirSync(manifest.stateRoot, { recursive: true });
-	atomicWriteJson(agentsPath(manifest), redactSecrets(records));
+	const filePath = agentsPath(manifest);
+	atomicWriteJson(filePath, redactSecrets(records));
+	asyncAgentReaderCache.delete(filePath);
 	for (const record of records) writeCrewAgentStatus(manifest, record);
 }
 

package/src/runtime/deadletter.ts

@@ -12,6 +12,7 @@ export interface DeadletterEntry {
 	reason: DeadletterReason;
 	attempts: number;
 	lastError?: string;
+	attemptId?: string;
 	timestamp: string;
 }