taskplane 0.23.16 → 0.24.0

package/bin/taskplane.mjs

@@ -234,7 +234,7 @@ orchestrator:
   worktree_prefix: "${vars.worktree_prefix}"
   batch_id_format: "timestamp"
   spawn_mode: "${vars.spawn_mode}"
-  tmux_prefix: "${vars.tmux_prefix}"
+  session_prefix: "${vars.session_prefix}"
 
 dependencies:
   source: "prompt"
@@ -315,7 +315,7 @@ function generateProjectConfig(vars) {
 				worktreePrefix: vars.worktree_prefix,
 				batchIdFormat: "timestamp",
 				spawnMode: vars.spawn_mode,
-				tmuxPrefix: vars.tmux_prefix,
+				sessionPrefix: vars.session_prefix,
 				operatorId: "",
 			},
 			dependencies: { source: "prompt", cache: true },
@@ -993,23 +993,6 @@ function detectInitMode(dir) {
 	};
 }
 
-// ─── tmux / spawn mode detection ────────────────────────────────────────────
-
-/**
- * Detect whether tmux is available and determine the default spawn_mode.
- *
- * Reusable for both repo mode (Step 3) and workspace mode (Step 4) init.
- *
- * @returns {{ spawnMode: string, hasTmux: boolean }}
- */
-function detectSpawnMode() {
-	const hasTmux = commandExists("tmux");
-	return {
-		spawnMode: hasTmux ? "tmux" : "subprocess",
-		hasTmux,
-	};
-}
-
 // ─── init ───────────────────────────────────────────────────────────────────
 
 async function cmdInit(args) {
@@ -1308,14 +1291,8 @@ async function cmdInit(args) {
 			vars = await getInteractiveVars(projectRoot, tasksRootOverride);
 		}
 
-		// ── tmux / spawn mode detection ─────────────────────────────
-		const { spawnMode, hasTmux } = detectSpawnMode();
-		vars.spawn_mode = spawnMode;
-
-		if (preset !== "runner-only" && !hasTmux) {
-			console.log(`  ${WARN} tmux not found. Using subprocess mode.`);
-			console.log(`     Run ${c.cyan}taskplane install-tmux${c.reset} for full orchestrator support.\n`);
-		}
+		// Runtime V2 is subprocess-only.
+		vars.spawn_mode = "subprocess";
 
 		const exampleTemplateDirs = noExamples ? [] : listExampleTaskTemplates();
 
@@ -1530,18 +1507,8 @@ async function cmdInit(args) {
 		vars = await getInteractiveVars(projectRoot, tasksRootOverride);
 	}
 
-	// ── tmux / spawn mode detection ──────────────────────────────
-	// Detect tmux availability and set spawn_mode for orchestrator config.
-	// Runs for all init modes (repo and workspace) per spec.
-	// Silent when tmux is found; shows guidance when missing.
-	// Skipped for runner-only preset (no orchestrator config generated).
-	const { spawnMode, hasTmux } = detectSpawnMode();
-	vars.spawn_mode = spawnMode;
-
-	if (preset !== "runner-only" && !hasTmux) {
-		console.log(`  ${WARN} tmux not found. Using subprocess mode.`);
-		console.log(`     Run ${c.cyan}taskplane install-tmux${c.reset} for full orchestrator support.\n`);
-	}
+	// Runtime V2 is subprocess-only.
+	vars.spawn_mode = "subprocess";
 
 	const exampleTemplateDirs = noExamples ? [] : listExampleTaskTemplates();
 
@@ -1672,7 +1639,7 @@ function getPresetVars(preset, projectRoot, tasksRootOverride = null) {
 		project_name: dirName,
 		max_lanes: 3,
 		worktree_prefix: `${slug}-wt`,
-		tmux_prefix: `${slug}-orch`,
+		session_prefix: `${slug}-orch`,
 		tasks_root: tasksRootOverride || "taskplane-tasks",
 		default_area: "general",
 		default_prefix: "TP",
@@ -1699,7 +1666,7 @@ async function getInteractiveVars(projectRoot, tasksRootOverride = null) {
 		project_name,
 		max_lanes,
 		worktree_prefix: `${slug}-wt`,
-		tmux_prefix: `${slug}-orch`,
+		session_prefix: `${slug}-orch`,
 		tasks_root,
 		default_area,
 		default_prefix,

package/dashboard/public/app.js

@@ -160,19 +160,18 @@ function showCopyToast(text) {
   toastTimer = setTimeout(() => toastEl.classList.remove("visible"), 2000);
 }
 
-function copyTmuxCmd(sessionName) {
-  const cmd = `tmux attach -t ${sessionName}`;
-  navigator.clipboard.writeText(cmd).then(() => {
-    showCopyToast(cmd);
+function copySessionId(sessionName) {
+  navigator.clipboard.writeText(sessionName).then(() => {
+    showCopyToast(`session ${sessionName}`);
     // Flash the button
-    const btn = document.querySelector(`[data-tmux="${sessionName}"]`);
+    const btn = document.querySelector(`[data-session="${sessionName}"]`);
     if (btn) {
       btn.classList.add("copied");
       setTimeout(() => btn.classList.remove("copied"), 1500);
     }
   }).catch(() => {
     // Fallback: select the text
-    const btn = document.querySelector(`[data-tmux="${sessionName}"]`);
+    const btn = document.querySelector(`[data-session="${sessionName}"]`);
     if (btn) {
       const range = document.createRange();
       range.selectNodeContents(btn);
@@ -517,30 +516,31 @@ function renderLanesTasks(batch, tmuxSessions) {
     }
 
     // TP-107: check V2 registry for liveness first, fall back to tmux
+    const laneSessionId = lane.laneSessionId;
     const v2Alive = isLaneAliveV2(lane.laneNumber);
-    const alive = v2Alive !== null ? v2Alive : tmuxSet.has(lane.tmuxSessionName);
-    const tmuxCmd = `tmux attach -t ${lane.tmuxSessionName}`;
+    const alive = v2Alive !== null ? v2Alive : tmuxSet.has(laneSessionId);
+    const sessionChip = `session: ${laneSessionId}`;
 
     // Lane header
     html += `<div class="lane-group">`;
     html += `<div class="lane-header">`;
     html += `  <span class="lane-num">${lane.laneNumber}</span>`;
     html += `  <div class="lane-meta">`;
-    html += `    <span class="lane-session">${escapeHtml(lane.tmuxSessionName || "—")}</span>`;
+    html += `    <span class="lane-session">${escapeHtml(laneSessionId || "—")}</span>`;
     html += `    <span class="lane-branch">${escapeHtml(lane.branch || "—")}</span>`;
     if (showRepos && lane.repoId) {
       html += `    ${repoBadgeHtml(lane.repoId, "repo-badge-lane")}`;
     }
     html += `  </div>`;
     html += `  <div class="lane-right">`;
-    html += `    <span class="tmux-dot ${alive ? "alive" : "dead"}" title="${alive ? "tmux alive" : "tmux dead"}"></span>`;
-    // View button: shows conversation stream if available, else tmux pane
-    const isViewingConv = viewerMode === 'conversation' && viewerTarget === lane.tmuxSessionName;
-    html += `    <button class="tmux-view-btn${isViewingConv ? ' active' : ''}" onclick="viewConversation('${escapeHtml(lane.tmuxSessionName)}')" title="View worker conversation">👁 View</button>`;
+    html += `    <span class="tmux-dot ${alive ? "alive" : "dead"}" title="${alive ? "session alive" : "session not active"}"></span>`;
+    // View button: shows conversation stream when available
+    const isViewingConv = viewerMode === 'conversation' && viewerTarget === laneSessionId;
+    html += `    <button class="tmux-view-btn${isViewingConv ? ' active' : ''}" onclick="viewConversation('${escapeHtml(laneSessionId)}')" title="View worker conversation">👁 View</button>`;
     if (alive) {
-      html += `    <span class="tmux-cmd" data-tmux="${escapeHtml(lane.tmuxSessionName)}" onclick="copyTmuxCmd('${escapeHtml(lane.tmuxSessionName)}')" title="Click to copy">${escapeHtml(tmuxCmd)}</span>`;
+      html += `    <span class="tmux-cmd" data-session="${escapeHtml(laneSessionId)}" onclick="copySessionId('${escapeHtml(laneSessionId)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span>`;
     } else {
-      html += `    <span class="tmux-cmd dead-session">${escapeHtml(tmuxCmd)}</span>`;
+      html += `    <span class="tmux-cmd dead-session">${escapeHtml(sessionChip)}</span>`;
     }
     html += `  </div>`;
     html += `</div>`;
@@ -555,9 +555,9 @@ function renderLanesTasks(batch, tmuxSessions) {
     // Get lane state and telemetry for worker stats
     // TP-107: V2 lane snapshots take precedence when present
     const v2snap = v2Snapshots[lane.laneNumber] || null;
-    const legacyLs = laneStates[lane.tmuxSessionName] || null;
+    const legacyLs = laneStates[laneSessionId] || null;
     const ls = v2snap ? mergeV2LaneSnapshot(legacyLs, v2snap) : legacyLs;
-    const tel = telemetry[lane.tmuxSessionName] || null;
+    const tel = telemetry[laneSessionId] || null;
 
     for (const task of laneTasks) {
       // Repo filtering at task level
@@ -768,8 +768,8 @@ function renderMergeAgents(batch, tmuxSessions) {
   // Extract the prefix-opId part from the first lane and use it to construct merge names.
   const lanes = batch?.lanes || [];
   let mergePrefix = "orch-merge"; // fallback for legacy/unknown patterns
-  if (lanes.length > 0 && lanes[0].tmuxSessionName) {
-    const laneName = lanes[0].tmuxSessionName;
+  if (lanes.length > 0 && lanes[0].laneSessionId) {
+    const laneName = lanes[0].laneSessionId;
     const laneMatch = laneName.match(/^(.+)-lane-\d+$/);
     if (laneMatch) {
       mergePrefix = laneMatch[1] + "-merge";
@@ -784,7 +784,7 @@ function renderMergeAgents(batch, tmuxSessions) {
   }
 
   let html = '<table class="merge-table"><thead><tr>';
-  html += '<th>Wave</th><th>Status</th><th>Session</th><th>Telemetry</th><th>Attach</th><th>Details</th>';
+  html += '<th>Wave</th><th>Status</th><th>Session</th><th>Telemetry</th><th>Session ID</th><th>Details</th>';
   html += '</tr></thead><tbody>';
 
   // Track sessions shown in wave result rows so we don't duplicate them below
@@ -855,8 +855,8 @@ function renderMergeAgents(batch, tmuxSessions) {
     html += `<td class="merge-telemetry-cell">${mergeTelemetryHtml(mergeTel, effectiveAlive)}</td>`;
     html += `<td>`;
     if (effectiveAlive) {
-      const cmd = `tmux attach -t ${effectiveSession}`;
-      html += `<span class="tmux-cmd" data-tmux="${escapeHtml(effectiveSession)}" onclick="copyTmuxCmd('${escapeHtml(effectiveSession)}')" title="Click to copy">${escapeHtml(cmd)}</span>`;
+      const sessionChip = `session: ${effectiveSession}`;
+      html += `<span class="tmux-cmd" data-session="${escapeHtml(effectiveSession)}" onclick="copySessionId('${escapeHtml(effectiveSession)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span>`;
     } else {
       html += '<span class="merge-no-data">—</span>';
     }
@@ -894,14 +894,14 @@ function renderMergeAgents(batch, tmuxSessions) {
     if (shownSessions.has(sess)) continue;
 
     const sessTel = telemetry[sess] || null;
-    const cmd = `tmux attach -t ${sess}`;
+    const sessionChip = `session: ${sess}`;
     html += `<tr>`;
     html += `<td class="merge-wave-cell">—</td>`;
     html += `<td><span class="status-badge status-running"><span class="status-dot running"></span> merging</span></td>`;
     html += `<td class="merge-session-cell">${escapeHtml(sess)}</td>`;
     // Full telemetry cell for active merge session
     html += `<td class="merge-telemetry-cell">${mergeTelemetryHtml(sessTel, true)}</td>`;
-    html += `<td><span class="tmux-cmd" data-tmux="${escapeHtml(sess)}" onclick="copyTmuxCmd('${escapeHtml(sess)}')" title="Click to copy">${escapeHtml(cmd)}</span></td>`;
+    html += `<td><span class="tmux-cmd" data-session="${escapeHtml(sess)}" onclick="copySessionId('${escapeHtml(sess)}')" title="Copy session ID">${escapeHtml(sessionChip)}</span></td>`;
     html += `<td>—</td>`;
     html += `</tr>`;
   }

package/dashboard/server.cjs

@@ -68,10 +68,31 @@ Options:
 
 // ─── Data Loading (ported from orch-dashboard.cjs) ──────────────────────────
 
+function normalizeBatchStateIngress(state) {
+  if (!state || typeof state !== "object" || !Array.isArray(state.lanes)) {
+    return state;
+  }
+
+  for (const lane of state.lanes) {
+    if (!lane || typeof lane !== "object") continue;
+    const laneSessionId = typeof lane.laneSessionId === "string"
+      ? lane.laneSessionId
+      : (typeof lane.tmuxSessionName === "string" ? lane.tmuxSessionName : undefined);
+    if (laneSessionId) {
+      lane.laneSessionId = laneSessionId;
+    }
+    if ("tmuxSessionName" in lane) {
+      delete lane.tmuxSessionName;
+    }
+  }
+
+  return state;
+}
+
 function loadBatchState() {
   try {
     const raw = fs.readFileSync(BATCH_STATE_PATH, "utf-8");
-    return JSON.parse(raw);
+    return normalizeBatchStateIngress(JSON.parse(raw));
   } catch {
     return null;
   }
@@ -344,13 +365,13 @@ function tailJsonlFile(filePath) {
 
 /**
  * Load and accumulate telemetry from .pi/telemetry/*.jsonl files.
- * Returns telemetry keyed by tmux session prefix (e.g., "orch-lane-1").
+ * Returns telemetry keyed by session prefix (e.g., "orch-lane-1").
  *
- * Uses batch-state lanes to map lane numbers → tmux prefixes.
+ * Uses batch-state lanes to map lane numbers → session prefixes.
  * For standalone /task mode (no lane number in filename), data is keyed as "standalone".
  *
  * @param {object|null} batchState - The batch state from batch-state.json
- * @returns {object} Map of tmuxPrefix → accumulated telemetry
+ * @returns {object} Map of sessionPrefix → accumulated telemetry
  */
 
 // ── Runtime V2 Data Loaders (TP-107) ─────────────────────────────
@@ -521,8 +542,9 @@ function loadTelemetryData(batchState) {
   const laneToPrefix = {};
   if (batchState && batchState.lanes) {
     for (const lane of batchState.lanes) {
-      if (lane.laneNumber != null && lane.tmuxSessionName) {
-        laneToPrefix[lane.laneNumber] = lane.tmuxSessionName;
+      const laneSessionId = lane.laneSessionId;
+      if (lane.laneNumber != null && laneSessionId) {
+        laneToPrefix[lane.laneNumber] = laneSessionId;
       }
     }
   }
@@ -1022,7 +1044,7 @@ function buildDashboardState() {
     for (const [laneNum, snap] of Object.entries(runtimeLaneSnapshots)) {
       // Find the matching lane record to get the session name key
       const laneRec = (state.lanes || []).find(l => l.laneNumber === Number(laneNum));
-      const key = laneRec ? laneRec.tmuxSessionName : `lane-${laneNum}`;
+      const key = laneRec ? (laneRec.laneSessionId) : `lane-${laneNum}`;
       if (!laneStates[key] || (snap.updatedAt && snap.updatedAt > (laneStates[key].timestamp || 0))) {
         const w = snap.worker || {};
         const statusMap = { running: "running", spawning: "running", exited: "done", crashed: "error", killed: "error", timed_out: "error", wrapping_up: "running" };

package/extensions/task-runner.ts

@@ -28,7 +28,7 @@ import {
 } from "fs";
 import { tmpdir, userInfo } from "os";
 import { join, dirname, basename, resolve } from "path";
-import { loadProjectConfig, toTaskConfig } from "./taskplane/config-loader.ts";
+import { ConfigLoadError, loadProjectConfig, toTaskConfig } from "./taskplane/config-loader.ts";
 import { loadWorkspaceConfig, resolvePointer } from "./taskplane/workspace.ts";
 import type { PointerResolution } from "./taskplane/types.ts";
 import {
@@ -292,8 +292,12 @@ export function loadConfig(cwd: string): TaskConfig {
 		const pointer = resolveTaskRunnerPointer();
 		const unified = loadProjectConfig(cwd, pointer?.configRoot);
 		return toTaskConfig(unified);
-	} catch {
-		// If config loading fails (e.g., malformed JSON), fall back to defaults
+	} catch (err: unknown) {
+		if (err instanceof ConfigLoadError && err.code === "CONFIG_LEGACY_FIELD") {
+			// Hard-fail deprecated TMUX-era config/prefs with migration guidance.
+			throw err;
+		}
+		// For malformed/unreadable config, preserve historical fallback behavior.
 		return { ...DEFAULT_CONFIG };
 	}
 }

package/extensions/taskplane/abort.ts

@@ -3,12 +3,11 @@
  * @module orch/abort
  */
 import { writeFileSync, existsSync } from "fs";
-import { execSync } from "child_process";
 import { join } from "path";
 
-import { execLog, resolveCanonicalTaskPaths, tmuxHasSession, tmuxKillSession } from "./execution.ts";
+import { execLog, killV2LaneAgents, resolveCanonicalTaskPaths } from "./execution.ts";
 import { killMergeAgentV2, killAllMergeAgentsV2 } from "./merge.ts";
-import { deleteBatchState, parseOrchSessionNames, persistRuntimeState } from "./persistence.ts";
+import { deleteBatchState, persistRuntimeState } from "./persistence.ts";
 import type { AbortActionStep, AbortErrorCode, AbortLaneResult, AbortMode, AbortResult, AbortTargetSession, AllocatedLane, OrchBatchRuntimeState, PersistedBatchState, PersistedLaneRecord } from "./types.ts";
 
 // ── Abort Pure Functions ─────────────────────────────────────────────
@@ -51,11 +50,11 @@ export function selectAbortTargetSessions(
 	});
 
 	// Build lookup from persisted lane records for workspace-aware laneId resolution.
-	// Keyed by tmuxSessionName for direct session-to-lane mapping.
+	// Keyed by lane session ID for direct session-to-lane mapping.
 	const persistedLaneLookup = new Map<string, PersistedLaneRecord>();
 	if (persistedState?.lanes) {
 		for (const lane of persistedState.lanes) {
-			persistedLaneLookup.set(lane.tmuxSessionName, lane);
+			persistedLaneLookup.set(lane.laneSessionId, lane);
 		}
 	}
 
@@ -82,7 +81,7 @@ export function selectAbortTargetSessions(
 	const runtimeLookup = new Map<string, { laneId: string; taskId: string | null; worktreePath: string; taskFolder: string | null }>();
 	for (const lane of runtimeLanes) {
 		const currentTask = lane.tasks.length > 0 ? lane.tasks[0] : null;
-		runtimeLookup.set(lane.tmuxSessionName, {
+		runtimeLookup.set(lane.laneSessionId, {
 			laneId: lane.laneId,
 			taskId: currentTask?.taskId || null,
 			worktreePath: lane.worktreePath,
@@ -143,6 +142,47 @@ export function planAbortActions(
 	];
 }
 
+/**
+ * Discover abort target session names from Runtime V2 state sources.
+ *
+ * Sources (deduped):
+ * - in-memory runtime lanes (`batchState.currentLanes`)
+ * - persisted lane records (`persistedState.lanes`)
+ * - persisted task records (`persistedState.tasks[].sessionName`)
+ */
+export function discoverAbortSessionNames(
+	prefix: string,
+	persistedState: PersistedBatchState | null,
+	runtimeLanes: AllocatedLane[],
+): string[] {
+	const names = new Set<string>();
+	const prefixWithDash = `${prefix}-`;
+	const add = (name: string | null | undefined) => {
+		if (!name) return;
+		const trimmed = name.trim();
+		if (!trimmed || !trimmed.startsWith(prefixWithDash)) return;
+		names.add(trimmed);
+	};
+
+	for (const lane of runtimeLanes) {
+		add(lane.laneSessionId);
+	}
+
+	if (persistedState?.lanes) {
+		for (const lane of persistedState.lanes) {
+			add(lane.laneSessionId);
+		}
+	}
+
+	if (persistedState?.tasks) {
+		for (const task of persistedState.tasks) {
+			add(task.sessionName);
+		}
+	}
+
+	return [...names];
+}
+
 
 // ── Abort Orchestration Functions ────────────────────────────────────
 
@@ -198,14 +238,15 @@ export function writeWrapUpFiles(
 }
 
 /**
- * Wait for TMUX sessions to exit gracefully.
+ * Wait for graceful shutdown window to elapse.
  *
- * Polls every `pollIntervalMs` until all sessions have exited or the
- * grace period expires.
+ * Runtime V2 no longer relies on TMUX session liveness as an abort signal.
+ * We keep this grace window so workers can observe `.task-wrap-up` and exit
+ * naturally before forced cleanup.
  *
- * @param sessionNames     - Session names to monitor
+ * @param sessionNames     - Session names being tracked for abort
  * @param gracePeriodMs    - Maximum time to wait
- * @param pollIntervalMs   - Polling interval
+ * @param pollIntervalMs   - Polling cadence for the grace wait loop
  * @returns Object with exited and remaining session names
  */
 export async function waitForSessionExit(
@@ -213,69 +254,52 @@ export async function waitForSessionExit(
 	gracePeriodMs: number,
 	pollIntervalMs: number,
 ): Promise<{ exited: string[]; remaining: string[] }> {
+	if (sessionNames.length === 0 || gracePeriodMs <= 0) {
+		return { exited: [], remaining: [...sessionNames] };
+	}
+
 	const deadline = Date.now() + gracePeriodMs;
-	const exited: string[] = [];
-	const remaining = new Set(sessionNames);
-
-	while (Date.now() < deadline && remaining.size > 0) {
-		for (const name of [...remaining]) {
-			if (!tmuxHasSession(name)) {
-				remaining.delete(name);
-				exited.push(name);
-			}
-		}
-		if (remaining.size === 0) break;
-		await new Promise(r => setTimeout(r, pollIntervalMs));
+	while (Date.now() < deadline) {
+		const sleepMs = Math.max(1, Math.min(pollIntervalMs, deadline - Date.now()));
+		await new Promise(r => setTimeout(r, sleepMs));
 	}
 
-	return { exited, remaining: [...remaining] };
+	return { exited: [], remaining: [...sessionNames] };
 }
 
 /**
- * Kill orchestrator TMUX sessions.
+ * Kill orchestrator Runtime V2 agents.
  *
- * Kills each session and its children (worker, reviewer).
- * Returns per-session kill results.
+ * Kills lane worker/reviewer agents and merge agents by process handle.
+ * Session names are normalized to base lane/merge IDs so child suffixes do
+ * not trigger duplicate cleanup attempts.
  *
  * @param sessionNames - Session names to kill
  * @returns Per-session kill results
  */
 export function killOrchSessions(
 	sessionNames: string[],
+	options?: { stateRoot?: string; batchId?: string },
 ): Array<{ sessionName: string; killed: boolean; error: string | null }> {
 	const results: Array<{ sessionName: string; killed: boolean; error: string | null }> = [];
+	const killedBaseSessions = new Set<string>();
+
+	for (const name of sessionNames) {
+		const baseSessionName = name.replace(/-(worker|reviewer)$/, "");
+		if (!killedBaseSessions.has(baseSessionName)) {
+			killV2LaneAgents(baseSessionName, {
+				stateRoot: options?.stateRoot,
+				batchId: options?.batchId,
+				logContext: "abort",
+			});
+			killMergeAgentV2(baseSessionName);
+			killedBaseSessions.add(baseSessionName);
+		}
 
-	// Group into base sessions (lane/merge) and child sessions
-	const baseSessionNames = sessionNames.filter(name =>
-		!name.endsWith("-worker") && !name.endsWith("-reviewer"),
-	);
-	const childSessionNames = sessionNames.filter(name =>
-		name.endsWith("-worker") || name.endsWith("-reviewer"),
-	);
-
-	// Kill explicitly-targeted child sessions first.
-	for (const name of childSessionNames) {
-		const killed = tmuxKillSession(name);
-		results.push({
-			sessionName: name,
-			killed,
-			error: killed ? null : `Session '${name}' still alive after kill attempt`,
-		});
-	}
-
-	// Then kill base sessions (and defensively kill their children).
-	for (const name of baseSessionNames) {
-		// Best-effort child cleanup even if not explicitly targeted.
-		tmuxKillSession(`${name}-worker`);
-		tmuxKillSession(`${name}-reviewer`);
-		// TP-108: Also kill V2 merge agents (no-op if not V2)
-		killMergeAgentV2(name);
-
-		const killed = tmuxKillSession(name);
 		results.push({
 			sessionName: name,
-			killed,
-			error: killed ? null : `Session '${name}' still alive after kill attempt`,
+			killed: true,
+			error: null,
 		});
 	}
 
@@ -296,7 +320,7 @@ export function killOrchSessions(
  * Non-goal: does NOT delete worktrees/branches (preserved for inspection).
  *
  * @param mode           - Abort mode (graceful or hard)
- * @param prefix         - TMUX session prefix (e.g., "orch")
+ * @param prefix         - orchestrator session prefix (e.g., "orch")
  * @param repoRoot       - Repository root path
  * @param batchState     - Current batch runtime state (mutated: phase set to stopped)
  * @param persistedState - Loaded persisted state (for session enrichment)
@@ -342,28 +366,10 @@ export async function executeAbort(
 		execLog("abort", batchState.batchId, `killed ${v2MergeKilled} V2 merge agent(s)`);
 	}
 
-	// Step 3: List all orch sessions (TMUX — legacy + fallback)
-	let allSessionNames: string[];
-	try {
-		allSessionNames = parseOrchSessionNames(
-			(() => {
-				try {
-					return execSync('tmux list-sessions -F "#{session_name}"', {
-						encoding: "utf-8",
-						timeout: 5000,
-					});
-				} catch {
-					return "";
-				}
-			})(),
-			prefix,
-		);
-	} catch (err) {
-		errors.push({
-			code: "ABORT_TMUX_LIST_FAILED",
-			message: err instanceof Error ? err.message : String(err),
-		});
-		allSessionNames = [];
+	// Step 3: Discover target sessions from Runtime V2 state sources.
+	const allSessionNames = discoverAbortSessionNames(prefix, persistedState, batchState.currentLanes);
+	if (allSessionNames.length === 0) {
+		execLog("abort", batchState.batchId, `No abort targets discovered for prefix "${prefix}" from runtime/persisted state.`);
 	}
 
 	// Step 4: Select and enrich target sessions
@@ -400,7 +406,10 @@ export async function executeAbort(
 		// Step 5c: Force-kill remaining sessions
 		const killResultBySession = new Map<string, { killed: boolean; error: string | null }>();
 		if (waitResult.remaining.length > 0) {
-			const killResults = killOrchSessions(waitResult.remaining);
+			const killResults = killOrchSessions(waitResult.remaining, {
+				stateRoot: repoRoot,
+				batchId: batchState.batchId,
+			});
 			for (const kr of killResults) {
 				killResultBySession.set(kr.sessionName, { killed: kr.killed, error: kr.error });
 			}
@@ -434,7 +443,10 @@ export async function executeAbort(
 	} else {
 		// Hard mode: kill all immediately
 		const allTargetNames = targets.map(t => t.sessionName);
-		const killResults = killOrchSessions(allTargetNames);
+		const killResults = killOrchSessions(allTargetNames, {
+			stateRoot: repoRoot,
+			batchId: batchState.batchId,
+		});
 		const killResultBySession = new Map<string, { killed: boolean; error: string | null }>();
 		for (const kr of killResults) {
 			killResultBySession.set(kr.sessionName, { killed: kr.killed, error: kr.error });

package/extensions/taskplane/agent-host.ts

@@ -1,17 +1,16 @@
 /**
  * Agent Host — Direct-child Pi agent hosting for Runtime V2
  *
- * Spawns `pi --mode rpc` as a direct child process (no TMUX, no shell),
+ * Spawns `pi --mode rpc` as a direct child process (no terminal multiplexer, no shell),
  * parses RPC JSONL events, normalizes them into RuntimeAgentEvents,
  * manages mailbox delivery, and produces exit summaries.
  *
- * This replaces the TMUX-backed hosting path (spawnAgentTmux in
- * task-runner.ts + rpc-wrapper.mjs as a TMUX session command) with
+ * This replaces the legacy terminal-session hosting path with
  * a programmatic parent-child model where the caller has full process
  * ownership.
  *
  * Key differences from the legacy path:
- *   1. No TMUX — `spawn()` with `shell: false`
+ *   1. No terminal-session backend — `spawn()` with `shell: false`
  *   2. No sidecar tailing — events flow directly to the caller via callbacks
  *   3. No PID-file orphan guessing — caller owns the process handle
  *   4. Registry integration — manifests updated on status transitions
@@ -301,7 +300,7 @@ export function spawnAgent(
 	piArgs.push("--no-skills");
 	if (opts.thinking) piArgs.push("--thinking", opts.thinking);
 
-	// Spawn directly — no shell, no TMUX
+	// Spawn directly — no shell, no terminal multiplexer
 	const proc = spawn(process.execPath, piArgs, {
 		shell: false,
 		cwd: opts.cwd,