taskplane 0.23.16 → 0.24.0

package/extensions/taskplane/persistence.ts

@@ -3,7 +3,6 @@
  * @module orch/persistence
  */
 import { readFileSync, writeFileSync, existsSync, unlinkSync, renameSync, mkdirSync, appendFileSync } from "fs";
-import { execSync } from "child_process";
 import { join, dirname, basename } from "path";
 
 import { execLog } from "./execution.ts";
@@ -12,6 +11,7 @@ import type { BatchHistorySummary } from "./types.ts";
 import type { AllocatedLane, DiscoveryResult, EngineEvent, EscalationContext, LaneTaskOutcome, LaneTaskStatus, MonitorState, OrchBatchPhase, OrchBatchRuntimeState, PersistedBatchState, PersistedLaneRecord, PersistedMergeResult, PersistedSegmentRecord, PersistedTaskRecord, TaskMonitorSnapshot, Tier0RecoveryPattern, WorkspaceMode } from "./types.ts";
 import { sleepSync } from "./worktree.ts";
 import type { PreserveFailedLaneProgressResult } from "./worktree.ts";
+import { normalizeLaneSessionAlias, readLaneSessionAliases } from "./tmux-compat.ts";
 
 // ── State Persistence Helper (TS-009 Step 2) ────────────────────────
 
@@ -151,7 +151,7 @@ export function seedPendingOutcomesForAllocatedLanes(
 				startTime: null,
 				endTime: null,
 				exitReason: "Pending execution",
-				sessionName: lane.tmuxSessionName,
+				sessionName: lane.laneSessionId,
 				doneFileFound: false,
 				laneNumber: lane.laneNumber,
 			}) || changed;
@@ -681,6 +681,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 
 	// ── Validate lane records ────────────────────────────────────
 	const lanes = obj.lanes as unknown[];
+	const legacyTmuxSessionLaneIndexes: number[] = [];
 	for (let i = 0; i < lanes.length; i++) {
 		const l = lanes[i] as Record<string, unknown>;
 		if (!l || typeof l !== "object") {
@@ -689,7 +690,7 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 				`lanes[${i}] is not an object`,
 			);
 		}
