vde-layout 0.0.4 → 0.0.6

package/dist/index.js

@@ -8,6 +8,8 @@ import fs from "fs-extra";
 import path from "node:path";
 import os from "node:os";
 import { z } from "zod";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
 import { execa } from "execa";
 import { createHash } from "node:crypto";
 
@@ -26,7 +28,12 @@ const ErrorCodes = {
 	NOT_IN_TMUX: "NOT_IN_TMUX",
 	TMUX_NOT_FOUND: "TMUX_NOT_FOUND",
 	TMUX_NOT_INSTALLED: "TMUX_NOT_INSTALLED",
-	UNSUPPORTED_TMUX_VERSION: "UNSUPPORTED_TMUX_VERSION"
+	UNSUPPORTED_TMUX_VERSION: "UNSUPPORTED_TMUX_VERSION",
+	BACKEND_NOT_FOUND: "BACKEND_NOT_FOUND",
+	TERMINAL_COMMAND_FAILED: "TERMINAL_COMMAND_FAILED",
+	WEZTERM_NOT_FOUND: "WEZTERM_NOT_FOUND",
+	UNSUPPORTED_WEZTERM_VERSION: "UNSUPPORTED_WEZTERM_VERSION",
+	USER_CANCELLED: "USER_CANCELLED"
 };
 const createBaseError = (name, message, code, details = {}) => {
 	const error = new Error(message);
@@ -44,6 +51,9 @@ const createValidationError = (message, code, details = {}) => {
 const createTmuxError = (message, code, details = {}) => {
 	return createBaseError("TmuxError", message, code, details);
 };
+const createEnvironmentError = (message, code, details = {}) => {
+	return createBaseError("EnvironmentError", message, code, details);
+};
 const isVDELayoutError = (error) => {
 	if (typeof error !== "object" || error === null) return false;
 	if (!("code" in error)) return false;
@@ -73,11 +83,36 @@ const formatters = {
 		const requiredVersion = error.details.requiredVersion;
 		if (typeof requiredVersion !== "string") return "";
 		return `\nRequired tmux version: ${requiredVersion} or higher\n`;
+	},
+	[ErrorCodes.BACKEND_NOT_FOUND]: (error) => {
+		const backend = typeof error.details.backend === "string" ? error.details.backend : "terminal backend";
+		const binary = typeof error.details.binary === "string" ? error.details.binary : backend;
+		const suggestion = backend === "wezterm" ? [
+			"",
+			`${backend} is required but not installed.`,
+			"Install wezterm using your package manager:",
+			"  - macOS: brew install --cask wezterm",
+			"  - Ubuntu/Debian: sudo apt-get install wezterm",
+			"  - Fedora: sudo dnf install wezterm"
+		].join("\n") : "";
+		return `\nMissing binary: ${binary}${suggestion}`;
+	},
+	[ErrorCodes.WEZTERM_NOT_FOUND]: () => {
+		return "\nwezterm command was not found.\nInstall wezterm using your package manager:\n  - macOS: brew install --cask wezterm\n  - Ubuntu/Debian: sudo apt-get install wezterm\n  - Fedora: sudo dnf install wezterm\n";
+	},
+	[ErrorCodes.UNSUPPORTED_WEZTERM_VERSION]: (error) => {
+		const requiredVersion = typeof error.details.requiredVersion === "string" ? error.details.requiredVersion : "";
+		const detected = typeof error.details.detectedVersion === "string" ? error.details.detectedVersion : "";
+		const lines = ["", "Unsupported wezterm version detected."];
+		if (detected) lines.push(`Detected version: ${detected}`);
+		if (requiredVersion) lines.push(`Required version: ${requiredVersion} or higher`);
+		return lines.join("\n");
 	}
 };
 
 //#endregion
 //#region src/models/schema.ts
+const WindowModeSchema = z.enum(["new-window", "current-window"]);
 const TerminalPaneSchema = z.object({
 	name: z.string().min(1),
 	command: z.string().optional(),
@@ -102,9 +137,13 @@ const PresetSchema = z.object({
 	name: z.string().min(1),
 	description: z.string().optional(),
 	layout: LayoutSchema.optional(),
-	command: z.string().optional()
+	command: z.string().optional(),
+	windowMode: WindowModeSchema.optional()
+});
+const ConfigSchema = z.object({
+	defaults: z.object({ windowMode: WindowModeSchema.optional() }).optional(),
+	presets: z.record(PresetSchema)
 });
-const ConfigSchema = z.object({ presets: z.record(PresetSchema) });
 
 //#endregion
 //#region src/config/validator.ts
@@ -231,7 +270,7 @@ const createConfigLoader = (options = {}) => {
 			const config = validateYAML(content);
 			mergedConfig = mergeConfigs(mergedConfig, config);
 		}
-		return mergedConfig;
+		return applyDefaults(mergedConfig);
 	};
 	return {
 		loadYAML: async () => {
@@ -290,10 +329,26 @@ const safeReadFile = async (filePath) => {
 	}
 };
 const mergeConfigs = (base, override) => {
-	return { presets: {
-		...base.presets,
-		...override.presets
-	} };
+	const mergedPresets = { ...base.presets };
+	for (const [presetKey, overridePreset] of Object.entries(override.presets)) {
+		const basePreset = base.presets[presetKey];
+		if (basePreset !== void 0 && basePreset.windowMode !== void 0 && overridePreset.windowMode !== void 0 && basePreset.windowMode !== overridePreset.windowMode) console.warn(`[vde-layout] Preset "${presetKey}" windowMode conflict: "${basePreset.windowMode}" overridden by "${overridePreset.windowMode}"`);
+		mergedPresets[presetKey] = overridePreset;
+	}
+	const baseDefaults = base.defaults;
+	const overrideDefaults = override.defaults;
+	if (baseDefaults?.windowMode !== void 0 && overrideDefaults?.windowMode !== void 0 && baseDefaults.windowMode !== overrideDefaults.windowMode) console.warn(`[vde-layout] defaults.windowMode conflict: "${baseDefaults.windowMode}" overridden by "${overrideDefaults.windowMode}"`);
+	const mergedDefaults = baseDefaults !== void 0 || overrideDefaults !== void 0 ? {
+		...baseDefaults ?? {},
+		...overrideDefaults ?? {}
+	} : void 0;
+	return mergedDefaults === void 0 ? { presets: mergedPresets } : {
+		defaults: mergedDefaults,
+		presets: mergedPresets
+	};
+};
+const applyDefaults = (config) => {
+	return config;
 };
 
 //#endregion
@@ -333,12 +388,16 @@ const createState = (options = {}) => {
 		if (typeof firstKey !== "string" || firstKey.length === 0) throw createConfigError("No presets defined", ErrorCodes.PRESET_NOT_FOUND);
 		return config.presets[firstKey];
 	};
+	const getDefaults = () => {
+		return ensureConfig().defaults;
+	};
 	return {
 		setConfigPath,
 		loadConfig,
 		getPreset,
 		listPresets,
-		getDefaultPreset
+		getDefaultPreset,
+		getDefaults
 	};
 };
 const createPresetManager = (options = {}) => {
@@ -348,7 +407,57 @@ const createPresetManager = (options = {}) => {
 		loadConfig: state.loadConfig,
 		getPreset: state.getPreset,
 		listPresets: state.listPresets,
-		getDefaultPreset: state.getDefaultPreset
+		getDefaultPreset: state.getDefaultPreset,
+		getDefaults: state.getDefaults
+	};
+};
+
+//#endregion
+//#region src/cli/window-mode.ts
+const resolveWindowMode = ({ cli, preset, defaults }) => {
+	if (cli !== void 0) return {
+		mode: cli,
+		source: "cli"
+	};
+	if (preset !== void 0) return {
+		mode: preset,
+		source: "preset"
+	};
+	if (defaults !== void 0) return {
+		mode: defaults,
+		source: "defaults"
+	};
+	return {
+		mode: "new-window",
+		source: "fallback"
+	};
+};
+
+//#endregion
+//#region src/cli/user-prompt.ts
+const createPaneKillPrompter = (logger) => {
+	return async ({ panesToClose, dryRun }) => {
+		if (panesToClose.length === 0) return true;
+		const paneList = panesToClose.join(", ");
+		if (dryRun) {
+			logger.warn(`[DRY RUN] Would close panes: ${paneList}`);
+			return true;
+		}
+		logger.warn(`This operation will close the following panes: ${paneList}`);
+		if (stdin.isTTY !== true || stdout.isTTY !== true) {
+			logger.error("Cannot prompt for confirmation because the terminal is not interactive");
+			return false;
+		}
+		const rl = createInterface({
+			input: stdin,
+			output: stdout
+		});
+		try {
+			const normalized = (await rl.question("Continue? [y/N]: ")).trim().toLowerCase();
+			return normalized === "y" || normalized === "yes";
+		} finally {
+			await rl.close();
+		}
 	};
 };
 
@@ -406,10 +515,10 @@ const createLogger = (options = {}) => {
 
 //#endregion
 //#region src/executor/real-executor.ts
-const parseCommand$1 = (commandOrArgs) => {
+const parseCommand$2 = (commandOrArgs) => {
 	return typeof commandOrArgs === "string" ? commandOrArgs.split(" ").filter((segment) => segment.length > 0).slice(1) : commandOrArgs;
 };
-const toCommandString$1 = (args) => {
+const toCommandString$2 = (args) => {
 	return ["tmux", ...args].join(" ");
 };
 const createRealExecutor = (options = {}) => {
@@ -419,8 +528,8 @@ const createRealExecutor = (options = {}) => {
 		prefix: "[tmux]"
 	});
 	const execute = async (commandOrArgs) => {
-		const args = parseCommand$1(commandOrArgs);
-		const commandString = toCommandString$1(args);
+		const args = parseCommand$2(commandOrArgs);
+		const commandString = toCommandString$2(args);
 		logger.info(`Executing: ${commandString}`);
 		try {
 			return (await execa("tmux", args)).stdout;
@@ -449,10 +558,10 @@ const createRealExecutor = (options = {}) => {
 
 //#endregion
 //#region src/executor/dry-run-executor.ts
-const parseCommand = (commandOrArgs) => {
+const parseCommand$1 = (commandOrArgs) => {
 	return typeof commandOrArgs === "string" ? commandOrArgs.split(" ").filter((segment) => segment.length > 0).slice(1) : commandOrArgs;
 };
-const toCommandString = (args) => {
+const toCommandString$1 = (args) => {
 	return ["tmux", ...args].join(" ");
 };
 const createDryRunExecutor = (options = {}) => {
@@ -462,8 +571,8 @@ const createDryRunExecutor = (options = {}) => {
 		prefix: "[tmux] [DRY RUN]"
 	});
 	const execute = async (commandOrArgs) => {
-		const args = parseCommand(commandOrArgs);
-		const commandString = toCommandString(args);
+		const args = parseCommand$1(commandOrArgs);
+		const commandString = toCommandString$1(args);
 		logger.info(`Would execute: ${commandString}`);
 		return "";
 	};
@@ -481,6 +590,130 @@ const createDryRunExecutor = (options = {}) => {
 	};
 };
 
+//#endregion
+//#region src/executor/mock-executor.ts
+const parseCommand = (commandOrArgs) => {
+	return typeof commandOrArgs === "string" ? commandOrArgs.split(" ").filter((segment) => segment.length > 0).slice(1) : commandOrArgs;
+};
+const isInTmuxSession = () => {
+	return Boolean(process.env.TMUX);
+};
+const toCommandString = (args) => {
+	return ["tmux", ...args].join(" ");
+};
+const createMockExecutor = () => {
+	let mockPaneCounter = 0;
+	let mockPaneIds = ["%0"];
+	let executedCommands = [];
+	const execute = async (commandOrArgs) => {
+		const args = parseCommand(commandOrArgs);
+		executedCommands.push(args);
+		if (args[0] === "new-window") {
+			mockPaneCounter = 0;
+			mockPaneIds = ["%0"];
+			return "%0";
+		}
+		if (args.includes("display-message") && args.includes("#{pane_id}")) return mockPaneIds[0] ?? "%0";
+		if (args.includes("list-panes") && args.includes("#{pane_id}")) return mockPaneIds.join("\n");
+		if (args[0] === "kill-pane" && args.includes("-a")) {
+			const targetIndex = args.indexOf("-t");
+			const targetPane = (targetIndex >= 0 && targetIndex + 1 < args.length ? args[targetIndex + 1] : mockPaneIds[0]) ?? "%0";
+			mockPaneIds = [targetPane];
+			const parsedCounter = Number(targetPane.replace("%", ""));
+			if (!Number.isNaN(parsedCounter)) mockPaneCounter = parsedCounter;
+			return "";
+		}
+		if (args.includes("split-window")) {
+			mockPaneCounter += 1;
+			const newPaneId = `%${mockPaneCounter}`;
+			mockPaneIds = [...mockPaneIds, newPaneId];
+		}
+		return "";
+	};
+	return {
+		execute,
+		async executeMany(commandsList) {
+			for (const args of commandsList) await execute(args);
+		},
+		isDryRun() {
+			return true;
+		},
+		logCommand() {},
+		getExecutedCommands() {
+			return executedCommands;
+		},
+		clearExecutedCommands() {
+			executedCommands = [];
+		},
+		setMockPaneIds(paneIds) {
+			mockPaneIds = [...paneIds];
+		},
+		getPaneIds() {
+			return mockPaneIds;
+		},
+		isInTmuxSession,
+		async verifyTmuxEnvironment() {
+			if (!isInTmuxSession()) throw createEnvironmentError("Must be run inside a tmux session", ErrorCodes.NOT_IN_TMUX, { hint: "Please start a tmux session and try again" });
+		},
+		getCommandString: toCommandString,
+		async getCurrentSessionName() {
+			return "mock-session";
+		}
+	};
+};
+
+//#endregion
+//#region src/tmux/executor.ts
+const createTmuxExecutor = (options = {}) => {
+	const executor = resolveExecutor(options);
+	const isInTmuxSession$1 = () => {
+		return Boolean(process.env.TMUX);
+	};
+	const verifyTmuxEnvironment = async () => {
+		if (!isInTmuxSession$1()) throw createEnvironmentError("Must be run inside a tmux session", ErrorCodes.NOT_IN_TMUX, { hint: "Please start a tmux session and try again" });
+		if (executor.isDryRun()) return;
+		try {
+			await execa("tmux", ["-V"]);
+		} catch (_error) {
+			throw createEnvironmentError("tmux is not installed", ErrorCodes.TMUX_NOT_FOUND, { hint: "Please install tmux" });
+		}
+	};
+	const execute = async (commandOrArgs) => {
+		return executor.execute(commandOrArgs);
+	};
+	const executeMany = async (commandsList) => {
+		for (const command of commandsList) await execute(command);
+	};
+	const getCommandString = (args) => {
+		return ["tmux", ...args].join(" ");
+	};
+	const getCurrentSessionName = async () => {
+		return execute([
+			"display-message",
+			"-p",
+			"#{session_name}"
+		]);
+	};
+	return {
+		verifyTmuxEnvironment,
+		execute,
+		executeMany,
+		isInTmuxSession: isInTmuxSession$1,
+		getCurrentSessionName,
+		getCommandString,
+		getExecutor: () => executor
+	};
+};
+const resolveExecutor = (options) => {
+	if (options.executor) return options.executor;
+	if (options.dryRun === true) return createDryRunExecutor({ verbose: options.verbose });
+	if (isTestEnvironment()) return createMockExecutor();
+	return createRealExecutor({ verbose: options.verbose });
+};
+const isTestEnvironment = () => {
+	return process.env.VDE_TEST_MODE === "true" || process.env.NODE_ENV === "test" || process.env.VITEST === "true";
+};
+
 //#endregion
 //#region src/core/errors.ts
 const createFunctionalError = (kind, error) => ({
@@ -501,25 +734,66 @@ const isFunctionalCoreError = (value) => {
 //#region src/executor/plan-runner.ts
 const DOUBLE_QUOTE = "\"";
 const ESCAPED_DOUBLE_QUOTE = "\\\"";
-const executePlan = async ({ emission, executor, windowName }) => {
+const executePlan = async ({ emission, executor, windowName, windowMode, onConfirmKill }) => {
 	const initialVirtualPaneId = emission.summary.initialPaneId;
 	if (typeof initialVirtualPaneId !== "string" || initialVirtualPaneId.length === 0) raiseExecutionError("INVALID_PLAN", {
 		message: "Plan emission is missing initial pane metadata",
 		path: "plan.initialPaneId"
 	});
 	const paneMap = /* @__PURE__ */ new Map();
-	const newWindowCommand = [
-		"new-window",
-		"-P",
-		"-F",
-		"#{pane_id}"
-	];
-	if (typeof windowName === "string" && windowName.trim().length > 0) newWindowCommand.push("-n", windowName.trim());
-	const initialPaneId = normalizePaneId(await executeCommand(executor, newWindowCommand, {
-		code: ErrorCodes.TMUX_COMMAND_FAILED,
-		message: "Failed to create tmux window",
-		path: initialVirtualPaneId
-	}));
+	const isDryRun = executor.isDryRun();
+	let initialPaneId;
+	if (windowMode === "current-window") {
+		const currentPaneId = await resolveCurrentPaneId({
+			executor,
+			contextPath: initialVirtualPaneId,
+			isDryRun
+		});
+		const panesToClose = (await listWindowPaneIds(executor, initialVirtualPaneId)).filter((paneId) => paneId !== currentPaneId);
+		if (panesToClose.length > 0) {
+			let confirmed = true;
+			if (onConfirmKill !== void 0) confirmed = await onConfirmKill({
+				panesToClose,
+				dryRun: isDryRun
+			});
+			if (confirmed !== true) throw createFunctionalError("execution", {
+				code: ErrorCodes.USER_CANCELLED,
+				message: "Aborted layout application for current window",
+				path: initialVirtualPaneId,
+				details: { panes: panesToClose }
+			});
+			await executeCommand(executor, [
+				"kill-pane",
+				"-a",
+				"-t",
+				currentPaneId
+			], {
+				code: ErrorCodes.TMUX_COMMAND_FAILED,
+				message: "Failed to close existing panes",
+				path: initialVirtualPaneId,
+				details: { command: [
+					"kill-pane",
+					"-a",
+					"-t",
+					currentPaneId
+				] }
+			});
+		}
+		initialPaneId = normalizePaneId(currentPaneId);
+	} else {
+		const newWindowCommand = [
+			"new-window",
+			"-P",
+			"-F",
+			"#{pane_id}"
+		];
+		if (typeof windowName === "string" && windowName.trim().length > 0) newWindowCommand.push("-n", windowName.trim());
+		initialPaneId = normalizePaneId(await executeCommand(executor, newWindowCommand, {
+			code: ErrorCodes.TMUX_COMMAND_FAILED,
+			message: "Failed to create tmux window",
+			path: initialVirtualPaneId
+		}));
+	}
 	registerPane(paneMap, initialVirtualPaneId, initialPaneId);
 	let executedSteps = 0;
 	for (const step of emission.steps) {
@@ -570,7 +844,7 @@ const executeSplitStep = async ({ step, executor, paneMap }) => {
 		details: { command: splitCommand }
 	});
 	const panesAfter = await listPaneIds(executor, step);
-	const newPaneId = ensureNonEmpty(findNewPaneId(panesBefore, panesAfter), () => raiseExecutionError("UNKNOWN_PANE", {
+	const newPaneId = ensureNonEmpty(findNewPaneId$1(panesBefore, panesAfter), () => raiseExecutionError("UNKNOWN_PANE", {
 		message: "Unable to determine newly created pane",
 		path: step.id
 	}));
@@ -664,7 +938,27 @@ const executeCommand = async (executor, command, context) => {
 		});
 	}
 };
-const listPaneIds = async (executor, step) => {
+const resolveCurrentPaneId = async ({ executor, contextPath, isDryRun }) => {
+	const envPaneId = process.env.TMUX_PANE;
+	if (typeof envPaneId === "string" && envPaneId.trim().length > 0) return normalizePaneId(envPaneId);
+	if (isDryRun) return "%0";
+	const paneId = (await executeCommand(executor, [
+		"display-message",
+		"-p",
+		"#{pane_id}"
+	], {
+		code: ErrorCodes.TMUX_COMMAND_FAILED,
+		message: "Failed to resolve current tmux pane",
+		path: contextPath
+	})).trim();
+	if (paneId.length === 0) throw createFunctionalError("execution", {
+		code: ErrorCodes.NOT_IN_TMUX_SESSION,
+		message: "Unable to determine current tmux pane",
+		path: contextPath
+	});
+	return normalizePaneId(paneId);
+};
+const listWindowPaneIds = async (executor, contextPath) => {
 	return (await executeCommand(executor, [
 		"list-panes",
 		"-F",
@@ -672,10 +966,13 @@ const listPaneIds = async (executor, step) => {
 	], {
 		code: ErrorCodes.TMUX_COMMAND_FAILED,
 		message: "Failed to list tmux panes",
-		path: step.id
+		path: contextPath
 	})).split("\n").map((pane) => pane.trim()).filter((pane) => pane.length > 0);
 };
-const findNewPaneId = (before, after) => {
+const listPaneIds = async (executor, step) => {
+	return listWindowPaneIds(executor, step.id);
+};
+const findNewPaneId$1 = (before, after) => {
 	const beforeSet = new Set(before);
 	return after.find((id) => !beforeSet.has(id));
 };
@@ -728,6 +1025,749 @@ const raiseExecutionError = (code, error) => {
 	});
 };
 
+//#endregion
+//#region src/executor/backends/tmux-backend.ts
+const createTmuxBackend = (context) => {
+	const tmuxExecutor = createTmuxExecutor({
+		executor: context.executor,
+		verbose: context.verbose,
+		dryRun: context.dryRun
+	});
+	const buildDryRunSteps$1 = (emission) => {
+		return emission.steps.map((step) => ({
+			backend: "tmux",
+			summary: step.summary,
+			command: tmuxExecutor.getCommandString([...step.command])
+		}));
+	};
+	const verifyEnvironment = async () => {
+		if (context.dryRun) return;
+		await tmuxExecutor.verifyTmuxEnvironment();
+	};
+	const applyPlan = async ({ emission, windowMode, windowName }) => {
+		return {
+			executedSteps: (await executePlan({
+				emission,
+				executor: tmuxExecutor.getExecutor(),
+				windowMode,
+				windowName,
+				onConfirmKill: context.prompt
+			})).executedSteps,
+			focusPaneId: emission.summary.focusPaneId
+		};
+	};
+	return {
+		verifyEnvironment,
+		applyPlan,
+		getDryRunSteps: buildDryRunSteps$1
+	};
+};
+
+//#endregion
+//#region src/wezterm/cli.ts
+const WEZTERM_BINARY = "wezterm";
+const MINIMUM_VERSION = "20220624-141144-bd1b7c5d";
+const VERSION_REGEX = /(\d{8})-(\d{6})-([0-9a-fA-F]+)/i;
+const verifyWeztermAvailability = async () => {
+	let stdout$1;
+	try {
+		stdout$1 = (await execa(WEZTERM_BINARY, ["--version"])).stdout;
+	} catch (error) {
+		const execaError = error;
+		if (execaError.code === "ENOENT") throw createEnvironmentError("wezterm is not installed", ErrorCodes.BACKEND_NOT_FOUND, {
+			backend: "wezterm",
+			binary: WEZTERM_BINARY
+		});
+		throw createEnvironmentError("Failed to execute wezterm --version", ErrorCodes.WEZTERM_NOT_FOUND, {
+			backend: "wezterm",
+			binary: WEZTERM_BINARY,
+			stderr: execaError.stderr
+		});
+	}
+	const detectedVersion = extractVersion(stdout$1);
+	if (detectedVersion === void 0) throw createEnvironmentError("Unable to determine wezterm version", ErrorCodes.UNSUPPORTED_WEZTERM_VERSION, {
+		requiredVersion: MINIMUM_VERSION,
+		detectedVersion: stdout$1.trim()
+	});
+	if (!isVersionSupported(detectedVersion, MINIMUM_VERSION)) throw createEnvironmentError("Unsupported wezterm version", ErrorCodes.UNSUPPORTED_WEZTERM_VERSION, {
+		requiredVersion: MINIMUM_VERSION,
+		detectedVersion
+	});
+	return { version: detectedVersion };
+};
+const runWeztermCli = async (args, errorContext) => {
+	try {
+		return (await execa(WEZTERM_BINARY, ["cli", ...args])).stdout;
+	} catch (error) {
+		const execaError = error;
+		throw createFunctionalError("execution", {
+			code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+			message: errorContext.message,
+			path: errorContext.path,
+			details: {
+				command: [
+					WEZTERM_BINARY,
+					"cli",
+					...args
+				],
+				stderr: execaError.stderr,
+				exitCode: execaError.exitCode,
+				backend: "wezterm",
+				...errorContext.details ?? {}
+			}
+		});
+	}
+};
+const listWeztermWindows = async () => {
+	const stdout$1 = await runWeztermCli([
+		"list",
+		"--format",
+		"json"
+	], { message: "Failed to list wezterm panes" });
+	const result = parseListResult(stdout$1);
+	if (result === void 0) throw createFunctionalError("execution", {
+		code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+		message: "Invalid wezterm list output",
+		details: { stdout: stdout$1 }
+	});
+	return result;
+};
+const killWeztermPane = async (paneId) => {
+	await runWeztermCli([
+		"kill-pane",
+		"--pane-id",
+		paneId
+	], {
+		message: `Failed to kill wezterm pane ${paneId}`,
+		path: paneId
+	});
+};
+const extractVersion = (raw) => {
+	const match = raw.match(VERSION_REGEX);
+	if (!match) return;
+	const date = match[1];
+	const time = match[2];
+	const commit = match[3];
+	if (date === void 0 || time === void 0 || commit === void 0) return;
+	return `${date}-${time}-${commit.toLowerCase()}`;
+};
+const isVersionSupported = (detected, minimum) => {
+	const parse$1 = (version) => {
+		const match = version.match(VERSION_REGEX);
+		if (!match) return;
+		const date = match[1];
+		const time = match[2];
+		const commit = match[3];
+		if (date === void 0 || time === void 0 || commit === void 0) return;
+		const build = Number(`${date}${time}`);
+		if (Number.isNaN(build)) return;
+		return {
+			build,
+			commit: commit.toLowerCase()
+		};
+	};
+	const detectedInfo = parse$1(detected);
+	const minimumInfo = parse$1(minimum);
+	if (detectedInfo === void 0 || minimumInfo === void 0) return false;
+	if (detectedInfo.build > minimumInfo.build) return true;
+	if (detectedInfo.build < minimumInfo.build) return false;
+	return detectedInfo.commit >= minimumInfo.commit;
+};
+const toIdString = (value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return value.toString();
+};
+const isNonEmptyString = (value) => {
+	return typeof value === "string" && value.length > 0;
+};
+const parseListResult = (stdout$1) => {
+	try {
+		const parsed = JSON.parse(stdout$1);
+		if (Array.isArray(parsed)) {
+			const windowMap = /* @__PURE__ */ new Map();
+			for (const entry of parsed) {
+				if (typeof entry !== "object" || entry === null) continue;
+				const listEntry = entry;
+				const windowIdRaw = toIdString(listEntry.window_id);
+				const paneIdRaw = toIdString(listEntry.pane_id);
+				const tabIdRaw = toIdString(listEntry.tab_id) ?? windowIdRaw;
+				if (!isNonEmptyString(windowIdRaw) || !isNonEmptyString(tabIdRaw) || !isNonEmptyString(paneIdRaw)) continue;
+				const windowId = windowIdRaw;
+				const tabId = tabIdRaw;
+				const paneId = paneIdRaw;
+				let windowRecord = windowMap.get(windowId);
+				if (!windowRecord) {
+					windowRecord = {
+						windowId,
+						isActive: false,
+						tabs: /* @__PURE__ */ new Map()
+					};
+					windowMap.set(windowId, windowRecord);
+				}
+				let tabRecord = windowRecord.tabs.get(tabId);
+				if (!tabRecord) {
+					tabRecord = {
+						tabId,
+						isActive: false,
+						panes: []
+					};
+					windowRecord.tabs.set(tabId, tabRecord);
+				}
+				const pane = {
+					paneId,
+					isActive: listEntry.is_active === true
+				};
+				windowRecord.isActive ||= listEntry.is_active === true;
+				tabRecord.isActive ||= listEntry.is_active === true;
+				tabRecord.panes.push(pane);
+			}
+			return { windows: Array.from(windowMap.values()).map((windowRecord) => ({
+				windowId: windowRecord.windowId,
+				isActive: windowRecord.isActive,
+				tabs: Array.from(windowRecord.tabs.values()).map((tabRecord) => ({
+					tabId: tabRecord.tabId,
+					isActive: tabRecord.isActive,
+					panes: tabRecord.panes.map((pane) => ({
+						paneId: pane.paneId,
+						isActive: pane.isActive
+					}))
+				}))
+			})) };
+		}
+		if (typeof parsed === "object" && parsed !== null) {
+			const candidate = parsed;
+			const windows = Array.isArray(candidate.windows) ? candidate.windows : [];
+			const mappedWindows = [];
+			for (const window of windows) {
+				if (typeof window !== "object" || window === null) continue;
+				const rawWindow = window;
+				const windowIdRaw = toIdString(rawWindow.window_id);
+				if (!isNonEmptyString(windowIdRaw)) continue;
+				const windowId = windowIdRaw;
+				const mappedTabs = [];
+				const tabs = Array.isArray(rawWindow.tabs) ? rawWindow.tabs : [];
+				for (const tab of tabs) {
+					if (typeof tab !== "object" || tab === null) continue;
+					const rawTab = tab;
+					const tabIdRaw = toIdString(rawTab.tab_id);
+					if (!isNonEmptyString(tabIdRaw)) continue;
+					const tabId = tabIdRaw;
+					const paneRecords = Array.isArray(rawTab.panes) ? rawTab.panes : [];
+					const mappedPanes = [];
+					for (const pane of paneRecords) {
+						if (typeof pane !== "object" || pane === null) continue;
+						const rawPane = pane;
+						const paneIdRaw = toIdString(rawPane.pane_id);
+						if (!isNonEmptyString(paneIdRaw)) continue;
+						const paneId = paneIdRaw;
+						mappedPanes.push({
+							paneId,
+							isActive: rawPane.is_active === true
+						});
+					}
+					mappedTabs.push({
+						tabId,
+						isActive: rawTab.is_active === true,
+						panes: mappedPanes
+					});
+				}
+				mappedWindows.push({
+					windowId,
+					isActive: rawWindow.is_active === true,
+					tabs: mappedTabs
+				});
+			}
+			return { windows: mappedWindows };
+		}
+		return;
+	} catch {
+		return;
+	}
+};
+
+//#endregion
+//#region src/executor/backends/wezterm-backend.ts
+const PANE_REGISTRATION_RETRIES = 5;
+const PANE_REGISTRATION_DELAY_MS = 100;
+const ensureVirtualPaneId = (emission) => {
+	const { initialPaneId } = emission.summary;
+	if (typeof initialPaneId !== "string" || initialPaneId.length === 0) throw createFunctionalError("execution", {
+		code: ErrorCodes.INVALID_PANE,
+		message: "Plan emission is missing initial pane metadata",
+		path: "plan.initialPaneId"
+	});
+	return initialPaneId;
+};
+const registerPaneWithAncestors = (map, virtualId, realId) => {
+	map.set(virtualId, realId);
+	let ancestor = virtualId;
+	while (ancestor.includes(".")) {
+		ancestor = ancestor.slice(0, ancestor.lastIndexOf("."));
+		if (!map.has(ancestor)) map.set(ancestor, realId);
+		else break;
+	}
+};
+const resolveRealPaneId = (paneMap, virtualId, context) => {
+	const direct = paneMap.get(virtualId);
+	if (typeof direct === "string" && direct.length > 0) return direct;
+	let ancestor = virtualId;
+	while (ancestor.includes(".")) {
+		ancestor = ancestor.slice(0, ancestor.lastIndexOf("."));
+		const candidate = paneMap.get(ancestor);
+		if (typeof candidate === "string" && candidate.length > 0) {
+			paneMap.set(virtualId, candidate);
+			return candidate;
+		}
+	}
+	for (const [key, value] of paneMap.entries()) if (key.startsWith(`${virtualId}.`)) {
+		if (typeof value === "string" && value.length > 0) {
+			paneMap.set(virtualId, value);
+			return value;
+		}
+	}
+	throw createFunctionalError("execution", {
+		code: ErrorCodes.INVALID_PANE,
+		message: `Unknown wezterm pane mapping for ${virtualId}`,
+		path: context.stepId
+	});
+};
+const buildDryRunSteps = (emission) => {
+	const steps = [];
+	for (const step of emission.steps) {
+		if (step.kind === "split") {
+			const target = step.targetPaneId ?? "<unknown>";
+			const args = buildSplitArguments({
+				targetPaneId: target,
+				percent: extractPercent(step.command),
+				horizontal: isHorizontalSplit(step.command)
+			});
+			steps.push({
+				backend: "wezterm",
+				summary: step.summary,
+				command: `wezterm cli ${args.join(" ")}`
+			});
+			continue;
+		}
+		if (step.kind === "focus") {
+			const target = step.targetPaneId ?? "<unknown>";
+			steps.push({
+				backend: "wezterm",
+				summary: step.summary,
+				command: `wezterm cli activate-pane --pane-id ${target}`
+			});
+			continue;
+		}
+		steps.push({
+			backend: "wezterm",
+			summary: step.summary,
+			command: `wezterm cli # ${step.command.join(" ")}`
+		});
+	}
+	for (const terminal of emission.terminals) {
+		const paneId = terminal.virtualPaneId;
+		if (typeof terminal.cwd === "string" && terminal.cwd.length > 0) {
+			const cwdCommand = `cd "${terminal.cwd.split("\"").join("\\\"")}"`;
+			steps.push({
+				backend: "wezterm",
+				summary: `set cwd for ${paneId}`,
+				command: `wezterm cli send-text --pane-id ${paneId} --no-paste -- '${cwdCommand.replace(/'/g, "\\'")}'`
+			});
+		}
+		if (terminal.env !== void 0) for (const [key, value] of Object.entries(terminal.env)) {
+			const envCommand = `export ${key}="${String(value).split("\"").join("\\\"")}"`;
+			steps.push({
+				backend: "wezterm",
+				summary: `set env ${key} for ${paneId}`,
+				command: `wezterm cli send-text --pane-id ${paneId} --no-paste -- '${envCommand.replace(/'/g, "\\'")}'`
+			});
+		}
+		if (typeof terminal.command === "string" && terminal.command.length > 0) steps.push({
+			backend: "wezterm",
+			summary: `run command for ${paneId}`,
+			command: `wezterm cli send-text --pane-id ${paneId} --no-paste -- '${terminal.command.replace(/'/g, "\\'")}'`
+		});
+	}
+	return steps;
+};
+const resolveCurrentWindow = async (context) => {
+	const activeWindow = context.list.windows.find((window) => window.isActive) ?? context.list.windows[0];
+	if (!activeWindow) throw createFunctionalError("execution", {
+		code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+		message: "No active wezterm window detected",
+		details: { hint: "Launch wezterm and ensure a window is focused, or run with --new-window." }
+	});
+	const activeTab = activeWindow.tabs.find((tab) => tab.isActive) ?? activeWindow.tabs[0];
+	if (!activeTab) throw createFunctionalError("execution", {
+		code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+		message: "No active wezterm tab detected",
+		path: activeWindow.windowId,
+		details: { hint: "Ensure a wezterm tab is focused before using --current-window." }
+	});
+	const activePane = activeTab.panes.find((pane) => pane.isActive) ?? activeTab.panes[0];
+	if (!activePane) throw createFunctionalError("execution", {
+		code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+		message: "No active wezterm pane detected",
+		path: activeTab.tabId,
+		details: { hint: "Ensure a wezterm pane is active before using --current-window." }
+	});
+	const panesToClose = activeTab.panes.filter((pane) => pane.paneId !== activePane.paneId).map((pane) => pane.paneId);
+	if (panesToClose.length > 0) {
+		let confirmed = true;
+		if (context.prompt) confirmed = await context.prompt({
+			panesToClose,
+			dryRun: context.dryRun
+		});
+		if (confirmed !== true) throw createFunctionalError("execution", {
+			code: ErrorCodes.USER_CANCELLED,
+			message: "Aborted layout application for current wezterm window",
+			path: activePane.paneId,
+			details: { panes: panesToClose }
+		});
+		for (const paneId of panesToClose) {
+			context.logCommand([
+				"kill-pane",
+				"--pane-id",
+				paneId
+			]);
+			await killWeztermPane(paneId);
+		}
+	}
+	return {
+		paneId: activePane.paneId,
+		windowId: activeWindow.windowId,
+		panesToClose
+	};
+};
+const findActiveWindow = (list) => {
+	return list.windows.find((window) => window.isActive) ?? list.windows[0];
+};
+const findWindowContainingPane = (list, paneId) => {
+	for (const window of list.windows) for (const tab of window.tabs) for (const pane of tab.panes) if (pane.paneId === paneId) return window.windowId;
+};
+const delay = (ms) => {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+};
+const waitForPaneRegistration = async ({ paneId, listWindows, windowHint }) => {
+	for (let attempt = 0; attempt < PANE_REGISTRATION_RETRIES; attempt += 1) {
+		const snapshot = await listWindows();
+		if (typeof windowHint === "string") try {
+			if (collectPaneIdsForWindow(snapshot, windowHint).has(paneId)) return windowHint;
+		} catch {}
+		const located = findWindowContainingPane(snapshot, paneId);
+		if (typeof located === "string" && located.length > 0) return located;
+		if (attempt < PANE_REGISTRATION_RETRIES - 1) await delay(PANE_REGISTRATION_DELAY_MS);
+	}
+	throw createFunctionalError("execution", {
+		code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+		message: "Unable to locate spawned wezterm window",
+		details: {
+			paneId,
+			hint: "Verify that wezterm is running and the CLI client can connect."
+		}
+	});
+};
+const resolveInitialPane = async ({ windowMode, prompt, dryRun, listWindows, runCommand, logCommand }) => {
+	if (windowMode === "current-window") {
+		const list = await listWindows();
+		return resolveCurrentWindow({
+			list,
+			prompt,
+			dryRun,
+			logCommand
+		});
+	}
+	const existing = await listWindows();
+	const activeWindow = findActiveWindow(existing);
+	if (activeWindow) {
+		const spawnOutput$1 = await runCommand([
+			"spawn",
+			"--window-id",
+			activeWindow.windowId
+		], { message: "Failed to spawn wezterm tab" });
+		const paneId$1 = extractSpawnPaneId(spawnOutput$1);
+		if (paneId$1.length === 0) throw createFunctionalError("execution", {
+			code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+			message: "wezterm spawn did not return a pane id",
+			details: { stdout: spawnOutput$1 }
+		});
+		const windowId = await waitForPaneRegistration({
+			paneId: paneId$1,
+			listWindows,
+			windowHint: activeWindow.windowId
+		});
+		return {
+			paneId: paneId$1,
+			windowId
+		};
+	}
+	const spawnOutput = await runCommand(["spawn", "--new-window"], { message: "Failed to spawn wezterm window" });
+	const paneId = extractSpawnPaneId(spawnOutput);
+	if (paneId.length === 0) throw createFunctionalError("execution", {
+		code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+		message: "wezterm spawn did not return a pane id",
+		details: { stdout: spawnOutput }
+	});
+	const newWindowId = await waitForPaneRegistration({
+		paneId,
+		listWindows
+	});
+	return {
+		paneId,
+		windowId: newWindowId
+	};
+};
+const collectPaneIdsForWindow = (list, windowId) => {
+	const targetWindow = list.windows.find((window) => window.windowId === windowId);
+	if (!targetWindow) throw createFunctionalError("execution", {
+		code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+		message: `Wezterm window ${windowId} not found`,
+		details: { windowId }
+	});
+	const paneIds = targetWindow.tabs.flatMap((tab) => tab.panes.map((pane) => pane.paneId));
+	return new Set(paneIds);
+};
+const extractSpawnPaneId = (output) => {
+	const trimmed = output.trim();
+	if (trimmed.length === 0) return "";
+	const tokens = (trimmed.split("\n").pop() ?? "").split(/\s+/).filter((segment) => segment.length > 0);
+	if (tokens.length === 0) return "";
+	const [paneId] = tokens;
+	if (typeof paneId !== "string") return "";
+	return paneId.trim();
+};
+const findNewPaneId = (before, after) => {
+	for (const paneId of after) if (!before.has(paneId)) return paneId;
+};
+const isHorizontalSplit = (command) => {
+	return command.includes("-h");
+};
+const extractPercent = (command) => {
+	const index = command.findIndex((segment) => segment === "-p");
+	if (index >= 0 && index + 1 < command.length) {
+		const value = command[index + 1];
+		if (typeof value === "string" && value.trim().length > 0) return value.trim();
+	}
+	return "50";
+};
+const buildSplitArguments = (params) => {
+	return [
+		"split-pane",
+		params.horizontal ? "--right" : "--bottom",
+		"--percent",
+		params.percent,
+		"--pane-id",
+		params.targetPaneId
+	];
+};
+const applyFocusStep = async ({ step, paneMap, runCommand }) => {
+	const targetVirtualId = step.targetPaneId;
+	if (typeof targetVirtualId !== "string" || targetVirtualId.length === 0) throw createFunctionalError("execution", {
+		code: ErrorCodes.INVALID_PANE,
+		message: "Focus step missing target pane metadata",
+		path: step.id
+	});
+	const targetRealId = resolveRealPaneId(paneMap, targetVirtualId, { stepId: step.id });
+	await runCommand([
+		"activate-pane",
+		"--pane-id",
+		targetRealId
+	], {
+		message: `Failed to execute focus step ${step.id}`,
+		path: step.id
+	});
+};
+const escapeDoubleQuotes = (value) => {
+	return value.split("\"").join("\\\"");
+};
+const appendCarriageReturn = (value) => {
+	return value.endsWith("\r") ? value : `${value}\r`;
+};
+const sendTextToPane = async ({ paneId, text, runCommand, context }) => {
+	await runCommand([
+		"send-text",
+		"--pane-id",
+		paneId,
+		"--no-paste",
+		"--",
+		appendCarriageReturn(text)
+	], context);
+};
+const applyTerminalCommands = async ({ terminals, paneMap, runCommand }) => {
+	for (const terminal of terminals) {
+		const realPaneId = resolveRealPaneId(paneMap, terminal.virtualPaneId, { stepId: terminal.virtualPaneId });
+		if (typeof terminal.cwd === "string" && terminal.cwd.length > 0) {
+			const escapedCwd = escapeDoubleQuotes(terminal.cwd);
+			await sendTextToPane({
+				paneId: realPaneId,
+				text: `cd "${escapedCwd}"`,
+				runCommand,
+				context: {
+					message: `Failed to change directory for pane ${terminal.virtualPaneId}`,
+					path: terminal.virtualPaneId,
+					details: { cwd: terminal.cwd }
+				}
+			});
+		}
+		if (terminal.env !== void 0) for (const [key, value] of Object.entries(terminal.env)) {
+			const escapedValue = escapeDoubleQuotes(String(value));
+			await sendTextToPane({
+				paneId: realPaneId,
+				text: `export ${key}="${escapedValue}"`,
+				runCommand,
+				context: {
+					message: `Failed to set environment variable ${key}`,
+					path: terminal.virtualPaneId
+				}
+			});
+		}
+		if (typeof terminal.command === "string" && terminal.command.length > 0) await sendTextToPane({
+			paneId: realPaneId,
+			text: terminal.command,
+			runCommand,
+			context: {
+				message: `Failed to execute command for pane ${terminal.virtualPaneId}`,
+				path: terminal.virtualPaneId,
+				details: { command: terminal.command }
+			}
+		});
+	}
+};
+const applySplitStep = async ({ step, paneMap, windowId, runCommand, listWindows, logPaneMapping }) => {
+	const targetVirtualId = step.targetPaneId;
+	if (typeof targetVirtualId !== "string" || targetVirtualId.length === 0) throw createFunctionalError("execution", {
+		code: ErrorCodes.INVALID_PANE,
+		message: "Split step missing target pane metadata",
+		path: step.id
+	});
+	const targetRealId = resolveRealPaneId(paneMap, targetVirtualId, { stepId: step.id });
+	const beforeList = await listWindows();
+	const beforePaneIds = collectPaneIdsForWindow(beforeList, windowId);
+	const args = buildSplitArguments({
+		targetPaneId: targetRealId,
+		percent: extractPercent(step.command),
+		horizontal: isHorizontalSplit(step.command)
+	});
+	await runCommand(args, {
+		message: `Failed to execute split step ${step.id}`,
+		path: step.id
+	});
+	const afterList = await listWindows();
+	const afterPaneIds = collectPaneIdsForWindow(afterList, windowId);
+	const newPaneId = findNewPaneId(beforePaneIds, afterPaneIds);
+	if (typeof newPaneId !== "string" || newPaneId.length === 0) throw createFunctionalError("execution", {
+		code: ErrorCodes.TERMINAL_COMMAND_FAILED,
+		message: "Unable to determine newly created wezterm pane",
+		path: step.id
+	});
+	if (typeof step.createdPaneId === "string" && step.createdPaneId.length > 0) {
+		registerPaneWithAncestors(paneMap, step.createdPaneId, newPaneId);
+		logPaneMapping(step.createdPaneId, newPaneId);
+	}
+};
+const createWeztermBackend = (context) => {
+	const formatCommand = (args) => {
+		return `wezterm cli ${args.join(" ")}`;
+	};
+	const logCommand = (args) => {
+		const message = `[wezterm] ${formatCommand(args)}`;
+		if (context.verbose) context.logger.info(message);
+		else context.logger.debug(message);
+	};
+	const logPaneMapping = (virtualId, realId) => {
+		const message = `[wezterm] pane ${virtualId} -> ${realId}`;
+		if (context.verbose) context.logger.info(message);
+		else context.logger.debug(message);
+	};
+	const runCommand = async (args, errorContext) => {
+		const commandArgs = [...args];
+		logCommand(commandArgs);
+		return runWeztermCli(commandArgs, errorContext);
+	};
+	const listWindows = async () => {
+		logCommand([
+			"list",
+			"--format",
+			"json"
+		]);
+		return listWeztermWindows();
+	};
+	const verifyEnvironment = async () => {
+		if (context.dryRun) return;
+		await verifyWeztermAvailability();
+	};
+	const applyPlan = async ({ emission, windowMode }) => {
+		const initialVirtualPaneId = ensureVirtualPaneId(emission);
+		const paneMap = /* @__PURE__ */ new Map();
+		const { paneId: initialPaneId, windowId } = await resolveInitialPane({
+			windowMode,
+			prompt: context.prompt,
+			dryRun: context.dryRun,
+			listWindows,
+			runCommand,
+			logCommand
+		});
+		registerPaneWithAncestors(paneMap, initialVirtualPaneId, initialPaneId);
+		logPaneMapping(initialVirtualPaneId, initialPaneId);
+		let executedSteps = 0;
+		for (const step of emission.steps) if (step.kind === "split") {
+			await applySplitStep({
+				step,
+				paneMap,
+				windowId,
+				runCommand,
+				listWindows,
+				logPaneMapping
+			});
+			executedSteps += 1;
+		} else if (step.kind === "focus") {
+			await applyFocusStep({
+				step,
+				paneMap,
+				runCommand
+			});
+			executedSteps += 1;
+		}
+		await applyTerminalCommands({
+			terminals: emission.terminals,
+			paneMap,
+			runCommand
+		});
+		const focusVirtual = emission.summary.focusPaneId;
+		const focusPaneId = typeof focusVirtual === "string" ? paneMap.get(focusVirtual) : void 0;
+		return {
+			executedSteps,
+			focusPaneId
+		};
+	};
+	return {
+		verifyEnvironment,
+		applyPlan,
+		getDryRunSteps: buildDryRunSteps
+	};
+};
+
+//#endregion
+//#region src/executor/backend-factory.ts
+const createTerminalBackend = (kind, context) => {
+	if (kind === "tmux") return createTmuxBackend(context);
+	if (kind === "wezterm") return createWeztermBackend(context);
+	throw new Error(`Unsupported backend "${kind}"`);
+};
+
+//#endregion
+//#region src/executor/backend-resolver.ts
+const KNOWN_BACKENDS = ["tmux", "wezterm"];
+const resolveTerminalBackendKind = ({ cliFlag, env }) => {
+	if (cliFlag !== void 0) {
+		if (!KNOWN_BACKENDS.includes(cliFlag)) throw new Error(`Unknown backend "${cliFlag}"`);
+		return cliFlag;
+	}
+	if (typeof env.TMUX === "string" && env.TMUX.trim().length > 0) return "tmux";
+	return "tmux";
+};
+
 //#endregion
 //#region src/core/diagnostics.ts
 const severityRank = {
@@ -1277,11 +2317,10 @@ const createCli = (options = {}) => {
 			console.log("");
 		}
 	};
-	const renderDryRun = (emission) => {
-		console.log(chalk.bold("\nPlanned tmux steps (dry-run)"));
-		emission.steps.forEach((step, index) => {
-			const commandString = step.command.join(" ");
-			console.log(` ${index + 1}. ${step.summary}: tmux ${commandString}`);
+	const renderDryRun = (steps) => {
+		console.log(chalk.bold("\nPlanned terminal steps (dry-run)"));
+		steps.forEach((step, index) => {
+			console.log(` ${index + 1}. [${step.backend}] ${step.summary}: ${step.command}`);
 		});
 	};
 	const buildPresetDocument = (preset, presetName) => {
@@ -1297,6 +2336,11 @@ const createCli = (options = {}) => {
 	const buildPresetSource = (presetName) => {
 		return typeof presetName === "string" && presetName.length > 0 ? `preset://${presetName}` : "preset://default";
 	};
+	const determineCliWindowMode = (options$1) => {
+		if (options$1.currentWindow === true && options$1.newWindow === true) throw new Error("Cannot use --current-window and --new-window at the same time");
+		if (options$1.currentWindow === true) return "current-window";
+		if (options$1.newWindow === true) return "new-window";
+	};
 	const handleFunctionalError = (error) => {
 		const header = [`[${error.kind}]`, `[${error.code}]`];
 		if (typeof error.path === "string" && error.path.length > 0) header.push(`[${error.path}]`);
@@ -1304,8 +2348,8 @@ const createCli = (options = {}) => {
 		if (typeof error.source === "string" && error.source.length > 0) lines.push(`source: ${error.source}`);
 		const commandDetail = error.details?.command;
 		if (Array.isArray(commandDetail)) {
-			const tmuxCommand = commandDetail.filter((segment) => typeof segment === "string");
-			if (tmuxCommand.length > 0) lines.push(`command: tmux ${tmuxCommand.join(" ")}`);
+			const parts = commandDetail.filter((segment) => typeof segment === "string");
+			if (parts.length > 0) lines.push(`command: ${parts.join(" ")}`);
 		} else if (typeof commandDetail === "string" && commandDetail.length > 0) lines.push(`command: ${commandDetail}`);
 		const stderrDetail = error.details?.stderr;
 		if (typeof stderrDetail === "string" && stderrDetail.length > 0) lines.push(`stderr: ${stderrDetail}`);
@@ -1361,12 +2405,36 @@ const createCli = (options = {}) => {
 		try {
 			await presetManager.loadConfig();
 			const preset = typeof presetName === "string" && presetName.length > 0 ? presetManager.getPreset(presetName) : presetManager.getDefaultPreset();
-			const tmuxEnv = process.env.TMUX;
-			if (!(typeof tmuxEnv === "string" && tmuxEnv.length > 0) && options$1.dryRun !== true) throw new Error("Must be run inside a tmux session");
+			const cliWindowMode = determineCliWindowMode({
+				currentWindow: options$1.currentWindow,
+				newWindow: options$1.newWindow
+			});
+			const defaults = presetManager.getDefaults();
+			const windowModeResolution = resolveWindowMode({
+				cli: cliWindowMode,
+				preset: preset.windowMode,
+				defaults: defaults?.windowMode
+			});
+			const windowMode = windowModeResolution.mode;
+			logger.info(`Window mode: ${windowMode} (source: ${windowModeResolution.source})`);
+			const confirmPaneClosure = createPaneKillPrompter(logger);
 			const executor = createCommandExecutor({
 				verbose: options$1.verbose,
 				dryRun: options$1.dryRun
 			});
+			const backendKind = resolveTerminalBackendKind({
+				cliFlag: options$1.backend,
+				env: process.env
+			});
+			logger.info(`Terminal backend: ${backendKind}`);
+			const backend = createTerminalBackend(backendKind, {
+				executor,
+				logger,
+				dryRun: options$1.dryRun,
+				verbose: options$1.verbose,
+				prompt: confirmPaneClosure
+			});
+			await backend.verifyEnvironment();
 			if (options$1.dryRun === true) console.log("[DRY RUN] No actual commands will be executed");
 			let compileResult;
 			let planResult;
@@ -1381,14 +2449,16 @@ const createCli = (options = {}) => {
 			} catch (error) {
 				return handlePipelineFailure(error);
 			}
-			if (options$1.dryRun === true) renderDryRun(emission);
-			else try {
-				const executionResult = await executePlan({
+			if (options$1.dryRun === true) {
+				const dryRunSteps = backend.getDryRunSteps(emission);
+				renderDryRun(dryRunSteps);
+			} else try {
+				const executionResult = await backend.applyPlan({
 					emission,
-					executor,
+					windowMode,
 					windowName: preset.name ?? presetName ?? "vde-layout"
 				});
-				logger.info(`Executed ${executionResult.executedSteps} tmux steps`);
+				logger.info(`Executed ${executionResult.executedSteps} ${backendKind} steps`);
 			} catch (error) {
 				return handlePipelineFailure(error);
 			}
@@ -1403,7 +2473,10 @@ const createCli = (options = {}) => {
 		program.option("--verbose", "Show detailed logs", false);
 		program.option("-V", "Show version (deprecated; use -v)");
 		program.option("--dry-run", "Display commands without executing", false);
+		program.option("--backend <backend>", "Select terminal backend (tmux or wezterm)");
 		program.option("--config <path>", "Path to configuration file");
+		program.option("--current-window", "Use the current tmux window for layout (kills other panes)", false);
+		program.option("--new-window", "Always create a new tmux window for layout", false);
 		program.command("list").description("List available presets").action(async () => {
 			await listPresets();
 		});
@@ -1414,7 +2487,10 @@ const createCli = (options = {}) => {
 			const opts = program.opts();
 			await executePreset(presetName, {
 				verbose: opts.verbose === true,
-				dryRun: opts.dryRun === true
+				dryRun: opts.dryRun === true,
+				currentWindow: opts.currentWindow === true,
+				newWindow: opts.newWindow === true,
+				backend: opts.backend
 			});
 		});
 	};