taskplane 0.22.18 → 0.23.0

package/extensions/taskplane/process-registry.ts

@@ -0,0 +1,345 @@
+/**
+ * Process Registry — Runtime V2 agent lifecycle management
+ *
+ * File-backed registry that replaces TMUX session discovery as the
+ * authoritative source of truth for agent liveness, identity, and
+ * attribution.
+ *
+ * Key design rules:
+ *   1. Parent writes manifest BEFORE child is considered visible.
+ *   2. Parent updates manifest on every status transition.
+ *   3. Operator tools read the registry, not TMUX.
+ *   4. Resume/cleanup validates pid + startedAt for orphan detection.
+ *
+ * File locations:
+ *   .pi/runtime/{batchId}/registry.json       — batch-level snapshot
+ *   .pi/runtime/{batchId}/agents/{agentId}/manifest.json — per-agent
+ *
+ * @module taskplane/process-registry
+ * @since TP-104
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, rmSync, appendFileSync, renameSync } from "fs";
+import { join, dirname } from "path";
+
+import {
+	TERMINAL_AGENT_STATUSES,
+	runtimeRoot,
+	runtimeAgentDir,
+	runtimeManifestPath,
+	runtimeRegistryPath,
+	runtimeAgentEventsPath,
+	runtimeLaneSnapshotPath,
+	validateAgentManifest,
+	type RuntimeAgentId,
+	type RuntimeAgentManifest,
+	type RuntimeAgentRole,
+	type RuntimeAgentStatus,
+	type RuntimeRegistry,
+	type PacketPaths,
+} from "./types.ts";
+
+// ── Manifest Lifecycle ───────────────────────────────────────────────
+
+/**
+ * Write or update an agent manifest atomically.
+ *
+ * Uses write-to-temp + rename for crash safety. Creates parent
+ * directories if they don't exist.
+ *
+ * @since TP-104
+ */
+export function writeManifest(stateRoot: string, manifest: RuntimeAgentManifest): void {
+	const dir = runtimeAgentDir(stateRoot, manifest.batchId, manifest.agentId);
+	mkdirSync(dir, { recursive: true });
+	const path = runtimeManifestPath(stateRoot, manifest.batchId, manifest.agentId);
+	const tmpPath = path + ".tmp";
+	writeFileSync(tmpPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+	// Atomic rename (same directory = safe on all platforms)
+	renameSync(tmpPath, path);
+}
+
+/**
+ * Read an agent manifest. Returns null if not found or malformed.
+ *
+ * @since TP-104
+ */
+export function readManifest(stateRoot: string, batchId: string, agentId: RuntimeAgentId): RuntimeAgentManifest | null {
+	const path = runtimeManifestPath(stateRoot, batchId, agentId);
+	if (!existsSync(path)) return null;
+	try {
+		const raw = readFileSync(path, "utf-8");
+		const parsed = JSON.parse(raw);
+		const errors = validateAgentManifest(parsed);
+		if (errors.length > 0) {
+			console.error(`[process-registry] invalid manifest ${agentId}: ${errors.join(", ")}`);
+			return null;
+		}
+		return parsed as RuntimeAgentManifest;
+	} catch (err: any) {
+		console.error(`[process-registry] failed to read manifest ${agentId}: ${err?.message}`);
+		return null;
+	}
+}
+
+/**
+ * Update an agent's status in its manifest.
+ *
+ * Reads the current manifest, updates the status field, and writes
+ * it back atomically. No-op if manifest doesn't exist.
+ *
+ * @since TP-104
+ */
+export function updateManifestStatus(
+	stateRoot: string,
+	batchId: string,
+	agentId: RuntimeAgentId,
+	status: RuntimeAgentStatus,
+): void {
+	const manifest = readManifest(stateRoot, batchId, agentId);
+	if (!manifest) return;
+	manifest.status = status;
+	writeManifest(stateRoot, manifest);
+}
+
+/**
+ * Create a fresh RuntimeAgentManifest with required fields.
+ *
+ * @since TP-104
+ */
+export function createManifest(opts: {
+	batchId: string;
+	agentId: RuntimeAgentId;
+	role: RuntimeAgentRole;
+	laneNumber: number | null;
+	taskId: string | null;
+	repoId: string;
+	pid: number;
+	parentPid: number;
+	cwd: string;
+	packet: PacketPaths | null;
+}): RuntimeAgentManifest {
+	return {
+		batchId: opts.batchId,
+		agentId: opts.agentId,
+		role: opts.role,
+		laneNumber: opts.laneNumber,
+		taskId: opts.taskId,
+		repoId: opts.repoId,
+		pid: opts.pid,
+		parentPid: opts.parentPid,
+		startedAt: Date.now(),
+		status: "spawning",
+		cwd: opts.cwd,
+		packet: opts.packet,
+	};
+}
+
+// ── Registry Snapshot ────────────────────────────────────────────────
+
+/**
+ * Build a registry snapshot from all agent manifests in a batch.
+ *
+ * Scans the agents/ directory under the runtime root and reads all
+ * valid manifests.
+ *
+ * @since TP-104
+ */
+export function buildRegistrySnapshot(stateRoot: string, batchId: string): RuntimeRegistry {
+	const agentsDir = join(runtimeRoot(stateRoot, batchId), "agents");
+	const agents: Record<RuntimeAgentId, RuntimeAgentManifest> = {};
+
+	if (existsSync(agentsDir)) {
+		try {
+			const entries = readdirSync(agentsDir, { withFileTypes: true });
+			for (const entry of entries) {
+				if (!entry.isDirectory()) continue;
+				const agentId = entry.name;
+				const manifest = readManifest(stateRoot, batchId, agentId);
+				if (manifest) {
+					agents[agentId] = manifest;
+				}
+			}
+		} catch (err: any) {
+			console.error(`[process-registry] failed to scan agents dir: ${err?.message}`);
+		}
+	}
+
+	return {
+		batchId,
+		updatedAt: Date.now(),
+		agents,
+	};
+}
+
+/**
+ * Write the registry snapshot to disk.
+ *
+ * @since TP-104
+ */
+export function writeRegistrySnapshot(stateRoot: string, registry: RuntimeRegistry): void {
+	const path = runtimeRegistryPath(stateRoot, registry.batchId);
+	mkdirSync(dirname(path), { recursive: true });
+	const tmpPath = path + ".tmp";
+	writeFileSync(tmpPath, JSON.stringify(registry, null, 2) + "\n", "utf-8");
+	renameSync(tmpPath, path);
+}
+
+/**
+ * Read the registry snapshot from disk. Returns null if not found.
+ *
+ * @since TP-104
+ */
+export function readRegistrySnapshot(stateRoot: string, batchId: string): RuntimeRegistry | null {
+	const path = runtimeRegistryPath(stateRoot, batchId);
+	if (!existsSync(path)) return null;
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+
+// ── Liveness Checks ──────────────────────────────────────────────────
+
+/**
+ * Check whether a process with the given PID is still alive.
+ *
+ * Uses `process.kill(pid, 0)` which sends no signal but checks existence.
+ * Returns false for PID 0, negative PIDs, and dead processes.
+ *
+ * @since TP-104
+ */
+export function isProcessAlive(pid: number): boolean {
+	if (!pid || pid <= 0 || !Number.isFinite(pid)) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Determine if an agent is in a terminal (non-alive) state.
+ *
+ * @since TP-104
+ */
+export function isTerminalStatus(status: RuntimeAgentStatus): boolean {
+	return TERMINAL_AGENT_STATUSES.has(status);
+}
+
+/**
+ * Get all live (non-terminal) agents from a registry snapshot.
+ *
+ * @since TP-104
+ */
+export function getLiveAgents(registry: RuntimeRegistry): RuntimeAgentManifest[] {
+	return Object.values(registry.agents).filter(m => !isTerminalStatus(m.status));
+}
+
+/**
+ * Get all agents matching a specific role from a registry snapshot.
+ *
+ * @since TP-104
+ */
+export function getAgentsByRole(registry: RuntimeRegistry, role: RuntimeAgentRole): RuntimeAgentManifest[] {
+	return Object.values(registry.agents).filter(m => m.role === role);
+}
+
+// ── Orphan Detection ─────────────────────────────────────────────────
+
+/**
+ * Detect orphaned agents — manifests that claim to be running but whose
+ * process is no longer alive.
+ *
+ * Returns agent IDs of orphans. Caller decides whether to terminate,
+ * update manifest status, or log.
+ *
+ * @since TP-104
+ */
+export function detectOrphans(registry: RuntimeRegistry): RuntimeAgentId[] {
+	const orphans: RuntimeAgentId[] = [];
+	for (const manifest of Object.values(registry.agents)) {
+		if (isTerminalStatus(manifest.status)) continue;
+		if (!isProcessAlive(manifest.pid)) {
+			orphans.push(manifest.agentId);
+		}
+	}
+	return orphans;
+}
+
+/**
+ * Mark detected orphans as crashed in their manifests.
+ *
+ * @since TP-104
+ */
+export function markOrphansCrashed(stateRoot: string, batchId: string, orphanIds: RuntimeAgentId[]): void {
+	for (const agentId of orphanIds) {
+		updateManifestStatus(stateRoot, batchId, agentId, "crashed");
+	}
+}
+
+// ── Cleanup ──────────────────────────────────────────────────────────
+
+/**
+ * Remove all runtime artifacts for a batch.
+ *
+ * Best-effort: logs errors but doesn't throw.
+ *
+ * @since TP-104
+ */
+export function cleanupBatchRuntime(stateRoot: string, batchId: string): { removed: boolean; error?: string } {
+	const root = runtimeRoot(stateRoot, batchId);
+	if (!existsSync(root)) return { removed: false };
+	try {
+		rmSync(root, { recursive: true, force: true });
+		return { removed: true };
+	} catch (err: any) {
+		console.error(`[process-registry] failed to cleanup batch runtime: ${err?.message}`);
+		return { removed: false, error: err?.message };
+	}
+}
+
+// ── Normalized Event Helpers ─────────────────────────────────────────
+
+/**
+ * Append a normalized event to an agent's event log.
+ *
+ * Creates the events file and parent directories if they don't exist.
+ * Best-effort: logs errors but doesn't throw.
+ *
+ * @since TP-104
+ */
+export function appendAgentEvent(
+	stateRoot: string,
+	batchId: string,
+	agentId: RuntimeAgentId,
+	event: Record<string, unknown>,
+): void {
+	const path = runtimeAgentEventsPath(stateRoot, batchId, agentId);
+	mkdirSync(dirname(path), { recursive: true });
+	try {
+		appendFileSync(path, JSON.stringify(event) + "\n", "utf-8");
+	} catch (err: any) {
+		console.error(`[process-registry] failed to append event for ${agentId}: ${err?.message}`);
+	}
+}
+
+/**
+ * Write a lane snapshot to disk.
+ *
+ * @since TP-104
+ */
+export function writeLaneSnapshot(
+	stateRoot: string,
+	batchId: string,
+	laneNumber: number,
+	snapshot: Record<string, unknown>,
+): void {
+	const path = runtimeLaneSnapshotPath(stateRoot, batchId, laneNumber);
+	mkdirSync(dirname(path), { recursive: true });
+	const tmpPath = path + ".tmp";
+	writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+	renameSync(tmpPath, path);
+}

package/extensions/taskplane/resume.ts

@@ -8,8 +8,30 @@ import { join } from "path";
 import { assembleDiagnosticInput, emitDiagnosticReports } from "./diagnostic-reports.ts";
 import { runDiscovery } from "./discovery.ts";
 import { executeOrchBatch } from "./engine.ts";
-import { computeTransitiveDependents, execLog, executeWave, pollUntilTaskComplete, spawnLaneSession, tmuxHasSession } from "./execution.ts";
-import type { MonitorUpdateCallback } from "./execution.ts";
+import { computeTransitiveDependents, execLog, executeLaneV2, executeWave, pollUntilTaskComplete, resolveCanonicalTaskPaths, spawnLaneSession, tmuxHasSession } from "./execution.ts";
+import type { MonitorUpdateCallback, RuntimeBackend } from "./execution.ts";
+import { selectRuntimeBackend } from "./engine.ts";
+import { readRegistrySnapshot, isTerminalStatus, isProcessAlive } from "./process-registry.ts";
+
+/**
+ * TP-112: Terminate any alive V2 agents for a lane before re-execution.
+ * Per Runtime V2 spec §7.3: detect + terminate + rehydrate.
+ * Prevents duplicate concurrent agents for the same lane/task on resume.
+ */
+function terminateAliveV2Agents(stateRoot: string, batchId: string, sessionName: string): void {
+	const registry = readRegistrySnapshot(stateRoot, batchId);
+	if (!registry) return;
+	for (const suffix of ["-worker", "-reviewer", ""]) {
+		const key = `${sessionName}${suffix}`;
+		const manifest = registry.agents[key];
+		if (manifest && !isTerminalStatus(manifest.status) && isProcessAlive(manifest.pid)) {
+			try {
+				process.kill(manifest.pid, "SIGTERM");
+				execLog("resume", key, `terminated alive V2 agent (PID ${manifest.pid}) before re-execute`);
+			} catch { /* already dead */ }
+		}
+	}
+}
 import { getCurrentBranch, runGit } from "./git.ts";
 import { mergeWaveByRepo } from "./merge.ts";
 import { applyMergeRetryLoop, computeCleanupGatePolicy, computeMergeFailurePolicy, formatRepoMergeSummary, ORCH_MESSAGES } from "./messages.ts";
@@ -851,20 +873,64 @@ export async function resumeOrchBatch(
 		"info",
 	);
 
+	// TP-108/112: Runtime V2 backend selection for resumed batches.
+	// MUST be computed before any backend-aware branch (section 3+).
+	const resumeBackend: RuntimeBackend = selectRuntimeBackend(
+		"all",
+		persistedState.wavePlan,
+		workspaceConfig,
+	).backend;
+	execLog("resume", batchState.batchId, `runtime backend for resumed execution: ${resumeBackend}`);
+
 	// ── 3. Discover live signals ─────────────────────────────────
-	// Check TMUX sessions
+	// TP-112: Backend-aware session liveness check.
+	// V2: check process registry (pid + status). Legacy: check TMUX.
 	const aliveSessions = new Set<string>();
-	for (const task of persistedState.tasks) {
-		if (task.sessionName && tmuxHasSession(task.sessionName)) {
-			aliveSessions.add(task.sessionName);
+	if (resumeBackend === "v2") {
+		const registry = readRegistrySnapshot(stateRoot, persistedState.batchId);
+		if (registry) {
+			for (const manifest of Object.values(registry.agents)) {
+				if (!isTerminalStatus(manifest.status) && isProcessAlive(manifest.pid)) {
+					aliveSessions.add(manifest.agentId);
+					// TP-112: Also add the lane session name (without role suffix)
+					// so reconciliation matches persisted task.sessionName.
+					// e.g., "orch-op-lane-1-worker" -> also add "orch-op-lane-1"
+					const laneSession = manifest.agentId.replace(/-(worker|reviewer)$/, "");
+					if (laneSession !== manifest.agentId) aliveSessions.add(laneSession);
+				}
+			}
+		}
+	} else {
+		for (const task of persistedState.tasks) {
+			if (task.sessionName && tmuxHasSession(task.sessionName)) {
+				aliveSessions.add(task.sessionName);
+			}
 		}
 	}
 
-	// Check .DONE files
+	// Check .DONE files — check both original path and worktree-relative path.
+	// TP-109: In workspace mode or V2 execution, .DONE is written in the worktree
+	// at the resolved packet path, not the original discovery path. Resume must
+	// check both locations for authoritative completion detection.
 	const doneTaskIds = new Set<string>();
 	for (const task of persistedState.tasks) {
+		// Check original task folder path
 		if (task.taskFolder && hasTaskDoneMarker(task.taskFolder)) {
 			doneTaskIds.add(task.taskId);
+			continue;
+		}
+		// Check worktree-relative path (packet-home authority)
+		const laneRec = persistedState.lanes.find(l => l.taskIds.includes(task.taskId));
+		if (laneRec?.worktreePath && task.taskFolder) {
+			const resolved = resolveCanonicalTaskPaths(
+				task.taskFolder,
+				laneRec.worktreePath,
+				repoRoot,
+				!!workspaceConfig,
+			);
+			if (existsSync(resolved.donePath)) {
+				doneTaskIds.add(task.taskId);
+			}
 		}
 	}
 
@@ -1035,6 +1101,7 @@ export async function resumeOrchBatch(
 	const depGraph = buildDependencyGraph(discovery.pending, discovery.completed);
 	batchState.dependencyGraph = depGraph;
 
+
 	// ── 8. Handle alive sessions (reconnect) ─────────────────────
 	// For tasks with alive sessions, we need to wait for them to complete.
 	// We poll each alive session's .DONE file.
@@ -1076,44 +1143,82 @@ export async function resumeOrchBatch(
 			// Resolve per-lane repo root for workspace mode (v1/repo mode: falls back to repoRoot)
 			const laneRepoRoot = resolveRepoRoot(laneRecord.repoId, repoRoot, workspaceConfig);
 
-			execLog("resume", task.taskId, "reconnecting to alive session", {
-				session: laneRecord.tmuxSessionName,
-				repoId: laneRecord.repoId ?? "(default)",
-			});
+			// TP-112: Backend-aware reconnect.
+			// V2: re-execute via executeLaneV2 (agent-host doesn't survive restart).
+			// Per spec §7.3: "detect + terminate + rehydrate".
+			// Legacy: poll the still-alive TMUX session.
+			if (resumeBackend === "v2") {
+				execLog("resume", task.taskId, "V2 reconnect: terminate + rehydrate via lane-runner", {
+					repoId: laneRecord.repoId ?? "(default)",
+				});
+				// TP-112 §7.3: detect + terminate + rehydrate.
+				// Kill any alive V2 agent before re-executing to prevent duplicates.
+				terminateAliveV2Agents(stateRoot, persistedState.batchId, laneRecord.tmuxSessionName);
+				try {
+					const laneResult = await executeLaneV2(
+						lane, orchConfig, laneRepoRoot, batchState.pauseSignal,
+						workspaceRoot, !!workspaceConfig,
+						{ ORCH_BATCH_ID: batchState.batchId },
+						emitAlert,
+					);
+					const taskResult = laneResult.tasks.find(t => t.taskId === task.taskId);
+					if (taskResult?.status === "succeeded") {
+						reconnectFinalStatus.set(task.taskId, "succeeded");
+						completedTaskSet.add(task.taskId);
+						failedTaskSet.delete(task.taskId);
+						reconnectTaskSet.delete(task.taskId);
+						batchState.succeededTasks++;
+					} else {
+						reconnectFinalStatus.set(task.taskId, "failed");
+						failedTaskSet.add(task.taskId);
+						completedTaskSet.delete(task.taskId);
+						reconnectTaskSet.delete(task.taskId);
+						batchState.failedTasks++;
+					}
+				} catch (err: unknown) {
+					reconnectFinalStatus.set(task.taskId, "failed");
+					failedTaskSet.add(task.taskId);
+					completedTaskSet.delete(task.taskId);
+					reconnectTaskSet.delete(task.taskId);
+					batchState.failedTasks++;
+					execLog("resume", task.taskId, `V2 reconnect error: ${err instanceof Error ? err.message : String(err)}`);
+				}
+			} else {
+				execLog("resume", task.taskId, "reconnecting to alive session", {
+					session: laneRecord.tmuxSessionName,
+					repoId: laneRecord.repoId ?? "(default)",
+				});
 
-			// Poll until task completes
-			try {
-				const pollResult = await pollUntilTaskComplete(
-					lane,
-					allocatedTask,
-					orchConfig,
-					laneRepoRoot,
-					batchState.pauseSignal,
-				);
+				try {
+					const pollResult = await pollUntilTaskComplete(
+						lane,
+						allocatedTask,
+						orchConfig,
+						laneRepoRoot,
+						batchState.pauseSignal,
+					);
 
-				if (pollResult.status === "succeeded") {
-					reconnectFinalStatus.set(task.taskId, "succeeded");
-					completedTaskSet.add(task.taskId);
-					failedTaskSet.delete(task.taskId);
-					reconnectTaskSet.delete(task.taskId);
-					batchState.succeededTasks++;
-					execLog("resume", task.taskId, "reconnected task succeeded");
-				} else {
+					if (pollResult.status === "succeeded") {
+						reconnectFinalStatus.set(task.taskId, "succeeded");
+						completedTaskSet.add(task.taskId);
+						failedTaskSet.delete(task.taskId);
+						reconnectTaskSet.delete(task.taskId);
+						batchState.succeededTasks++;
+					} else {
+						reconnectFinalStatus.set(task.taskId, "failed");
+						failedTaskSet.add(task.taskId);
+						completedTaskSet.delete(task.taskId);
+						reconnectTaskSet.delete(task.taskId);
+						batchState.failedTasks++;
+					}
+				} catch (err: unknown) {
 					reconnectFinalStatus.set(task.taskId, "failed");
 					failedTaskSet.add(task.taskId);
 					completedTaskSet.delete(task.taskId);
 					reconnectTaskSet.delete(task.taskId);
 					batchState.failedTasks++;
-					execLog("resume", task.taskId, `reconnected task ${pollResult.status}: ${pollResult.exitReason}`);
+					execLog("resume", task.taskId, `reconnection error: ${err instanceof Error ? err.message : String(err)}`);
 				}
-			} catch (err: unknown) {
-				reconnectFinalStatus.set(task.taskId, "failed");
-				failedTaskSet.add(task.taskId);
-				completedTaskSet.delete(task.taskId);
-				reconnectTaskSet.delete(task.taskId);
-				batchState.failedTasks++;
-				const msg = err instanceof Error ? err.message : String(err);
-				execLog("resume", task.taskId, `reconnection error: ${msg}`);
 			}
 		}
 	}
@@ -1167,16 +1272,35 @@ export async function resumeOrchBatch(
 			});
 
 			try {
-				spawnLaneSession(lane, allocatedTask, orchConfig, reExecRepoRoot, undefined, {
-					ORCH_BATCH_ID: batchState.batchId,
-				});
-				const pollResult = await pollUntilTaskComplete(
-					lane,
-					allocatedTask,
-					orchConfig,
-					reExecRepoRoot,
-					batchState.pauseSignal,
-				);
+				// TP-112: Backend-aware re-execution.
+				let pollResult: { status: LaneTaskStatus; exitReason: string; doneFileFound: boolean };
+				if (resumeBackend === "v2") {
+					// TP-112: terminate any alive V2 agent before re-execute
+					terminateAliveV2Agents(stateRoot, batchState.batchId, laneRecord.tmuxSessionName);
+					const laneResult = await executeLaneV2(
+						lane, orchConfig, reExecRepoRoot, batchState.pauseSignal,
+						workspaceRoot, !!workspaceConfig,
+						{ ORCH_BATCH_ID: batchState.batchId },
+						emitAlert,
+					);
+					const taskResult = laneResult.tasks.find(t => t.taskId === task.taskId);
+					pollResult = {
+						status: taskResult?.status ?? "failed",
+						exitReason: taskResult?.exitReason ?? "V2 re-execution completed",
+						doneFileFound: taskResult?.doneFileFound ?? false,
+					};
+				} else {
+					spawnLaneSession(lane, allocatedTask, orchConfig, reExecRepoRoot, undefined, {
+						ORCH_BATCH_ID: batchState.batchId,
+					});
+					pollResult = await pollUntilTaskComplete(
+						lane,
+						allocatedTask,
+						orchConfig,
+						reExecRepoRoot,
+						batchState.pauseSignal,
+					);
+				}
 
 				if (pollResult.status === "succeeded") {
 					reExecuteFinalStatus.set(task.taskId, "succeeded");
@@ -1275,6 +1399,9 @@ export async function resumeOrchBatch(
 				stateRoot,
 				agentRoot,
 				runnerConfig.testing_commands,
+				undefined, // healthMonitor
+				undefined, // forceMixedOutcome
+				resumeBackend,
 			);
 
 			if (reExecMergeResult.status === "succeeded") {
@@ -1530,6 +1657,9 @@ export async function resumeOrchBatch(
 					stateRoot,
 					agentRoot,
 					runnerConfig.testing_commands,
+					undefined, // healthMonitor
+					undefined, // forceMixedOutcome
+					resumeBackend,
 				);
 				batchState.mergeResults.push(mergeRetryResult);
 
@@ -1603,6 +1733,8 @@ export async function resumeOrchBatch(
 				}
 			},
 			workspaceConfig,
+			resumeBackend,
+			emitAlert,
 		);
 
 		batchState.waveResults.push(waveResult);
@@ -1740,6 +1872,9 @@ export async function resumeOrchBatch(
 					stateRoot,
 					agentRoot,
 					runnerConfig.testing_commands,
+					undefined, // healthMonitor
+					undefined, // forceMixedOutcome
+					resumeBackend,
 				);
 				batchState.mergeResults.push(mergeResult);
 
@@ -1904,6 +2039,9 @@ export async function resumeOrchBatch(
 							stateRoot,
 							agentRoot,
 							runnerConfig.testing_commands,
+							undefined, // healthMonitor
+							undefined, // forceMixedOutcome
+							resumeBackend,
 						);
 					},
 					persist: (trigger) => persistRuntimeState(trigger, batchState, wavePlan, latestAllocatedLanes, allTaskOutcomes, discovery, stateRoot),