taskplane 0.23.16 → 0.24.0

package/extensions/taskplane/extension.ts

@@ -15,9 +15,9 @@ import { ORCH_MESSAGES, computeIntegrateCleanupResult } from "./messages.ts";
 import type { IntegrateCleanupRepoFindings } from "./messages.ts";
 import { computeWaveAssignments } from "./waves.ts";
 import { createOrchWidget, formatDependencyGraph, formatWavePlan } from "./formatting.ts";
-import { deleteBatchState, loadBatchState, saveBatchState, detectOrphanSessions, parseOrchSessionNames } from "./persistence.ts";
+import { deleteBatchState, loadBatchState, saveBatchState, detectOrphanSessions } from "./persistence.ts";
 import { deleteStaleBranches, listWorktrees, resolveWorktreeBasePath, formatPreflightResults, runPreflight } from "./worktree.ts";
-import { computeTransitiveDependents, executeLane, resolveCanonicalTaskPaths, tmuxHasSession } from "./execution.ts";
+import { computeTransitiveDependents, resolveCanonicalTaskPaths } from "./execution.ts";
 import { executeOrchBatch } from "./engine.ts";
 import { formatDiscoveryResults, runDiscovery } from "./discovery.ts";
 import { formatOrchSessions, listOrchSessions } from "./sessions.ts";
@@ -29,6 +29,7 @@ import { buildExecutionContext } from "./workspace.ts";
 import { openSettingsTui } from "./settings-tui.ts";
 import { loadProjectConfig } from "./config-loader.ts";
 import { runMigrations } from "./migrations.ts";
+import { executeAbort } from "./abort.ts";
 import { serializeWorkspaceConfig, applySerializedState, deserializeWorkspaceConfig } from "./engine-worker.ts";
 import type { EngineWorkerData, WorkerToMainMessage } from "./engine-worker.ts";
 import { cleanupPostIntegrate, formatPostIntegrateCleanup, sweepStaleArtifacts, formatPreflightSweep, rotateSupervisorLogs, formatLogRotation } from "./cleanup.ts";