-		for (const field of ["laneId", "tmuxSessionName", "worktreePath", "branch"] as const) {
+		for (const field of ["laneId", "worktreePath", "branch"] as const) {
 			if (typeof l[field] !== "string") {
 				throw new StateFileError(
 					"STATE_SCHEMA_INVALID",
@@ -697,6 +698,35 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 				);
 			}
 		}
+
+		const { laneSessionId, tmuxSessionName } = readLaneSessionAliases(l);
+		if (laneSessionId !== undefined && typeof laneSessionId !== "string") {
+			throw new StateFileError(
+				"STATE_SCHEMA_INVALID",
+				`lanes[${i}].laneSessionId is not a string (got ${typeof laneSessionId})`,
+			);
+		}
+
+		if (tmuxSessionName !== undefined && typeof tmuxSessionName !== "string") {
+			throw new StateFileError(
+				"STATE_SCHEMA_INVALID",
+				`lanes[${i}].tmuxSessionName is not a string (got ${typeof tmuxSessionName})`,
+			);
+		}
+
+		if (typeof laneSessionId !== "string" && typeof tmuxSessionName !== "string") {
+			throw new StateFileError(
+				"STATE_SCHEMA_INVALID",
+				`lanes[${i}] must include either laneSessionId or tmuxSessionName as a string`,
+			);
+		}
+
+		if (typeof tmuxSessionName === "string") {
+			legacyTmuxSessionLaneIndexes.push(i);
+		}
+
+		normalizeLaneSessionAlias(l);
+
 		if (typeof l.laneNumber !== "number") {
 			throw new StateFileError(
 				"STATE_SCHEMA_INVALID",
@@ -718,6 +748,13 @@ export function validatePersistedState(data: unknown): PersistedBatchState {
 		}
 	}
 
+	if (legacyTmuxSessionLaneIndexes.length > 0) {
+		console.error(
+			"[taskplane] migration: detected legacy lanes[].tmuxSessionName in .pi/batch-state.json; " +
+			"normalized to lanes[].laneSessionId for this release. Re-save state (or re-run /orch-resume) to persist canonical fields.",
+		);
+	}
+
 	// ── Validate merge results ───────────────────────────────────
 	const mergeResults = obj.mergeResults as unknown[];
 	for (let i = 0; i < mergeResults.length; i++) {
@@ -1197,7 +1234,7 @@ export function serializeBatchState(
 			const record: PersistedTaskRecord = {
 				taskId,
 				laneNumber: lane?.laneNumber ?? outcome?.laneNumber ?? 0,
-				sessionName: outcome?.sessionName || lane?.tmuxSessionName || "",
+				sessionName: outcome?.sessionName || lane?.laneSessionId || "",
 				status: outcome?.status ?? "pending",
 				taskFolder: "", // Enriched by caller from discovery
 				startedAt: outcome?.startTime ?? null,
@@ -1249,7 +1286,7 @@ export function serializeBatchState(
 		const record: PersistedLaneRecord = {
 			laneNumber: lane.laneNumber,
 			laneId: lane.laneId,
-			tmuxSessionName: lane.tmuxSessionName,
+			laneSessionId: lane.laneSessionId,
 			worktreePath: lane.worktreePath,
 			branch: lane.branch,
 			taskIds: lane.tasks.map((t) => t.taskId),
@@ -1695,32 +1732,22 @@ export function analyzeOrchestratorStartupState(
 }
 
 /**
- * Detect orphan TMUX sessions and analyze startup state.
- *
- * Combines session discovery (via tmux), state file loading (with typed
- * error handling), and .DONE file checking into a single result.
+ * Detect orphan orchestrator state and analyze startup recovery action.
  *
- * Non-blocking: detection failures (e.g., tmux not running) are handled
- * gracefully and do NOT crash `/orch` startup.
+ * Runtime V2 no longer relies on TMUX session discovery. Startup decisions
+ * are based on persisted batch state plus task .DONE markers.
  *
- * @param prefix   - TMUX session prefix to search for (e.g., "orch")
+ * @param prefix   - Legacy orchestrator session prefix (unused in Runtime V2)
  * @param repoRoot - Absolute path to the repository root
  * @returns OrphanDetectionResult with recommended action
  */
 export function detectOrphanSessions(prefix: string, repoRoot: string): OrphanDetectionResult {
-	// ── 1. Discover TMUX sessions ────────────────────────────────
-	let orphanSessions: string[] = [];
-	try {
-		const stdout = execSync('tmux list-sessions -F "#{session_name}"', {
-			encoding: "utf-8",
-			timeout: 5000,
-		});
-		orphanSessions = parseOrchSessionNames(stdout, prefix);
-	} catch {
-		// tmux not available or no sessions — proceed with empty orphan list
-	}
+	void prefix;
+
+	// Runtime V2 uses persisted state as the source of truth for orphan analysis.
+	const orphanSessions: string[] = [];
 
-	// ── 2. Load batch state file ─────────────────────────────────
+	// ── 1. Load batch state file ─────────────────────────────────
 	let stateStatus: OrphanStateStatus = "missing";
 	let loadedState: PersistedBatchState | null = null;
 	let stateError: string | null = null;
@@ -1747,7 +1774,7 @@ export function detectOrphanSessions(prefix: string, repoRoot: string): OrphanDe
 		}
 	}
 
-	// ── 3. Check .DONE files for stale state detection ───────────
+	// ── 2. Check .DONE files for stale state detection ───────────
 	const doneTaskIds = new Set<string>();
 	if (loadedState && orphanSessions.length === 0) {
 		// Only check .DONE files when we have state but no orphans
@@ -1759,7 +1786,7 @@ export function detectOrphanSessions(prefix: string, repoRoot: string): OrphanDe
 		}
 	}
 
-	// ── 4. Analyze and return ────────────────────────────────────
+	// ── 3. Analyze and return ────────────────────────────────────
 	return analyzeOrchestratorStartupState(
 		orphanSessions,
 		stateStatus,

package/extensions/taskplane/process-registry.ts

@@ -1,14 +1,14 @@
 /**
  * Process Registry — Runtime V2 agent lifecycle management
  *
- * File-backed registry that replaces TMUX session discovery as the
+ * File-backed registry that replaces legacy 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.
+ *   3. Operator tools read the registry, not terminal-session probes.
  *   4. Resume/cleanup validates pid + startedAt for orphan detection.
  *
  * File locations:

package/extensions/taskplane/resume.ts

@@ -8,7 +8,7 @@ import { join } from "path";
 import { assembleDiagnosticInput, emitDiagnosticReports } from "./diagnostic-reports.ts";
 import { runDiscovery } from "./discovery.ts";
 import { executeOrchBatch } from "./engine.ts";
-import { computeTransitiveDependents, execLog, executeLaneV2, executeWave, pollUntilTaskComplete, resolveCanonicalTaskPaths, spawnLaneSession, tmuxHasSession } from "./execution.ts";
+import { computeTransitiveDependents, execLog, executeLaneV2, executeWave, resolveCanonicalTaskPaths } from "./execution.ts";
 import type { MonitorUpdateCallback, RuntimeBackend } from "./execution.ts";
 import { selectRuntimeBackend } from "./engine.ts";
 import { readRegistrySnapshot, isTerminalStatus, isProcessAlive } from "./process-registry.ts";
@@ -143,7 +143,7 @@ export function reconstructAllocatedLanes(
 	return persistedLanes.map((lr) => ({
 		laneNumber: lr.laneNumber,
 		laneId: lr.laneId,
-		tmuxSessionName: lr.tmuxSessionName,
+		laneSessionId: lr.laneSessionId,
 		worktreePath: lr.worktreePath,
 		branch: lr.branch,
 		tasks: lr.taskIds.map((taskId) => {
@@ -337,7 +337,7 @@ export function checkResumeEligibility(state: PersistedBatchState, force: boolea
  * Reconcile persisted task states against live signals.
  *
  * For each task in the persisted state, determines the correct action
- * based on the current state of TMUX sessions and .DONE files.
+ * based on the current state of lane-session liveness and .DONE files.
  *
  * Precedence rules (applied per-task):
  * 1. .DONE file found → "mark-complete" (even if session is alive — task is done)
@@ -350,7 +350,7 @@ export function checkResumeEligibility(state: PersistedBatchState, force: boolea
  * Pure function — no process or filesystem access.
  *
  * @param persistedState  - Loaded and validated batch state
- * @param aliveSessions   - Set of TMUX session names currently alive
+ * @param aliveSessions   - Set of lane session names currently alive
  * @param doneTaskIds     - Set of task IDs whose .DONE files exist
  * @returns Array of reconciled task states in persisted order
  */
@@ -777,7 +777,6 @@ export async function resumeOrchBatch(
 	// State files (.pi/batch-state.json, lane-state, etc.) belong in the workspace root,
 	// which is where .pi/ config lives. In repo mode, stateRoot === repoRoot.
 	const stateRoot = workspaceRoot ?? cwd;
-	const prefix = orchConfig.orchestrator.tmux_prefix;
 
 	// ── TP-076: Supervisor alert emission helper ─────────────────
 	const emitAlert = (alert: import("./types.ts").SupervisorAlert): void => {
@@ -883,27 +882,19 @@ export async function resumeOrchBatch(
 	execLog("resume", batchState.batchId, `runtime backend for resumed execution: ${resumeBackend}`);
 
 	// ── 3. Discover live signals ─────────────────────────────────
-	// TP-112: Backend-aware session liveness check.
-	// V2: check process registry (pid + status). Legacy: check TMUX.
+	// TP-112/119: Runtime V2 session liveness check only.
+	// Alive sessions are discovered from the process registry.
 	const aliveSessions = new Set<string>();
-	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);
+	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);
+				// Also add 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);
 			}
 		}
 	}
@@ -951,8 +942,8 @@ export async function resumeOrchBatch(
 	// failed resume but were never actually started need their allocation
 	// metadata cleared so they can be freshly assigned to new lanes.
 	// We also prune these tasks from persisted lane records so that
-	// serializeBatchState() doesn't reintroduce stale sessionName via the
-	// `outcome?.sessionName || lane?.tmuxSessionName` fallback path.
+	// serializeBatchState() doesn't reintroduce stale sessionName via lane
+	// fallback paths when outcome.sessionName is absent.
 	const stalePendingTaskIds = new Set<string>();
 	for (const reconciled of reconciledTasks) {
 		if (reconciled.action === "pending") {
@@ -1130,7 +1121,7 @@ export async function resumeOrchBatch(
 			const lane: AllocatedLane = {
 				laneNumber: laneRecord.laneNumber,
 				laneId: laneRecord.laneId,
-				tmuxSessionName: laneRecord.tmuxSessionName,
+				laneSessionId: laneRecord.laneSessionId,
 				worktreePath: laneRecord.worktreePath,
 				branch: laneRecord.branch,
 				tasks: [allocatedTask],
@@ -1143,82 +1134,41 @@ 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);
 
-			// 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);
+			// TP-112: Runtime V2 reconnect.
+			// Agent-host processes do not survive supervisor restart, so reconnect
+			// uses terminate + rehydrate via executeLaneV2.
+			execLog("resume", task.taskId, "V2 reconnect: terminate + rehydrate via lane-runner", {
+				repoId: laneRecord.repoId ?? "(default)",
+			});
+			terminateAliveV2Agents(stateRoot, persistedState.batchId, laneRecord.laneSessionId);
+			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.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)",
-				});
-
-				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++;
-					} else {
-						reconnectFinalStatus.set(task.taskId, "failed");
-						failedTaskSet.add(task.taskId);
-						completedTaskSet.delete(task.taskId);
-						reconnectTaskSet.delete(task.taskId);
-						batchState.failedTasks++;
-					}
-				} catch (err: unknown) {
+					batchState.succeededTasks++;
+				} else {
 					reconnectFinalStatus.set(task.taskId, "failed");
 					failedTaskSet.add(task.taskId);
 					completedTaskSet.delete(task.taskId);
 					reconnectTaskSet.delete(task.taskId);
 					batchState.failedTasks++;
-					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++;
+				execLog("resume", task.taskId, `V2 reconnect error: ${err instanceof Error ? err.message : String(err)}`);
 			}
 		}
 	}
@@ -1252,7 +1202,7 @@ export async function resumeOrchBatch(
 			const lane: AllocatedLane = {
 				laneNumber: laneRecord.laneNumber,
 				laneId: laneRecord.laneId,
-				tmuxSessionName: laneRecord.tmuxSessionName,
+				laneSessionId: laneRecord.laneSessionId,
 				worktreePath: laneRecord.worktreePath,
 				branch: laneRecord.branch,
 				tasks: [allocatedTask],
@@ -1266,41 +1216,26 @@ export async function resumeOrchBatch(
 			const reExecRepoRoot = resolveRepoRoot(laneRecord.repoId, repoRoot, workspaceConfig);
 
 			execLog("resume", task.taskId, "re-executing interrupted task in existing worktree", {
-				session: laneRecord.tmuxSessionName,
+				session: laneRecord.laneSessionId,
 				worktree: laneRecord.worktreePath,
 				repoId: laneRecord.repoId ?? "(default)",
 			});
 
 			try {
-				// 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,
-					);
-				}
+				// TP-112: Runtime V2 re-execution.
+				terminateAliveV2Agents(stateRoot, batchState.batchId, laneRecord.laneSessionId);
+				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);
+				const pollResult: { status: LaneTaskStatus; exitReason: string; doneFileFound: boolean } = {
+					status: taskResult?.status ?? "failed",
+					exitReason: taskResult?.exitReason ?? "V2 re-execution completed",
+					doneFileFound: taskResult?.doneFileFound ?? false,
+				};
 
 				if (pollResult.status === "succeeded") {
 					reExecuteFinalStatus.set(task.taskId, "succeeded");
@@ -1354,7 +1289,7 @@ export async function resumeOrchBatch(
 					startTime: Date.now(),
 					endTime: Date.now(),
 					exitReason: "Re-executed task completed successfully",
-					sessionName: lane.tmuxSessionName,
+					sessionName: lane.laneSessionId,
 					doneFileFound: true,
 					laneNumber: lane.laneNumber,
 				})),
@@ -1604,7 +1539,7 @@ export async function resumeOrchBatch(
 									: status === "skipped" ? "Task skipped (merge retry)"
 									: status === "stalled" ? "Task stalled (merge retry)"
 									: "Task failed (merge retry)",
-							sessionName: lane.tmuxSessionName,
+							sessionName: lane.laneSessionId,
 							doneFileFound: status === "succeeded",
 							laneNumber: lane.laneNumber,
 						};

package/extensions/taskplane/sessions.ts

@@ -1,92 +1,57 @@
-/**
- * TMUX session discovery and formatting
- * @module orch/sessions
- */
-import { execSync } from "child_process";
-import { join } from "path";
-
-import { tmuxHasSession } from "./execution.ts";
-import { ORCH_MESSAGES } from "./messages.ts";
-import type { OrchBatchRuntimeState, OrchestratorSessionEntry } from "./types.ts";
-
-// ── Session Discovery ────────────────────────────────────────────────
-
-/**
- * List all TMUX sessions matching the orchestrator prefix.
- *
- * Parses `tmux list-sessions` output and filters by prefix.
- * Returns entries sorted alphabetically by session name.
- *
- * @param tmuxPrefix  - Prefix to match (e.g., "orch")
- * @param batchState  - Current batch state for enrichment (optional)
- * @returns Array of session entries
- */
-export function listOrchSessions(
-	tmuxPrefix: string,
-	batchState?: OrchBatchRuntimeState,
-): OrchestratorSessionEntry[] {
-	let stdout = "";
-	try {
-		stdout = execSync('tmux list-sessions -F "#{session_name}"', {
-			encoding: "utf-8",
-			timeout: 5000,
-		});
-	} catch {
-		// No tmux server running or no sessions
-		return [];
-	}
-
-	const sessionNames = stdout
-		.trim()
-		.split("\n")
-		.filter(Boolean)
-		.filter(name => name.startsWith(`${tmuxPrefix}-`))
-		.sort();
-
-	if (sessionNames.length === 0) return [];
-
-	// Build a lookup from current batch state for enrichment
-	const laneLookup = new Map<string, { laneId: string; taskId: string | null; worktreePath: string }>();
-	if (batchState && batchState.currentLanes.length > 0) {
-		for (const lane of batchState.currentLanes) {
-			laneLookup.set(lane.tmuxSessionName, {
-				laneId: lane.laneId,
-				taskId: lane.tasks.length > 0 ? lane.tasks[0].taskId : null,
-				worktreePath: lane.worktreePath,
-			});
-		}
-	}
-
-	return sessionNames.map(name => {
-		const laneInfo = laneLookup.get(name);
-		return {
-			sessionName: name,
-			laneId: laneInfo?.laneId || "unknown",
-			taskId: laneInfo?.taskId || null,
-			status: tmuxHasSession(name) ? "alive" as const : "dead" as const,
-			worktreePath: laneInfo?.worktreePath || "",
-			attachCmd: `tmux attach -t ${name}`,
-		};
-	});
-}
-
-/**
- * Format session listing for display.
- */
-export function formatOrchSessions(sessions: OrchestratorSessionEntry[]): string {
-	if (sessions.length === 0) {
-		return ORCH_MESSAGES.sessionsNone();
-	}
-
-	const lines: string[] = [ORCH_MESSAGES.sessionsHeader(sessions.length), ""];
-
-	for (const s of sessions) {
-		const statusIcon = s.status === "alive" ? "🟢" : "🔴";
-		const taskInfo = s.taskId ? ` (${s.taskId})` : "";
-		lines.push(`  ${statusIcon} ${s.sessionName} [${s.laneId}]${taskInfo}`);
-		lines.push(`     ${s.attachCmd}`);
-	}
-
-	return lines.join("\n");
-}
-
+/**
+ * Runtime V2 session discovery and formatting
+ * @module orch/sessions
+ */
+
+import { ORCH_MESSAGES } from "./messages.ts";
+import type { OrchBatchRuntimeState, OrchestratorSessionEntry } from "./types.ts";
+
+// ── Session Discovery ────────────────────────────────────────────────
+
+/**
+ * List active orchestrator sessions from in-memory batch state.
+ *
+ * Runtime V2 no longer uses TMUX as the execution owner. Session rows are
+ * derived from canonical lane session IDs in runtime state.
+ *
+ * @param _tmuxPrefix - Legacy parameter kept for API compatibility
+ * @param batchState  - Current batch state for lane/task enrichment
+ * @returns Array of session entries
+ */
+export function listOrchSessions(
+	_tmuxPrefix: string,
+	batchState?: OrchBatchRuntimeState,
+): OrchestratorSessionEntry[] {
+	if (!batchState || batchState.currentLanes.length === 0) return [];
+
+	return batchState.currentLanes
+		.map(lane => ({
+			sessionName: lane.laneSessionId,
+			laneId: lane.laneId,
+			taskId: lane.tasks.length > 0 ? lane.tasks[0].taskId : null,
+			status: "alive" as const,
+			worktreePath: lane.worktreePath,
+			attachCmd: "Runtime V2 (no tmux attach)",
+		}))
+		.sort((a, b) => a.sessionName.localeCompare(b.sessionName));
+}
+
+/**
+ * Format session listing for display.
+ */
+export function formatOrchSessions(sessions: OrchestratorSessionEntry[]): string {
+	if (sessions.length === 0) {
+		return ORCH_MESSAGES.sessionsNone();
+	}
+
+	const lines: string[] = [ORCH_MESSAGES.sessionsHeader(sessions.length), ""];
+
+	for (const s of sessions) {
+		const statusIcon = s.status === "alive" ? "🟢" : "🔴";
+		const taskInfo = s.taskId ? ` (${s.taskId})` : "";
+		lines.push(`  ${statusIcon} ${s.sessionName} [${s.laneId}]${taskInfo}`);
+		lines.push(`     ${s.attachCmd}`);
+	}
+
+	return lines.join("\n");
+}