taskplane 0.29.2 → 0.30.0

package/extensions/taskplane/execution.ts

@@ -2,16 +2,61 @@
  * Lane execution, monitoring, wave execution loop
  * @module orch/execution
  */
-import { readFileSync, existsSync, statSync, unlinkSync, mkdirSync, writeFileSync, copyFileSync } from "fs";
+import {
+	readFileSync,
+	existsSync,
+	statSync,
+	unlinkSync,
+	mkdirSync,
+	writeFileSync,
+	copyFileSync,
+} from "fs";
 import { access as fsAccess, readFile as fsReadFile, stat as fsStat } from "fs/promises";
 import { join, dirname, basename, resolve, relative, delimiter as pathDelimiter } from "path";
 import { userInfo } from "os";
 
-import { DONE_GRACE_MS, EXECUTION_POLL_INTERVAL_MS, ExecutionError, SESSION_SPAWN_RETRY_MAX } from "./types.ts";
-import type { AllocatedLane, AllocatedTask, DependencyGraph, LaneExecutionResult, LaneMonitorSnapshot, LaneTaskOutcome, LaneTaskStatus, MonitorState, MtimeTracker, OrchestratorConfig, ParsedTask, TaskMonitorSnapshot, WaveExecutionResult, WorkspaceConfig, ExecutionUnit, PacketPaths, RuntimeAgentId, RuntimeAgentRole, RuntimeLaneSnapshot, SupervisorAlertCallback } from "./types.ts";
+import {
+	DONE_GRACE_MS,
+	EXECUTION_POLL_INTERVAL_MS,
+	ExecutionError,
+	SESSION_SPAWN_RETRY_MAX,
+} from "./types.ts";
+import type {
+	AllocatedLane,
+	AllocatedTask,
+	DependencyGraph,
+	LaneExecutionResult,
+	LaneMonitorSnapshot,
+	LaneTaskOutcome,
+	LaneTaskStatus,
+	MonitorState,
+	MtimeTracker,
+	OrchestratorConfig,
+	ParsedTask,
+	TaskMonitorSnapshot,
+	WaveExecutionResult,
+	WorkspaceConfig,
+	ExecutionUnit,
+	PacketPaths,
+	RuntimeAgentId,
+	RuntimeAgentRole,
+	RuntimeLaneSnapshot,
+	RuntimeRegistry,
+	SupervisorAlertCallback,
+} from "./types.ts";
 import { resolvePacketPaths, buildRuntimeAgentId } from "./types.ts";
 import type { TaskExitDiagnostic } from "./diagnostics.ts";
-import { readRegistrySnapshot, readLaneSnapshot, isTerminalStatus, isProcessAlive, detectOrphans, markOrphansCrashed, buildRegistrySnapshot, writeRegistrySnapshot, writeLaneSnapshot } from "./process-registry.ts";
+import {
+	readRegistrySnapshot,
+	readLaneSnapshot,
+	isTerminalStatus,
+	isProcessAlive,
+	detectOrphans,
+	markOrphansCrashed,
+	buildRegistrySnapshot,
+	writeRegistrySnapshot,
+	writeLaneSnapshot,
+} from "./process-registry.ts";
 import { allocateLanes } from "./waves.ts";
 import { resolveOperatorId } from "./naming.ts";
 import { runGit, runGitWithEnv } from "./git.ts";
