taskplane 0.23.16 → 0.24.0

package/extensions/taskplane/config-loader.ts

@@ -56,11 +56,13 @@ import type {
  * - CONFIG_JSON_MALFORMED: File exists but is not valid JSON
  * - CONFIG_VERSION_UNSUPPORTED: configVersion is not supported by this version
  * - CONFIG_VERSION_MISSING: configVersion field is missing from JSON
+ * - CONFIG_LEGACY_FIELD: removed TMUX-era field/value detected; migration required
  */
 export type ConfigLoadErrorCode =
 	| "CONFIG_JSON_MALFORMED"
 	| "CONFIG_VERSION_UNSUPPORTED"
-	| "CONFIG_VERSION_MISSING";
+	| "CONFIG_VERSION_MISSING"
+	| "CONFIG_LEGACY_FIELD";
 
 export class ConfigLoadError extends Error {
 	code: ConfigLoadErrorCode;
@@ -110,6 +112,61 @@ function deepMerge<T extends Record<string, any>>(target: T, source: Record<stri
 	return target;
 }
 
+function hasOwn(obj: unknown, key: string): boolean {
+	return !!obj && typeof obj === "object" && Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function throwLegacyFieldError(fieldPath: string, source: string, fixHint: string): never {
+	throw new ConfigLoadError(
+		"CONFIG_LEGACY_FIELD",
+		`[taskplane] ${source}: "${fieldPath}" is no longer supported under Runtime V2. ${fixHint}`,
+	);
+}
+
+function assertNoLegacyTmuxProjectConfig(config: TaskplaneConfig, source: string): void {
+	const orchestratorCore = config.orchestrator?.orchestrator as Record<string, unknown> | undefined;
+	if (hasOwn(orchestratorCore, "tmuxPrefix")) {
+		throwLegacyFieldError(
+			"orchestrator.orchestrator.tmuxPrefix",
+			source,
+			"Use \"orchestrator.orchestrator.sessionPrefix\" instead.",
+		);
+	}
+	if (orchestratorCore?.spawnMode === "tmux") {
+		throwLegacyFieldError(
+			"orchestrator.orchestrator.spawnMode",
+			source,
+			"Use \"subprocess\" instead.",
+		);
+	}
+
+	const workerConfig = config.taskRunner?.worker as Record<string, unknown> | undefined;
+	if (workerConfig?.spawnMode === "tmux") {
+		throwLegacyFieldError(
+			"taskRunner.worker.spawnMode",
+			source,
+			"Use \"subprocess\" or remove the field to inherit defaults.",
+		);
+	}
+}
+
+function assertNoLegacyTmuxUserPreferences(raw: Record<string, any>, prefsPath: string): void {
+	if (hasOwn(raw, "tmuxPrefix")) {
+		throwLegacyFieldError(
+			"tmuxPrefix",
+			`user preferences (${prefsPath})`,
+			"Rename it to \"sessionPrefix\".",
+		);
+	}
+	if (raw.spawnMode === "tmux") {
+		throwLegacyFieldError(
+			"spawnMode",
+			`user preferences (${prefsPath})`,
+			"Set it to \"subprocess\".",
+		);
+	}
+}
+
 
 // ── YAML snake_case → camelCase Mapping ──────────────────────────────
 
@@ -600,19 +657,25 @@ export function loadUserPreferences(): UserPreferences {
 	}
 
 	// Extract only allowlisted fields — unknown keys are ignored
-	return extractAllowlistedPreferences(parsed);
+	return extractAllowlistedPreferences(parsed, prefsPath);
 }
 
 /**
  * Extract only recognized/allowlisted fields from a raw parsed object.
  * Unknown keys are silently dropped — this is the Layer 2 boundary guardrail.
  */
-function extractAllowlistedPreferences(raw: Record<string, any>): UserPreferences {
+function extractAllowlistedPreferences(raw: Record<string, any>, prefsPath: string): UserPreferences {
+	assertNoLegacyTmuxUserPreferences(raw, prefsPath);
+
 	const prefs: UserPreferences = {};
 
 	if (typeof raw.operatorId === "string") prefs.operatorId = raw.operatorId;
-	if (typeof raw.tmuxPrefix === "string") prefs.tmuxPrefix = raw.tmuxPrefix;
-	if (raw.spawnMode === "tmux" || raw.spawnMode === "subprocess") prefs.spawnMode = raw.spawnMode;
+	if (typeof raw.sessionPrefix === "string") {
+		prefs.sessionPrefix = raw.sessionPrefix;
+	}
+	if (raw.spawnMode === "subprocess") {
+		prefs.spawnMode = "subprocess";
+	}
 	if (typeof raw.workerModel === "string") prefs.workerModel = raw.workerModel;
 	if (typeof raw.reviewerModel === "string") prefs.reviewerModel = raw.reviewerModel;
 	if (typeof raw.mergeModel === "string") prefs.mergeModel = raw.mergeModel;
@@ -638,7 +701,7 @@ function extractAllowlistedPreferences(raw: Record<string, any>): UserPreference
  *
  * Mapping table:
  *   prefs.operatorId    → config.orchestrator.orchestrator.operatorId
- *   prefs.tmuxPrefix    → config.orchestrator.orchestrator.tmuxPrefix
+ *   prefs.sessionPrefix → config.orchestrator.orchestrator.sessionPrefix
  *   prefs.spawnMode     → config.orchestrator.orchestrator.spawnMode
  *   prefs.workerModel   → config.taskRunner.worker.model
  *   prefs.reviewerModel → config.taskRunner.reviewer.model
@@ -653,7 +716,7 @@ export function applyUserPreferences(config: TaskplaneConfig, prefs: UserPrefere
 	};
 
 	applyStr(prefs.operatorId, (v) => { config.orchestrator.orchestrator.operatorId = v; });
-	applyStr(prefs.tmuxPrefix, (v) => { config.orchestrator.orchestrator.tmuxPrefix = v; });
+	applyStr(prefs.sessionPrefix, (v) => { config.orchestrator.orchestrator.sessionPrefix = v; });
 	applyStr(prefs.workerModel, (v) => { config.taskRunner.worker.model = v; });
 	applyStr(prefs.reviewerModel, (v) => { config.taskRunner.reviewer.model = v; });
 	applyStr(prefs.mergeModel, (v) => { config.orchestrator.merge.model = v; });
@@ -661,6 +724,13 @@ export function applyUserPreferences(config: TaskplaneConfig, prefs: UserPrefere
 
 	// spawnMode: enum — apply if defined (not a string-empty check)
 	if (prefs.spawnMode !== undefined) {
+		if (prefs.spawnMode === "tmux") {
+			throwLegacyFieldError(
+				"spawnMode",
+				"user preferences (runtime)",
+				"Set it to \"subprocess\".",
+			);
+		}
 		config.orchestrator.orchestrator.spawnMode = prefs.spawnMode;
 	}
 
@@ -670,7 +740,6 @@ export function applyUserPreferences(config: TaskplaneConfig, prefs: UserPrefere
 	return config;
 }
 
-
 // ── Unified Loader ───────────────────────────────────────────────────
 
 /**
@@ -784,9 +853,12 @@ export function loadProjectConfig(cwd: string, pointerConfigRoot?: string): Task
 		};
 	}
 
+	assertNoLegacyTmuxProjectConfig(config, `project config (${configRoot})`);
+
 	// Layer 2: User preferences (allowlisted fields only)
 	const prefs = loadUserPreferences();
 	applyUserPreferences(config, prefs);
+	assertNoLegacyTmuxProjectConfig(config, `project config (${configRoot}) after preferences merge`);
 
 	return config;
 }
@@ -810,6 +882,7 @@ export function loadLayer1Config(cwd: string, pointerConfigRoot?: string): Taskp
 	// Try JSON first
 	const jsonConfig = loadJsonConfig(configRoot);
 	if (jsonConfig !== null) {
+		assertNoLegacyTmuxProjectConfig(jsonConfig, `project config (${configRoot})`);
 		return jsonConfig;
 	}
 
@@ -817,12 +890,14 @@ export function loadLayer1Config(cwd: string, pointerConfigRoot?: string): Taskp
 	const taskRunner = loadTaskRunnerYaml(configRoot);
 	const orchestrator = loadOrchestratorYaml(configRoot);
 	const workspace = loadWorkspaceYaml(configRoot);
-	return {
+	const config: TaskplaneConfig = {
 		configVersion: CONFIG_VERSION,
 		taskRunner,
 		orchestrator,
 		...(workspace ? { workspace } : {}),
 	};
+	assertNoLegacyTmuxProjectConfig(config, `project config (${configRoot})`);
+	return config;
 }
 
 
@@ -847,7 +922,7 @@ export function toOrchestratorConfig(config: TaskplaneConfig): import("./types.t
 			worktree_prefix: o.orchestrator.worktreePrefix,
 			batch_id_format: o.orchestrator.batchIdFormat,
 			spawn_mode: o.orchestrator.spawnMode,
-			tmux_prefix: o.orchestrator.tmuxPrefix,
+			sessionPrefix: o.orchestrator.sessionPrefix,
 			operator_id: o.orchestrator.operatorId,
 			integration: o.orchestrator.integration,
 		},
@@ -942,7 +1017,7 @@ export function toTaskConfig(config: TaskplaneConfig): {
 	standards: { docs: string[]; rules: string[] };
 	standards_overrides: Record<string, { docs?: string[]; rules?: string[] }>;
 	task_areas: Record<string, { path: string; [key: string]: any }>;
-	worker: { model: string; tools: string; thinking: string; spawn_mode?: "subprocess" | "tmux" };
+	worker: { model: string; tools: string; thinking: string; spawn_mode?: "subprocess" };
 	reviewer: { model: string; tools: string; thinking: string };
 	context: {
 		worker_context_window: number;

package/extensions/taskplane/config-schema.ts

@@ -109,8 +109,8 @@ export interface WorkerConfig {
 	tools: string;
 	/** Thinking mode setting passed to worker agent */
 	thinking: string;
-	/** Optional spawn mode override for task-runner */
-	spawnMode?: "subprocess" | "tmux";
+	/** Optional spawn mode override for task-runner (Runtime V2 subprocess-only). */
+	spawnMode?: "subprocess";
 }
 
 /** Reviewer agent configuration */
@@ -139,7 +139,7 @@ export interface ContextConfig {
 	maxReviewCycles: number;
 	/** Max no-progress iterations before marking failure */
 	noProgressLimit: number;
-	/** Optional per-worker wall-clock cap (minutes, used in tmux/orchestrated flows) */
+	/** Optional per-worker wall-clock cap (minutes, used in orchestrated flows) */
 	maxWorkerMinutes?: number;
 }
 
@@ -260,10 +260,10 @@ export interface OrchestratorCoreConfig {
 	worktreePrefix: string;
 	/** Batch ID format used in logs/branch naming */
 	batchIdFormat: "timestamp" | "sequential";
-	/** How lane sessions are spawned */
-	spawnMode: "tmux" | "subprocess";
-	/** Prefix for orchestrator tmux sessions (tmux mode) */
-	tmuxPrefix: string;
+	/** How lane sessions are spawned (Runtime V2 subprocess-only). */
+	spawnMode: "subprocess";
+	/** Prefix for orchestrator session naming */
+	sessionPrefix: string;
 	/** Operator identifier. Auto-detected from OS username if empty */
 	operatorId: string;
 	/** How completed batches are integrated. manual = user runs /orch-integrate. supervised = supervisor proposes plan, asks confirmation. auto = supervisor executes without asking. */
@@ -498,7 +498,7 @@ export interface TaskplaneConfig {
  * | Preference field   | Config path                          | Type    |
  * |--------------------|--------------------------------------|---------|
  * | operatorId         | orchestrator.orchestrator.operatorId | string  |
- * | tmuxPrefix         | orchestrator.orchestrator.tmuxPrefix | string  |
+ * | sessionPrefix      | orchestrator.orchestrator.sessionPrefix | string  |
  * | spawnMode          | orchestrator.orchestrator.spawnMode  | string  |
  * | workerModel        | taskRunner.worker.model              | string  |
  * | reviewerModel      | taskRunner.reviewer.model            | string  |
@@ -509,10 +509,10 @@ export interface TaskplaneConfig {
 export interface UserPreferences {
 	/** Operator identifier (overrides orchestrator.orchestrator.operatorId) */
 	operatorId?: string;
-	/** TMUX session prefix (overrides orchestrator.orchestrator.tmuxPrefix) */
-	tmuxPrefix?: string;
-	/** Spawn mode override (overrides orchestrator.orchestrator.spawnMode) */
-	spawnMode?: "tmux" | "subprocess";
+	/** Orchestrator session prefix (overrides orchestrator.orchestrator.sessionPrefix) */
+	sessionPrefix?: string;
+	/** Spawn mode override (overrides orchestrator.orchestrator.spawnMode). */
+	spawnMode?: "subprocess";
 	/** Worker model override (overrides taskRunner.worker.model) */
 	workerModel?: string;
 	/** Reviewer model override (overrides taskRunner.reviewer.model) */
@@ -582,7 +582,7 @@ export const DEFAULT_ORCHESTRATOR_SECTION: OrchestratorSection = {
 		worktreePrefix: "taskplane-wt",
 		batchIdFormat: "timestamp",
 		spawnMode: "subprocess",
-		tmuxPrefix: "orch",
+		sessionPrefix: "orch",
 		operatorId: "",
 		integration: "manual",
 	},

package/extensions/taskplane/diagnostic-reports.ts

@@ -411,7 +411,7 @@ export function assembleDiagnosticInput(
 			const record: PersistedTaskRecord = {
 				taskId,
 				laneNumber: lane?.laneNumber ?? 0,
-				sessionName: outcome?.sessionName || lane?.tmuxSessionName || "",
+				sessionName: outcome?.sessionName || lane?.laneSessionId || "",
 				status: outcome?.status ?? "pending",
 				taskFolder: "",
 				startedAt: outcome?.startTime ?? null,

package/extensions/taskplane/diagnostics.ts

@@ -49,9 +49,9 @@ export interface SessionTokenCounts {
  * | `context_overflow`   | Hit context window limit (compactions + high ctx %)  |
  * | `wall_clock_timeout` | Killed by task-runner's max_worker_minutes timer     |
  * | `process_crash`      | Non-zero exit code with no API error indicators      |
- * | `session_vanished`   | Tmux session disappeared without exit summary        |
+ * | `session_vanished`   | Session disappeared without exit summary             |
  * | `stall_timeout`      | No STATUS.md progress for stall_timeout minutes      |
- * | `user_killed`        | User manually killed the session (e.g., tmux kill)   |
+ * | `user_killed`        | User manually killed the session (e.g., forced process kill) |
  * | `unknown`            | Could not determine cause                            |
  */
 export type ExitClassification =
@@ -157,7 +157,7 @@ export interface ExitSummary {
  * - `timerKilled`: true if task-runner's max_worker_minutes timer killed the session
  * - `contextKilled`: true if the task-runner explicitly killed the session due to context limit
  * - `stallDetected`: true if monitoring detected no STATUS.md progress
- * - `userKilled`: true if user manually killed the session (e.g., /orch-abort, tmux kill)
+ * - `userKilled`: true if user manually killed the session (e.g., /orch-abort, forced process kill)
  * - `contextPct`: estimated context utilization % (0-100), null if unknown
  *
  * Design: single structured input object (not positional args) for

package/extensions/taskplane/engine.ts

@@ -6,19 +6,19 @@ import { existsSync, readdirSync, readFileSync, unlinkSync } from "fs";
 import { join, resolve } from "path";
 
 import { formatDiscoveryResults, runDiscovery } from "./discovery.ts";
-import { computeTransitiveDependents, execLog, executeLane, executeLaneV2, executeWave, tmuxKillSession } from "./execution.ts";
+import { computeTransitiveDependents, execLog, executeLaneV2, executeWave, killV2LaneAgents } from "./execution.ts";
 import type { RuntimeBackend } from "./execution.ts";
 import type { MonitorUpdateCallback } from "./execution.ts";
 // classifyExit no longer called directly — Tier 0 uses exitDiagnostic.classification
 // from the diagnostic-reports pipeline (populated by assembleDiagnosticInput).
 import { getCurrentBranch, runGit } from "./git.ts";
-import { mergeWaveByRepo, MergeHealthMonitor } from "./merge.ts";
+import { killAllMergeAgentsV2, mergeWaveByRepo, MergeHealthMonitor } from "./merge.ts";
 import { applyMergeRetryLoop, computeCleanupGatePolicy, computeMergeFailurePolicy, extractFailedRepoId, formatRepoMergeSummary, ORCH_MESSAGES } from "./messages.ts";
 import type { CleanupGateRepoFailure } from "./messages.ts";
 import { assembleDiagnosticInput, emitDiagnosticReports } from "./diagnostic-reports.ts";
 import { resolveOperatorId } from "./naming.ts";
 import { applyPartialProgressToOutcomes, buildTier0EventBase, deleteBatchState, emitEngineEvent, emitTier0Event, loadBatchHistory, loadBatchState, persistRuntimeState, saveBatchHistory, seedPendingOutcomesForAllocatedLanes, syncTaskOutcomesFromMonitor, upsertTaskOutcome } from "./persistence.ts";
-import { listOrchSessions } from "./sessions.ts";
+import { readRegistrySnapshot, isTerminalStatus, isProcessAlive as registryIsProcessAlive } from "./process-registry.ts";
 import { buildBatchProgressSnapshot, buildEngineEventBase, defaultResilienceState, FATAL_DISCOVERY_CODES, generateBatchId, TIER0_RETRYABLE_CLASSIFICATIONS, TIER0_RETRY_BUDGETS, tier0ScopeKey, tier0WaveScopeKey } from "./types.ts";
 import type { AllocatedLane, AllocatedTask, BatchHistorySummary, BatchTaskSummary, BatchWaveSummary, DiscoveryResult, EngineEventCallback, EscalationContext, LaneExecutionResult, LaneTaskOutcome, MergeWaveResult, OrchBatchPhase, OrchBatchRuntimeState, OrchestratorConfig, SupervisorAlert, SupervisorAlertCallback, TaskRunnerConfig, Tier0EscalationPattern, Tier0RecoveryPattern, TokenCounts, WaveExecutionResult, WorkspaceConfig } from "./types.ts";
 import { buildDependencyGraph, computeWaves, resolveBaseBranch, resolveRepoRoot, validateGraph } from "./waves.ts";
@@ -278,8 +278,7 @@ async function attemptWorkerCrashRetry(
 			// may be paused due to stop-wave policy, but Tier 0 retry should
 			// attempt recovery before the stop decision takes effect (R002-4).
 			const retryPauseSignal = { paused: false };
-			const retryExecutor = (runtimeBackend === "v2") ? executeLaneV2 : executeLane;
-			const retryResult = await retryExecutor(
+			const retryResult = await executeLaneV2(
 				retryLane,
 				orchConfig,
 				repoRoot,
@@ -546,8 +545,7 @@ async function attemptModelFallbackRetry(
 			// the task-runner to use the session model instead of configured model.
 			// TP-089: Also include ORCH_BATCH_ID so mailbox steering works for retries.
 			const modelFallbackEnv = { TASKPLANE_MODEL_FALLBACK: "1", ORCH_BATCH_ID: batchState.batchId };
-			const retryExecutor = (runtimeBackend === "v2") ? executeLaneV2 : executeLane;
-			const retryResult = await retryExecutor(
+			const retryResult = await executeLaneV2(
 				retryLane,
 				orchConfig,
 				repoRoot,
@@ -2475,16 +2473,39 @@ export async function executeOrchBatch(
 	if (preserveWorktreesForResume) {
 		execLog("batch", batchState.batchId, "skipping final cleanup to preserve worktrees/branches for resume");
 	} else {
-		// Kill any lingering lane tmux sessions BEFORE removing worktrees.
-		// On Windows, tmux sessions with cwd inside the worktree lock the
-		// directory, causing git worktree remove to fail.
-		const orchPrefix = orchConfig.orchestrator.tmux_prefix;
-		const lingering = listOrchSessions(orchPrefix, batchState);
-		if (lingering.length > 0) {
-			execLog("batch", batchState.batchId, `killing ${lingering.length} lingering tmux session(s) before cleanup`);
-			for (const sess of lingering) {
-				tmuxKillSession(sess.sessionName);
+		// Kill lingering Runtime V2 agents BEFORE removing worktrees.
+		// On Windows, lingering processes with cwd inside the worktree can lock
+		// the directory and cause `git worktree remove` to fail.
+		const lingeringLaneSessions = new Set<string>();
+		const registry = readRegistrySnapshot(stateRoot, batchState.batchId);
+		if (registry) {
+			for (const manifest of Object.values(registry.agents)) {
+				if (manifest.role !== "worker" && manifest.role !== "reviewer") continue;
+				if (isTerminalStatus(manifest.status) || !registryIsProcessAlive(manifest.pid)) continue;
+				lingeringLaneSessions.add(manifest.agentId.replace(/-(worker|reviewer)$/, ""));
 			}
+		}
+
+		let performedAgentCleanup = false;
+		if (lingeringLaneSessions.size > 0) {
+			execLog("batch", batchState.batchId, `killing ${lingeringLaneSessions.size} lingering lane agent session(s) before cleanup`);
+			for (const sessionName of lingeringLaneSessions) {
+				killV2LaneAgents(sessionName, {
+					stateRoot,
+					batchId: batchState.batchId,
+					logContext: "batch",
+				});
+			}
+			performedAgentCleanup = true;
+		}
+
+		const killedMergeAgents = killAllMergeAgentsV2();
+		if (killedMergeAgents > 0) {
+			execLog("batch", batchState.batchId, `killed ${killedMergeAgents} lingering merge agent(s) before cleanup`);
+			performedAgentCleanup = true;
+		}
+
+		if (performedAgentCleanup) {
 			sleepSync(1000); // Give OS time to release file locks
 		}