vde-worktree 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -0,0 +1,3355 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { constants } from "node:fs";
+import { access, appendFile, chmod, cp, mkdir, open, readFile, readdir, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "citty";
+import { execa } from "execa";
+import stringWidth from "string-width";
+import chalk from "chalk";
+
+//#region src/core/constants.ts
+const SCHEMA_VERSION = 1;
+const EXIT_CODE = {
+	OK: 0,
+	NOT_GIT_REPOSITORY: 2,
+	INVALID_ARGUMENT: 3,
+	SAFETY_REJECTED: 4,
+	DEPENDENCY_MISSING: 5,
+	LOCK_FAILED: 6,
+	HOOK_FAILED: 10,
+	GIT_COMMAND_FAILED: 20,
+	CHILD_PROCESS_FAILED: 21,
+	INTERNAL_ERROR: 30
+};
+const DEFAULT_HOOK_TIMEOUT_MS = 3e4;
+const DEFAULT_LOCK_TIMEOUT_MS = 15e3;
+const DEFAULT_STALE_LOCK_TTL_SECONDS = 1800;
+const COMMAND_NAMES = {
+	INIT: "init",
+	LIST: "list",
+	STATUS: "status",
+	PATH: "path",
+	SWITCH: "switch",
+	NEW: "new",
+	MV: "mv",
+	DEL: "del",
+	GONE: "gone",
+	GET: "get",
+	EXTRACT: "extract",
+	USE: "use",
+	EXEC: "exec",
+	INVOKE: "invoke",
+	COPY: "copy",
+	LINK: "link",
+	LOCK: "lock",
+	UNLOCK: "unlock",
+	CD: "cd",
+	COMPLETION: "completion"
+};
+const WRITE_COMMANDS = new Set([
+	COMMAND_NAMES.INIT,
+	COMMAND_NAMES.SWITCH,
+	COMMAND_NAMES.NEW,
+	COMMAND_NAMES.MV,
+	COMMAND_NAMES.DEL,
+	COMMAND_NAMES.GONE,
+	COMMAND_NAMES.GET,
+	COMMAND_NAMES.EXTRACT,
+	COMMAND_NAMES.USE,
+	COMMAND_NAMES.LOCK,
+	COMMAND_NAMES.UNLOCK
+]);
+
+//#endregion
+//#region src/core/errors.ts
+const ERROR_CODE_TO_EXIT_CODE = {
+	NOT_GIT_REPOSITORY: EXIT_CODE.NOT_GIT_REPOSITORY,
+	INVALID_ARGUMENT: EXIT_CODE.INVALID_ARGUMENT,
+	UNKNOWN_COMMAND: EXIT_CODE.INVALID_ARGUMENT,
+	UNSAFE_FLAG_REQUIRED: EXIT_CODE.SAFETY_REJECTED,
+	NOT_INITIALIZED: EXIT_CODE.SAFETY_REJECTED,
+	WORKTREE_NOT_FOUND: EXIT_CODE.SAFETY_REJECTED,
+	BRANCH_ALREADY_ATTACHED: EXIT_CODE.SAFETY_REJECTED,
+	BRANCH_ALREADY_EXISTS: EXIT_CODE.SAFETY_REJECTED,
+	BRANCH_IN_USE: EXIT_CODE.SAFETY_REJECTED,
+	TARGET_PATH_NOT_EMPTY: EXIT_CODE.SAFETY_REJECTED,
+	PATH_OUTSIDE_REPO: EXIT_CODE.SAFETY_REJECTED,
+	ABSOLUTE_PATH_NOT_ALLOWED: EXIT_CODE.SAFETY_REJECTED,
+	LOCK_CONFLICT: EXIT_CODE.SAFETY_REJECTED,
+	DETACHED_HEAD: EXIT_CODE.SAFETY_REJECTED,
+	DIRTY_WORKTREE: EXIT_CODE.SAFETY_REJECTED,
+	UNMERGED_WORKTREE: EXIT_CODE.SAFETY_REJECTED,
+	UNPUSHED_WORKTREE: EXIT_CODE.SAFETY_REJECTED,
+	LOCKED_WORKTREE: EXIT_CODE.SAFETY_REJECTED,
+	STASH_APPLY_FAILED: EXIT_CODE.SAFETY_REJECTED,
+	REMOTE_NOT_FOUND: EXIT_CODE.SAFETY_REJECTED,
+	REMOTE_BRANCH_NOT_FOUND: EXIT_CODE.SAFETY_REJECTED,
+	INVALID_REMOTE_BRANCH_FORMAT: EXIT_CODE.INVALID_ARGUMENT,
+	HOOK_NOT_FOUND: EXIT_CODE.SAFETY_REJECTED,
+	DEPENDENCY_MISSING: EXIT_CODE.DEPENDENCY_MISSING,
+	REPO_LOCK_TIMEOUT: EXIT_CODE.LOCK_FAILED,
+	REPO_LOCK_STALE_RECOVERY_FAILED: EXIT_CODE.LOCK_FAILED,
+	HOOK_NOT_EXECUTABLE: EXIT_CODE.HOOK_FAILED,
+	HOOK_TIMEOUT: EXIT_CODE.HOOK_FAILED,
+	HOOK_FAILED: EXIT_CODE.HOOK_FAILED,
+	GIT_COMMAND_FAILED: EXIT_CODE.GIT_COMMAND_FAILED,
+	INTERNAL_ERROR: EXIT_CODE.INTERNAL_ERROR
+};
+var CliError = class extends Error {
+	code;
+	exitCode;
+	details;
+	constructor(code, options) {
+		super(options.message, { cause: options.cause });
+		this.code = code;
+		this.exitCode = ERROR_CODE_TO_EXIT_CODE[code];
+		this.details = options.details ?? {};
+	}
+};
+const createCliError = (code, options) => {
+	return new CliError(code, options);
+};
+const ensureCliError = (error) => {
+	if (error instanceof CliError) return error;
+	if (error instanceof Error) return createCliError("INTERNAL_ERROR", {
+		message: error.message,
+		cause: error
+	});
+	return createCliError("INTERNAL_ERROR", {
+		message: "An unexpected error occurred",
+		details: { value: String(error) }
+	});
+};
+
+//#endregion
+//#region src/git/exec.ts
+const runGitCommand = async ({ cwd, args, reject = true }) => {
+	try {
+		const result = await execa("git", [...args], {
+			cwd,
+			reject
+		});
+		return {
+			stdout: result.stdout,
+			stderr: result.stderr,
+			exitCode: result.exitCode ?? 0
+		};
+	} catch (error) {
+		const execaError = error;
+		throw createCliError("GIT_COMMAND_FAILED", {
+			message: "git command failed",
+			details: {
+				command: ["git", ...args],
+				cwd,
+				exitCode: execaError.exitCode,
+				stdout: execaError.stdout ?? "",
+				stderr: execaError.stderr ?? "",
+				shortMessage: execaError.shortMessage ?? execaError.message
+			},
+			cause: error
+		});
+	}
+};
+const doesGitRefExist = async (cwd, ref) => {
+	return (await runGitCommand({
+		cwd,
+		args: [
+			"show-ref",
+			"--verify",
+			"--quiet",
+			ref
+		],
+		reject: false
+	})).exitCode === 0;
+};
+
+//#endregion
+//#region src/core/paths.ts
+const GIT_DIR_NAME = ".git";
+const resolveRepoRootFromCommonDir = ({ currentWorktreeRoot, gitCommonDir }) => {
+	if (gitCommonDir.endsWith(`/${GIT_DIR_NAME}`)) return dirname(gitCommonDir);
+	if (gitCommonDir.endsWith(`\\${GIT_DIR_NAME}`)) return dirname(gitCommonDir);
+	return currentWorktreeRoot;
+};
+const resolveRepoContext = async (cwd) => {
+	const toplevelResult = await runGitCommand({
+		cwd,
+		args: ["rev-parse", "--show-toplevel"],
+		reject: false
+	});
+	if (toplevelResult.exitCode !== 0) throw createCliError("NOT_GIT_REPOSITORY", {
+		message: "Current directory is not inside a Git repository",
+		details: { cwd }
+	});
+	const currentWorktreeRoot = toplevelResult.stdout.trim();
+	const commonDirResult = await runGitCommand({
+		cwd,
+		args: [
+			"rev-parse",
+			"--path-format=absolute",
+			"--git-common-dir"
+		],
+		reject: false
+	});
+	const gitCommonDir = commonDirResult.exitCode === 0 ? commonDirResult.stdout.trim() : join(currentWorktreeRoot, GIT_DIR_NAME);
+	return {
+		repoRoot: resolveRepoRootFromCommonDir({
+			currentWorktreeRoot,
+			gitCommonDir
+		}),
+		currentWorktreeRoot,
+		gitCommonDir
+	};
+};
+const getWorktreeRootPath = (repoRoot) => {
+	return join(repoRoot, ".worktree");
+};
+const getWorktreeMetaRootPath = (repoRoot) => {
+	return join(repoRoot, ".vde", "worktree");
+};
+const getHooksDirectoryPath = (repoRoot) => {
+	return join(getWorktreeMetaRootPath(repoRoot), "hooks");
+};
+const getLogsDirectoryPath = (repoRoot) => {
+	return join(getWorktreeMetaRootPath(repoRoot), "logs");
+};
+const getLocksDirectoryPath = (repoRoot) => {
+	return join(getWorktreeMetaRootPath(repoRoot), "locks");
+};
+const getStateDirectoryPath = (repoRoot) => {
+	return join(getWorktreeMetaRootPath(repoRoot), "state");
+};
+const branchToWorktreeId = (branch) => {
+	return encodeURIComponent(branch);
+};
+const branchToWorktreePath = (repoRoot, branch) => {
+	return join(getWorktreeRootPath(repoRoot), branchToWorktreeId(branch));
+};
+const ensurePathInsideRepo = ({ repoRoot, path }) => {
+	const rel = relative(repoRoot, path);
+	if (rel === "") return path;
+	if (rel === ".." || rel.startsWith(`..${sep}`)) throw createCliError("PATH_OUTSIDE_REPO", {
+		message: "Path is outside repository root",
+		details: {
+			repoRoot,
+			path
+		}
+	});
+	return path;
+};
+const resolveRepoRelativePath = ({ repoRoot, relativePath }) => {
+	if (isAbsolute(relativePath)) throw createCliError("ABSOLUTE_PATH_NOT_ALLOWED", {
+		message: "Absolute path is not allowed",
+		details: { path: relativePath }
+	});
+	return ensurePathInsideRepo({
+		repoRoot,
+		path: resolve(repoRoot, normalize(relativePath))
+	});
+};
+const resolvePathFromCwd = ({ cwd, path }) => {
+	if (isAbsolute(path)) return path;
+	return resolve(cwd, path);
+};
+
+//#endregion
+//#region src/core/hooks.ts
+const nowTimestamp = () => {
+	return (/* @__PURE__ */ new Date()).toISOString().replace(/[^\d]/g, "").slice(0, 14);
+};
+const toLogFileName = ({ action, branch }) => {
+	const safeBranch = typeof branch === "string" && branch.length > 0 ? branch.replace(/[^\w.-]/g, "_") : "none";
+	return `${nowTimestamp()}_${action}_${safeBranch}.log`;
+};
+const hookPath = (repoRoot, hookName) => {
+	return join(getHooksDirectoryPath(repoRoot), hookName);
+};
+const appendHookLog = async ({ repoRoot, action, branch, content }) => {
+	const logsDir = getLogsDirectoryPath(repoRoot);
+	await mkdir(logsDir, { recursive: true });
+	await appendFile(join(logsDir, toLogFileName({
+		action,
+		branch
+	})), content, "utf8");
+};
+const runHook = async ({ phase, hookName, args, context, requireExists = false }) => {
+	if (context.enabled !== true) return;
+	const path = hookPath(context.repoRoot, hookName);
+	try {
+		await access(path, constants.F_OK);
+	} catch {
+		if (requireExists) throw createCliError("HOOK_NOT_FOUND", {
+			message: `Hook not found: ${hookName}`,
+			details: {
+				hook: hookName,
+				path
+			}
+		});
+		return;
+	}
+	try {
+		await access(path, constants.X_OK);
+	} catch {
+		throw createCliError("HOOK_NOT_EXECUTABLE", {
+			message: `Hook is not executable: ${hookName}`,
+			details: {
+				hook: hookName,
+				path
+			}
+		});
+	}
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+	try {
+		const result = await execa(path, [...args], {
+			cwd: context.worktreePath ?? context.repoRoot,
+			env: {
+				...process.env,
+				WT_REPO_ROOT: context.repoRoot,
+				WT_ACTION: context.action,
+				WT_BRANCH: context.branch ?? "",
+				WT_WORKTREE_PATH: context.worktreePath ?? "",
+				WT_IS_TTY: process.stdout.isTTY === true ? "1" : "0",
+				WT_TOOL: "vde-worktree",
+				...context.extraEnv ?? {}
+			},
+			timeout: context.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS,
+			reject: false
+		});
+		const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+		const logContent = [
+			`hook=${hookName}`,
+			`phase=${phase}`,
+			`start=${startedAt}`,
+			`end=${endedAt}`,
+			`exitCode=${String(result.exitCode ?? 0)}`,
+			`stderr=${result.stderr ?? ""}`,
+			""
+		].join("\n");
+		await appendHookLog({
+			repoRoot: context.repoRoot,
+			action: context.action,
+			branch: context.branch,
+			content: logContent
+		});
+		if ((result.exitCode ?? 0) === 0) return;
+		const message = `Hook failed: ${hookName} (exitCode=${String(result.exitCode ?? 1)})`;
+		if (phase === "post" && context.strictPostHooks !== true) {
+			context.stderr(message);
+			return;
+		}
+		throw createCliError("HOOK_FAILED", {
+			message,
+			details: {
+				hook: hookName,
+				exitCode: result.exitCode,
+				stderr: result.stderr
+			}
+		});
+	} catch (error) {
+		if (error instanceof CliError) throw error;
+		const hookError = error;
+		if (hookError.code === "ETIMEDOUT" || hookError.code === "ERR_EXECA_TIMEOUT") throw createCliError("HOOK_TIMEOUT", {
+			message: `Hook timed out: ${hookName}`,
+			details: {
+				hook: hookName,
+				timeoutMs: context.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS,
+				stderr: hookError.stderr ?? ""
+			},
+			cause: error
+		});
+		if (phase === "post" && context.strictPostHooks !== true) {
+			context.stderr(`Hook failed: ${hookName}`);
+			return;
+		}
+		throw createCliError("HOOK_FAILED", {
+			message: `Hook failed: ${hookName}`,
+			details: {
+				hook: hookName,
+				stderr: hookError.stderr ?? hookError.message
+			},
+			cause: error
+		});
+	}
+};
+const runPreHook = async ({ name, context }) => {
+	await runHook({
+		phase: "pre",
+		hookName: `pre-${name}`,
+		args: [],
+		context
+	});
+};
+const runPostHook = async ({ name, context }) => {
+	await runHook({
+		phase: "post",
+		hookName: `post-${name}`,
+		args: [],
+		context
+	});
+};
+const invokeHook = async ({ hookName, args, context }) => {
+	await runHook({
+		phase: hookName.startsWith("pre-") ? "pre" : "post",
+		hookName,
+		args,
+		context,
+		requireExists: true
+	});
+};
+
+//#endregion
+//#region src/core/init.ts
+const MANAGED_EXCLUDE_BLOCK = `# vde-worktree (managed)\n.worktree/\n.vde/worktree/\n`;
+const DEFAULT_HOOKS = [{
+	name: "post-new",
+	lines: [
+		"#!/usr/bin/env bash",
+		"set -eu",
+		"",
+		"# example:",
+		"#   vde-worktree copy .envrc .claude/settings.local.json",
+		"",
+		"exit 0"
+	]
+}, {
+	name: "post-switch",
+	lines: [
+		"#!/usr/bin/env bash",
+		"set -eu",
+		"",
+		"# example:",
+		"#   vde-worktree link .envrc",
+		"",
+		"exit 0"
+	]
+}];
+const createHookTemplate = async (hooksDir, name, lines) => {
+	const targetPath = join(hooksDir, name);
+	try {
+		await access(targetPath, constants.F_OK);
+		return;
+	} catch {
+		await writeFile(targetPath, `${lines.join("\n")}\n`, "utf8");
+		await chmod(targetPath, 493);
+	}
+};
+const ensureExcludeBlock = async (repoRoot) => {
+	const excludePath = join(repoRoot, ".git", "info", "exclude");
+	let current = "";
+	try {
+		current = await readFile(excludePath, "utf8");
+	} catch {
+		current = "";
+	}
+	if (current.includes(MANAGED_EXCLUDE_BLOCK)) return;
+	await writeFile(excludePath, `${current.endsWith("\n") || current.length === 0 ? current : `${current}\n`}${MANAGED_EXCLUDE_BLOCK}`, "utf8");
+};
+const isInitialized = async (repoRoot) => {
+	try {
+		await access(getWorktreeMetaRootPath(repoRoot), constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const initializeRepository = async (repoRoot) => {
+	const wasInitialized = await isInitialized(repoRoot);
+	await mkdir(getWorktreeRootPath(repoRoot), { recursive: true });
+	await mkdir(getHooksDirectoryPath(repoRoot), { recursive: true });
+	await mkdir(getLogsDirectoryPath(repoRoot), { recursive: true });
+	await mkdir(getLocksDirectoryPath(repoRoot), { recursive: true });
+	await mkdir(getStateDirectoryPath(repoRoot), { recursive: true });
+	await ensureExcludeBlock(repoRoot);
+	for (const hook of DEFAULT_HOOKS) await createHookTemplate(getHooksDirectoryPath(repoRoot), hook.name, hook.lines);
+	return { alreadyInitialized: wasInitialized };
+};
+
+//#endregion
+//#region src/core/repo-lock.ts
+const sleep = async (ms) => {
+	await new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+};
+const isProcessAlive = (pid) => {
+	if (pid <= 0 || Number.isFinite(pid) !== true) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		if (error.code === "ESRCH") return false;
+		return true;
+	}
+};
+const safeParseLockFile = (content) => {
+	try {
+		const parsed = JSON.parse(content);
+		if (parsed.schemaVersion !== 1) return null;
+		if (typeof parsed.command !== "string" || typeof parsed.owner !== "string") return null;
+		if (typeof parsed.pid !== "number" || typeof parsed.host !== "string" || typeof parsed.startedAt !== "string") return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+};
+const lockFilePath$1 = async (repoRoot) => {
+	const stateDir = getStateDirectoryPath(repoRoot);
+	try {
+		await access(stateDir, constants.F_OK);
+		return join(stateDir, "repo.lock");
+	} catch {
+		return join(repoRoot, ".git", "vde-worktree.init.lock");
+	}
+};
+const buildLockPayload = (command) => {
+	return {
+		schemaVersion: 1,
+		owner: "vde-worktree",
+		command,
+		pid: process.pid,
+		host: hostname(),
+		startedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+};
+const canRecoverStaleLock = ({ lock, staleLockTTLSeconds }) => {
+	if (lock === null) return true;
+	const startedAtMs = Date.parse(lock.startedAt);
+	if (Number.isFinite(startedAtMs) !== true) return true;
+	if (startedAtMs + staleLockTTLSeconds * 1e3 > Date.now()) return false;
+	if (lock.host === hostname() && isProcessAlive(lock.pid)) return false;
+	return true;
+};
+const writeNewLockFile = async (path, payload) => {
+	try {
+		const handle = await open(path, "wx");
+		await handle.writeFile(`${JSON.stringify(payload)}\n`, "utf8");
+		await handle.close();
+		return true;
+	} catch (error) {
+		if (error.code === "EEXIST") return false;
+		throw error;
+	}
+};
+const acquireRepoLock = async ({ repoRoot, command, timeoutMs = DEFAULT_LOCK_TIMEOUT_MS, staleLockTTLSeconds = DEFAULT_STALE_LOCK_TTL_SECONDS }) => {
+	const path = await lockFilePath$1(repoRoot);
+	const startAt = Date.now();
+	const payload = buildLockPayload(command);
+	while (Date.now() - startAt <= timeoutMs) {
+		if (await writeNewLockFile(path, payload)) return { release: async () => {
+			try {
+				await rm(path, { force: true });
+			} catch {
+				return;
+			}
+		} };
+		let lockContent = "";
+		try {
+			lockContent = await readFile(path, "utf8");
+		} catch {
+			await sleep(100);
+			continue;
+		}
+		if (canRecoverStaleLock({
+			lock: safeParseLockFile(lockContent),
+			staleLockTTLSeconds
+		})) {
+			try {
+				await rm(path, { force: true });
+			} catch {
+				throw createCliError("REPO_LOCK_STALE_RECOVERY_FAILED", {
+					message: "Failed to recover stale repo lock",
+					details: { path }
+				});
+			}
+			continue;
+		}
+		await sleep(100);
+	}
+	throw createCliError("REPO_LOCK_TIMEOUT", {
+		message: "Timed out while acquiring repo lock",
+		details: {
+			path,
+			timeoutMs
+		}
+	});
+};
+const withRepoLock = async (options, task) => {
+	const handle = await acquireRepoLock(options);
+	try {
+		return await task();
+	} finally {
+		await handle.release();
+	}
+};
+const readNumberFromEnvOrDefault = ({ rawValue, defaultValue }) => {
+	if (typeof rawValue !== "number" || Number.isFinite(rawValue) !== true) return defaultValue;
+	return rawValue;
+};
+
+//#endregion
+//#region src/core/worktree-lock.ts
+const parseLock = (content) => {
+	try {
+		const parsed = JSON.parse(content);
+		if (parsed.schemaVersion !== 1 || typeof parsed.branch !== "string" || typeof parsed.worktreeId !== "string" || typeof parsed.reason !== "string" || typeof parsed.owner !== "string" || typeof parsed.host !== "string" || typeof parsed.pid !== "number" || typeof parsed.createdAt !== "string" || typeof parsed.updatedAt !== "string") return {
+			valid: false,
+			record: null
+		};
+		return {
+			valid: true,
+			record: parsed
+		};
+	} catch {
+		return {
+			valid: false,
+			record: null
+		};
+	}
+};
+const writeJsonAtomically = async ({ filePath, payload }) => {
+	const tmpPath = `${filePath}.tmp-${String(process.pid)}-${String(Date.now())}`;
+	await writeFile(tmpPath, `${JSON.stringify(payload)}\n`, "utf8");
+	await rename(tmpPath, filePath);
+};
+const lockFilePath = (repoRoot, branch) => {
+	return join(getLocksDirectoryPath(repoRoot), `${branchToWorktreeId(branch)}.json`);
+};
+const readWorktreeLock = async ({ repoRoot, branch }) => {
+	const path = lockFilePath(repoRoot, branch);
+	try {
+		await access(path, constants.F_OK);
+	} catch {
+		return {
+			path,
+			exists: false,
+			valid: true,
+			record: null
+		};
+	}
+	try {
+		return {
+			path,
+			exists: true,
+			...parseLock(await readFile(path, "utf8"))
+		};
+	} catch {
+		return {
+			path,
+			exists: true,
+			valid: false,
+			record: null
+		};
+	}
+};
+const upsertWorktreeLock = async ({ repoRoot, branch, reason, owner }) => {
+	const { path, record } = await readWorktreeLock({
+		repoRoot,
+		branch
+	});
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const next = {
+		schemaVersion: 1,
+		branch,
+		worktreeId: branchToWorktreeId(branch),
+		reason,
+		owner,
+		host: hostname(),
+		pid: process.pid,
+		createdAt: record?.createdAt ?? now,
+		updatedAt: now
+	};
+	await writeJsonAtomically({
+		filePath: path,
+		payload: next
+	});
+	return next;
+};
+const deleteWorktreeLock = async ({ repoRoot, branch }) => {
+	await rm(lockFilePath(repoRoot, branch), { force: true });
+};
+
+//#endregion
+//#region src/integrations/gh.ts
+const defaultRunGh = async ({ cwd, args }) => {
+	const result = await execa("gh", [...args], {
+		cwd,
+		reject: false
+	});
+	return {
+		exitCode: result.exitCode ?? 0,
+		stdout: result.stdout,
+		stderr: result.stderr
+	};
+};
+const parseMergedResult = (raw) => {
+	try {
+		const parsed = JSON.parse(raw);
+		if (Array.isArray(parsed) !== true) return null;
+		const records = parsed;
+		if (records.length === 0) return false;
+		return records.some((record) => typeof record?.mergedAt === "string" && record.mergedAt.length > 0);
+	} catch {
+		return null;
+	}
+};
+const resolveMergedByPr = async ({ repoRoot, branch, enabled = true, runGh = defaultRunGh }) => {
+	if (enabled !== true) return null;
+	try {
+		const result = await runGh({
+			cwd: repoRoot,
+			args: [
+				"pr",
+				"list",
+				"--state",
+				"merged",
+				"--head",
+				branch,
+				"--limit",
+				"1",
+				"--json",
+				"mergedAt"
+			]
+		});
+		if (result.exitCode !== 0) return null;
+		return parseMergedResult(result.stdout);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		return null;
+	}
+};
+
+//#endregion
+//#region src/git/worktree.ts
+const BRANCH_PREFIX = "refs/heads/";
+const parseBranchName = (rawRef) => {
+	if (rawRef.startsWith(BRANCH_PREFIX)) return rawRef.slice(11);
+	return rawRef.length > 0 ? rawRef : null;
+};
+const parseWorktreePorcelain = (raw) => {
+	const tokens = raw.split("\0");
+	const worktrees = [];
+	let currentPath = "";
+	let currentHead = "";
+	let currentBranch = null;
+	const flush = () => {
+		if (currentPath.length === 0) return;
+		worktrees.push({
+			path: currentPath,
+			head: currentHead,
+			branch: currentBranch
+		});
+		currentPath = "";
+		currentHead = "";
+		currentBranch = null;
+	};
+	for (const token of tokens) {
+		if (token.length === 0) {
+			flush();
+			continue;
+		}
+		if (token.startsWith("worktree ")) {
+			flush();
+			currentPath = token.slice(9);
+			continue;
+		}
+		if (token.startsWith("HEAD ")) {
+			currentHead = token.slice(5);
+			continue;
+		}
+		if (token.startsWith("branch ")) {
+			currentBranch = parseBranchName(token.slice(7));
+			continue;
+		}
+		if (token === "detached") currentBranch = null;
+	}
+	flush();
+	return worktrees;
+};
+const listGitWorktrees = async (repoRoot) => {
+	return parseWorktreePorcelain((await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"worktree",
+			"list",
+			"--porcelain",
+			"-z"
+		]
+	})).stdout);
+};
+
+//#endregion
+//#region src/core/worktree-state.ts
+const resolveBaseBranch$1 = async (repoRoot) => {
+	const explicit = await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"config",
+			"--get",
+			"vde-worktree.baseBranch"
+		],
+		reject: false
+	});
+	if (explicit.exitCode === 0 && explicit.stdout.trim().length > 0) return explicit.stdout.trim();
+	for (const candidate of ["main", "master"]) if (await doesGitRefExist(repoRoot, `refs/heads/${candidate}`)) return candidate;
+	return null;
+};
+const resolveEnableGh = async (repoRoot) => {
+	const result = await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"config",
+			"--bool",
+			"--get",
+			"vde-worktree.enableGh"
+		],
+		reject: false
+	});
+	if (result.exitCode !== 0) return true;
+	const value = result.stdout.trim().toLowerCase();
+	if (value === "false" || value === "no" || value === "off" || value === "0") return false;
+	return true;
+};
+const resolveDirty = async (worktreePath) => {
+	return (await runGitCommand({
+		cwd: worktreePath,
+		args: ["status", "--porcelain"],
+		reject: false
+	})).stdout.trim().length > 0;
+};
+const parseLockPayload = (content) => {
+	try {
+		const parsed = JSON.parse(content);
+		if (parsed.schemaVersion !== 1) return null;
+		if (typeof parsed.branch !== "string" || typeof parsed.worktreeId !== "string" || typeof parsed.reason !== "string" || parsed.reason.length === 0) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+};
+const resolveLockState = async ({ repoRoot, branch }) => {
+	if (branch === null) return {
+		value: false,
+		reason: null,
+		owner: null
+	};
+	const id = branchToWorktreeId(branch);
+	const lockPath = join(getLocksDirectoryPath(repoRoot), `${id}.json`);
+	try {
+		await access(lockPath, constants.F_OK);
+	} catch {
+		return {
+			value: false,
+			reason: null,
+			owner: null
+		};
+	}
+	try {
+		const lock = parseLockPayload(await readFile(lockPath, "utf8"));
+		if (lock === null) return {
+			value: true,
+			reason: "invalid lock metadata",
+			owner: null
+		};
+		return {
+			value: true,
+			reason: lock.reason,
+			owner: typeof lock.owner === "string" && lock.owner.length > 0 ? lock.owner : null
+		};
+	} catch {
+		return {
+			value: true,
+			reason: "invalid lock metadata",
+			owner: null
+		};
+	}
+};
+const resolveMergedState = async ({ repoRoot, branch, baseBranch, enableGh }) => {
+	if (branch === null) return {
+		byAncestry: null,
+		byPR: null,
+		overall: null
+	};
+	let byAncestry = null;
+	if (baseBranch !== null) {
+		const result = await runGitCommand({
+			cwd: repoRoot,
+			args: [
+				"merge-base",
+				"--is-ancestor",
+				branch,
+				baseBranch
+			],
+			reject: false
+		});
+		if (result.exitCode === 0) byAncestry = true;
+		else if (result.exitCode === 1) byAncestry = false;
+	}
+	const byPR = await resolveMergedByPr({
+		repoRoot,
+		branch,
+		enabled: enableGh
+	});
+	return {
+		byAncestry,
+		byPR,
+		overall: resolveMergedOverall({
+			byAncestry,
+			byPR
+		})
+	};
+};
+const resolveMergedOverall = ({ byAncestry, byPR }) => {
+	if (byPR === true) return true;
+	if (byPR === false) return false;
+	return byAncestry;
+};
+const resolveUpstreamState = async (worktreePath) => {
+	const upstreamRef = await runGitCommand({
+		cwd: worktreePath,
+		args: [
+			"rev-parse",
+			"--abbrev-ref",
+			"--symbolic-full-name",
+			"@{upstream}"
+		],
+		reject: false
+	});
+	if (upstreamRef.exitCode !== 0) return {
+		ahead: null,
+		behind: null,
+		remote: null
+	};
+	const distance = await runGitCommand({
+		cwd: worktreePath,
+		args: [
+			"rev-list",
+			"--left-right",
+			"--count",
+			"@{upstream}...HEAD"
+		],
+		reject: false
+	});
+	if (distance.exitCode !== 0) return {
+		ahead: null,
+		behind: null,
+		remote: upstreamRef.stdout.trim()
+	};
+	const [behindRaw, aheadRaw] = distance.stdout.trim().split(/\s+/);
+	const behind = Number.parseInt(behindRaw ?? "", 10);
+	const ahead = Number.parseInt(aheadRaw ?? "", 10);
+	return {
+		ahead: Number.isNaN(ahead) ? null : ahead,
+		behind: Number.isNaN(behind) ? null : behind,
+		remote: upstreamRef.stdout.trim()
+	};
+};
+const enrichWorktree = async ({ repoRoot, worktree, baseBranch, enableGh }) => {
+	const [dirty, locked, merged, upstream] = await Promise.all([
+		resolveDirty(worktree.path),
+		resolveLockState({
+			repoRoot,
+			branch: worktree.branch
+		}),
+		resolveMergedState({
+			repoRoot,
+			branch: worktree.branch,
+			baseBranch,
+			enableGh
+		}),
+		resolveUpstreamState(worktree.path)
+	]);
+	return {
+		branch: worktree.branch,
+		path: worktree.path,
+		head: worktree.head,
+		dirty,
+		locked,
+		merged,
+		upstream
+	};
+};
+const collectWorktreeSnapshot = async (repoRoot) => {
+	const [baseBranch, worktrees, enableGh] = await Promise.all([
+		resolveBaseBranch$1(repoRoot),
+		listGitWorktrees(repoRoot),
+		resolveEnableGh(repoRoot)
+	]);
+	return {
+		repoRoot,
+		baseBranch,
+		worktrees: await Promise.all(worktrees.map(async (worktree) => {
+			return enrichWorktree({
+				repoRoot,
+				worktree,
+				baseBranch,
+				enableGh
+			});
+		}))
+	};
+};
+
+//#endregion
+//#region src/integrations/fzf.ts
+const FZF_BINARY = "fzf";
+const FZF_CHECK_TIMEOUT_MS = 5e3;
+const RESERVED_FZF_ARGS = new Set([
+	"prompt",
+	"layout",
+	"height",
+	"border"
+]);
+const sanitizeCandidate = (value) => value.replace(/[\t\r\n]+/g, " ").trim();
+const buildFzfInput = (candidates) => {
+	return candidates.map((candidate) => sanitizeCandidate(candidate)).filter((candidate) => candidate.length > 0).join("\n");
+};
+const validateExtraFzfArgs = (fzfExtraArgs) => {
+	for (const arg of fzfExtraArgs) {
+		if (typeof arg !== "string" || arg.length === 0) throw new Error("Empty value is not allowed for --fzf-arg");
+		if (!arg.startsWith("--")) continue;
+		const withoutPrefix = arg.slice(2);
+		if (withoutPrefix.length === 0) continue;
+		const optionName = withoutPrefix.split("=")[0];
+		if (optionName !== void 0 && RESERVED_FZF_ARGS.has(optionName)) throw new Error(`--fzf-arg cannot override reserved fzf option: --${optionName}`);
+	}
+};
+const buildFzfArgs = ({ prompt, fzfExtraArgs }) => {
+	validateExtraFzfArgs(fzfExtraArgs);
+	return [
+		`--prompt=${prompt}`,
+		"--layout=reverse",
+		"--height=80%",
+		"--border",
+		...fzfExtraArgs
+	];
+};
+const defaultCheckFzfAvailability = async () => {
+	try {
+		await execa(FZF_BINARY, ["--version"], { timeout: FZF_CHECK_TIMEOUT_MS });
+		return true;
+	} catch (error) {
+		const execaError = error;
+		if (execaError.code === "ENOENT" || execaError.code === "ETIMEDOUT" || execaError.code === "ERR_EXECA_TIMEOUT" || execaError.timedOut === true) return false;
+		throw error;
+	}
+};
+const defaultRunFzf = async ({ args, input, cwd, env }) => {
+	return { stdout: (await execa(FZF_BINARY, args, {
+		input,
+		cwd,
+		env,
+		stderr: "inherit"
+	})).stdout };
+};
+const ensureFzfAvailable = async (checkFzfAvailability) => {
+	if (await checkFzfAvailability()) return;
+	throw new Error("fzf is required for interactive selection");
+};
+const selectPathWithFzf = async ({ candidates, prompt = "worktree> ", fzfExtraArgs = [], cwd = process.cwd(), env = process.env, isInteractive = () => process.stdout.isTTY === true && process.stderr.isTTY === true, checkFzfAvailability = defaultCheckFzfAvailability, runFzf = defaultRunFzf }) => {
+	if (candidates.length === 0) throw new Error("No candidates provided for fzf selection");
+	if (isInteractive() !== true) throw new Error("fzf selection requires an interactive terminal");
+	await ensureFzfAvailable(checkFzfAvailability);
+	const args = buildFzfArgs({
+		prompt,
+		fzfExtraArgs
+	});
+	const input = buildFzfInput(candidates);
+	if (input.length === 0) throw new Error("All candidates are empty after sanitization");
+	const candidateSet = new Set(input.split("\n"));
+	try {
+		const selectedPath = (await runFzf({
+			args,
+			input,
+			cwd,
+			env
+		})).stdout.trim();
+		if (selectedPath.length === 0) return { status: "cancelled" };
+		if (!candidateSet.has(selectedPath)) throw new Error("fzf returned a value that is not in the candidate list");
+		return {
+			status: "selected",
+			path: selectedPath
+		};
+	} catch (error) {
+		if (error.exitCode === 130) return { status: "cancelled" };
+		throw error;
+	}
+};
+
+//#endregion
+//#region src/utils/logger.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+	LogLevel[LogLevel["WARN"] = 1] = "WARN";
+	LogLevel[LogLevel["INFO"] = 2] = "INFO";
+	LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+	return LogLevel;
+}({});
+const resolveDefaultLogLevel = () => {
+	if (process.env.VDE_WORKTREE_DEBUG === "true" || process.env.VDE_DEBUG === "true") return LogLevel.DEBUG;
+	if (process.env.VDE_WORKTREE_VERBOSE === "true" || process.env.VDE_VERBOSE === "true") return LogLevel.INFO;
+	return LogLevel.WARN;
+};
+const formatMessage = (prefix, message) => {
+	return prefix ? `${prefix} ${message}` : message;
+};
+const createLogger = (options = {}) => {
+	const level = options.level ?? resolveDefaultLogLevel();
+	const prefix = options.prefix ?? "";
+	const build = (nextPrefix, nextLevel) => {
+		const resolvedPrefix = nextPrefix;
+		return {
+			level: nextLevel,
+			prefix: resolvedPrefix,
+			error(message, error) {
+				if (nextLevel >= LogLevel.ERROR) {
+					console.error(chalk.red(formatMessage(resolvedPrefix, `Error: ${message}`)));
+					if (error && (process.env.VDE_WORKTREE_DEBUG === "true" || process.env.VDE_DEBUG === "true")) console.error(chalk.gray(error.stack));
+				}
+			},
+			warn(message) {
+				if (nextLevel >= LogLevel.WARN) console.warn(chalk.yellow(formatMessage(resolvedPrefix, message)));
+			},
+			info(message) {
+				if (nextLevel >= LogLevel.INFO) console.log(formatMessage(resolvedPrefix, message));
+			},
+			debug(message) {
+				if (nextLevel >= LogLevel.DEBUG) console.log(chalk.gray(formatMessage(resolvedPrefix, `[DEBUG] ${message}`)));
+			},
+			success(message) {
+				console.log(chalk.green(formatMessage(resolvedPrefix, message)));
+			},
+			createChild(suffix) {
+				return build(resolvedPrefix ? `${resolvedPrefix} ${suffix}` : suffix, nextLevel);
+			}
+		};
+	};
+	return build(prefix, level);
+};
+
+//#endregion
+//#region src/cli/package-version.ts
+const CANDIDATE_PATHS = ["../package.json", "../../package.json"];
+const isModuleNotFoundError = (error) => {
+	return error instanceof Error && error.code === "MODULE_NOT_FOUND";
+};
+const loadPackageVersion = (requireFn) => {
+	let lastNotFound;
+	for (const candidatePath of CANDIDATE_PATHS) try {
+		return requireFn(candidatePath).version;
+	} catch (error) {
+		if (isModuleNotFoundError(error)) {
+			lastNotFound = error;
+			continue;
+		}
+		throw error;
+	}
+	throw lastNotFound ?? /* @__PURE__ */ new Error(`Unable to resolve package version from candidates: ${CANDIDATE_PATHS.join(", ")}`);
+};
+
+//#endregion
+//#region src/cli/index.ts
+const EXIT_CODE_CANCELLED = 130;
+const optionNamesAllowOptionLikeValue = new Set(["fzfArg", "fzf-arg"]);
+const COMPLETION_SHELLS = ["zsh", "fish"];
+const COMPLETION_FILE_BY_SHELL = {
+	zsh: "zsh/_vw",
+	fish: "fish/vw.fish"
+};
+const commandHelpEntries = [
+	{
+		name: "init",
+		usage: "vw init",
+		summary: "Initialize directories, hooks, and managed exclude entries.",
+		details: ["Creates .worktree and .vde/worktree directories.", "Appends managed entries to .git/info/exclude (idempotent)."]
+	},
+	{
+		name: "list",
+		usage: "vw list [--json]",
+		summary: "List worktrees with status metadata.",
+		details: ["Includes branch, path, dirty, lock, merged, and upstream fields."]
+	},
+	{
+		name: "status",
+		usage: "vw status [branch] [--json]",
+		summary: "Show a single worktree status.",
+		details: ["Without branch, resolves from current working directory."]
+	},
+	{
+		name: "path",
+		usage: "vw path <branch> [--json]",
+		summary: "Print absolute worktree path for the branch.",
+		details: []
+	},
+	{
+		name: "new",
+		usage: "vw new [branch]",
+		summary: "Create branch + worktree under .worktree.",
+		details: ["Without branch, generates wip-xxxxxx."]
+	},
+	{
+		name: "switch",
+		usage: "vw switch <branch>",
+		summary: "Idempotent branch entrypoint.",
+		details: ["Reuses existing worktree when present, otherwise creates one."]
+	},
+	{
+		name: "mv",
+		usage: "vw mv <new-branch>",
+		summary: "Rename current non-primary worktree branch and move its directory.",
+		details: ["Requires branch checkout (detached HEAD is rejected)."]
+	},
+	{
+		name: "del",
+		usage: "vw del [branch] [flags]",
+		summary: "Delete worktree + branch with safety checks.",
+		details: ["Default rejects dirty, locked, unmerged/unknown, or unpushed/unknown states.", "For non-TTY force usage, --allow-unsafe is required."],
+		options: [
+			"--force-dirty",
+			"--allow-unpushed",
+			"--force-unmerged",
+			"--force-locked",
+			"--force",
+			"--allow-unsafe"
+		]
+	},
+	{
+		name: "gone",
+		usage: "vw gone [--json] [--apply|--dry-run]",
+		summary: "Bulk cleanup by safety-filtered candidate selection.",
+		details: ["Default mode is dry-run. Use --apply to delete candidates."]
+	},
+	{
+		name: "get",
+		usage: "vw get <remote/branch>",
+		summary: "Fetch remote branch, create tracking local branch if needed, then attach worktree.",
+		details: ["Example target format: origin/feature/foo."]
+	},
+	{
+		name: "extract",
+		usage: "vw extract --current [--stash]",
+		summary: "Extract current primary branch into .worktree and switch primary back to base.",
+		details: ["Current implementation targets primary worktree extraction flow."],
+		options: [
+			"--current",
+			"--stash",
+			"--from <path>"
+		]
+	},
+	{
+		name: "use",
+		usage: "vw use <branch> [--allow-agent --allow-unsafe]",
+		summary: "Checkout target branch in primary worktree.",
+		details: ["Non-TTY execution requires --allow-agent and --allow-unsafe."]
+	},
+	{
+		name: "exec",
+		usage: "vw exec <branch> -- <cmd...>",
+		summary: "Run command in target branch worktree.",
+		details: ["Returns exit code 21 when child process exits non-zero."]
+	},
+	{
+		name: "invoke",
+		usage: "vw invoke <pre-*/post-*> [-- <args...>]",
+		summary: "Manually run hook script for debugging/operations.",
+		details: []
+	},
+	{
+		name: "copy",
+		usage: "vw copy <repo-relative-path...>",
+		summary: "Copy repo-root files/dirs to target worktree (typically WT_WORKTREE_PATH).",
+		details: []
+	},
+	{
+		name: "link",
+		usage: "vw link <repo-relative-path...> [--no-fallback]",
+		summary: "Create symlink from target worktree to repo-root file.",
+		details: ["On Windows, fallback copy is used unless --no-fallback is set."]
+	},
+	{
+		name: "lock",
+		usage: "vw lock <branch> [--owner <name>] [--reason <text>]",
+		summary: "Create/update lock metadata to protect worktree from cleanup/deletion.",
+		details: []
+	},
+	{
+		name: "unlock",
+		usage: "vw unlock <branch> [--owner <name>] [--force]",
+		summary: "Remove lock metadata with owner/force checks.",
+		details: []
+	},
+	{
+		name: "cd",
+		usage: "vw cd",
+		summary: "Interactive fzf picker that prints selected worktree absolute path.",
+		details: ["Use with shell: cd \"$(vw cd)\""],
+		options: ["--prompt <text>", "--fzf-arg <arg>"]
+	},
+	{
+		name: "completion",
+		usage: "vw completion <zsh|fish> [--install] [--path <file>]",
+		summary: "Print or install shell completion scripts.",
+		details: ["Without --install, prints completion script to stdout.", "With --install, writes completion file to default shell path or --path."],
+		options: ["--install", "--path <file>"]
+	}
+];
+const splitRawArgsByDoubleDash = (args) => {
+	const separatorIndex = args.indexOf("--");
+	if (separatorIndex < 0) return {
+		beforeDoubleDash: [...args],
+		afterDoubleDash: []
+	};
+	return {
+		beforeDoubleDash: args.slice(0, separatorIndex),
+		afterDoubleDash: args.slice(separatorIndex + 1)
+	};
+};
+const toKebabCase = (value) => {
+	return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+};
+const toOptionSpec = (kind, optionName) => {
+	return {
+		kind,
+		allowOptionLikeValue: optionNamesAllowOptionLikeValue.has(optionName)
+	};
+};
+const buildOptionSpecs = (argsDef) => {
+	const longOptions = /* @__PURE__ */ new Map();
+	const shortOptions = /* @__PURE__ */ new Map();
+	for (const [argName, arg] of Object.entries(argsDef)) {
+		if (arg.type === "positional") continue;
+		const valueKind = arg.type === "boolean" ? "boolean" : "value";
+		const kebabName = toKebabCase(argName);
+		longOptions.set(argName, toOptionSpec(valueKind, argName));
+		longOptions.set(kebabName, toOptionSpec(valueKind, kebabName));
+		const aliases = "alias" in arg ? Array.isArray(arg.alias) ? arg.alias : typeof arg.alias === "string" ? [arg.alias] : [] : [];
+		for (const alias of aliases) {
+			if (alias.length === 1) {
+				shortOptions.set(alias, toOptionSpec(valueKind, alias));
+				continue;
+			}
+			longOptions.set(alias, toOptionSpec(valueKind, alias));
+			const kebabAlias = toKebabCase(alias);
+			longOptions.set(kebabAlias, toOptionSpec(valueKind, kebabAlias));
+		}
+	}
+	return {
+		longOptions,
+		shortOptions
+	};
+};
+const validateRawOptions = (args, optionSpecs) => {
+	for (let index = 0; index < args.length; index += 1) {
+		const token = args[index];
+		if (typeof token !== "string") continue;
+		if (token === "--") break;
+		if (!token.startsWith("-") || token === "-") continue;
+		if (token.startsWith("--")) {
+			const value = token.slice(2);
+			if (value.length === 0) continue;
+			const separatorIndex = value.indexOf("=");
+			const rawOptionName = separatorIndex >= 0 ? value.slice(0, separatorIndex) : value;
+			const directOptionSpec = optionSpecs.longOptions.get(rawOptionName);
+			const optionNameForNegation = rawOptionName.startsWith("no-") ? rawOptionName.slice(3) : rawOptionName;
+			const optionSpec = directOptionSpec ?? optionSpecs.longOptions.get(optionNameForNegation);
+			if (optionSpec === void 0) throw createCliError("INVALID_ARGUMENT", { message: `Unknown option: --${rawOptionName}` });
+			if (optionSpec.kind === "value") if (separatorIndex >= 0) {
+				if (value.slice(separatorIndex + 1).length === 0) throw createCliError("INVALID_ARGUMENT", { message: `Missing value for option: --${rawOptionName}` });
+			} else {
+				const nextToken = args[index + 1];
+				if (typeof nextToken !== "string" || nextToken.length === 0) throw createCliError("INVALID_ARGUMENT", { message: `Missing value for option: --${rawOptionName}` });
+				if (nextToken.startsWith("-") && optionSpec.allowOptionLikeValue !== true) throw createCliError("INVALID_ARGUMENT", { message: `Missing value for option: --${rawOptionName}` });
+				index += 1;
+			}
+			continue;
+		}
+		const shortFlags = token.slice(1);
+		for (let flagIndex = 0; flagIndex < shortFlags.length; flagIndex += 1) {
+			const option = shortFlags[flagIndex];
+			if (typeof option !== "string" || option.length === 0) continue;
+			const optionSpec = optionSpecs.shortOptions.get(option);
+			if (optionSpec === void 0) throw createCliError("INVALID_ARGUMENT", { message: `Unknown option: -${option}` });
+			if (optionSpec.kind === "value") {
+				if (flagIndex < shortFlags.length - 1) break;
+				const nextToken = args[index + 1];
+				if (typeof nextToken !== "string" || nextToken.length === 0) throw createCliError("INVALID_ARGUMENT", { message: `Missing value for option: -${option}` });
+				if (nextToken.startsWith("-") && optionSpec.allowOptionLikeValue !== true) throw createCliError("INVALID_ARGUMENT", { message: `Missing value for option: -${option}` });
+				index += 1;
+				break;
+			}
+		}
+	}
+};
+const getPositionals = (args) => {
+	return args._.filter((value) => typeof value === "string");
+};
+const collectOptionValues = ({ args, optionNames }) => {
+	const values = [];
+	const optionNameSet = new Set(optionNames);
+	for (let index = 0; index < args.length; index += 1) {
+		const token = args[index];
+		if (typeof token !== "string") continue;
+		if (token === "--") break;
+		if (!token.startsWith("--")) continue;
+		const eqIndex = token.indexOf("=");
+		const rawName = eqIndex >= 0 ? token.slice(2, eqIndex) : token.slice(2);
+		if (optionNameSet.has(rawName) !== true) continue;
+		if (eqIndex >= 0) {
+			values.push(token.slice(eqIndex + 1));
+			continue;
+		}
+		const nextToken = args[index + 1];
+		if (typeof nextToken === "string") {
+			values.push(nextToken);
+			index += 1;
+		}
+	}
+	return values;
+};
+const toNumberOption = ({ value, optionName }) => {
+	if (value === void 0) return;
+	if (typeof value !== "string") throw createCliError("INVALID_ARGUMENT", { message: `${optionName} must be a number` });
+	const parsed = Number.parseInt(value, 10);
+	if (Number.isFinite(parsed) !== true || parsed <= 0) throw createCliError("INVALID_ARGUMENT", { message: `${optionName} must be a positive integer` });
+	return parsed;
+};
+const ensureArgumentCount = ({ command, args, min, max }) => {
+	if (args.length < min || args.length > max) throw createCliError("INVALID_ARGUMENT", {
+		message: `${command} expects ${String(min)}-${String(max)} positional argument(s), received ${String(args.length)}`,
+		details: {
+			command,
+			args
+		}
+	});
+};
+const ensureHasCommandAfterDoubleDash = ({ command, argsAfterDoubleDash }) => {
+	if (argsAfterDoubleDash.length === 0) throw createCliError("INVALID_ARGUMENT", { message: `${command} requires arguments after --` });
+};
+const readGitConfigInt = async (repoRoot, key) => {
+	const result = await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"config",
+			"--get",
+			key
+		],
+		reject: false
+	});
+	if (result.exitCode !== 0) return;
+	const parsed = Number.parseInt(result.stdout.trim(), 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+};
+const readGitConfigBoolean = async (repoRoot, key) => {
+	const result = await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"config",
+			"--bool",
+			"--get",
+			key
+		],
+		reject: false
+	});
+	if (result.exitCode !== 0) return;
+	const value = result.stdout.trim().toLowerCase();
+	if (value === "true" || value === "yes" || value === "on" || value === "1") return true;
+	if (value === "false" || value === "no" || value === "off" || value === "0") return false;
+};
+const resolveConfiguredBaseRemote = async (repoRoot) => {
+	const configured = await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"config",
+			"--get",
+			"vde-worktree.baseRemote"
+		],
+		reject: false
+	});
+	if (configured.exitCode === 0 && configured.stdout.trim().length > 0) return configured.stdout.trim();
+	return "origin";
+};
+const resolveBaseBranch = async (repoRoot) => {
+	const configured = await runGitCommand({
+		cwd: repoRoot,
+		args: [
+			"config",
+			"--get",
+			"vde-worktree.baseBranch"
+		],
+		reject: false
+	});
+	if (configured.exitCode === 0 && configured.stdout.trim().length > 0) return configured.stdout.trim();
+	const remotesToProbe = [
+		await resolveConfiguredBaseRemote(repoRoot),
+		"origin",
+		"upstream"
+	].filter((value, index, arr) => {
+		return arr.indexOf(value) === index;
+	});
+	for (const remote of remotesToProbe) {
+		const resolved = await runGitCommand({
+			cwd: repoRoot,
+			args: [
+				"symbolic-ref",
+				"--quiet",
+				"--short",
+				`refs/remotes/${remote}/HEAD`
+			],
+			reject: false
+		});
+		if (resolved.exitCode !== 0) continue;
+		const raw = resolved.stdout.trim();
+		const prefix = `${remote}/`;
+		if (raw.startsWith(prefix)) return raw.slice(prefix.length);
+	}
+	for (const candidate of ["main", "master"]) if (await doesGitRefExist(repoRoot, `refs/heads/${candidate}`)) return candidate;
+	throw createCliError("INVALID_ARGUMENT", { message: "Unable to resolve base branch. Configure vde-worktree.baseBranch." });
+};
+const ensureTargetPathWritable = async (targetPath) => {
+	try {
+		await access(targetPath, constants.F_OK);
+	} catch {
+		return;
+	}
+	if ((await readdir(targetPath)).length > 0) throw createCliError("TARGET_PATH_NOT_EMPTY", {
+		message: `Target path is not empty: ${targetPath}`,
+		details: { path: targetPath }
+	});
+};
+const buildJsonSuccess = ({ command, status, repoRoot, details }) => {
+	return {
+		schemaVersion: SCHEMA_VERSION,
+		command,
+		status,
+		repoRoot,
+		...details ?? {}
+	};
+};
+const buildJsonError = ({ command, repoRoot, error }) => {
+	return {
+		schemaVersion: SCHEMA_VERSION,
+		command,
+		status: "error",
+		repoRoot,
+		code: error.code,
+		message: error.message,
+		details: error.details
+	};
+};
+const resolveTargetWorktreeByBranch = ({ branch, worktrees }) => {
+	const found = worktrees.find((worktree) => worktree.branch === branch);
+	if (found !== void 0) return found;
+	throw createCliError("WORKTREE_NOT_FOUND", {
+		message: `Worktree not found for branch: ${branch}`,
+		details: { branch }
+	});
+};
+const resolveCurrentWorktree = ({ snapshot, currentWorktreeRoot }) => {
+	const directMatch = snapshot.worktrees.find((worktree) => worktree.path === currentWorktreeRoot);
+	if (directMatch !== void 0) return directMatch;
+	const containing = snapshot.worktrees.find((worktree) => {
+		return currentWorktreeRoot.startsWith(`${worktree.path}${sep}`);
+	});
+	if (containing !== void 0) return containing;
+	throw createCliError("WORKTREE_NOT_FOUND", {
+		message: "No worktree found for current location",
+		details: { currentWorktreeRoot }
+	});
+};
+const validateInitializedForWrite = async (repoRoot) => {
+	if (await isInitialized(repoRoot)) return;
+	throw createCliError("NOT_INITIALIZED", {
+		message: "Repository is not initialized. Run `vde-worktree init` first.",
+		details: { repoRoot }
+	});
+};
+const randomWipBranchName = () => {
+	const random = Math.floor(Math.random() * 1e6);
+	return `wip-${String(random).padStart(6, "0")}`;
+};
+const parseForceFlags = (parsedArgs) => {
+	const globalForce = parsedArgs.force === true;
+	return {
+		forceDirty: globalForce || parsedArgs.forceDirty === true,
+		allowUnpushed: globalForce || parsedArgs.allowUnpushed === true,
+		forceUnmerged: globalForce || parsedArgs.forceUnmerged === true,
+		forceLocked: globalForce || parsedArgs.forceLocked === true
+	};
+};
+const hasAnyForceFlag = (flags) => {
+	return flags.forceDirty || flags.allowUnpushed || flags.forceUnmerged || flags.forceLocked;
+};
+const ensureUnsafeForNonTty = ({ runtime, reason }) => {
+	if (runtime.isInteractive || runtime.allowUnsafe) return;
+	throw createCliError("UNSAFE_FLAG_REQUIRED", { message: `UNSAFE_FLAG_REQUIRED: ${reason}` });
+};
+const resolveRemoteAndBranch = (remoteBranch) => {
+	const separatorIndex = remoteBranch.indexOf("/");
+	if (separatorIndex <= 0 || separatorIndex >= remoteBranch.length - 1) throw createCliError("INVALID_REMOTE_BRANCH_FORMAT", {
+		message: `Invalid remote branch format: ${remoteBranch}`,
+		details: { value: remoteBranch }
+	});
+	return {
+		remote: remoteBranch.slice(0, separatorIndex),
+		branch: remoteBranch.slice(separatorIndex + 1)
+	};
+};
+const resolveCompletionShell = (value) => {
+	if (COMPLETION_SHELLS.includes(value)) return value;
+	throw createCliError("INVALID_ARGUMENT", {
+		message: `Unsupported shell for completion: ${value}`,
+		details: {
+			value,
+			supported: COMPLETION_SHELLS
+		}
+	});
+};
+const resolveCompletionSourceCandidates = (shell) => {
+	const relativeCompletionFile = COMPLETION_FILE_BY_SHELL[shell];
+	const moduleDirectory = dirname(fileURLToPath(import.meta.url));
+	return [
+		resolve(moduleDirectory, "..", "..", "completions", relativeCompletionFile),
+		resolve(moduleDirectory, "..", "completions", relativeCompletionFile),
+		resolve(process.cwd(), "completions", relativeCompletionFile)
+	];
+};
+const loadCompletionScript = async (shell) => {
+	const candidates = resolveCompletionSourceCandidates(shell);
+	for (const candidate of candidates) try {
+		return await readFile(candidate, "utf8");
+	} catch {
+		continue;
+	}
+	throw createCliError("INTERNAL_ERROR", {
+		message: `Completion template not found for shell: ${shell}`,
+		details: {
+			shell,
+			candidates
+		}
+	});
+};
+const resolveDefaultCompletionInstallPath = (shell) => {
+	const homeDirectory = homedir();
+	if (homeDirectory.length === 0) throw createCliError("INTERNAL_ERROR", {
+		message: "Unable to resolve home directory for completion installation",
+		details: { shell }
+	});
+	if (shell === "zsh") return join(homeDirectory, ".zsh", "completions", "_vw");
+	return join(homeDirectory, ".config", "fish", "completions", "vw.fish");
+};
+const resolveCompletionInstallPath = ({ shell, requestedPath }) => {
+	if (typeof requestedPath === "string" && requestedPath.trim().length > 0) return resolve(requestedPath);
+	return resolveDefaultCompletionInstallPath(shell);
+};
+const installCompletionScript = async ({ content, destinationPath }) => {
+	await mkdir(dirname(destinationPath), { recursive: true });
+	await writeFile(destinationPath, content, "utf8");
+};
+const normalizeHookName = (value) => {
+	if (/^(pre|post)-[a-z0-9][a-z0-9-]*$/.test(value) !== true) throw createCliError("INVALID_ARGUMENT", {
+		message: "hookName must be pre-* or post-*",
+		details: { hookName: value }
+	});
+	return value;
+};
+const defaultOwner = () => {
+	return process.env.USER ?? process.env.USERNAME ?? "unknown";
+};
+const resolveBranchDeleteMode = (forceFlags) => {
+	if (forceFlags.forceDirty || forceFlags.forceUnmerged || forceFlags.allowUnpushed || forceFlags.forceLocked) return "-D";
+	return "-d";
+};
+const validateDeleteSafety = ({ target, forceFlags }) => {
+	if (target.dirty && forceFlags.forceDirty !== true) throw createCliError("DIRTY_WORKTREE", {
+		message: "Worktree has uncommitted changes",
+		details: {
+			branch: target.branch,
+			path: target.path
+		}
+	});
+	if (target.locked.value && forceFlags.forceLocked !== true) throw createCliError("LOCKED_WORKTREE", {
+		message: "Worktree is locked",
+		details: {
+			branch: target.branch,
+			path: target.path,
+			reason: target.locked.reason
+		}
+	});
+	if (target.merged.overall !== true && forceFlags.forceUnmerged !== true) throw createCliError("UNMERGED_WORKTREE", {
+		message: "Worktree is not merged (or merge state is unknown)",
+		details: {
+			branch: target.branch,
+			path: target.path,
+			merged: target.merged
+		}
+	});
+	if ((target.upstream.ahead === null || target.upstream.ahead > 0) && forceFlags.allowUnpushed !== true) throw createCliError("UNPUSHED_WORKTREE", {
+		message: "Worktree has unpushed commits (or push state is unknown)",
+		details: {
+			branch: target.branch,
+			path: target.path,
+			upstream: target.upstream
+		}
+	});
+};
+const resolveLinkTargetPath = ({ sourcePath, destinationPath }) => {
+	return relative(dirname(destinationPath), sourcePath);
+};
+const resolveFileCopyTargets = ({ repoRoot, worktreePath, relativePath }) => {
+	const sourcePath = resolveRepoRelativePath({
+		repoRoot,
+		relativePath
+	});
+	const relativeFromRoot = relative(repoRoot, sourcePath);
+	return {
+		sourcePath,
+		destinationPath: ensurePathInsideRepo({
+			repoRoot,
+			path: resolve(worktreePath, relativeFromRoot)
+		}),
+		relativeFromRoot
+	};
+};
+const ensureBranchIsNotPrimary = ({ branch, baseBranch }) => {
+	if (branch !== baseBranch) return;
+	throw createCliError("INVALID_ARGUMENT", {
+		message: "extract cannot target the base branch",
+		details: {
+			branch,
+			baseBranch
+		}
+	});
+};
+const formatDisplayPath = (absolutePath) => {
+	const homeDirectory = homedir();
+	if (homeDirectory.length === 0) return absolutePath;
+	if (absolutePath === homeDirectory) return "~";
+	if (absolutePath.startsWith(`${homeDirectory}${sep}`)) return `~${absolutePath.slice(homeDirectory.length)}`;
+	return absolutePath;
+};
+const padEndByWidth = (value, targetWidth) => {
+	const width = stringWidth(value);
+	if (width >= targetWidth) return value;
+	return `${value}${" ".repeat(targetWidth - width)}`;
+};
+const containsBranch = ({ branch, worktrees }) => {
+	return worktrees.some((worktree) => worktree.branch === branch);
+};
+const readStringOption = (parsedArgsRecord, key) => {
+	const value = parsedArgsRecord[key];
+	if (typeof value === "string") return value;
+};
+const findCommandHelp = (commandName) => {
+	return commandHelpEntries.find((entry) => entry.name === commandName);
+};
+const renderGeneralHelpText = ({ version }) => {
+	const commandList = commandHelpEntries.map((entry) => `  ${entry.name.padEnd(8)} ${entry.summary}`).join("\n");
+	return [
+		"vde-worktree",
+		"",
+		"Usage:",
+		"  vw <command> [options]",
+		"  vde-worktree <command> [options]",
+		"",
+		`Version: ${version}`,
+		"",
+		"Commands:",
+		commandList,
+		"",
+		"Global options:",
+		"  --json                  Output machine-readable JSON.",
+		"  --verbose               Enable verbose logs.",
+		"  --no-hooks              Disable hooks for this run (requires --allow-unsafe).",
+		"  --allow-unsafe          Explicitly allow unsafe behavior in non-TTY mode.",
+		"  --hook-timeout-ms <ms>  Override hook timeout.",
+		"  --lock-timeout-ms <ms>  Override repository lock timeout.",
+		"  -h, --help              Show help.",
+		"  -v, --version           Show version.",
+		"",
+		"Help commands:",
+		"  vw help",
+		"  vw help <command>",
+		"  vw <command> --help",
+		"",
+		"Examples:",
+		"  vw switch feature/foo",
+		"  cd \"$(vw cd)\"",
+		"  vw completion zsh --install",
+		"  vw del feature/foo --force-unmerged --allow-unpushed --allow-unsafe"
+	].join("\n");
+};
+const renderCommandHelpText = ({ entry }) => {
+	const lines = [
+		`Command: ${entry.name}`,
+		"",
+		"Usage:",
+		`  ${entry.usage}`,
+		"",
+		"Summary:",
+		`  ${entry.summary}`
+	];
+	if (entry.details.length > 0) {
+		lines.push("", "Details:");
+		for (const detail of entry.details) lines.push(`  - ${detail}`);
+	}
+	if (entry.options !== void 0 && entry.options.length > 0) {
+		lines.push("", "Options:");
+		for (const option of entry.options) lines.push(`  - ${option}`);
+	}
+	if (entry.examples !== void 0 && entry.examples.length > 0) {
+		lines.push("", "Examples:");
+		for (const example of entry.examples) lines.push(`  ${example}`);
+	}
+	lines.push("", "Show all commands: vw help");
+	return lines.join("\n");
+};
+const createHookContext = ({ runtime, repoRoot, action, branch, worktreePath, stderr, extraEnv }) => {
+	return {
+		repoRoot,
+		action,
+		branch,
+		worktreePath,
+		timeoutMs: runtime.hookTimeoutMs,
+		enabled: runtime.hooksEnabled,
+		strictPostHooks: runtime.strictPostHooks,
+		stderr,
+		extraEnv
+	};
+};
+const createCli = (options = {}) => {
+	const require = createRequire(import.meta.url);
+	const version = options.version ?? (() => {
+		try {
+			return loadPackageVersion(require);
+		} catch {
+			return "0.0.0";
+		}
+	})();
+	const runtimeCwd = options.cwd ?? process.cwd();
+	const stdout = options.stdout ?? ((line) => console.log(line));
+	const stderr = options.stderr ?? ((line) => console.error(line));
+	const selectPathWithFzf$1 = options.selectPathWithFzf ?? selectPathWithFzf;
+	const isInteractiveFn = options.isInteractive ?? (() => process.stdout.isTTY === true && process.stderr.isTTY === true);
+	let logger = createLogger();
+	const rootArgsDef = {
+		command: {
+			type: "positional",
+			description: "Command name",
+			required: false
+		},
+		prompt: {
+			type: "string",
+			valueHint: "text",
+			description: "Custom fzf prompt for cd command"
+		},
+		fzfArg: {
+			type: "string",
+			valueHint: "arg",
+			description: "Additional argument passed to fzf (repeatable)"
+		},
+		json: {
+			type: "boolean",
+			description: "Output JSON on stdout"
+		},
+		verbose: {
+			type: "boolean",
+			description: "Show detailed logs"
+		},
+		hooks: {
+			type: "boolean",
+			description: "Enable hooks (disable with --no-hooks)",
+			default: true
+		},
+		allowUnsafe: {
+			type: "boolean",
+			description: "Allow unsafe operations"
+		},
+		strictPostHooks: {
+			type: "boolean",
+			description: "Fail when post hooks fail"
+		},
+		hookTimeoutMs: {
+			type: "string",
+			valueHint: "ms",
+			description: "Override hook timeout (ms)"
+		},
+		lockTimeoutMs: {
+			type: "string",
+			valueHint: "ms",
+			description: "Override lock timeout (ms)"
+		},
+		allowAgent: {
+			type: "boolean",
+			description: "Allow non-TTY execution for use command"
+		},
+		reason: {
+			type: "string",
+			valueHint: "text",
+			description: "Reason text for lock command"
+		},
+		owner: {
+			type: "string",
+			valueHint: "owner",
+			description: "Owner for lock/unlock commands"
+		},
+		force: {
+			type: "boolean",
+			description: "Force operation"
+		},
+		forceDirty: {
+			type: "boolean",
+			description: "Allow dirty worktree for del"
+		},
+		allowUnpushed: {
+			type: "boolean",
+			description: "Allow unpushed commits for del"
+		},
+		forceUnmerged: {
+			type: "boolean",
+			description: "Allow unmerged worktree for del"
+		},
+		forceLocked: {
+			type: "boolean",
+			description: "Allow deleting locked worktree"
+		},
+		apply: {
+			type: "boolean",
+			description: "Apply changes"
+		},
+		dryRun: {
+			type: "boolean",
+			description: "Dry-run mode"
+		},
+		current: {
+			type: "boolean",
+			description: "Use current worktree for extract"
+		},
+		from: {
+			type: "string",
+			valueHint: "path",
+			description: "Path used by extract --from"
+		},
+		stash: {
+			type: "boolean",
+			description: "Allow stash for extract"
+		},
+		fallback: {
+			type: "boolean",
+			description: "Enable fallback behavior (disable with --no-fallback)",
+			default: true
+		},
+		install: {
+			type: "boolean",
+			description: "Install generated artifacts to default location (used by completion command)"
+		},
+		path: {
+			type: "string",
+			valueHint: "path",
+			description: "Custom file path (used by completion command install)"
+		},
+		help: {
+			type: "boolean",
+			alias: "h",
+			description: "Show help"
+		},
+		version: {
+			type: "boolean",
+			alias: "v",
+			description: "Show version"
+		}
+	};
+	const optionSpecs = buildOptionSpecs(rootArgsDef);
+	const run = async (rawArgs = process.argv.slice(2)) => {
+		logger = createLogger();
+		let command = "unknown";
+		let jsonEnabled = false;
+		let repoRootForJson = null;
+		try {
+			const { beforeDoubleDash, afterDoubleDash } = splitRawArgsByDoubleDash(rawArgs);
+			validateRawOptions(beforeDoubleDash, optionSpecs);
+			const parsedArgs = parseArgs(beforeDoubleDash, rootArgsDef);
+			const parsedArgsRecord = parsedArgs;
+			const positionals = getPositionals(parsedArgs);
+			command = positionals[0] ?? "unknown";
+			jsonEnabled = parsedArgs.json === true;
+			if (parsedArgs.help === true) {
+				const commandHelpTarget = typeof command === "string" && command !== "unknown" && command !== "help" ? command : null;
+				if (commandHelpTarget !== null) {
+					const entry = findCommandHelp(commandHelpTarget);
+					if (entry !== void 0) {
+						stdout(`${renderCommandHelpText({ entry })}\n`);
+						return EXIT_CODE.OK;
+					}
+				}
+				stdout(`${renderGeneralHelpText({ version })}\n`);
+				return EXIT_CODE.OK;
+			}
+			if (parsedArgs.version === true) {
+				stdout(version);
+				return EXIT_CODE.OK;
+			}
+			logger = parsedArgs.verbose === true ? createLogger({ level: LogLevel.INFO }) : createLogger();
+			if (positionals.length === 0) {
+				stdout(`${renderGeneralHelpText({ version })}\n`);
+				return EXIT_CODE.OK;
+			}
+			if (command === "help") {
+				const helpTarget = positionals[1];
+				if (typeof helpTarget !== "string" || helpTarget.length === 0) {
+					stdout(`${renderGeneralHelpText({ version })}\n`);
+					return EXIT_CODE.OK;
+				}
+				const entry = findCommandHelp(helpTarget);
+				if (entry === void 0) throw createCliError("INVALID_ARGUMENT", {
+					message: `Unknown command for help: ${helpTarget}`,
+					details: {
+						requested: helpTarget,
+						availableCommands: commandHelpEntries.map((item) => item.name)
+					}
+				});
+				stdout(`${renderCommandHelpText({ entry })}\n`);
+				return EXIT_CODE.OK;
+			}
+			const commandArgs = positionals.slice(1);
+			if (command === "completion") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const shell = resolveCompletionShell(commandArgs[0]);
+				const script = await loadCompletionScript(shell);
+				if (parsedArgs.install === true) {
+					const destinationPath = resolveCompletionInstallPath({
+						shell,
+						requestedPath: readStringOption(parsedArgsRecord, "path")
+					});
+					await installCompletionScript({
+						content: script,
+						destinationPath
+					});
+					if (jsonEnabled) {
+						stdout(JSON.stringify(buildJsonSuccess({
+							command,
+							status: "ok",
+							repoRoot: null,
+							details: {
+								shell,
+								installed: true,
+								path: destinationPath
+							}
+						})));
+						return EXIT_CODE.OK;
+					}
+					stdout(`installed completion: ${destinationPath}`);
+					if (shell === "zsh") stdout("zsh note: ensure completion path is in fpath, then run: autoload -Uz compinit && compinit");
+					return EXIT_CODE.OK;
+				}
+				if (jsonEnabled) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot: null,
+						details: {
+							shell,
+							installed: false,
+							script
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(script);
+				return EXIT_CODE.OK;
+			}
+			const allowUnsafe = parsedArgs.allowUnsafe === true;
+			if (parsedArgs.hooks === false && allowUnsafe !== true) throw createCliError("UNSAFE_FLAG_REQUIRED", { message: "UNSAFE_FLAG_REQUIRED: --no-hooks requires --allow-unsafe" });
+			const repoContext = await resolveRepoContext(runtimeCwd);
+			const repoRoot = repoContext.repoRoot;
+			repoRootForJson = repoRoot;
+			const configuredHookTimeoutMs = await readGitConfigInt(repoRoot, "vde-worktree.hookTimeoutMs");
+			const configuredLockTimeoutMs = await readGitConfigInt(repoRoot, "vde-worktree.lockTimeoutMs");
+			const configuredStaleTTL = await readGitConfigInt(repoRoot, "vde-worktree.staleLockTTLSeconds");
+			const configuredHooksEnabled = await readGitConfigBoolean(repoRoot, "vde-worktree.hooksEnabled");
+			const runtime = {
+				command,
+				json: jsonEnabled,
+				hooksEnabled: parsedArgs.hooks !== false && configuredHooksEnabled !== false,
+				strictPostHooks: parsedArgs.strictPostHooks === true,
+				hookTimeoutMs: readNumberFromEnvOrDefault({
+					rawValue: toNumberOption({
+						value: parsedArgs.hookTimeoutMs,
+						optionName: "--hook-timeout-ms"
+					}) ?? configuredHookTimeoutMs,
+					defaultValue: DEFAULT_HOOK_TIMEOUT_MS
+				}),
+				lockTimeoutMs: readNumberFromEnvOrDefault({
+					rawValue: toNumberOption({
+						value: parsedArgs.lockTimeoutMs,
+						optionName: "--lock-timeout-ms"
+					}) ?? configuredLockTimeoutMs,
+					defaultValue: DEFAULT_LOCK_TIMEOUT_MS
+				}),
+				allowUnsafe,
+				isInteractive: isInteractiveFn()
+			};
+			const staleLockTTLSeconds = readNumberFromEnvOrDefault({
+				rawValue: configuredStaleTTL,
+				defaultValue: DEFAULT_STALE_LOCK_TTL_SECONDS
+			});
+			const runWriteOperation = async (task) => {
+				if (WRITE_COMMANDS.has(command) !== true) return task();
+				if (command !== "init") await validateInitializedForWrite(repoRoot);
+				return withRepoLock({
+					repoRoot,
+					command,
+					timeoutMs: runtime.lockTimeoutMs,
+					staleLockTTLSeconds
+				}, task);
+			};
+			if (command === "init") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 0,
+					max: 0
+				});
+				const result = await runWriteOperation(async () => {
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "init",
+						branch: null,
+						worktreePath: repoRoot,
+						stderr
+					});
+					await runPreHook({
+						name: "init",
+						context: hookContext
+					});
+					const initialized = await initializeRepository(repoRoot);
+					await runPostHook({
+						name: "init",
+						context: hookContext
+					});
+					return initialized;
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							initialized: true,
+							alreadyInitialized: result.alreadyInitialized
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				return EXIT_CODE.OK;
+			}
+			if (command === "list") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 0,
+					max: 0
+				});
+				const snapshot = await collectWorktreeSnapshot(repoRoot);
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							baseBranch: snapshot.baseBranch,
+							worktrees: snapshot.worktrees
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				const rows = snapshot.worktrees.map((worktree) => {
+					return {
+						branch: worktree.branch ?? "(detached)",
+						path: formatDisplayPath(worktree.path)
+					};
+				});
+				const branchWidth = rows.reduce((max, row) => {
+					return Math.max(max, stringWidth(row.branch));
+				}, 0);
+				for (const row of rows) stdout(`${padEndByWidth(row.branch, branchWidth)}  ${row.path}`);
+				return EXIT_CODE.OK;
+			}
+			if (command === "status") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 0,
+					max: 1
+				});
+				const snapshot = await collectWorktreeSnapshot(repoRoot);
+				const targetBranch = commandArgs[0];
+				const targetWorktree = typeof targetBranch === "string" && targetBranch.length > 0 ? resolveTargetWorktreeByBranch({
+					branch: targetBranch,
+					worktrees: snapshot.worktrees
+				}) : resolveCurrentWorktree({
+					snapshot,
+					currentWorktreeRoot: repoContext.currentWorktreeRoot
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: { worktree: targetWorktree }
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(`branch: ${targetWorktree.branch ?? "(detached)"}`);
+				stdout(`path: ${formatDisplayPath(targetWorktree.path)}`);
+				stdout(`dirty: ${targetWorktree.dirty ? "true" : "false"}`);
+				stdout(`locked: ${targetWorktree.locked.value ? "true" : "false"}`);
+				return EXIT_CODE.OK;
+			}
+			if (command === "path") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const branch = commandArgs[0];
+				const target = resolveTargetWorktreeByBranch({
+					branch,
+					worktrees: (await collectWorktreeSnapshot(repoRoot)).worktrees
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							branch,
+							path: target.path
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(target.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "new") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 0,
+					max: 1
+				});
+				const branch = commandArgs[0] ?? randomWipBranchName();
+				const result = await runWriteOperation(async () => {
+					if (containsBranch({
+						branch,
+						worktrees: (await collectWorktreeSnapshot(repoRoot)).worktrees
+					})) throw createCliError("BRANCH_ALREADY_ATTACHED", {
+						message: `Branch is already attached to a worktree: ${branch}`,
+						details: { branch }
+					});
+					if (await doesGitRefExist(repoRoot, `refs/heads/${branch}`)) throw createCliError("BRANCH_ALREADY_EXISTS", {
+						message: `Branch already exists locally: ${branch}`,
+						details: { branch }
+					});
+					const targetPath = branchToWorktreePath(repoRoot, branch);
+					await ensureTargetPathWritable(targetPath);
+					const baseBranch = await resolveBaseBranch(repoRoot);
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "new",
+						branch,
+						worktreePath: targetPath,
+						stderr
+					});
+					await runPreHook({
+						name: "new",
+						context: hookContext
+					});
+					await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"worktree",
+							"add",
+							"-b",
+							branch,
+							targetPath,
+							baseBranch
+						]
+					});
+					await runPostHook({
+						name: "new",
+						context: hookContext
+					});
+					return {
+						branch,
+						path: targetPath
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "created",
+						repoRoot,
+						details: result
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "switch") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const branch = commandArgs[0];
+				const result = await runWriteOperation(async () => {
+					const existing = (await collectWorktreeSnapshot(repoRoot)).worktrees.find((worktree) => worktree.branch === branch);
+					if (existing !== void 0) return {
+						status: "existing",
+						branch,
+						path: existing.path
+					};
+					const targetPath = branchToWorktreePath(repoRoot, branch);
+					await ensureTargetPathWritable(targetPath);
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "switch",
+						branch,
+						worktreePath: targetPath,
+						stderr
+					});
+					await runPreHook({
+						name: "switch",
+						context: hookContext
+					});
+					if (await doesGitRefExist(repoRoot, `refs/heads/${branch}`)) await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"worktree",
+							"add",
+							targetPath,
+							branch
+						]
+					});
+					else await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"worktree",
+							"add",
+							"-b",
+							branch,
+							targetPath,
+							await resolveBaseBranch(repoRoot)
+						]
+					});
+					await runPostHook({
+						name: "switch",
+						context: hookContext
+					});
+					return {
+						status: "created",
+						branch,
+						path: targetPath
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: result.status,
+						repoRoot,
+						details: {
+							branch: result.branch,
+							path: result.path
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "mv") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const newBranch = commandArgs[0];
+				const result = await runWriteOperation(async () => {
+					const snapshot = await collectWorktreeSnapshot(repoRoot);
+					const current = resolveCurrentWorktree({
+						snapshot,
+						currentWorktreeRoot: repoContext.currentWorktreeRoot
+					});
+					const oldBranch = current.branch;
+					if (oldBranch === null) throw createCliError("DETACHED_HEAD", {
+						message: "mv requires a branch checkout (detached HEAD is not supported)",
+						details: { path: current.path }
+					});
+					if (current.path === repoRoot) throw createCliError("INVALID_ARGUMENT", {
+						message: "mv cannot move the primary worktree",
+						details: { path: current.path }
+					});
+					if (oldBranch === newBranch) return {
+						branch: newBranch,
+						path: current.path
+					};
+					if (containsBranch({
+						branch: newBranch,
+						worktrees: snapshot.worktrees
+					})) throw createCliError("BRANCH_ALREADY_ATTACHED", {
+						message: `Branch is already attached to another worktree: ${newBranch}`,
+						details: { branch: newBranch }
+					});
+					if (await doesGitRefExist(repoRoot, `refs/heads/${newBranch}`)) throw createCliError("BRANCH_ALREADY_EXISTS", {
+						message: `Branch already exists locally: ${newBranch}`,
+						details: { branch: newBranch }
+					});
+					const newPath = branchToWorktreePath(repoRoot, newBranch);
+					await ensureTargetPathWritable(newPath);
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "mv",
+						branch: newBranch,
+						worktreePath: newPath,
+						stderr,
+						extraEnv: {
+							WT_OLD_BRANCH: oldBranch,
+							WT_NEW_BRANCH: newBranch
+						}
+					});
+					await runPreHook({
+						name: "mv",
+						context: hookContext
+					});
+					await runGitCommand({
+						cwd: current.path,
+						args: [
+							"branch",
+							"-m",
+							oldBranch,
+							newBranch
+						]
+					});
+					await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"worktree",
+							"move",
+							current.path,
+							newPath
+						]
+					});
+					await runPostHook({
+						name: "mv",
+						context: hookContext
+					});
+					return {
+						branch: newBranch,
+						path: newPath
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: result
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "del") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 0,
+					max: 1
+				});
+				const forceFlags = parseForceFlags(parsedArgsRecord);
+				if (hasAnyForceFlag(forceFlags)) ensureUnsafeForNonTty({
+					runtime,
+					reason: "force flags in non-TTY mode require --allow-unsafe"
+				});
+				const branchArg = commandArgs[0];
+				const result = await runWriteOperation(async () => {
+					const snapshot = await collectWorktreeSnapshot(repoRoot);
+					const target = typeof branchArg === "string" && branchArg.length > 0 ? resolveTargetWorktreeByBranch({
+						branch: branchArg,
+						worktrees: snapshot.worktrees
+					}) : resolveCurrentWorktree({
+						snapshot,
+						currentWorktreeRoot: repoContext.currentWorktreeRoot
+					});
+					if (target.branch === null) throw createCliError("DETACHED_HEAD", {
+						message: "Cannot delete detached worktree without branch",
+						details: { path: target.path }
+					});
+					if (target.path === repoRoot) throw createCliError("INVALID_ARGUMENT", {
+						message: "Cannot delete the primary worktree",
+						details: { path: target.path }
+					});
+					validateDeleteSafety({
+						target,
+						forceFlags
+					});
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "del",
+						branch: target.branch,
+						worktreePath: target.path,
+						stderr
+					});
+					await runPreHook({
+						name: "del",
+						context: hookContext
+					});
+					const removeArgs = [
+						"worktree",
+						"remove",
+						target.path
+					];
+					if (forceFlags.forceDirty) removeArgs.push("--force");
+					await runGitCommand({
+						cwd: repoRoot,
+						args: removeArgs
+					});
+					await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"branch",
+							resolveBranchDeleteMode(forceFlags),
+							target.branch
+						]
+					});
+					await deleteWorktreeLock({
+						repoRoot,
+						branch: target.branch
+					});
+					await runPostHook({
+						name: "del",
+						context: hookContext
+					});
+					return {
+						branch: target.branch,
+						path: target.path
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "deleted",
+						repoRoot,
+						details: result
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "gone") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 0,
+					max: 0
+				});
+				if (parsedArgs.apply === true && parsedArgs.dryRun === true) throw createCliError("INVALID_ARGUMENT", { message: "Cannot use --apply and --dry-run together" });
+				const dryRun = parsedArgs.apply !== true;
+				const execute = async () => {
+					const candidates = (await collectWorktreeSnapshot(repoRoot)).worktrees.filter((worktree) => worktree.branch !== null).filter((worktree) => worktree.path !== repoRoot).filter((worktree) => worktree.dirty === false).filter((worktree) => worktree.locked.value === false).filter((worktree) => worktree.merged.overall === true).filter((worktree) => worktree.upstream.ahead === 0).map((worktree) => worktree.branch);
+					if (dryRun) return {
+						deleted: [],
+						candidates,
+						dryRun: true
+					};
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "gone",
+						branch: null,
+						worktreePath: repoRoot,
+						stderr
+					});
+					await runPreHook({
+						name: "gone",
+						context: hookContext
+					});
+					const deleted = [];
+					for (const branch of candidates) {
+						await runGitCommand({
+							cwd: repoRoot,
+							args: [
+								"worktree",
+								"remove",
+								resolveTargetWorktreeByBranch({
+									branch,
+									worktrees: (await collectWorktreeSnapshot(repoRoot)).worktrees
+								}).path
+							]
+						});
+						await runGitCommand({
+							cwd: repoRoot,
+							args: [
+								"branch",
+								"-d",
+								branch
+							]
+						});
+						await deleteWorktreeLock({
+							repoRoot,
+							branch
+						});
+						deleted.push(branch);
+					}
+					await runPostHook({
+						name: "gone",
+						context: hookContext
+					});
+					return {
+						deleted,
+						candidates,
+						dryRun: false
+					};
+				};
+				const result = await runWriteOperation(execute);
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							dryRun: result.dryRun,
+							candidates: result.candidates,
+							deleted: result.deleted
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				const label = result.dryRun ? "candidates" : "deleted";
+				const branches = result.dryRun ? result.candidates : result.deleted;
+				for (const branch of branches) stdout(`${label}: ${branch}`);
+				return EXIT_CODE.OK;
+			}
+			if (command === "get") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const remoteBranchArg = commandArgs[0];
+				const { remote, branch } = resolveRemoteAndBranch(remoteBranchArg);
+				const result = await runWriteOperation(async () => {
+					if ((await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"remote",
+							"get-url",
+							remote
+						],
+						reject: false
+					})).exitCode !== 0) throw createCliError("REMOTE_NOT_FOUND", {
+						message: `Remote not found: ${remote}`,
+						details: { remote }
+					});
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "get",
+						branch,
+						worktreePath: branchToWorktreePath(repoRoot, branch),
+						stderr
+					});
+					await runPreHook({
+						name: "get",
+						context: hookContext
+					});
+					if ((await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"fetch",
+							remote,
+							branch
+						],
+						reject: false
+					})).exitCode !== 0) throw createCliError("REMOTE_BRANCH_NOT_FOUND", {
+						message: `Remote branch not found: ${remote}/${branch}`,
+						details: {
+							remote,
+							branch
+						}
+					});
+					if (await doesGitRefExist(repoRoot, `refs/heads/${branch}`) !== true) await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"branch",
+							"--track",
+							branch,
+							`${remote}/${branch}`
+						]
+					});
+					const existing = (await collectWorktreeSnapshot(repoRoot)).worktrees.find((worktree) => worktree.branch === branch);
+					if (existing !== void 0) {
+						await runPostHook({
+							name: "get",
+							context: hookContext
+						});
+						return {
+							status: "existing",
+							branch,
+							path: existing.path
+						};
+					}
+					const targetPath = branchToWorktreePath(repoRoot, branch);
+					await ensureTargetPathWritable(targetPath);
+					await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"worktree",
+							"add",
+							targetPath,
+							branch
+						]
+					});
+					await runPostHook({
+						name: "get",
+						context: hookContext
+					});
+					return {
+						status: "created",
+						branch,
+						path: targetPath
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: result.status,
+						repoRoot,
+						details: {
+							branch: result.branch,
+							path: result.path
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "extract") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 0,
+					max: 0
+				});
+				const fromPath = typeof parsedArgs.from === "string" ? parsedArgs.from : void 0;
+				if (fromPath !== void 0 && parsedArgs.current === true) throw createCliError("INVALID_ARGUMENT", { message: "extract cannot use --current and --from together" });
+				const result = await runWriteOperation(async () => {
+					const snapshot = await collectWorktreeSnapshot(repoRoot);
+					const resolvedSourcePath = ensurePathInsideRepo({
+						repoRoot,
+						path: fromPath !== void 0 ? resolvePathFromCwd({
+							cwd: runtimeCwd,
+							path: fromPath
+						}) : repoContext.currentWorktreeRoot
+					});
+					const sourceWorktree = snapshot.worktrees.find((worktree) => worktree.path === resolvedSourcePath) ?? snapshot.worktrees.find((worktree) => resolvedSourcePath.startsWith(`${worktree.path}${sep}`));
+					if (sourceWorktree === void 0) throw createCliError("WORKTREE_NOT_FOUND", {
+						message: "extract source worktree not found",
+						details: { path: resolvedSourcePath }
+					});
+					if (sourceWorktree.path !== repoRoot) throw createCliError("INVALID_ARGUMENT", {
+						message: "extract currently supports only the primary worktree",
+						details: { sourcePath: sourceWorktree.path }
+					});
+					if (sourceWorktree.branch === null) throw createCliError("DETACHED_HEAD", {
+						message: "extract requires current branch checkout",
+						details: { path: sourceWorktree.path }
+					});
+					const branch = sourceWorktree.branch;
+					const baseBranch = await resolveBaseBranch(repoRoot);
+					ensureBranchIsNotPrimary({
+						branch,
+						baseBranch
+					});
+					const targetPath = branchToWorktreePath(repoRoot, branch);
+					await ensureTargetPathWritable(targetPath);
+					const dirty = (await runGitCommand({
+						cwd: repoRoot,
+						args: ["status", "--porcelain"],
+						reject: false
+					})).stdout.trim().length > 0;
+					if (dirty && parsedArgs.stash !== true) throw createCliError("DIRTY_WORKTREE", { message: "extract requires clean worktree unless --stash is specified" });
+					let stashRef = null;
+					if (dirty && parsedArgs.stash === true) {
+						await runGitCommand({
+							cwd: repoRoot,
+							args: [
+								"stash",
+								"push",
+								"-u",
+								"-m",
+								`vde-worktree extract ${branch}`
+							]
+						});
+						const stashTop = await runGitCommand({
+							cwd: repoRoot,
+							args: [
+								"stash",
+								"list",
+								"--max-count=1",
+								"--format=%gd"
+							]
+						});
+						stashRef = stashTop.stdout.trim().length > 0 ? stashTop.stdout.trim() : null;
+					}
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "extract",
+						branch,
+						worktreePath: targetPath,
+						stderr
+					});
+					await runPreHook({
+						name: "extract",
+						context: hookContext
+					});
+					await runGitCommand({
+						cwd: repoRoot,
+						args: ["checkout", baseBranch]
+					});
+					await runGitCommand({
+						cwd: repoRoot,
+						args: [
+							"worktree",
+							"add",
+							targetPath,
+							branch
+						]
+					});
+					if (stashRef !== null) {
+						if ((await runGitCommand({
+							cwd: targetPath,
+							args: [
+								"stash",
+								"apply",
+								stashRef
+							],
+							reject: false
+						})).exitCode !== 0) throw createCliError("STASH_APPLY_FAILED", {
+							message: "Failed to apply stash to extracted worktree",
+							details: {
+								stashRef,
+								branch,
+								path: targetPath
+							}
+						});
+						await runGitCommand({
+							cwd: repoRoot,
+							args: [
+								"stash",
+								"drop",
+								stashRef
+							]
+						});
+					}
+					await runPostHook({
+						name: "extract",
+						context: hookContext
+					});
+					return {
+						branch,
+						path: targetPath
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "created",
+						repoRoot,
+						details: result
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "use") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const branch = commandArgs[0];
+				if (runtime.isInteractive !== true) {
+					if (parsedArgs.allowAgent !== true) throw createCliError("UNSAFE_FLAG_REQUIRED", { message: "UNSAFE_FLAG_REQUIRED: use in non-TTY requires --allow-agent" });
+					ensureUnsafeForNonTty({
+						runtime,
+						reason: "use in non-TTY mode requires --allow-unsafe"
+					});
+				}
+				const result = await runWriteOperation(async () => {
+					if ((await runGitCommand({
+						cwd: repoRoot,
+						args: ["status", "--porcelain"],
+						reject: false
+					})).stdout.trim().length > 0) throw createCliError("DIRTY_WORKTREE", {
+						message: "use requires clean primary worktree",
+						details: { repoRoot }
+					});
+					const hookContext = createHookContext({
+						runtime,
+						repoRoot,
+						action: "use",
+						branch,
+						worktreePath: repoRoot,
+						stderr
+					});
+					await runPreHook({
+						name: "use",
+						context: hookContext
+					});
+					await runGitCommand({
+						cwd: repoRoot,
+						args: ["checkout", branch]
+					});
+					await runPostHook({
+						name: "use",
+						context: hookContext
+					});
+					return {
+						branch,
+						path: repoRoot
+					};
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: result
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(result.path);
+				return EXIT_CODE.OK;
+			}
+			if (command === "exec") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				ensureHasCommandAfterDoubleDash({
+					command,
+					argsAfterDoubleDash: afterDoubleDash
+				});
+				const branch = commandArgs[0];
+				const target = resolveTargetWorktreeByBranch({
+					branch,
+					worktrees: (await collectWorktreeSnapshot(repoRoot)).worktrees
+				});
+				const executable = afterDoubleDash[0];
+				if (typeof executable !== "string" || executable.length === 0) throw createCliError("INVALID_ARGUMENT", { message: "exec requires executable after --" });
+				const childExitCode = (await execa(executable, afterDoubleDash.slice(1), {
+					cwd: target.path,
+					stdin: "inherit",
+					stdout: "inherit",
+					stderr: "inherit",
+					reject: false
+				})).exitCode ?? 0;
+				if (runtime.json) {
+					if (childExitCode === 0) {
+						stdout(JSON.stringify(buildJsonSuccess({
+							command,
+							status: "ok",
+							repoRoot,
+							details: {
+								branch,
+								path: target.path,
+								childExitCode
+							}
+						})));
+						return EXIT_CODE.OK;
+					}
+					stdout(JSON.stringify({
+						schemaVersion: SCHEMA_VERSION,
+						command,
+						status: "error",
+						repoRoot,
+						code: "CHILD_PROCESS_FAILED",
+						message: "target command exited with non-zero status",
+						details: {
+							branch,
+							path: target.path,
+							childExitCode
+						}
+					}));
+					return EXIT_CODE.CHILD_PROCESS_FAILED;
+				}
+				return childExitCode === 0 ? EXIT_CODE.OK : EXIT_CODE.CHILD_PROCESS_FAILED;
+			}
+			if (command === "invoke") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const hookName = normalizeHookName(commandArgs[0]);
+				const current = resolveCurrentWorktree({
+					snapshot: await collectWorktreeSnapshot(repoRoot),
+					currentWorktreeRoot: repoContext.currentWorktreeRoot
+				});
+				await invokeHook({
+					hookName,
+					args: afterDoubleDash,
+					context: createHookContext({
+						runtime,
+						repoRoot,
+						action: `invoke:${hookName}`,
+						branch: current.branch,
+						worktreePath: current.path,
+						stderr
+					})
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							hook: hookName,
+							exitCode: 0
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				return EXIT_CODE.OK;
+			}
+			if (command === "copy") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: Number.MAX_SAFE_INTEGER
+				});
+				const worktreePath = ensurePathInsideRepo({
+					repoRoot,
+					path: resolvePathFromCwd({
+						cwd: repoContext.currentWorktreeRoot,
+						path: process.env.WT_WORKTREE_PATH ?? "."
+					})
+				});
+				for (const relativePath of commandArgs) {
+					const { sourcePath, destinationPath } = resolveFileCopyTargets({
+						repoRoot,
+						worktreePath,
+						relativePath
+					});
+					await access(sourcePath, constants.F_OK);
+					await mkdir(dirname(destinationPath), { recursive: true });
+					await cp(sourcePath, destinationPath, {
+						recursive: true,
+						force: true,
+						errorOnExist: false,
+						dereference: false
+					});
+				}
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							copied: commandArgs,
+							worktreePath
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				return EXIT_CODE.OK;
+			}
+			if (command === "link") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: Number.MAX_SAFE_INTEGER
+				});
+				const worktreePath = ensurePathInsideRepo({
+					repoRoot,
+					path: resolvePathFromCwd({
+						cwd: repoContext.currentWorktreeRoot,
+						path: process.env.WT_WORKTREE_PATH ?? "."
+					})
+				});
+				const fallbackEnabled = parsedArgs.fallback !== false;
+				for (const relativePath of commandArgs) {
+					const { sourcePath, destinationPath } = resolveFileCopyTargets({
+						repoRoot,
+						worktreePath,
+						relativePath
+					});
+					await access(sourcePath, constants.F_OK);
+					await rm(destinationPath, {
+						recursive: true,
+						force: true
+					});
+					await mkdir(dirname(destinationPath), { recursive: true });
+					try {
+						await symlink(resolveLinkTargetPath({
+							sourcePath,
+							destinationPath
+						}), destinationPath);
+					} catch (error) {
+						if (process.platform === "win32" && fallbackEnabled) {
+							stderr(`symlink failed for ${relativePath}; fallback to copy`);
+							await cp(sourcePath, destinationPath, {
+								recursive: true,
+								force: true,
+								errorOnExist: false,
+								dereference: false
+							});
+							continue;
+						}
+						throw createCliError("INVALID_ARGUMENT", {
+							message: `Failed to create symlink for ${relativePath}`,
+							cause: error
+						});
+					}
+				}
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							linked: commandArgs,
+							worktreePath,
+							fallback: fallbackEnabled
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				return EXIT_CODE.OK;
+			}
+			if (command === "lock") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const branch = commandArgs[0];
+				const ownerOption = readStringOption(parsedArgsRecord, "owner");
+				const reasonOption = readStringOption(parsedArgsRecord, "reason");
+				const owner = typeof ownerOption === "string" && ownerOption.length > 0 ? ownerOption : defaultOwner();
+				const reason = typeof reasonOption === "string" && reasonOption.length > 0 ? reasonOption : "locked";
+				const result = await runWriteOperation(async () => {
+					resolveTargetWorktreeByBranch({
+						branch,
+						worktrees: (await collectWorktreeSnapshot(repoRoot)).worktrees
+					});
+					const existing = await readWorktreeLock({
+						repoRoot,
+						branch
+					});
+					if (existing.exists && existing.valid !== true) throw createCliError("LOCK_CONFLICT", {
+						message: "Cannot update lock with invalid metadata; fix or remove lock file first",
+						details: {
+							branch,
+							path: existing.path
+						}
+					});
+					if (existing.record !== null && existing.record.owner !== owner) throw createCliError("LOCK_CONFLICT", {
+						message: "Lock is owned by another owner",
+						details: {
+							branch,
+							owner: existing.record.owner
+						}
+					});
+					return await upsertWorktreeLock({
+						repoRoot,
+						branch,
+						reason,
+						owner
+					});
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							branch,
+							locked: {
+								value: true,
+								reason: result.reason,
+								owner: result.owner
+							}
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				return EXIT_CODE.OK;
+			}
+			if (command === "unlock") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 1,
+					max: 1
+				});
+				const branch = commandArgs[0];
+				const ownerOption = readStringOption(parsedArgsRecord, "owner");
+				const owner = typeof ownerOption === "string" && ownerOption.length > 0 ? ownerOption : defaultOwner();
+				const force = parsedArgs.force === true;
+				await runWriteOperation(async () => {
+					const existing = await readWorktreeLock({
+						repoRoot,
+						branch
+					});
+					if (existing.exists !== true) return;
+					if (existing.valid !== true) {
+						if (force) {
+							await deleteWorktreeLock({
+								repoRoot,
+								branch
+							});
+							return;
+						}
+						throw createCliError("LOCK_CONFLICT", {
+							message: "Lock metadata is invalid; use --force to unlock",
+							details: {
+								branch,
+								path: existing.path
+							}
+						});
+					}
+					if (existing.record !== null && existing.record.owner !== owner && force !== true) throw createCliError("LOCK_CONFLICT", {
+						message: "Lock is owned by another owner. Use --force to unlock.",
+						details: {
+							branch,
+							owner: existing.record.owner
+						}
+					});
+					await deleteWorktreeLock({
+						repoRoot,
+						branch
+					});
+				});
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: {
+							branch,
+							locked: {
+								value: false,
+								reason: null
+							}
+						}
+					})));
+					return EXIT_CODE.OK;
+				}
+				return EXIT_CODE.OK;
+			}
+			if (command === "cd") {
+				ensureArgumentCount({
+					command,
+					args: commandArgs,
+					min: 0,
+					max: 0
+				});
+				const candidates = (await collectWorktreeSnapshot(repoRoot)).worktrees.map((worktree) => worktree.path);
+				if (candidates.length === 0) throw createCliError("WORKTREE_NOT_FOUND", { message: "No worktree candidates found" });
+				const promptValue = readStringOption(parsedArgsRecord, "prompt");
+				const selection = await selectPathWithFzf$1({
+					candidates,
+					prompt: typeof promptValue === "string" && promptValue.length > 0 ? promptValue : "worktree> ",
+					fzfExtraArgs: collectOptionValues({
+						args: beforeDoubleDash,
+						optionNames: ["fzfArg", "fzf-arg"]
+					}),
+					cwd: repoRoot,
+					isInteractive: () => runtime.isInteractive || process.stderr.isTTY === true
+				}).catch((error) => {
+					const message = error instanceof Error ? error.message : String(error);
+					if (message.includes("interactive terminal") || message.includes("fzf is required")) throw createCliError("DEPENDENCY_MISSING", { message: `DEPENDENCY_MISSING: ${message}` });
+					throw error;
+				});
+				if (selection.status === "cancelled") return EXIT_CODE_CANCELLED;
+				if (runtime.json) {
+					stdout(JSON.stringify(buildJsonSuccess({
+						command,
+						status: "ok",
+						repoRoot,
+						details: { path: selection.path }
+					})));
+					return EXIT_CODE.OK;
+				}
+				stdout(selection.path);
+				return EXIT_CODE.OK;
+			}
+			throw createCliError("UNKNOWN_COMMAND", { message: `Unknown command: ${command}` });
+		} catch (error) {
+			const cliError = ensureCliError(error);
+			if (jsonEnabled) stdout(JSON.stringify(buildJsonError({
+				command,
+				repoRoot: repoRootForJson,
+				error: cliError
+			})));
+			else {
+				stderr(`[${cliError.code}] ${cliError.message}`);
+				logger.debug(JSON.stringify(cliError.details));
+			}
+			return cliError.exitCode;
+		}
+	};
+	return { run };
+};
+
+//#endregion
+//#region src/index.ts
+const main = async () => {
+	const cli = createCli();
+	try {
+		const exitCode = await cli.run(process.argv.slice(2));
+		if (typeof exitCode === "number" && exitCode !== 0) process.exit(exitCode);
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error("Error:", error.message);
+			if (process.env.VDE_WORKTREE_DEBUG === "true" || process.env.VDE_DEBUG === "true") console.error(error.stack);
+		} else console.error("An unexpected error occurred:", String(error));
+		process.exit(1);
+	}
+};
+main();
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map