@@ -51,7 +96,15 @@ export function execLog(
 	laneId: string,
 	taskId: string,
 	message: string,
-	extra?: Record<string, string | number | boolean>,
+	// TP-195: widened from `Record<string, string|number|boolean>` to
+	// `Record<string, unknown>` so callers can pass structured values
+	// (string[] arrays, repo objects, etc.) without TS errors. Runtime
+	// stringification via `${v}` is unchanged: primitives render as today,
+	// arrays render with comma separators (existing behavior), objects
+	// render as `[object Object]` (already today's behavior — see
+	// historic execLog calls in engine.ts/resume.ts that have always been
+	// passing structured payloads). No runtime change.
+	extra?: Record<string, unknown>,
 ): void {
 	const prefix = `[orch] ${laneId}/${taskId}`;
 	if (extra) {
@@ -74,7 +127,11 @@ export function execLog(
  * @returns true if agent is alive
  * @since TP-112
  */
-export function isV2AgentAlive(agentIdOrSessionName: string, _runtimeBackend?: RuntimeBackend, laneNumber?: number): boolean {
+export function isV2AgentAlive(
+	agentIdOrSessionName: string,
+	_runtimeBackend?: RuntimeBackend,
+	laneNumber?: number,
+): boolean {
 	// Read the registry from the global state root.
 	// Since this is a pure liveness check, we scan for matching agentId
 	// patterns: direct match, or lane-session + "-worker" suffix.
@@ -85,15 +142,24 @@ export function isV2AgentAlive(agentIdOrSessionName: string, _runtimeBackend?: R
 	if (manifest && !isTerminalStatus(manifest.status) && isProcessAlive(manifest.pid)) return true;
 	// Try worker suffix (monitor uses lane session name, registry uses agentId)
 	const workerManifest = agents[`${agentIdOrSessionName}-worker`];
-	if (workerManifest && !isTerminalStatus(workerManifest.status) && isProcessAlive(workerManifest.pid)) return true;
+	if (
+		workerManifest &&
+		!isTerminalStatus(workerManifest.status) &&
+		isProcessAlive(workerManifest.pid)
+	)
+		return true;
 	// TP-148: In workspace mode, laneSessionId includes repoId and uses a local
 	// lane number (e.g., "orch-henry-api-lane-1") while the V2 registry uses
 	// global lane numbers without repoId (e.g., "orch-henry-lane-3-worker").
 	// Fall back to scanning the registry by global lane number when provided.
 	if (laneNumber != null) {
 		for (const agent of Object.values(agents)) {
-			if (agent.laneNumber === laneNumber && agent.role === "worker" &&
-				!isTerminalStatus(agent.status) && isProcessAlive(agent.pid)) {
+			if (
+				agent.laneNumber === laneNumber &&
+				agent.role === "worker" &&
+				!isTerminalStatus(agent.status) &&
+				isProcessAlive(agent.pid)
+			) {
 				return true;
 			}
 		}
@@ -102,14 +168,14 @@ export function isV2AgentAlive(agentIdOrSessionName: string, _runtimeBackend?: R
 }
 
 /** Cached registry for V2 liveness checks within a monitor cycle. @since TP-112 */
-let _v2LivenessRegistryCache: import("./process-registry.ts").RuntimeRegistry | null = null;
+let _v2LivenessRegistryCache: RuntimeRegistry | null = null;
 
 /**
  * Set the V2 liveness registry cache for the current monitor cycle.
  * Called at the start of each monitor poll to avoid re-reading the file per-task.
  * @since TP-112
  */
-export function setV2LivenessRegistryCache(registry: import("./process-registry.ts").RuntimeRegistry | null): void {
+export function setV2LivenessRegistryCache(registry: RuntimeRegistry | null): void {
 	_v2LivenessRegistryCache = registry;
 }
 
@@ -125,11 +191,11 @@ export function killV2LaneAgents(
 	sessionName: string,
 	options?: { stateRoot?: string; batchId?: string; logContext?: string; laneNumber?: number },
 ): void {
-	const registry = _v2LivenessRegistryCache ?? (
-		options?.stateRoot && options?.batchId
+	const registry =
+		_v2LivenessRegistryCache ??
+		(options?.stateRoot && options?.batchId
 			? readRegistrySnapshot(options.stateRoot, options.batchId)
-			: null
-	);
+			: null);
 	if (!registry) return;
 
 	const agents = registry.agents;
@@ -138,25 +204,38 @@ export function killV2LaneAgents(
 	for (const suffix of ["-worker", "-reviewer", ""]) {
 		const key = `${sessionName}${suffix}`;
 		const manifest = agents[key];
-		if (manifest && !isTerminalStatus(manifest.status) && isProcessAlive(manifest.pid) && !killedPids.has(manifest.pid)) {
+		if (
+			manifest &&
+			!isTerminalStatus(manifest.status) &&
+			isProcessAlive(manifest.pid) &&
+			!killedPids.has(manifest.pid)
+		) {
 			try {
 				process.kill(manifest.pid, "SIGTERM");
 				killedPids.add(manifest.pid);
 				execLog(logContext, key, `killed V2 agent (PID ${manifest.pid})`);
-			} catch { /* already dead */ }
+			} catch {
+				/* already dead */
+			}
 		}
 	}
 	// TP-148: Workspace-mode fallback — match by global lane number when
 	// session name lookup misses (repoId/local-vs-global lane mismatch).
 	if (options?.laneNumber != null) {
 		for (const agent of Object.values(agents)) {
-			if (agent.laneNumber === options.laneNumber &&
-				!isTerminalStatus(agent.status) && isProcessAlive(agent.pid) && !killedPids.has(agent.pid)) {
+			if (
+				agent.laneNumber === options.laneNumber &&
+				!isTerminalStatus(agent.status) &&
+				isProcessAlive(agent.pid) &&
+				!killedPids.has(agent.pid)
+			) {
 				try {
 					process.kill(agent.pid, "SIGTERM");
 					killedPids.add(agent.pid);
 					execLog(logContext, agent.agentId, `killed V2 agent by lane number (PID ${agent.pid})`);
-				} catch { /* already dead */ }
+				} catch {
+					/* already dead */
+				}
 			}
 		}
 	}
@@ -164,7 +243,6 @@ export function killV2LaneAgents(
 
 // ── Async File/Status Helpers (TP-070) ───────────────────────────────
 
-
 /**
  * Async version of readTaskStatusTail — reads STATUS.md tail without
  * blocking the event loop.
@@ -215,10 +293,7 @@ function laneSessionIdOf(lane: Pick<AllocatedLane, "laneSessionId">): string {
  * Logs are written under the lane worktree to keep per-lane execution
  * artifacts colocated with task state and available after failures.
  */
-export function resolveLaneLogPath(
-	lane: AllocatedLane,
-	task: AllocatedTask,
-): string {
+export function resolveLaneLogPath(lane: AllocatedLane, task: AllocatedTask): string {
 	return join(lane.worktreePath, ".pi", "orch-logs", `${laneSessionIdOf(lane)}-${task.taskId}.log`);
 }
 
@@ -227,10 +302,7 @@ export function resolveLaneLogPath(
  *
  * Relative paths avoid Windows drive-letter parsing issues in shell redirection.
  */
-export function resolveLaneLogRelativePath(
-	lane: AllocatedLane,
-	task: AllocatedTask,
-): string {
+export function resolveLaneLogRelativePath(lane: AllocatedLane, task: AllocatedTask): string {
 	return join(".pi", "orch-logs", `${laneSessionIdOf(lane)}-${task.taskId}.log`).replace(/\\/g, "/");
 }
 
@@ -449,7 +521,6 @@ export function resolveTaskDonePath(
 	return resolveCanonicalTaskPaths(taskFolder, worktreePath, repoRoot, isWorkspaceMode).donePath;
 }
 
-
 /*
  * Removed in TP-120 while decommissioning the legacy session backend.
  *
@@ -466,7 +537,11 @@ export async function pollUntilTaskComplete(
 	_pauseSignal: { paused: boolean },
 	_isWorkspaceMode?: boolean,
 ): Promise<{ status: LaneTaskStatus; exitReason: string; doneFileFound: boolean }> {
-	return { status: "failed", exitReason: "Legacy pollUntilTaskComplete removed — use V2 lane-runner", doneFileFound: false };
+	return {
+		status: "failed",
+		exitReason: "Legacy pollUntilTaskComplete removed — use V2 lane-runner",
+		doneFileFound: false,
+	};
 }
 
 // ── Post-Task Commit ─────────────────────────────────────────────────
@@ -485,11 +560,7 @@ export async function pollUntilTaskComplete(
  * @param task   - The task that just completed
  * @param laneId - Lane identifier for logging
  */
-function commitTaskArtifacts(
-	lane: AllocatedLane,
-	task: AllocatedTask,
-	laneId: string,
-): void {
+function commitTaskArtifacts(lane: AllocatedLane, task: AllocatedTask, laneId: string): void {
 	const worktreePath = lane.worktreePath;
 
 	// Check if there are any uncommitted changes in the worktree
@@ -502,7 +573,11 @@ function commitTaskArtifacts(
 	// Stage all changes in the worktree
 	const addResult = runGit(["add", "-A"], worktreePath);
 	if (!addResult.ok) {
-		execLog(laneId, task.taskId, `post-task stage failed (non-fatal): ${addResult.stderr.slice(0, 200)}`);
+		execLog(
+			laneId,
+			task.taskId,
+			`post-task stage failed (non-fatal): ${addResult.stderr.slice(0, 200)}`,
+		);
 		return;
 	}
 
@@ -514,7 +589,11 @@ function commitTaskArtifacts(
 	if (!commitResult.ok) {
 		// "nothing to commit" is not an error — worker may have already committed
 		if (!commitResult.stderr.includes("nothing to commit")) {
-			execLog(laneId, task.taskId, `post-task commit failed (non-fatal): ${commitResult.stderr.slice(0, 200)}`);
+			execLog(
+				laneId,
+				task.taskId,
+				`post-task commit failed (non-fatal): ${commitResult.stderr.slice(0, 200)}`,
+			);
 		}
 		return;
 	}
@@ -524,9 +603,6 @@ function commitTaskArtifacts(
 	});
 }
 
-
-
-
 // ── STATUS.md Parsing for Worktree ───────────────────────────────────
 
 /**
@@ -583,7 +659,10 @@ export function parseWorktreeStatusMd(
 		content = readFileSync(statusPath, "utf-8");
 		mtime = statSync(statusPath).mtimeMs;
 	} catch (err: unknown) {
-		return { parsed: null, error: `Cannot read STATUS.md: ${err instanceof Error ? err.message : String(err)}` };
+		return {
+			parsed: null,
+			error: `Cannot read STATUS.md: ${err instanceof Error ? err.message : String(err)}`,
+		};
 	}
 
 	// Parse using same regex patterns as task-runner's parseStatusMd
@@ -607,7 +686,7 @@ export function parseWorktreeStatusMd(
 		const stepMatch = line.match(/^###\s+Step\s+(\d+):\s*(.+)/);
 		if (stepMatch) {
 			if (currentStep) {
-				const totalChecked = currentStep.checkboxes.filter(c => c).length;
+				const totalChecked = currentStep.checkboxes.filter((c) => c).length;
 				steps.push({
 					number: currentStep.number,
 					name: currentStep.name,
@@ -641,7 +720,7 @@ export function parseWorktreeStatusMd(
 		}
 	}
 	if (currentStep) {
-		const totalChecked = currentStep.checkboxes.filter(c => c).length;
+		const totalChecked = currentStep.checkboxes.filter((c) => c).length;
 		steps.push({
 			number: currentStep.number,
 			name: currentStep.name,
@@ -708,7 +787,10 @@ async function parseStatusMdContent(
 		content = await fsReadFile(statusPath, "utf-8");
 		mtime = (await fsStat(statusPath)).mtimeMs;
 	} catch (err: unknown) {
-		return { parsed: null, error: `Cannot read STATUS.md: ${err instanceof Error ? err.message : String(err)}` };
+		return {
+			parsed: null,
+			error: `Cannot read STATUS.md: ${err instanceof Error ? err.message : String(err)}`,
+		};
 	}
 
 	// Parse logic is identical to the sync version
@@ -732,7 +814,7 @@ async function parseStatusMdContent(
 		const stepMatch = line.match(/^###\s+Step\s+(\d+):\s*(.+)/);
 		if (stepMatch) {
 			if (currentStep) {
-				const totalChecked = currentStep.checkboxes.filter(c => c).length;
+				const totalChecked = currentStep.checkboxes.filter((c) => c).length;
 				steps.push({
 					number: currentStep.number,
 					name: currentStep.name,
@@ -766,7 +848,7 @@ async function parseStatusMdContent(
 		}
 	}
 	if (currentStep) {
-		const totalChecked = currentStep.checkboxes.filter(c => c).length;
+		const totalChecked = currentStep.checkboxes.filter((c) => c).length;
 		steps.push({
 			number: currentStep.number,
 			name: currentStep.name,
@@ -782,7 +864,6 @@ async function parseStatusMdContent(
 	};
 }
 
-
 // ── State Resolution ─────────────────────────────────────────────────
 
 /**
@@ -829,7 +910,7 @@ export async function resolveTaskMonitorState(
 			// Snapshot not written yet OR snapshot still points to a prior task.
 			// Assume alive initially, but if stale for >30s consult the registry
 			// to avoid indefinite false "running" if the lane-runner died.
-			const staleMs = snap?.updatedAt ? (now - snap.updatedAt) : 0;
+			const staleMs = snap?.updatedAt ? now - snap.updatedAt : 0;
 			const trackerAgeMs = now - tracker.firstObservedAt;
 			if (staleMs > 30_000) {
 				// Snapshot hasn't been updated for 30s+ — check registry as fallback.
@@ -875,7 +956,7 @@ export async function resolveTaskMonitorState(
 			const trackerAgeMs = now - tracker.firstObservedAt;
 			if (
 				snap.updatedAt &&
-				(now - snap.updatedAt) > stallTimeoutMs / 2 &&
+				now - snap.updatedAt > stallTimeoutMs / 2 &&
 				trackerAgeMs >= 60_000 &&
 				!isV2AgentAlive(sessionName, runtimeBackend, v2Context?.laneNumber)
 			) {
@@ -918,13 +999,13 @@ export async function resolveTaskMonitorState(
 		}
 
 		// Find the current step (first in-progress, or first not-started after last complete)
-		const inProgress = steps.find(s => s.status === "in-progress");
+		const inProgress = steps.find((s) => s.status === "in-progress");
 		if (inProgress) {
 			currentStepName = inProgress.name;
 			currentStepNumber = inProgress.number;
 		} else {
 			// Find first not-started step
-			const notStarted = steps.find(s => s.status === "not-started");
+			const notStarted = steps.find((s) => s.status === "not-started");
 			if (notStarted) {
 				currentStepName = notStarted.name;
 				currentStepNumber = notStarted.number;
@@ -979,7 +1060,7 @@ export async function resolveTaskMonitorState(
 		sessionAlive &&
 		tracker.statusFileSeenOnce &&
 		tracker.stallTimerStart !== null &&
-		(now - tracker.stallTimerStart) >= stallTimeoutMs
+		now - tracker.stallTimerStart >= stallTimeoutMs
 	) {
 		const stallMinutes = Math.round((now - tracker.stallTimerStart) / 60_000);
 		const stallReason = `STATUS.md unchanged for ${stallMinutes} minutes (threshold: ${Math.round(stallTimeoutMs / 60_000)} min)`;
@@ -1052,7 +1133,6 @@ export async function resolveTaskMonitorState(
 	};
 }
 
-
 // ── Core Monitor Loop ────────────────────────────────────────────────
 
 /**
@@ -1136,10 +1216,15 @@ export async function monitorLanes(
 	// Build the total task count
 	const tasksTotal = lanes.reduce((sum, lane) => sum + lane.tasks.length, 0);
 
-	execLog("monitor", "ALL", `starting monitoring for ${lanes.length} lane(s), ${tasksTotal} task(s)`, {
-		pollIntervalMs,
-		stallTimeoutMin: Math.round(stallTimeoutMs / 60_000),
-	});
+	execLog(
+		"monitor",
+		"ALL",
+		`starting monitoring for ${lanes.length} lane(s), ${tasksTotal} task(s)`,
+		{
+			pollIntervalMs,
+			stallTimeoutMin: Math.round(stallTimeoutMs / 60_000),
+		},
+	);
 
 	while (true) {
 		const now = Date.now();
@@ -1239,17 +1324,23 @@ export async function monitorLanes(
 						stallTimeoutMs,
 						now,
 						runtimeBackend,
-						(runtimeBackend === "v2" && batchId) ? {
-							stateRoot: stateRootForRegistry ?? repoRoot,
-							batchId,
-							laneNumber: lane.laneNumber,
-						} : undefined,
+						runtimeBackend === "v2" && batchId
+							? {
+									stateRoot: stateRootForRegistry ?? repoRoot,
+									batchId,
+									laneNumber: lane.laneNumber,
+								}
+							: undefined,
 					);
 
 					currentTaskSnapshot = snapshot;
 
 					// Check if this task just became terminal
-					if (snapshot.status === "succeeded" || snapshot.status === "failed" || snapshot.status === "stalled") {
+					if (
+						snapshot.status === "succeeded" ||
+						snapshot.status === "failed" ||
+						snapshot.status === "stalled"
+					) {
 						terminalTasks.set(task.taskId, snapshot);
 						if (snapshot.status === "succeeded") {
 							completedTasks.push(task.taskId);
@@ -1322,8 +1413,12 @@ export async function monitorLanes(
 		// Log summary only on state changes (lane completes or fails) — not every poll
 		const currentStateKey = `${totalDone}/${totalFailed}`;
 		if (currentStateKey !== lastMonitorStateKey) {
-			const activeLanes = laneSnapshots.filter(l => l.currentTaskId !== null);
-			execLog("monitor", "ALL", `poll #${pollCount}: ${totalDone}/${tasksTotal} done, ${totalFailed} failed, ${activeLanes.length} active lane(s)`);
+			const activeLanes = laneSnapshots.filter((l) => l.currentTaskId !== null);
+			execLog(
+				"monitor",
+				"ALL",
+				`poll #${pollCount}: ${totalDone}/${tasksTotal} done, ${totalFailed} failed, ${activeLanes.length} active lane(s)`,
+			);
 			lastMonitorStateKey = currentStateKey;
 		}
 
@@ -1340,12 +1435,12 @@ export async function monitorLanes(
 		}
 
 		// Wait for next poll cycle
-		await new Promise(r => setTimeout(r, pollIntervalMs));
+		await new Promise((r) => setTimeout(r, pollIntervalMs));
 	}
 
 	// Reached here due to pause signal — return current state
 	const now = Date.now();
-	const laneSnapshots: LaneMonitorSnapshot[] = lanes.map(lane => ({
+	const laneSnapshots: LaneMonitorSnapshot[] = lanes.map((lane) => ({
 		laneId: lane.laneId,
 		laneNumber: lane.laneNumber,
 		sessionName: laneSessionIdOf(lane),
@@ -1354,7 +1449,7 @@ export async function monitorLanes(
 		currentTaskSnapshot: null,
 		completedTasks: [],
 		failedTasks: [],
-		remainingTasks: lane.tasks.map(t => t.taskId),
+		remainingTasks: lane.tasks.map((t) => t.taskId),
 	}));
 
 	setV2LivenessRegistryCache(null);
@@ -1370,7 +1465,6 @@ export async function monitorLanes(
 	};
 }
 
-
 // ── Transitive Dependent Computation ─────────────────────────────────
 
 /**
@@ -1414,7 +1508,6 @@ export function computeTransitiveDependents(
 	return blocked;
 }
 
-
 // ── Pre-flight: Commit Untracked Task Files ─────────────────────────
 
 /**
@@ -1499,29 +1592,31 @@ export function ensureTaskFilesCommitted(
 
 			try {
 				// Read orch branch tree into temporary index
-				const readTreeRes = runGitWithEnv(
-					["read-tree", orchTip],
-					repoRoot,
-					{ GIT_INDEX_FILE: tmpIdx },
-				);
+				const readTreeRes = runGitWithEnv(["read-tree", orchTip], repoRoot, { GIT_INDEX_FILE: tmpIdx });
 				if (!readTreeRes.ok) {
-					execLog("wave", `W${waveIndex}`, `orch branch staging: read-tree failed, falling back to HEAD commit`, {
-						error: readTreeRes.stderr,
-					});
+					execLog(
+						"wave",
+						`W${waveIndex}`,
+						`orch branch staging: read-tree failed, falling back to HEAD commit`,
+						{
+							error: readTreeRes.stderr,
+						},
+					);
 					// Fall through to legacy path
 				} else {
 					// Add task files to temporary index
 					let addFailed = false;
 					for (const folder of foldersToStage) {
-						const addRes = runGitWithEnv(
-							["add", "--", folder],
-							repoRoot,
-							{ GIT_INDEX_FILE: tmpIdx },
-						);
+						const addRes = runGitWithEnv(["add", "--", folder], repoRoot, { GIT_INDEX_FILE: tmpIdx });
 						if (!addRes.ok) {
-							execLog("wave", `W${waveIndex}`, `orch branch staging: git add failed for ${folder}, falling back`, {
-								error: addRes.stderr,
-							});
+							execLog(
+								"wave",
+								`W${waveIndex}`,
+								`orch branch staging: git add failed for ${folder}, falling back`,
+								{
+									error: addRes.stderr,
+								},
+							);
 							addFailed = true;
 							break;
 						}
@@ -1529,15 +1624,11 @@ export function ensureTaskFilesCommitted(
 
 					if (!addFailed) {
 						// Write tree from temporary index
-						const writeTreeRes = runGitWithEnv(
-							["write-tree"],
-							repoRoot,
-							{ GIT_INDEX_FILE: tmpIdx },
-						);
+						const writeTreeRes = runGitWithEnv(["write-tree"], repoRoot, { GIT_INDEX_FILE: tmpIdx });
 
 						if (writeTreeRes.ok) {
 							const tree = writeTreeRes.stdout.trim();
-							const taskIds = foldersToStage.map(f => f.split("/").pop() || f).join(", ");
+							const taskIds = foldersToStage.map((f) => f.split("/").pop() || f).join(", ");
 							const commitMsg = `chore: stage task files for orchestrator wave ${waveIndex} (${taskIds})`;
 
 							// Create commit directly on orch branch
@@ -1554,14 +1645,23 @@ export function ensureTaskFilesCommitted(
 								);
 
 								if (refUpdateRes.ok) {
-									execLog("wave", `W${waveIndex}`, `committed ${foldersToStage.length} task folder(s) directly on orch branch`, {
-										orchBranch,
-										folders: foldersToStage,
-										from: orchTip.slice(0, 8),
-										to: newCommit.slice(0, 8),
-									});
+									execLog(
+										"wave",
+										`W${waveIndex}`,
+										`committed ${foldersToStage.length} task folder(s) directly on orch branch`,
+										{
+											orchBranch,
+											folders: foldersToStage,
+											from: orchTip.slice(0, 8),
+											to: newCommit.slice(0, 8),
+										},
+									);
 									// Clean up temp index and return — no need for legacy path
-									try { unlinkSync(tmpIdx); } catch { /* best effort */ }
+									try {
+										unlinkSync(tmpIdx);
+									} catch {
+										/* best effort */
+									}
 									return;
 								}
 								execLog("wave", `W${waveIndex}`, `orch branch staging: ref update failed, falling back`, {
@@ -1580,12 +1680,21 @@ export function ensureTaskFilesCommitted(
 					}
 				}
 			} catch (err: unknown) {
-				execLog("wave", `W${waveIndex}`, `orch branch staging: unexpected error, falling back to HEAD commit`, {
-					error: err instanceof Error ? err.message : String(err),
-				});
+				execLog(
+					"wave",
+					`W${waveIndex}`,
+					`orch branch staging: unexpected error, falling back to HEAD commit`,
+					{
+						error: err instanceof Error ? err.message : String(err),
+					},
+				);
 			} finally {
 				// Always clean up temp index
-				try { unlinkSync(tmpIdx); } catch { /* best effort */ }
+				try {
+					unlinkSync(tmpIdx);
+				} catch {
+					/* best effort */
+				}
 			}
 		}
 	}
@@ -1609,7 +1718,7 @@ export function ensureTaskFilesCommitted(
 	}
 
 	// Commit
-	const taskIds = foldersToStage.map(f => f.split("/").pop() || f).join(", ");
+	const taskIds = foldersToStage.map((f) => f.split("/").pop() || f).join(", ");
 	const commitMsg = `chore: stage task files for orchestrator wave ${waveIndex} (${taskIds})`;
 	const commitResult = runGit(["commit", "-m", commitMsg], repoRoot);
 	if (!commitResult.ok) {
@@ -1622,10 +1731,15 @@ export function ensureTaskFilesCommitted(
 		);
 	}
 
-	execLog("wave", `W${waveIndex}`, `committed ${foldersToStage.length} task folder(s) to ensure worktree visibility`, {
-		folders: foldersToStage,
-		commit: commitResult.stdout.trim().split("\n")[0],
-	});
+	execLog(
+		"wave",
+		`W${waveIndex}`,
+		`committed ${foldersToStage.length} task folder(s) to ensure worktree visibility`,
+		{
+			folders: foldersToStage,
+			commit: commitResult.stdout.trim().split("\n")[0],
+		},
+	);
 
 	// Fast-forward (or merge) the orch branch to include the staging commit so
 	// that worktrees—which branch from orchBranch—see the new task files and
@@ -1639,10 +1753,7 @@ export function ensureTaskFilesCommitted(
 				const newHead = headRes.stdout.trim();
 				const orchTip = orchTipRes.stdout.trim();
 
-				const ancestorCheck = runGit(
-					["merge-base", "--is-ancestor", orchTip, newHead],
-					repoRoot,
-				);
+				const ancestorCheck = runGit(["merge-base", "--is-ancestor", orchTip, newHead], repoRoot);
 
 				if (ancestorCheck.ok) {
 					const ffResult = runGit(
@@ -1662,10 +1773,7 @@ export function ensureTaskFilesCommitted(
 						});
 					}
 				} else {
-					const mergeTreeRes = runGit(
-						["merge-tree", "--write-tree", orchTip, newHead],
-						repoRoot,
-					);
+					const mergeTreeRes = runGit(["merge-tree", "--write-tree", orchTip, newHead], repoRoot);
 					if (mergeTreeRes.ok) {
 						const mergedTree = mergeTreeRes.stdout.trim().split("\n")[0];
 						if (/^[0-9a-f]{40}$/i.test(mergedTree)) {
@@ -1692,10 +1800,15 @@ export function ensureTaskFilesCommitted(
 				}
 			}
 		} catch (refErr: unknown) {
-			execLog("wave", `W${waveIndex}`, `warning: orch branch ref update threw unexpectedly (non-fatal)`, {
-				orchBranch,
-				error: refErr instanceof Error ? refErr.message : String(refErr),
-			});
+			execLog(
+				"wave",
+				`W${waveIndex}`,
+				`warning: orch branch ref update threw unexpectedly (non-fatal)`,
+				{
+					orchBranch,
+					error: refErr instanceof Error ? refErr.message : String(refErr),
+				},
+			);
 		}
 	}
 }
@@ -1768,8 +1881,18 @@ export async function executeWave(
 	runtimeBackend?: RuntimeBackend,
 	onSupervisorAlert?: SupervisorAlertCallback,
 	supervisorAutonomy: "interactive" | "supervised" | "autonomous" = "autonomous",
-	reviewerConfig?: { model?: string; thinking?: string; tools?: string; excludeExtensions?: string[] },
-	workerConfig?: { model?: string; thinking?: string; tools?: string; excludeExtensions?: string[] } | null,
+	reviewerConfig?: {
+		model?: string;
+		thinking?: string;
+		tools?: string;
+		excludeExtensions?: string[];
+	},
+	workerConfig?: {
+		model?: string;
+		thinking?: string;
+		tools?: string;
+		excludeExtensions?: string[];
+	} | null,
 	workerExcludeExtensions?: string[],
 	onLaneTerminated?: import("./types.ts").LaneTerminatedCallback,
 	onLaneRespawned?: (laneNumber: number, agentId: string, batchId: string) => void,
@@ -1814,7 +1937,15 @@ export async function executeWave(
 	}
 
 	// ── Stage 1: Allocate lanes ──────────────────────────────────
-	const allocResult = allocateLanes(waveTasks, pending, config, repoRoot, batchId, orchBranch, workspaceConfig);
+	const allocResult = allocateLanes(
+		waveTasks,
+		pending,
+		config,
+		repoRoot,
+		batchId,
+		orchBranch,
+		workspaceConfig,
+	);
 
 	if (!allocResult.success) {
 		const errMsg = allocResult.error?.message || "Unknown allocation failure";
@@ -1859,7 +1990,11 @@ export async function executeWave(
 	const isWsMode = !!workspaceConfig;
 	const backend: RuntimeBackend = "v2";
 	if (runtimeBackend && runtimeBackend !== "v2") {
-		execLog("wave", `W${waveIndex}`, `legacy runtime backend '${runtimeBackend}' requested but ignored; using Runtime V2`);
+		execLog(
+			"wave",
+			`W${waveIndex}`,
+			`legacy runtime backend '${runtimeBackend}' requested but ignored; using Runtime V2`,
+		);
 	}
 	execLog("wave", `W${waveIndex}`, "using Runtime V2 backend (executeLaneV2)");
 
@@ -1870,19 +2005,39 @@ export async function executeWave(
 	const snapshotStateRoot = resolveRuntimeStateRoot(repoRoot, wsRoot);
 	for (const lane of lanes) {
 		try {
-			const snapPath = join(snapshotStateRoot, ".pi", "runtime", batchId, "lanes", `lane-${lane.laneNumber}.json`);
+			const snapPath = join(
+				snapshotStateRoot,
+				".pi",
+				"runtime",
+				batchId,
+				"lanes",
+				`lane-${lane.laneNumber}.json`,
+			);
 			if (existsSync(snapPath)) unlinkSync(snapPath);
-		} catch { /* best effort */ }
+		} catch {
+			/* best effort */
+		}
 	}
 
-	const lanePromises = lanes.map(lane =>
-		executeLaneV2(lane, config, repoRoot, wavePauseSignal, wsRoot, isWsMode, {
-			ORCH_BATCH_ID: batchId,
-			TASKPLANE_SUPERVISOR_AUTONOMY: supervisorAutonomy,
-			...buildWorkerEnv(workerConfig),
-			...buildReviewerEnv(reviewerConfig),
-			...buildWorkerExcludeEnv(workerExcludeExtensions),
-		}, onSupervisorAlert, onLaneTerminated, onLaneRespawned),
+	const lanePromises = lanes.map((lane) =>
+		executeLaneV2(
+			lane,
+			config,
+			repoRoot,
+			wavePauseSignal,
+			wsRoot,
+			isWsMode,
+			{
+				ORCH_BATCH_ID: batchId,
+				TASKPLANE_SUPERVISOR_AUTONOMY: supervisorAutonomy,
+				...buildWorkerEnv(workerConfig),
+				...buildReviewerEnv(reviewerConfig),
+				...buildWorkerExcludeEnv(workerExcludeExtensions),
+			},
+			onSupervisorAlert,
+			onLaneTerminated,
+			onLaneRespawned,
+		),
 	);
 
 	// Start monitoring as a sibling async loop
@@ -1929,7 +2084,7 @@ export async function executeWave(
 			return {
 				laneNumber: lanes[idx].laneNumber,
 				laneId: lanes[idx].laneId,
-				tasks: lanes[idx].tasks.map(t => ({
+				tasks: lanes[idx].tasks.map((t) => ({
 					taskId: t.taskId,
 					status: "failed" as LaneTaskStatus,
 					startTime: null,
@@ -1947,8 +2102,8 @@ export async function executeWave(
 
 		// For stop-wave: if any task failed, set pause to prevent next wave
 		if (policy === "stop-wave") {
-			const hasFailure = laneResults.some(lr =>
-				lr.tasks.some(t => t.status === "failed" || t.status === "stalled"),
+			const hasFailure = laneResults.some((lr) =>
+				lr.tasks.some((t) => t.status === "failed" || t.status === "stalled"),
 			);
 			if (hasFailure) {
 				wavePauseSignal.paused = true;
@@ -1991,21 +2146,24 @@ export async function executeWave(
 	// Compute blocked tasks for future waves (skip-dependents policy)
 	let blockedTaskIds: string[] = [];
 	if (policy === "skip-dependents" && failedTaskIds.length > 0) {
-		const blocked = computeTransitiveDependents(
-			new Set(failedTaskIds),
-			dependencyGraph,
-		);
+		const blocked = computeTransitiveDependents(new Set(failedTaskIds), dependencyGraph);
 		blockedTaskIds = [...blocked].sort();
 		if (blockedTaskIds.length > 0) {
-			execLog("wave", `W${waveIndex}`, `skip-dependents: ${blockedTaskIds.length} task(s) blocked for future waves`, {
-				blocked: blockedTaskIds.join(","),
-			});
+			execLog(
+				"wave",
+				`W${waveIndex}`,
+				`skip-dependents: ${blockedTaskIds.length} task(s) blocked for future waves`,
+				{
+					blocked: blockedTaskIds.join(","),
+				},
+			);
 		}
 	}
 
 	// Determine overall wave status
-	const stoppedEarly = policy === "stop-all" && failedTaskIds.length > 0
-		|| policy === "stop-wave" && failedTaskIds.length > 0;
+	const stoppedEarly =
+		(policy === "stop-all" && failedTaskIds.length > 0) ||
+		(policy === "stop-wave" && failedTaskIds.length > 0);
 
 	let overallStatus: WaveExecutionResult["overallStatus"];
 	if (policy === "stop-all" && failedTaskIds.length > 0) {
@@ -2085,9 +2243,7 @@ export async function executeWithStopAll(
 
 			// Check if any task failed
 			if (!abortTriggered) {
-				const hasFailure = result.tasks.some(
-					t => t.status === "failed" || t.status === "stalled",
-				);
+				const hasFailure = result.tasks.some((t) => t.status === "failed" || t.status === "stalled");
 				if (hasFailure) {
 					// First failure detected — trigger stop-all
 					abortTriggered = true;
@@ -2095,7 +2251,7 @@ export async function executeWithStopAll(
 
 					// Determine which task failed first for logging
 					const firstFailed = result.tasks
-						.filter(t => t.status === "failed" || t.status === "stalled")
+						.filter((t) => t.status === "failed" || t.status === "stalled")
 						.sort((a, b) => {
 							// Sort by startTime, then by taskId for deterministic tie-break
 							const timeA = a.startTime || 0;
@@ -2104,9 +2260,14 @@ export async function executeWithStopAll(
 							return a.taskId.localeCompare(b.taskId);
 						})[0];
 
-					execLog("wave", `W${waveIndex}`, `stop-all triggered by ${firstFailed?.taskId || "unknown"} in ${lanes[idx].laneId}`, {
-						session: laneSessionIdOf(lanes[idx]),
-					});
+					execLog(
+						"wave",
+						`W${waveIndex}`,
+						`stop-all triggered by ${firstFailed?.taskId || "unknown"} in ${lanes[idx].laneId}`,
+						{
+							session: laneSessionIdOf(lanes[idx]),
+						},
+					);
 
 					// Kill ALL lane sessions immediately
 					for (const lane of lanes) {
@@ -2122,7 +2283,11 @@ export async function executeWithStopAll(
 			if (!abortTriggered) {
 				abortTriggered = true;
 				pauseSignal.paused = true;
-				execLog("wave", `W${waveIndex}`, `stop-all triggered by lane error in ${lanes[idx].laneId}: ${errMsg}`);
+				execLog(
+					"wave",
+					`W${waveIndex}`,
+					`stop-all triggered by lane error in ${lanes[idx].laneId}: ${errMsg}`,
+				);
 				for (const lane of lanes) {
 					killV2LaneAgents(laneSessionIdOf(lane), { laneNumber: lane.laneNumber });
 				}
@@ -2132,7 +2297,7 @@ export async function executeWithStopAll(
 			const failedResult: LaneExecutionResult = {
 				laneNumber: lanes[idx].laneNumber,
 				laneId: lanes[idx].laneId,
-				tasks: lanes[idx].tasks.map(t => ({
+				tasks: lanes[idx].tasks.map((t) => ({
 					taskId: t.taskId,
 					status: "failed" as LaneTaskStatus,
 					startTime: null,
@@ -2155,14 +2320,17 @@ export async function executeWithStopAll(
 	await Promise.allSettled(wrappedPromises);
 
 	// Fill in any null results (shouldn't happen, but defensive)
-	return results.map((r, idx) => r || {
-		laneNumber: lanes[idx].laneNumber,
-		laneId: lanes[idx].laneId,
-		tasks: [],
-		overallStatus: "failed" as const,
-		startTime: Date.now(),
-		endTime: Date.now(),
-	});
+	return results.map(
+		(r, idx) =>
+			r || {
+				laneNumber: lanes[idx].laneNumber,
+				laneId: lanes[idx].laneId,
+				tasks: [],
+				overallStatus: "failed" as const,
+				startTime: Date.now(),
+				endTime: Date.now(),
+			},
+	);
 }
 
 // ── Runtime V2 Bridge Helpers (TP-102) ─────────────────────────────────────
@@ -2223,8 +2391,8 @@ export function buildExecutionUnit(
 		throw new ExecutionError(
 			"EXEC_MISSING_TASK_FOLDER",
 			`Cannot build execution unit for task ${task.taskId}: taskFolder is ${taskFolder === "" ? "empty" : "undefined"}. ` +
-			`This typically means the task's persisted record was not enriched with discovery data. ` +
-			`Re-run discovery or check that the task exists in the task area.`,
+				`This typically means the task's persisted record was not enriched with discovery data. ` +
+				`Re-run discovery or check that the task exists in the task area.`,
 			"execution",
 			task.taskId,
 		);
@@ -2248,18 +2416,17 @@ export function buildExecutionUnit(
 	// the execution repo (cross-repo segment). When they're the same repo,
 	// resolve packet paths inside the worktree so .DONE, STATUS.md etc. are
 	// written to the worktree (not the original repo outside the worktree).
-	const useAbsolutePacketPath = task.task.packetTaskPath
-		&& packetHomeRepoId !== executionRepoId;
+	const useAbsolutePacketPath = task.task.packetTaskPath && packetHomeRepoId !== executionRepoId;
 
 	const packet = useAbsolutePacketPath
 		? resolvePacketPaths(task.task.packetTaskPath!)
 		: {
-			promptPath: resolved.taskFolderResolved + "/PROMPT.md",
-			statusPath: resolved.statusPath,
-			donePath: resolved.donePath,
-			reviewsDir: resolved.taskFolderResolved + "/.reviews",
-			taskFolder: resolved.taskFolderResolved,
-		};
+				promptPath: resolved.taskFolderResolved + "/PROMPT.md",
+				statusPath: resolved.statusPath,
+				donePath: resolved.donePath,
+				reviewsDir: resolved.taskFolderResolved + "/.reviews",
+				taskFolder: resolved.taskFolderResolved,
+			};
 
 	return {
 		id,
@@ -2339,7 +2506,9 @@ function parseAgentFile(filePath: string): { fm: Record<string, string>; body: s
 			if (m) fm[m[1]] = m[2].trim();
 		}
 		return { fm, body: raw.slice(fmEnd + 3).trim() };
-	} catch { return null; }
+	} catch {
+		return null;
+	}
 }
 
 /**
@@ -2357,7 +2526,9 @@ function loadBaseAgentPrompt(agentName: string): string {
 			const def = parseAgentFile(resolved);
 			if (def?.body) return def.body;
 		}
-	} catch { /* fall through */ }
+	} catch {
+		/* fall through */
+	}
 	return "";
 }
 
@@ -2433,11 +2604,11 @@ function resolveAgentPointerRoot(): string | null {
  * @returns Composed agent definition, or null if no base and no local file found
  * @since TP-161
  */
-export function loadAgentDef(cwd: string, name: string): { systemPrompt: string; tools: string; model: string } | null {
-	const localPaths = [
-		join(cwd, ".pi", "agents", `${name}.md`),
-		join(cwd, "agents", `${name}.md`),
-	];
+export function loadAgentDef(
+	cwd: string,
+	name: string,
+): { systemPrompt: string; tools: string; model: string } | null {
+	const localPaths = [join(cwd, ".pi", "agents", `${name}.md`), join(cwd, "agents", `${name}.md`)];
 
 	// In workspace mode, add pointer-resolved agent root as fallback
 	const agentRoot = resolveAgentPointerRoot();
@@ -2452,7 +2623,9 @@ export function loadAgentDef(cwd: string, name: string): { systemPrompt: string;
 		if (existsSync(basePath)) {
 			baseDef = parseAgentFile(basePath);
 		}
-	} catch { /* fall through */ }
+	} catch {
+		/* fall through */
+	}
 
 	// Load local override (first found wins)
 	let localDef: { fm: Record<string, string>; body: string } | null = null;
@@ -2487,10 +2660,7 @@ export function loadAgentDef(cwd: string, name: string): { systemPrompt: string;
 	return { systemPrompt: composedPrompt.trim(), tools, model };
 }
 
-export function resolveRuntimeStateRoot(
-	repoRoot: string,
-	workspaceRoot?: string,
-): string {
+export function resolveRuntimeStateRoot(repoRoot: string, workspaceRoot?: string): string {
 	return workspaceRoot ?? repoRoot;
 }
 
@@ -2532,13 +2702,21 @@ function parseJsonArrayEnv(value?: string): string[] {
 	if (!value) return [];
 	try {
 		const parsed = JSON.parse(value);
-		if (Array.isArray(parsed)) return parsed.filter((v: unknown): v is string => typeof v === "string");
-	} catch { /* ignore malformed */ }
+		if (Array.isArray(parsed))
+			return parsed.filter((v: unknown): v is string => typeof v === "string");
+	} catch {
+		/* ignore malformed */
+	}
 	return [];
 }
 
 export function buildReviewerEnv(
-	reviewerConfig?: { model?: string; thinking?: string; tools?: string; excludeExtensions?: string[] } | null,
+	reviewerConfig?: {
+		model?: string;
+		thinking?: string;
+		tools?: string;
+		excludeExtensions?: string[];
+	} | null,
 ): Record<string, string> {
 	const env: Record<string, string> = {};
 	if (reviewerConfig?.model) env.TASKPLANE_REVIEWER_MODEL = reviewerConfig.model;
@@ -2560,7 +2738,12 @@ export function buildReviewerEnv(
  * @since TP-181
  */
 export function buildWorkerEnv(
-	workerConfig?: { model?: string; thinking?: string; tools?: string; excludeExtensions?: string[] } | null,
+	workerConfig?: {
+		model?: string;
+		thinking?: string;
+		tools?: string;
+		excludeExtensions?: string[];
+	} | null,
 ): Record<string, string> {
 	const env: Record<string, string> = {};
 	if (workerConfig?.model) env.TASKPLANE_WORKER_MODEL = workerConfig.model;
@@ -2620,7 +2803,8 @@ export async function executeLaneV2(
 	// The base template (templates/agents/task-worker.md) contains critical behavioral
 	// rules: checkpoint discipline, STATUS.md resume algorithm, review_step instructions.
 	// The local file (.pi/agents/task-worker.md) adds project-specific guidance.
-	let workerSystemPrompt = "You are a task execution agent. Read STATUS.md first, find unchecked items, work on them, checkpoint after each.";
+	let workerSystemPrompt =
+		"You are a task execution agent. Read STATUS.md first, find unchecked items, work on them, checkpoint after each.";
 	let workerSegmentPrompt = "";
 	try {
 		const basePrompt = loadBaseAgentPrompt("task-worker");
@@ -2635,7 +2819,9 @@ export async function executeLaneV2(
 		// Load segment-scoped prompt overlay (appended when isSegmentScoped)
 		const segPrompt = loadBaseAgentPrompt("task-worker-segment");
 		if (segPrompt) workerSegmentPrompt = segPrompt;
-	} catch { /* use default */ }
+	} catch {
+		/* use default */
+	}
 
 	execLog(laneId, "LANE", `starting Runtime V2 execution of ${lane.tasks.length} task(s)`, {
 		worktree: lane.worktreePath,
@@ -2647,16 +2833,26 @@ export async function executeLaneV2(
 	// this lane number is lifted before new alerts begin to flow.
 	if (onLaneRespawned) {
 		try {
-			onLaneRespawned(lane.laneNumber, buildRuntimeAgentId(agentIdPrefix, lane.laneNumber, "worker"), batchId);
+			onLaneRespawned(
+				lane.laneNumber,
+				buildRuntimeAgentId(agentIdPrefix, lane.laneNumber, "worker"),
+				batchId,
+			);
 		} catch (err) {
-			execLog(laneId, "LANE", `lane-respawned callback failed: ${err instanceof Error ? err.message : String(err)}`);
+			execLog(
+				laneId,
+				"LANE",
+				`lane-respawned callback failed: ${err instanceof Error ? err.message : String(err)}`,
+			);
 		}
 	}
 
 	for (const task of lane.tasks) {
 		const taskSegmentId = task.task.activeSegmentId ?? null;
 		if (shouldSkipRemaining || pauseSignal.paused) {
-			const reason = pauseSignal.paused ? "Skipped due to pause signal" : "Skipped due to prior task failure in lane";
+			const reason = pauseSignal.paused
+				? "Skipped due to pause signal"
+				: "Skipped due to prior task failure in lane";
 			outcomes.push({
 				taskId: task.taskId,
 				status: "skipped",
@@ -2674,10 +2870,12 @@ export async function executeLaneV2(
 		// Build execution unit
 		const unit = buildExecutionUnit(lane, task, repoRoot, isWorkspaceMode);
 
-		const rawAutonomy = String(extraEnvVars?.TASKPLANE_SUPERVISOR_AUTONOMY ?? "autonomous").toLowerCase();
+		const rawAutonomy = String(
+			extraEnvVars?.TASKPLANE_SUPERVISOR_AUTONOMY ?? "autonomous",
+		).toLowerCase();
 		const supervisorAutonomy: LaneRunnerConfig["supervisorAutonomy"] =
-			(rawAutonomy === "interactive" || rawAutonomy === "supervised" || rawAutonomy === "autonomous")
-				? rawAutonomy as LaneRunnerConfig["supervisorAutonomy"]
+			rawAutonomy === "interactive" || rawAutonomy === "supervised" || rawAutonomy === "autonomous"
+				? (rawAutonomy as LaneRunnerConfig["supervisorAutonomy"])
 				: "autonomous";
 
 		const laneRunnerConfig: LaneRunnerConfig = {
@@ -2701,12 +2899,26 @@ export async function executeLaneV2(
 			reviewerTools: extraEnvVars?.TASKPLANE_REVIEWER_TOOLS || "",
 			// TP-180: Extension exclusion lists from config
 			workerExcludeExtensions: parseJsonArrayEnv(extraEnvVars?.TASKPLANE_WORKER_EXCLUDE_EXTENSIONS),
-			reviewerExcludeExtensions: parseJsonArrayEnv(extraEnvVars?.TASKPLANE_REVIEWER_EXCLUDE_EXTENSIONS),
+			reviewerExcludeExtensions: parseJsonArrayEnv(
+				extraEnvVars?.TASKPLANE_REVIEWER_EXCLUDE_EXTENSIONS,
+			),
 			supervisorAutonomy,
-			projectName: config.project?.name || "project",
+			// TP-195: replaced `config.project?.name` (no `project` field on
+			// `OrchestratorConfig`; always undefined) with the env-var read
+			// already used elsewhere in the codebase (lane-runner.ts:668 sets
+			// `TASKPLANE_PROJECT_NAME` from the same source). When the env
+			// var is unset, falls through to the same `"project"` literal as
+			// before — behavior-neutral.
+			projectName: extraEnvVars?.TASKPLANE_PROJECT_NAME || "project",
 			maxIterations: 20,
 			noProgressLimit: 3,
-			maxWorkerMinutes: config.failure?.maxWorkerMinutes || 120,
+			// TP-195: read the canonical `max_worker_minutes` field (snake_case
+			// per `OrchestratorConfig.failure` in types.ts). The previous code
+			// read a non-existent `maxWorkerMinutes` camelCase alias — always
+			// undefined — silently ignoring any operator-set value. Honoring
+			// the config is the intended behavior; default of 120 preserved
+			// when the field is unset.
+			maxWorkerMinutes: config.failure?.max_worker_minutes || 120,
 			warnPercent: 85,
 			killPercent: 95,
 			onSupervisorAlert,
@@ -2811,13 +3023,22 @@ export async function executeLaneV2(
 					progress: null,
 					updatedAt: Date.now(),
 				};
-				writeLaneSnapshot(stateRoot, batchId, lane.laneNumber, spawnFailureSnapshot as unknown as Record<string, unknown>);
+				writeLaneSnapshot(
+					stateRoot,
+					batchId,
+					lane.laneNumber,
+					spawnFailureSnapshot as unknown as Record<string, unknown>,
+				);
 			} catch (snapErr) {
 				// Best effort — if the snapshot write fails, the monitor's
 				// 30s-staleness fallback (snap with old updatedAt) eventually
 				// kicks in via the registry liveness check. Log so this is
 				// visible in operator diagnostics, but do NOT throw.
-				execLog(laneId, task.taskId, `spawn-failure snapshot write failed (non-fatal): ${snapErr instanceof Error ? snapErr.message : String(snapErr)}`);
+				execLog(
+					laneId,
+					task.taskId,
+					`spawn-failure snapshot write failed (non-fatal): ${snapErr instanceof Error ? snapErr.message : String(snapErr)}`,
+				);
 			}
 
 			shouldSkipRemaining = true;
@@ -2825,8 +3046,8 @@ export async function executeLaneV2(
 	}
 
 	const endTime = Date.now();
-	const succeeded = outcomes.every(o => o.status === "succeeded");
-	const failed = outcomes.some(o => o.status === "failed" || o.status === "stalled");
+	const succeeded = outcomes.every((o) => o.status === "succeeded");
+	const failed = outcomes.some((o) => o.status === "failed" || o.status === "stalled");
 
 	return {
 		laneNumber: lane.laneNumber,
@@ -2839,4 +3060,3 @@ export async function executeLaneV2(
 }
 
 // ── /orch Command — Full Execution (Step 5) ─────────────────────────
-