@@ -1481,7 +1482,7 @@ export default function (pi: ExtensionAPI) {
 	function updateOrchWidget() {
 		if (!orchWidgetCtx) return;
 		const ctx = orchWidgetCtx;
-		const prefix = orchConfig.orchestrator.tmux_prefix;
+		const prefix = orchConfig.orchestrator.sessionPrefix;
 
 		ctx.ui.setWidget(
 			"task-orchestrator",
@@ -1641,6 +1642,7 @@ export default function (pi: ExtensionAPI) {
 			}
 
 			// ── Section 1: Preflight ─────────────────────────────────
+			ctx.ui.notify("ℹ️ Runtime V2 is the default backend (subprocess-only).", "info");
 			const preflight = runPreflight(orchConfig, execCtx!.repoRoot);
 			ctx.ui.notify(formatPreflightResults(preflight), preflight.passed ? "info" : "error");
 			if (!preflight.passed) return;
@@ -1783,7 +1785,7 @@ export default function (pi: ExtensionAPI) {
 
 		// Orphan detection
 		const orphanResult = detectOrphanSessions(
-			orchConfig.orchestrator.tmux_prefix,
+			orchConfig.orchestrator.sessionPrefix,
 			repoRoot,
 		);
 
@@ -2215,9 +2217,9 @@ export default function (pi: ExtensionAPI) {
 	 * Core logic for orch-abort. Returns accumulated status messages.
 	 * Works even without execCtx (safety-critical).
 	 */
-	function doOrchAbort(hard: boolean, ctx: ExtensionContext): string {
+	async function doOrchAbort(hard: boolean, ctx: ExtensionContext): Promise<string> {
 		const mode: AbortMode = hard ? "hard" : "graceful";
-		const prefix = orchConfig.orchestrator.tmux_prefix;
+		const prefix = orchConfig.orchestrator.sessionPrefix;
 
 		const stateRoot = execCtx?.repoRoot ?? ctx.cwd;
 		const messages: string[] = [`🛑 Abort requested (${mode} mode, prefix: ${prefix})...`];
@@ -2249,7 +2251,6 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
-		// Step 3: Check what we're aborting
 		const hasActiveBatch = orchBatchState.phase !== "idle" &&
 			orchBatchState.phase !== "completed" &&
 			orchBatchState.phase !== "failed" &&
@@ -2267,67 +2268,25 @@ export default function (pi: ExtensionAPI) {
 			`persisted=${persistedState ? persistedState.batchId : "none"}`,
 		);
 
-		// If no batch AND no sessions, nothing to abort
 		if (!hasActiveBatch && !persistedState) {
-			// Still check for sessions below, but short-circuit if none
-			let allSessionNames: string[] = [];
-			try {
-				const tmuxOutput = execSync('tmux list-sessions -F "#{session_name}"', {
-					encoding: "utf-8",
-					timeout: 5000,
-				}).trim();
-				const all = tmuxOutput ? tmuxOutput.split("\n").map(s => s.trim()).filter(Boolean) : [];
-				allSessionNames = all.filter(name => name.startsWith(`${prefix}-`));
-			} catch {
-				// tmux not available
-			}
-			if (allSessionNames.length === 0) {
-				try { unlinkSync(abortSignalFile); } catch {}
-				return ORCH_MESSAGES.abortNoBatch();
-			}
+			try { unlinkSync(abortSignalFile); } catch {}
+			return ORCH_MESSAGES.abortNoBatch();
 		}
 
 		const batchId = orchBatchState.batchId || persistedState?.batchId || "unknown";
+		const gracePeriodMs = Math.max(0, orchConfig.failure.abort_grace_period * 1000);
+		const pollIntervalMs = Math.max(250, orchConfig.monitoring.poll_interval * 1000);
 
-		// Step 5: Kill sessions
-		let allSessionNames: string[] = [];
-		try {
-			const tmuxOutput = execSync('tmux list-sessions -F "#{session_name}"', {
-				encoding: "utf-8",
-				timeout: 5000,
-			}).trim();
-			const all = tmuxOutput ? tmuxOutput.split("\n").map(s => s.trim()).filter(Boolean) : [];
-			allSessionNames = all.filter(name => name.startsWith(`${prefix}-`));
-			messages.push(`  Found ${allSessionNames.length} session(s) matching prefix "${prefix}-"`);
-		} catch {
-			messages.push("  ⚠ Could not list tmux sessions (tmux not available?)");
-		}
-
-		if (allSessionNames.length > 0) {
-			messages.push(`  Killing ${allSessionNames.length} tmux session(s)...`);
-			let killed = 0;
-			for (const name of allSessionNames) {
-				try {
-					execSync(`tmux kill-session -t "${name}-worker" 2>/dev/null`, { timeout: 3000 }).toString();
-				} catch {}
-				try {
-					execSync(`tmux kill-session -t "${name}-reviewer" 2>/dev/null`, { timeout: 3000 }).toString();
-				} catch {}
-				try {
-					execSync(`tmux kill-session -t "${name}" 2>/dev/null`, { timeout: 3000 }).toString();
-					killed++;
-					messages.push(`    ✓ Killed: ${name}`);
-				} catch {
-					messages.push(`    · ${name} (already exited)`);
-					killed++;
-				}
-			}
-			messages.push(`  ✓ ${killed}/${allSessionNames.length} session(s) terminated`);
-		} else {
-			messages.push("  No tmux sessions to kill");
-		}
+		const abortResult = await executeAbort(
+			mode,
+			prefix,
+			stateRoot,
+			orchBatchState,
+			persistedState,
+			gracePeriodMs,
+			pollIntervalMs,
+		);
 
-		// Step 6: Clean up batch state
 		deactivateSupervisor(pi, supervisorState);
 
 		try {
@@ -2339,19 +2298,30 @@ export default function (pi: ExtensionAPI) {
 			messages.push(`  ⚠ Failed to update in-memory state: ${err instanceof Error ? err.message : String(err)}`);
 		}
 
-		try {
-			deleteBatchState(stateRoot);
-			messages.push("  ✓ Batch state file deleted (.pi/batch-state.json)");
-		} catch (err) {
-			messages.push(`  ⚠ Failed to delete batch state file: ${err instanceof Error ? err.message : String(err)}`);
+		messages.push(`  Found ${abortResult.sessionsFound} session target(s) matching prefix "${prefix}-"`);
+		if (mode === "graceful") {
+			const forceKilled = Math.max(0, abortResult.sessionsKilled - abortResult.gracefulExits);
+			messages.push(ORCH_MESSAGES.abortGracefulComplete(batchId, abortResult.gracefulExits, forceKilled, Math.round(abortResult.durationMs / 1000)));
+		} else {
+			messages.push(ORCH_MESSAGES.abortHardComplete(batchId, abortResult.sessionsKilled, Math.round(abortResult.durationMs / 1000)));
+		}
+
+		if (!abortResult.stateDeleted) {
+			messages.push("  ⚠ Batch state file was not deleted cleanly");
+		}
+		if (abortResult.errors.length > 0) {
+			messages.push(ORCH_MESSAGES.abortPartialFailure(abortResult.errors.length));
+			for (const err of abortResult.errors) {
+				messages.push(`    - ${err.code}: ${err.message}`);
+			}
 		}
 
 		// Step 7: Clean up abort signal file
 		try { unlinkSync(abortSignalFile); } catch {}
 
 		messages.push(
-			`✅ Abort complete for batch ${batchId}. Sessions killed, state cleaned up.\n` +
-			`   Worktrees and branches are preserved for inspection.`,
+			`🏁 Abort (${mode}) complete for batch ${batchId}. ` +
+			`Worktrees and branches are preserved for inspection.`,
 		);
 
 		return messages.join("\n");
@@ -3091,15 +3061,13 @@ export default function (pi: ExtensionAPI) {
 		handler: async (args, ctx) => {
 			try {
 				const hard = args?.trim() === "--hard";
-				const result = doOrchAbort(hard, ctx);
+				const result = await doOrchAbort(hard, ctx);
 				ctx.ui.notify(result, "info");
 			} catch (err) {
 				// Top-level catch: ensure the user ALWAYS sees something
 				ctx.ui.notify(
 					`❌ Abort failed with error: ${err instanceof Error ? err.message : String(err)}\n` +
-					`   Stack: ${err instanceof Error ? err.stack : "N/A"}\n\n` +
-					`   Manual cleanup: tmux kill-server (kills ALL tmux sessions)\n` +
-					`   Or: tmux kill-session -t <session-name> for each session`,
+					`   Stack: ${err instanceof Error ? err.stack : "N/A"}`,
 					"error",
 				);
 			}
@@ -3185,9 +3153,9 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("orch-sessions", {
-		description: "List active orchestrator TMUX sessions",
+		description: "List active orchestrator sessions",
 		handler: async (_args, ctx) => {
-			const sessions = listOrchSessions(orchConfig.orchestrator.tmux_prefix, orchBatchState);
+			const sessions = listOrchSessions(orchConfig.orchestrator.sessionPrefix, orchBatchState);
 			ctx.ui.notify(formatOrchSessions(sessions), "info");
 		},
 	});
@@ -3445,13 +3413,13 @@ export default function (pi: ExtensionAPI) {
 		name: "orch_abort",
 		label: "Abort Batch",
 		description:
-			"Abort the running batch. Kills tmux sessions, cleans up state. " +
+			"Abort the running batch. Stops Runtime V2 lane + merge agents and cleans up state. " +
 			"Use hard=true for immediate kill (no grace period). " +
 			"Works even without execution context (safety-critical).",
 		promptSnippet: "orch_abort(hard?) — abort the running batch",
 		promptGuidelines: [
 			"Call orch_abort to stop a running batch.",
-			"Default (hard=false) is graceful abort — writes signal file and kills sessions.",
+			"Default (hard=false) is graceful abort — writes signal file and waits for checkpoint exit before forced cleanup.",
 			"Set hard=true for immediate termination without grace period.",
 			"Use this when a batch is stuck, failing repeatedly, or the operator requests it.",
 			"Worktrees and branches are preserved for inspection after abort.",
@@ -3463,7 +3431,7 @@ export default function (pi: ExtensionAPI) {
 		}),
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			try {
-				const result = doOrchAbort(params.hard ?? false, ctx);
+				const result = await doOrchAbort(params.hard ?? false, ctx);
 				return { content: [{ type: "text" as const, text: result }], details: undefined };
 			} catch (err) {
 				return {
@@ -3722,12 +3690,12 @@ export default function (pi: ExtensionAPI) {
 		// Legacy fallback from lane naming when registry is absent/empty.
 		if (ids.size === 0) {
 			const orchConfig = execCtx?.orchestratorConfig;
-			const tmuxPrefix = orchConfig?.orchestrator?.tmux_prefix ?? "orch";
+			const sessionPrefix = orchConfig?.orchestrator?.sessionPrefix ?? "orch";
 			const opId = orchConfig ? resolveOperatorId(orchConfig) : "op";
 			for (const lane of state.lanes) {
-				ids.add(`${lane.tmuxSessionName}-worker`);
-				ids.add(`${lane.tmuxSessionName}-reviewer`);
-				ids.add(`${tmuxPrefix}-${opId}-merge-${lane.laneNumber}`);
+				ids.add(`${lane.laneSessionId}-worker`);
+				ids.add(`${lane.laneSessionId}-reviewer`);
+				ids.add(`${sessionPrefix}-${opId}-merge-${lane.laneNumber}`);
 			}
 		}
 
@@ -3776,21 +3744,16 @@ export default function (pi: ExtensionAPI) {
 			return `❌ Unknown session "${to}" in batch ${state.batchId}.\nValid targets: ${examples}${validSessions.size > 5 ? ` (${validSessions.size} total)` : ""}`;
 		}
 
-		// Guard: ensure the target agent is currently alive.
-		// Check process registry first (Runtime V2), fall back to TMUX (legacy).
+		// Guard: ensure the target agent is currently alive via Runtime V2 registry.
 		let agentAlive = false;
 		try {
 			const registry = readRegistrySnapshot(stateRoot, state.batchId);
 			if (registry && registry.agents[to]) {
 				const manifest = registry.agents[to];
 				agentAlive = !isTerminalStatus(manifest.status) && registryIsProcessAlive(manifest.pid);
-			} else {
-				// No registry entry — fall back to TMUX for legacy batches
-				agentAlive = tmuxHasSession(to);
 			}
 		} catch {
-			// Registry read failed — fall back to TMUX
-			agentAlive = tmuxHasSession(to);
+			// Registry read failure — treat as not alive.
 		}
 		if (!agentAlive) {
 			return `❌ Agent "${to}" is not currently running. Use orch_status() or orch_resume() before sending messages.`;
@@ -4098,7 +4061,7 @@ export default function (pi: ExtensionAPI) {
 			const runningTask = laneTasks.find(t => t.status === "running");
 			const currentTask = runningTask || laneTasks[laneTasks.length - 1];
 
-			lines.push(`### Lane ${laneRec.laneNumber} — ${laneRec.tmuxSessionName}`);
+			lines.push(`### Lane ${laneRec.laneNumber} — ${laneRec.laneSessionId}`);
 			lines.push(`**Branch:** ${laneRec.branch}`);
 
 			if (currentTask) {
@@ -4142,7 +4105,7 @@ export default function (pi: ExtensionAPI) {
 
 			// Read lane-state sidecar
 			try {
-				const lsPath = join(stateRoot, ".pi", `lane-state-${laneRec.tmuxSessionName}.json`);
+				const lsPath = join(stateRoot, ".pi", `lane-state-${laneRec.laneSessionId}.json`);
 				if (existsSync(lsPath)) {
 					const ls = JSON.parse(readFileSync(lsPath, "utf-8"));
 					const parts: string[] = [];
@@ -4378,8 +4341,8 @@ export default function (pi: ExtensionAPI) {
 		name: "list_active_agents",
 		label: "List Active Agents",
 		description:
-			"List all tmux sessions with their role, lane, task, context %, and elapsed time.",
-		promptSnippet: "list_active_agents() — show all tmux sessions with role, lane, task, context %, elapsed",
+			"List all active Runtime V2 agents with their role, lane, task, status, and elapsed time.",
+		promptSnippet: "list_active_agents() — show active Runtime V2 agents with role, lane, task, status, elapsed",
 		promptGuidelines: [
 			"Call list_active_agents to see all running agent sessions.",
 			"Shows: session name, role (worker/reviewer/merger/supervisor), lane, task, context %, elapsed.",
@@ -4399,7 +4362,7 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	/**
-	 * List all active tmux sessions with agent metadata.
+	 * List all active Runtime V2 agents using the persisted registry.
 	 * @since TP-096
 	 */
 	function doListActiveAgents(ctx: ExtensionContext): string {
@@ -4414,99 +4377,7 @@ export default function (pi: ExtensionAPI) {
 			}
 		}
 
-		// Fall back to TMUX-based discovery for legacy batches
-		let sessions: string[] = [];
-		try {
-			const output = execSync('tmux list-sessions -F "#{session_name}"', {
-				encoding: "utf-8",
-				timeout: 5000,
-				stdio: ["ignore", "pipe", "ignore"],
-			}).trim();
-			sessions = output ? output.split("\n").map(s => s.trim()).filter(Boolean) : [];
-		} catch {
-			return "❌ No active agents found (no registry and no tmux sessions).";
-		}
-
-		if (sessions.length === 0) return "❌ No active agents found.";
-
-		// state already loaded above for registry check (may be null)
-
-		// Build a map of session name → lane-state data
-		const laneStates: Record<string, any> = {};
-		try {
-			const piDir = join(stateRoot, ".pi");
-			if (existsSync(piDir)) {
-				const files = readdirSync(piDir).filter(f => f.startsWith("lane-state-") && f.endsWith(".json"));
-				for (const file of files) {
-					try {
-						const data = JSON.parse(readFileSync(join(piDir, file), "utf-8"));
-						if (data.prefix) laneStates[data.prefix] = data;
-					} catch { continue; }
-				}
-			}
-		} catch { /* .pi dir missing */ }
-
-		const lines: string[] = [];
-		lines.push(`👥 **Active Agents** (${sessions.length} sessions)\n`);
-
-		// Parse each session name to extract role, lane, etc.
-		for (const sess of sessions) {
-			let role = "unknown";
-			let laneNum = "";
-			let taskId = "";
-			let contextPct = "";
-			let elapsed = "";
-			let costStr = "";
-
-			// Parse session name pattern:
-			// Workers/reviewers: orch-{opId}-lane-{N} (or -worker/-reviewer suffix)
-			// Mergers: orch-{opId}-merge-{N}
-			// Supervisor: pi-supervisor-{...}
-			const laneMatch = sess.match(/-lane-(\d+)/);
-			const mergeMatch = sess.match(/-merge-(\d+)/);
-
-			if (mergeMatch) {
-				role = "merger";
-				laneNum = mergeMatch[1];
-			} else if (laneMatch) {
-				if (sess.includes("-reviewer")) {
-					role = "reviewer";
-				} else {
-					role = "worker";
-				}
-				laneNum = laneMatch[1];
-			} else if (sess.includes("supervisor")) {
-				role = "supervisor";
-			}
-
-			// Find matching task and lane-state
-			if (state && laneNum) {
-				const ln = parseInt(laneNum);
-				const task = state.tasks.find(t => t.laneNumber === ln && t.status === "running");
-				if (task) taskId = task.taskId;
-
-				// Find lane-state prefix (may be the session name or a prefix of it)
-				const laneRec = state.lanes.find(l => l.laneNumber === ln);
-				const prefix = laneRec?.tmuxSessionName || sess;
-				const ls = laneStates[prefix];
-				if (ls) {
-					if (ls.workerContextPct) contextPct = `${Math.round(ls.workerContextPct)}%`;
-					if (ls.workerElapsed) elapsed = `${Math.round(ls.workerElapsed / 1000)}s`;
-					if (ls.workerCostUsd) costStr = `$${ls.workerCostUsd.toFixed(3)}`;
-				}
-			}
-
-			const parts: string[] = [`**${sess}**`];
-			parts.push(`role: ${role}`);
-			if (laneNum) parts.push(`lane: ${laneNum}`);
-			if (taskId) parts.push(`task: ${taskId}`);
-			if (contextPct) parts.push(`ctx: ${contextPct}`);
-			if (elapsed) parts.push(`elapsed: ${elapsed}`);
-			if (costStr) parts.push(`cost: ${costStr}`);
-			lines.push(`- ${parts.join(" · ")}`);
-		}
-
-		return lines.join("\n");
+		return "❌ No active agents found (Runtime V2 registry is empty).";
 	}
 
 
@@ -4744,14 +4615,14 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.notify(
 			"Task Orchestrator ready\n\n" +
 			`Mode: ${modeLabel}\n` +
+			`Runtime: V2 default (configured spawn_mode: ${orchConfig.orchestrator.spawn_mode})\n` +
 			`Config: ${orchConfig.orchestrator.max_lanes} lanes, ` +
-			`${orchConfig.orchestrator.spawn_mode} mode, ` +
 			`${orchConfig.dependencies.source} deps\n` +
 			`Areas: ${areaCount} registered\n\n` +
 			"/orch <areas|all>        Start batch execution\n" +
 			"/orch-plan <areas|all>   Preview execution plan\n" +
 			"/orch-deps <areas|all>   Show dependency graph\n" +
-			"/orch-sessions           List TMUX sessions\n" +
+			"/orch-sessions           List orchestrator sessions\n" +
 			"/orch-takeover           Force supervisor takeover\n" +
 			"/orch-integrate          Integrate orch branch into working branch",
 			"info",

package/extensions/taskplane/formatting.ts

@@ -401,7 +401,7 @@ export function buildDashboardViewModel(
 			laneCards.push({
 				laneNumber: lane.laneNumber,
 				laneId: lane.laneId,
-				sessionName: lane.tmuxSessionName,
+				sessionName: lane.laneSessionId,
 				sessionAlive: true, // assumed alive during allocation
 				currentTaskId: lane.tasks.length > 0 ? lane.tasks[0].taskId : null,
 				currentStepName: null,
@@ -419,9 +419,9 @@ export function buildDashboardViewModel(
 	let attachHint = "";
 	const aliveLane = laneCards.find(l => l.sessionAlive && l.status === "running");
 	if (aliveLane) {
-		attachHint = `tmux attach -t ${aliveLane.sessionName}`;
+		attachHint = `Use /orch-sessions to inspect active lane sessions (${aliveLane.sessionName})`;
 	} else if (laneCards.length > 0) {
-		attachHint = "/orch-sessions for session list";
+		attachHint = "Use /orch-sessions for active lane session list";
 	}
 
 	// Determine failure policy if batch was stopped
@@ -545,12 +545,12 @@ export function renderLaneCard(card: OrchLaneCardData, colWidth: number, theme:
  *
  * @param getBatchState   - Getter for current batch state
  * @param getMonitorState - Getter for current monitor state (may be null)
- * @param tmuxPrefix      - TMUX session prefix for attach hints
+ * @param sessionPrefix   - Session prefix for lane identification
  */
 export function createOrchWidget(
 	getBatchState: () => OrchBatchRuntimeState,
 	getMonitorState: () => MonitorState | null,
-	tmuxPrefix: string,
+	sessionPrefix: string,
 ): (_tui: any, theme: any) => { render(width: number): string[]; invalidate(): void } {
 	return (_tui: any, theme: any) => {
 		return {