pi-crew 0.9.48 → 0.9.50

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

@@ -15,6 +15,7 @@ import { assertCleanLeaderAsync, findGitRootAsync } from "../../worktree/worktre
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- type-only import for TS inference
 const _typeCheck: typeof ExecuteTeamRunFn = null as never as typeof ExecuteTeamRunFn;
 
+import { errorMessage } from "../../utils/guards.ts";
 import { logInternalError } from "../../utils/internal-error.ts";
 import { resolveContainedPath, resolveRealContainedPath } from "../../utils/safe-paths.ts";
 
@@ -432,7 +433,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 			try {
 				await assertCleanLeaderAsync(gitRoot);
 			} catch (err) {
-				const msg = err instanceof Error ? err.message : String(err);
+				const msg = errorMessage(err);
 				return result(
 					`${msg}\nCommit or stash changes before using worktree mode, or use workspaceMode: 'single'.`,
 					{ action: "run", status: "error" },
@@ -655,7 +656,7 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 				// Round-11 runtime fix: persist manifest with status=failed when runner throws
 				// (e.g., script timeout, script syntax error, async failure). Previously the
 				// manifest stayed at 'queued' indefinitely, leaving an orphan state file.
-				const failureReason = runnerError instanceof Error ? runnerError.message : String(runnerError);
+				const failureReason = errorMessage(runnerError);
 				const failedManifest = {
 					...dwfManifest,
 					status: "failed" as const,
@@ -856,13 +857,13 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 				workspaceId: ctx.sessionId ?? ctx.cwd,
 			});
 		} catch (waitError: unknown) {
-			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
+			const waitErrMsg = errorMessage(waitError);
 			return result(
 				[
 					`pi-crew run timed out or failed: ${updatedManifest.runId}`,
 					`Team: ${team.name}`,
 					`Workflow: ${workflow.name}`,
-					`Error: ${errorMessage}`,
+					`Error: ${waitErrMsg}`,
 					"",
 					`Check status with: team status runId=${updatedManifest.runId}`,
 					`State: ${updatedManifest.stateRoot}`,
@@ -970,13 +971,13 @@ export async function handleRun(params: TeamToolParamsValue, ctx: TeamContext):
 				workspaceId: ctx.sessionId ?? ctx.cwd,
 			});
 		} catch (waitError: unknown) {
-			const errorMessage = waitError instanceof Error ? waitError.message : String(waitError);
+			const waitErrMsg = errorMessage(waitError);
 			return result(
 				[
 					`pi-crew run timed out or failed: ${updatedManifest.runId}`,
 					`Team: ${team.name}`,
 					`Workflow: ${workflow.name}`,
-					`Error: ${errorMessage}`,
+					`Error: ${waitErrMsg}`,
 					"",
 					`Check status with: team status runId=${updatedManifest.runId}`,
 					`State: ${updatedManifest.stateRoot}`,

package/src/runtime/background-runner.ts

@@ -8,6 +8,7 @@ import { withRunLockSync } from "../state/locks.ts";
 import { createRunPaths, loadRunManifestById, saveRunManifestAsync, updateRunStatus } from "../state/state-store.ts";
 import type { TeamRunManifest, TeamTaskState } from "../state/types.ts";
 import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
+import { errorMessage } from "../utils/guards.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
 import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
 // Heavy runtime — lazy-loaded to avoid pulling team-runner into background-runner
@@ -175,7 +176,7 @@ function setupUnhandledRejectionGuard(
 	setExitFlag: () => void,
 ): void {
 	process.on("unhandledRejection", (reason, promise) => {
-		const message = reason instanceof Error ? reason.message : String(reason);
+		const message = errorMessage(reason);
 		console.error("[background-runner] UNHANDLED REJECTION:", reason);
 		console.error("[background-runner] Stack:", reason instanceof Error ? reason.stack : "N/A");
 		try {
@@ -234,9 +235,7 @@ function runCleanup(
 	try {
 		killed = terminateActiveChildPiProcesses();
 	} catch (error) {
-		console.log(
-			`[background-runner] runCleanup: terminateActiveChildPiProcesses error: ${error instanceof Error ? error.message : String(error)}`,
-		);
+		console.log(`[background-runner] runCleanup: terminateActiveChildPiProcesses error: ${errorMessage(error)}`);
 	}
 	console.log(`[background-runner] runCleanup: killed ${killed} child processes`);
 	// FIX Issue #5: Unregister this worker from the orphan registry on exit.
@@ -245,13 +244,13 @@ function runCleanup(
 	try {
 		unregisterWorker(process.pid);
 	} catch (error) {
-		console.log(`[background-runner] runCleanup: unregisterWorker error: ${error instanceof Error ? error.message : String(error)}`);
+		console.log(`[background-runner] runCleanup: unregisterWorker error: ${errorMessage(error)}`);
 		if (eventsPath) {
 			try {
 				appendEvent(eventsPath, {
 					type: "background.unregister_worker_failed",
 					runId: argValue("--run-id") ?? "unknown",
-					message: `unregisterWorker failed: ${error instanceof Error ? error.message : String(error)}`,
+					message: `unregisterWorker failed: ${errorMessage(error)}`,
 					data: { pid: process.pid },
 				});
 			} catch {
@@ -391,7 +390,7 @@ async function main(): Promise<void> {
 			staleMs: 30_000,
 		});
 	} catch (lockErr) {
-		throw new Error(`Failed to acquire lock for run '${runId}': ${lockErr instanceof Error ? lockErr.message : String(lockErr)}`);
+		throw new Error(`Failed to acquire lock for run '${runId}': ${errorMessage(lockErr)}`);
 	}
 	if (!loaded) throw new Error(`Run '${runId}' not found.`);
 	let { manifest, tasks } = loaded;
@@ -750,9 +749,7 @@ async function main(): Promise<void> {
 				}
 				console.log(`[background-runner] executeTeamRun returned, status=${result.manifest.status}`);
 			} catch (execError) {
-				console.log(
-					`[background-runner] executeTeamRun THREW: ${execError instanceof Error ? execError.message : String(execError)}`,
-				);
+				console.log(`[background-runner] executeTeamRun THREW: ${errorMessage(execError)}`);
 				console.log(`[background-runner] stack: ${execError instanceof Error ? execError.stack : "N/A"}`);
 				throw execError;
 			}
@@ -782,7 +779,7 @@ async function main(): Promise<void> {
 		} catch {
 			/* best-effort */
 		}
-		const message = error instanceof Error ? error.message : String(error);
+		const message = errorMessage(error);
 		manifest = updateRunStatus(manifest, "failed", message);
 		appendEvent(manifest.eventsPath, {
 			type: "async.failed",
@@ -790,7 +787,7 @@ async function main(): Promise<void> {
 			message,
 		});
 		process.exitCode = 1;
-		console.log(`[background-runner] catch block, error=${error instanceof Error ? error.message : String(error)}`);
+		console.log(`[background-runner] catch block, error=${errorMessage(error)}`);
 	} finally {
 		// FIX Issue #4: Use shared runCleanup() function for consistent cleanup
 		// across all exit paths (normal, unhandled rejection, main() exception).
@@ -807,9 +804,7 @@ async function main(): Promise<void> {
 				manifest.eventsPath,
 			);
 		} catch (cleanupError) {
-			console.error(
-				`[background-runner] runCleanup threw: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`,
-			);
+			console.error(`[background-runner] runCleanup threw: ${errorMessage(cleanupError)}`);
 		}
 		// NOTE: If exitDueToRejection was set, runCleanup() already called process.exit(1)
 		// so this finally block never continues past that point.
@@ -828,7 +823,7 @@ async function main(): Promise<void> {
 try {
 	await main();
 } catch (err) {
-	console.error(`[background-runner] DEBUG: main() uncaught: ${err instanceof Error ? err.message : String(err)}`);
+	console.error(`[background-runner] DEBUG: main() uncaught: ${errorMessage(err)}`);
 	// FIX Issue #1: Set the flag so the finally block's runCleanup() call
 	// will trigger process.exit(1) after cleanup completes. Previously this
 	// called process.exit(1) directly, bypassing the finally block and leaving

package/src/runtime/chain-runner.ts

@@ -10,6 +10,7 @@
  * @see docs/pi-boomerang-integration-plan.md
  */
 
+import { errorMessage } from "../utils/guards.ts";
 import type { ChainStep as DSLChainStep } from "./chain-parser.ts";
 import { parseChainDSL } from "./chain-parser.ts";
 import type { HandoffManager, HandoffSummary, TaskPacket, TaskResult } from "./handoff-manager.ts";
@@ -250,14 +251,14 @@ export class ChainRunner {
 					});
 				}
 			} catch (error) {
-				const errorMessage = error instanceof Error ? error.message : String(error);
+				const errMsg = errorMessage(error);
 
 				stepResults.push({
 					step: i + 1,
 					name: step.name,
 					outcome: "failure",
 					duration: Date.now() - stepStart,
-					error: errorMessage,
+					error: errMsg,
 				});
 
 				// Stop chain on failure unless configured to continue

package/src/runtime/heartbeat-watcher.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as path from "node:path";
 import type { NotificationDescriptor } from "../extension/notification-router.ts";
 import type { MetricRegistry } from "../observability/metric-registry.ts";
 import { appendEvent } from "../state/event-log.ts";
@@ -142,6 +143,28 @@ export class HeartbeatWatcher {
 				if (level === "dead" && isProcessAlive) {
 					level = "stale";
 				}
+				// W8 fix: completion-artifact check — prevents false-positive "dead"
+				// during the exit-before-manifest-update race. When a worker process
+				// exits normally after completing its task, the result artifact is
+				// already on disk, but the manifest status update may lag by a few
+				// seconds (status + finishedAt are set atomically in task-runner.ts).
+				// If the result file exists, the task completed — downgrade to
+				// "stale" so the watcher doesn't fire a misleading "dead" notification
+				// for a task that already produced its output.
+				// W8-fix-v2 — path-traversal defense-in-depth. task.id is
+				// generated internally (e.g. "ts1", "ts2") but we still
+				// resolve the candidate path and verify it's strictly
+				// contained within <artifactsRoot>/results/. If task.id
+				// contained "../" or absolute path segments, the containment
+				// check fails and we skip the W8 check (fail-closed: don't
+				// accidentally treat a malicious task ID as "completed").
+				if (level === "dead" && !isProcessAlive && loaded.manifest.artifactsRoot) {
+					const resultsDir = path.resolve(loaded.manifest.artifactsRoot, "results");
+					const candidate = path.resolve(resultsDir, `${task.id}.txt`);
+					if (candidate.startsWith(resultsDir + path.sep) && fs.existsSync(candidate)) {
+						level = "stale";
+					}
+				}
 				this.opts.registry
 					.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds")
 					.set({ runId: run.runId, taskId: task.id }, Number.isFinite(elapsed) ? elapsed : thresholds.deadMs);
@@ -161,12 +184,16 @@ export class HeartbeatWatcher {
 							elapsedMs: Number.isFinite(elapsed) ? elapsed : undefined,
 						},
 					});
+					// W9 fix — prefix title with short run label (first 8 chars of runId)
+					// so ambient notifications are scannable when multiple runs are
+					// in flight. Full runId remains in the notification object.
+					const runLabel = run.runId.slice(0, 8);
 					this.opts.router.enqueue({
 						id: `dead_${run.runId}_${task.id}`,
 						severity: "warning",
 						source: "heartbeat-watcher",
 						runId: run.runId,
-						title: `Task ${task.id} heartbeat dead`,
+						title: `[${runLabel}] Task ${task.id} heartbeat dead`,
 						body: "Background watcher detected a stuck worker.",
 					});
 					this.opts.onDead?.(run.runId, task.id, Number.isFinite(elapsed) ? elapsed : thresholds.deadMs);

package/src/runtime/pipeline-runner.ts

@@ -1,5 +1,6 @@
 import { errors } from "../errors.ts";
 import { appendEventAsync, flushEventLogBuffer } from "../state/event-log.ts";
+import { errorMessage } from "../utils/guards.ts";
 import type { WorkflowConfig } from "../workflows/workflow-config.ts";
 import { mapConcurrent } from "./parallel-utils.ts";
 
@@ -166,26 +167,26 @@ export class PipelineRunner {
 					});
 				} catch (error) {
 					const duration = Date.now() - stageStartTime;
-					const errorMessage = error instanceof Error ? error.message : String(error);
+					const errMsg = errorMessage(error);
 
 					if (effectiveStopOnError) {
 						stages.push({
 							name: stage.name,
 							status: "failed",
 							results: [],
-							error: errorMessage,
+							error: errMsg,
 							duration,
 						});
 
 						await appendEventAsync(eventsPath, {
 							type: "pipeline:stage_failed",
 							runId,
-							message: `Stage '${stage.name}' failed: ${errorMessage}`,
+							message: `Stage '${stage.name}' failed: ${errMsg}`,
 							data: {
 								stageIndex: i,
 								stageName: stage.name,
 								duration,
-								error: errorMessage,
+								error: errMsg,
 							},
 						});
 
@@ -193,7 +194,7 @@ export class PipelineRunner {
 							type: "pipeline:failed",
 							runId,
 							message: `Pipeline '${workflow.name}' failed at stage '${stage.name}'`,
-							data: { failedStage: stage.name, error: errorMessage },
+							data: { failedStage: stage.name, error: errMsg },
 						});
 
 						return {
@@ -207,7 +208,7 @@ export class PipelineRunner {
 							name: stage.name,
 							status: "failed",
 							results: [],
-							error: errorMessage,
+							error: errMsg,
 							duration,
 						});
 
@@ -219,7 +220,7 @@ export class PipelineRunner {
 								stageIndex: i,
 								stageName: stage.name,
 								duration,
-								error: errorMessage,
+								error: errMsg,
 							},
 						});
 					}

package/src/runtime/task-runner.ts

@@ -485,131 +485,177 @@ export async function runTeamTask(input: TaskRunnerInput): Promise<{ manifest: T
 					data: { role: task.role, model: model ?? "default" },
 				});
 				upsertCrewAgent(manifest, recordFromTask(manifest, task, "child-process"));
-				const childResult = await runChildPi({
-					cwd: task.cwd,
-					task: prompt,
-					agent: input.agent,
-					model,
-					signal: input.signal,
-					transcriptPath,
-					maxDepth: input.limits?.maxTaskDepth,
-					skillPaths,
-					maxTurns: input.runtimeConfig?.maxTurns,
-					graceTurns: input.runtimeConfig?.graceTurns,
-					inheritContext: input.runtimeConfig?.inheritContext,
-					parentContext: input.parentContext,
-					excludeContextBash: input.runtimeConfig?.excludeContextBash,
-					sessionId: manifest.sessionId,
-					role: task.role,
-					runId: manifest.runId,
-					agentId: task.id,
-					artifactsRoot: manifest.artifactsRoot,
-					steeringFile: resolveContainedPath(`${manifest.artifactsRoot}/steering`, `${task.id}.jsonl`),
-					onSpawn: (pid) => {
-						try {
-							({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));
-							if (task.pendingSteers?.length) {
-								const steeringDir = `${manifest.artifactsRoot}/steering`;
-								// Fire-and-forget async write for steering events
-								void appendSteeringAsync(steeringDir, task.id, task.pendingSteers);
-								task.pendingSteers = [];
-								tasks = persistSingleTaskUpdate(manifest, tasks, task);
-							}
-						} catch (err) {
-							logInternalError("task-runner.on-spawn", err as Error, `pid=${pid}, taskId=${task.id}`);
-						}
-					},
-					onLifecycleEvent: (event: ChildPiLifecycleEvent) => {
-						void appendEventAsync(manifest.eventsPath, {
-							type: `worker.${event.type}` as const,
-							runId: manifest.runId,
-							taskId: task.id,
-							message: `Worker lifecycle: ${event.type}${event.error ? ` error=${event.error}` : ""}${event.exitCode != null ? ` exit=${event.exitCode}` : ""}`,
-							data: { ...event },
-						}).catch((error) =>
-							logInternalError("task-runner.lifecycle-event", error, `taskId=${task.id}, type=${event.type}`),
-						);
-					},
-					onStdoutLine: (line) => {
-						appendCrewAgentOutput(manifest, task.id, line);
-						persistHeartbeat();
-						// Check for supervisor contact requests from child Pi
-						const contact = parseSupervisorContactFromLine(line);
-						if (contact) {
-							recordSupervisorContact(manifest, {
-								runId: manifest.runId,
-								...contact,
-							});
+				// W2 fix — wall-clock timeout per task. We create our own
+				// AbortController, link the caller's signal to it, and abort
+				// from a timer. The internal signal is passed to runChildPi so
+				// the existing SIGTERM → SIGKILL escalation in child-pi.ts
+				// handles cleanup. Prevents runaway agent loops (e.g. 11_build
+				// in the oh-my-pi distill run that re-verified completed files
+				// 14+ times).
+				const taskTimeoutMs = input.runtimeConfig?.taskTimeoutMs ?? 0;
+				const timeoutController = new AbortController();
+				// W2 fix (memory leak) — store the listener reference so we can
+				// removeEventListener() it in the finally block below. { once: true }
+				// alone is NOT enough: when the timeout fires first, the listener
+				// never fires → { once: true } never auto-removes → listener stays
+				// attached to input.signal for the rest of the run (run-level
+				// signal = long-lived → leak accumulates per task run).
+				let externalAbortListener: (() => void) | undefined;
+				if (input.signal) {
+					if (input.signal.aborted) {
+						timeoutController.abort(input.signal.reason);
+					} else {
+						externalAbortListener = () => timeoutController.abort(input.signal!.reason);
+						input.signal.addEventListener("abort", externalAbortListener, { once: true });
+					}
+				}
+				let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+				if (taskTimeoutMs > 0 && !timeoutController.signal.aborted) {
+					timeoutHandle = setTimeout(() => {
+						if (!timeoutController.signal.aborted) {
+							timeoutController.abort(new Error(`Task exceeded wall-clock timeout of ${taskTimeoutMs}ms`));
 						}
-					},
-					onJsonEvent: (event) => {
-						// Top-level error boundary: prevent any single event from crashing the task.
-						// Errors are logged but processing continues so subsequent events still update state.
-						try {
-							appendCrewAgentEvent(manifest, task.id, event);
-							if (collectedJsonEvents && event && typeof event === "object" && !Array.isArray(event))
-								collectedJsonEvents.push(event as Record<string, unknown>);
-							if (collectedJsonEvents && collectedJsonEvents.length > 1000) {
-								collectedJsonEvents.splice(0, collectedJsonEvents.length - 1000);
-							}
-							// Accumulate lifetime usage via message_end events (survives compaction)
-							if (event && typeof event === "object" && (event as Record<string, unknown>).type === "message_end") {
-								const msg = (event as Record<string, unknown>).message as Record<string, unknown> | undefined;
-								if (msg?.role === "assistant") {
-									const usage = msg.usage as Record<string, number> | undefined;
-									if (usage) {
-										task.lifetimeUsage = {
-											input: (task.lifetimeUsage?.input ?? 0) + (usage.input ?? 0),
-											output: (task.lifetimeUsage?.output ?? 0) + (usage.output ?? 0),
-											cacheWrite: (task.lifetimeUsage?.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
-										};
-									}
+					}, taskTimeoutMs);
+					timeoutHandle.unref?.();
+				}
+				let childResult;
+				try {
+					childResult = await runChildPi({
+						cwd: task.cwd,
+						task: prompt,
+						agent: input.agent,
+						model,
+						signal: timeoutController.signal,
+						transcriptPath,
+						maxDepth: input.limits?.maxTaskDepth,
+						skillPaths,
+						maxTurns: input.runtimeConfig?.maxTurns,
+						graceTurns: input.runtimeConfig?.graceTurns,
+						inheritContext: input.runtimeConfig?.inheritContext,
+						parentContext: input.parentContext,
+						excludeContextBash: input.runtimeConfig?.excludeContextBash,
+						sessionId: manifest.sessionId,
+						role: task.role,
+						runId: manifest.runId,
+						agentId: task.id,
+						artifactsRoot: manifest.artifactsRoot,
+						steeringFile: resolveContainedPath(`${manifest.artifactsRoot}/steering`, `${task.id}.jsonl`),
+						onSpawn: (pid) => {
+							try {
+								({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));
+								if (task.pendingSteers?.length) {
+									const steeringDir = `${manifest.artifactsRoot}/steering`;
+									// Fire-and-forget async write for steering events
+									void appendSteeringAsync(steeringDir, task.id, task.pendingSteers);
+									task.pendingSteers = [];
+									tasks = persistSingleTaskUpdate(manifest, tasks, task);
 								}
+							} catch (err) {
+								logInternalError("task-runner.on-spawn", err as Error, `pid=${pid}, taskId=${task.id}`);
 							}
-							persistHeartbeat();
-							// Bug #3 fix: Write worker JSON events to background.log for debugging when running in background mode.
-							// This supplements the event log so developers can see what the child Pi worker produced.
-							if (process.env.PI_CREW_BACKGROUND_MODE === "1" && event) {
-								const bgLogPath = `${manifest.stateRoot}/background.log`;
-								const eventLine =
-									typeof event === "object" && !Array.isArray(event) ? JSON.stringify(event) : String(event);
-								// Fire-and-forget async write for background log
-								void appendBackgroundLogAsync(bgLogPath, eventLine);
-							}
-							// Always keep in-memory agentProgress fresh (cheap) so the UI/events see
-							// the latest progress, but THROTTLE the disk persist. Previously this
-							// did a full locked read-parse-write of tasks.json on EVERY child JSON
-							// event — a 200-event task produced 200 such cycles (Round 15 P1).
-							// Final state is force-flushed on task completion (persistHeartbeat(true)).
-							const nextProgress = applyAgentProgressEvent(
-								task.agentProgress ?? emptyCrewAgentProgress(),
-								event,
-								task.startedAt,
+						},
+						onLifecycleEvent: (event: ChildPiLifecycleEvent) => {
+							void appendEventAsync(manifest.eventsPath, {
+								type: `worker.${event.type}` as const,
+								runId: manifest.runId,
+								taskId: task.id,
+								message: `Worker lifecycle: ${event.type}${event.error ? ` error=${event.error}` : ""}${event.exitCode != null ? ` exit=${event.exitCode}` : ""}`,
+								data: { ...event },
+							}).catch((error) =>
+								logInternalError("task-runner.lifecycle-event", error, `taskId=${task.id}, type=${event.type}`),
 							);
-							task = { ...task, agentProgress: nextProgress };
-							tasks = updateTask(tasks, task);
-							const progressNow = Date.now();
-							if (progressNow - lastTaskProgressPersistedAt >= 500) {
-								tasks = persistSingleTaskUpdate(manifest, tasks, task);
-								lastTaskProgressPersistedAt = progressNow;
-							}
-							// Bridge event to UI event bus for near-instant updates
-							const bridgeEvent = bridgeEventFromJsonEvent(manifest.runId, task.id, event);
-							if (bridgeEvent) streamBridge?.handler(bridgeEvent);
-							// Feed overflow recovery tracker
-							if (input.onJsonEvent) {
-								input.onJsonEvent(task.id, manifest.runId, event);
+						},
+						onStdoutLine: (line) => {
+							appendCrewAgentOutput(manifest, task.id, line);
+							persistHeartbeat();
+							// Check for supervisor contact requests from child Pi
+							const contact = parseSupervisorContactFromLine(line);
+							if (contact) {
+								recordSupervisorContact(manifest, {
+									runId: manifest.runId,
+									...contact,
+								});
 							}
-							if (!finalCheckpointWritten && isFinalChildEvent(event)) {
-								finalCheckpointWritten = true;
-								({ task, tasks } = checkpointTask(manifest, tasks, task, "child-stdout-final"));
+						},
+						onJsonEvent: (event) => {
+							// Top-level error boundary: prevent any single event from crashing the task.
+							// Errors are logged but processing continues so subsequent events still update state.
+							try {
+								appendCrewAgentEvent(manifest, task.id, event);
+								if (collectedJsonEvents && event && typeof event === "object" && !Array.isArray(event))
+									collectedJsonEvents.push(event as Record<string, unknown>);
+								if (collectedJsonEvents && collectedJsonEvents.length > 1000) {
+									collectedJsonEvents.splice(0, collectedJsonEvents.length - 1000);
+								}
+								// Accumulate lifetime usage via message_end events (survives compaction)
+								if (event && typeof event === "object" && (event as Record<string, unknown>).type === "message_end") {
+									const msg = (event as Record<string, unknown>).message as Record<string, unknown> | undefined;
+									if (msg?.role === "assistant") {
+										const usage = msg.usage as Record<string, number> | undefined;
+										if (usage) {
+											task.lifetimeUsage = {
+												input: (task.lifetimeUsage?.input ?? 0) + (usage.input ?? 0),
+												output: (task.lifetimeUsage?.output ?? 0) + (usage.output ?? 0),
+												cacheWrite: (task.lifetimeUsage?.cacheWrite ?? 0) + (usage.cacheWrite ?? 0),
+											};
+										}
+									}
+								}
+								persistHeartbeat();
+								// Bug #3 fix: Write worker JSON events to background.log for debugging when running in background mode.
+								// This supplements the event log so developers can see what the child Pi worker produced.
+								if (process.env.PI_CREW_BACKGROUND_MODE === "1" && event) {
+									const bgLogPath = `${manifest.stateRoot}/background.log`;
+									const eventLine =
+										typeof event === "object" && !Array.isArray(event) ? JSON.stringify(event) : String(event);
+									// Fire-and-forget async write for background log
+									void appendBackgroundLogAsync(bgLogPath, eventLine);
+								}
+								// Always keep in-memory agentProgress fresh (cheap) so the UI/events see
+								// the latest progress, but THROTTLE the disk persist. Previously this
+								// did a full locked read-parse-write of tasks.json on EVERY child JSON
+								// event — a 200-event task produced 200 such cycles (Round 15 P1).
+								// Final state is force-flushed on task completion (persistHeartbeat(true)).
+								const nextProgress = applyAgentProgressEvent(
+									task.agentProgress ?? emptyCrewAgentProgress(),
+									event,
+									task.startedAt,
+								);
+								task = { ...task, agentProgress: nextProgress };
+								tasks = updateTask(tasks, task);
+								const progressNow = Date.now();
+								if (progressNow - lastTaskProgressPersistedAt >= 500) {
+									tasks = persistSingleTaskUpdate(manifest, tasks, task);
+									lastTaskProgressPersistedAt = progressNow;
+								}
+								// Bridge event to UI event bus for near-instant updates
+								const bridgeEvent = bridgeEventFromJsonEvent(manifest.runId, task.id, event);
+								if (bridgeEvent) streamBridge?.handler(bridgeEvent);
+								// Feed overflow recovery tracker
+								if (input.onJsonEvent) {
+									input.onJsonEvent(task.id, manifest.runId, event);
+								}
+								if (!finalCheckpointWritten && isFinalChildEvent(event)) {
+									finalCheckpointWritten = true;
+									({ task, tasks } = checkpointTask(manifest, tasks, task, "child-stdout-final"));
+								}
+								persistChildProgress(event);
+							} catch (err) {
+								logInternalError("task-runner.on-json-event", err as Error, `taskId=${task.id}`);
 							}
-							persistChildProgress(event);
-						} catch (err) {
-							logInternalError("task-runner.on-json-event", err as Error, `taskId=${task.id}`);
-						}
-					},
-				});
+						},
+					});
+				} finally {
+					if (timeoutHandle) clearTimeout(timeoutHandle);
+					// W2 fix — release the listener so it doesn't leak. {once:true}
+					// only auto-removes when the listener FIRES; if the timeout
+					// fires first, the listener never fires and stays attached
+					// to input.signal (run-level signal = long-lived → leak per
+					// task). Remove explicitly here.
+					if (externalAbortListener && input.signal) {
+						input.signal.removeEventListener("abort", externalAbortListener);
+					}
+				}
 				const evidenceStatus = childResult.exitStatus?.cancelled
 					? "cancelled"
 					: childResult.error || (childResult.exitCode && childResult.exitCode !== 0)

package/src/schema/config-schema.ts

@@ -51,6 +51,7 @@ export const PiTeamsRuntimeConfigSchema = Type.Object(
 		allowChildProcessFallback: Type.Optional(Type.Boolean()),
 		maxTurns: Type.Optional(Type.Integer({ minimum: 1 })),
 		graceTurns: Type.Optional(Type.Integer({ minimum: 1 })),
+		taskTimeoutMs: Type.Optional(Type.Integer({ minimum: 1 })),
 		inheritContext: Type.Optional(Type.Boolean()),
 		promptMode: Type.Optional(Type.Union([Type.Literal("replace"), Type.Literal("append")])),
 		groupJoin: Type.Optional(Type.Union([Type.Literal("off"), Type.Literal("group"), Type.Literal("smart")])),

package/src/ui/live-run-sidebar.ts

@@ -270,10 +270,12 @@ export class LiveRunSidebar {
 			if (isTerminal && !hasActiveAgents && !this.hasAutoClosed) {
 				const autoCloseMs = this.config?.autoCloseDashboardMs ?? 3000;
 				if (autoCloseMs > 0) {
+					if (this.autoCloseTimeout) clearTimeout(this.autoCloseTimeout);
 					this.autoCloseTimeout = setTimeout(() => {
 						this.hasAutoClosed = true;
 						this.done(undefined);
 					}, autoCloseMs);
+					this.autoCloseTimeout?.unref();
 					lines.push(line(`auto-close in ${Math.round(autoCloseMs / 1000)}s…`, w));
 				}
 			}