vde-worktree 0.0.18 → 0.0.20

package/dist/index.mjs

@@ -1,7 +1,7 @@
 #!/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 { access, appendFile, chmod, cp, lstat, mkdir, open, readFile, readdir, realpath, 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";
@@ -10,6 +10,7 @@ import { parseArgs } from "citty";
 import { execa } from "execa";
 import stringWidth from "string-width";
 import { getBorderCharacters, table } from "table";
+import { parse } from "yaml";
 import { createHash } from "node:crypto";
 
 //#region src/core/constants.ts
@@ -74,6 +75,7 @@ const WRITE_COMMANDS = new Set([
 const ERROR_CODE_TO_EXIT_CODE = {
 	NOT_GIT_REPOSITORY: EXIT_CODE.NOT_GIT_REPOSITORY,
 	INVALID_ARGUMENT: EXIT_CODE.INVALID_ARGUMENT,
+	INVALID_CONFIG: EXIT_CODE.INVALID_ARGUMENT,
 	UNKNOWN_COMMAND: EXIT_CODE.INVALID_ARGUMENT,
 	UNSAFE_FLAG_REQUIRED: EXIT_CODE.SAFETY_REJECTED,
 	NOT_INITIALIZED: EXIT_CODE.SAFETY_REJECTED,
@@ -130,6 +132,691 @@ const ensureCliError = (error) => {
 	});
 };
 
+//#endregion
+//#region src/config/git-boundary.ts
+const hasGitMarker = async (directory) => {
+	try {
+		const stat = await lstat(join(directory, ".git"));
+		return stat.isDirectory() || stat.isFile();
+	} catch {
+		return false;
+	}
+};
+const findGitBoundaryDirectory = async (cwd) => {
+	let current = resolve(cwd);
+	while (true) {
+		if (await hasGitMarker(current)) return current;
+		const parent = dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+};
+const collectConfigSearchDirectories = async (cwd) => {
+	const absoluteCwd = resolve(cwd);
+	const boundary = await findGitBoundaryDirectory(absoluteCwd);
+	if (boundary === null) return [absoluteCwd];
+	const directories = [];
+	let current = absoluteCwd;
+	while (true) {
+		directories.push(current);
+		if (current === boundary) break;
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return directories.reverse();
+};
+
+//#endregion
+//#region src/config/types.ts
+const LIST_TABLE_COLUMNS = [
+	"branch",
+	"dirty",
+	"merged",
+	"pr",
+	"locked",
+	"ahead",
+	"behind",
+	"path"
+];
+const LIST_PATH_TRUNCATE_VALUES = ["auto", "never"];
+const SELECTOR_CD_SURFACE_VALUES = [
+	"auto",
+	"inline",
+	"tmux-popup"
+];
+const DEFAULT_CONFIG = {
+	paths: { worktreeRoot: ".worktree" },
+	git: {
+		baseBranch: null,
+		baseRemote: "origin"
+	},
+	github: { enabled: true },
+	hooks: {
+		enabled: true,
+		timeoutMs: DEFAULT_HOOK_TIMEOUT_MS
+	},
+	locks: {
+		timeoutMs: DEFAULT_LOCK_TIMEOUT_MS,
+		staleLockTTLSeconds: DEFAULT_STALE_LOCK_TTL_SECONDS
+	},
+	list: { table: {
+		columns: [...LIST_TABLE_COLUMNS],
+		path: {
+			truncate: "auto",
+			minWidth: 12
+		}
+	} },
+	selector: { cd: {
+		prompt: "worktree> ",
+		surface: "auto",
+		tmuxPopupOpts: "80%,70%",
+		fzf: { extraArgs: [] }
+	} }
+};
+
+//#endregion
+//#region src/config/loader.ts
+const CONFIG_FILE_BASENAME = "config.yml";
+const LOCAL_CONFIG_PATH_SEGMENTS = [
+	".vde",
+	"worktree",
+	CONFIG_FILE_BASENAME
+];
+const GLOBAL_CONFIG_PATH_SEGMENTS = [
+	"vde",
+	"worktree",
+	CONFIG_FILE_BASENAME
+];
+const isRecord = (value) => {
+	return value !== null && typeof value === "object" && Array.isArray(value) !== true;
+};
+const toKeyPath = (segments) => {
+	if (segments.length === 0) return "<root>";
+	return segments.join(".");
+};
+const throwInvalidConfig = ({ file, keyPath, reason }) => {
+	throw createCliError("INVALID_CONFIG", {
+		message: `Invalid config: ${file} (${keyPath}: ${reason})`,
+		details: {
+			file,
+			keyPath,
+			reason
+		}
+	});
+};
+const expectRecord = ({ value, ctx, keyPath }) => {
+	if (isRecord(value)) return value;
+	return throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: "must be an object"
+	});
+};
+const ensureNoUnknownKeys = ({ record, allowedKeys, ctx, keyPath }) => {
+	const allowed = new Set(allowedKeys);
+	for (const key of Object.keys(record)) {
+		if (allowed.has(key)) continue;
+		const path = [...keyPath, key];
+		throwInvalidConfig({
+			file: ctx.file,
+			keyPath: toKeyPath(path),
+			reason: "unknown key"
+		});
+	}
+};
+const parseBoolean = ({ value, ctx, keyPath }) => {
+	if (typeof value === "boolean") return value;
+	return throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: "must be boolean"
+	});
+};
+const parseNonEmptyString = ({ value, ctx, keyPath }) => {
+	if (typeof value === "string" && value.trim().length > 0) return value;
+	return throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: "must be a non-empty string"
+	});
+};
+const parsePositiveInteger = ({ value, ctx, keyPath }) => {
+	if (typeof value === "number" && Number.isInteger(value) && value > 0) return value;
+	return throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: "must be a positive integer"
+	});
+};
+const parseStringArray = ({ value, ctx, keyPath }) => {
+	if (Array.isArray(value) !== true) return throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: "must be an array"
+	});
+	const values = value;
+	const result = [];
+	for (const [index, item] of values.entries()) {
+		if (typeof item !== "string" || item.length === 0) throwInvalidConfig({
+			file: ctx.file,
+			keyPath: toKeyPath([...keyPath, String(index)]),
+			reason: "must be a non-empty string"
+		});
+		result.push(item);
+	}
+	return result;
+};
+const parseColumns = ({ value, ctx, keyPath }) => {
+	if (Array.isArray(value) !== true) return throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: "must be an array"
+	});
+	const values = value;
+	if (values.length === 0) return throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: "must not be empty"
+	});
+	const allowed = new Set(LIST_TABLE_COLUMNS);
+	const seen = /* @__PURE__ */ new Set();
+	const parsed = [];
+	for (const [index, item] of values.entries()) {
+		if (typeof item !== "string") throwInvalidConfig({
+			file: ctx.file,
+			keyPath: toKeyPath([...keyPath, String(index)]),
+			reason: "must be a string"
+		});
+		if (allowed.has(item) !== true) throwInvalidConfig({
+			file: ctx.file,
+			keyPath: toKeyPath([...keyPath, String(index)]),
+			reason: `unsupported column: ${item}`
+		});
+		if (seen.has(item)) throwInvalidConfig({
+			file: ctx.file,
+			keyPath: toKeyPath([...keyPath, String(index)]),
+			reason: `duplicate column: ${item}`
+		});
+		seen.add(item);
+		parsed.push(item);
+	}
+	return parsed;
+};
+const parseListPathTruncate = ({ value, ctx, keyPath }) => {
+	if (typeof value !== "string" || LIST_PATH_TRUNCATE_VALUES.includes(value) !== true) throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: `must be one of: ${LIST_PATH_TRUNCATE_VALUES.join(", ")}`
+	});
+	return value;
+};
+const parseSelectorSurface = ({ value, ctx, keyPath }) => {
+	if (typeof value !== "string" || SELECTOR_CD_SURFACE_VALUES.includes(value) !== true) throwInvalidConfig({
+		file: ctx.file,
+		keyPath: toKeyPath(keyPath),
+		reason: `must be one of: ${SELECTOR_CD_SURFACE_VALUES.join(", ")}`
+	});
+	return value;
+};
+const validatePartialConfig = ({ rawConfig, ctx }) => {
+	if (rawConfig === null || rawConfig === void 0) return {};
+	const root = expectRecord({
+		value: rawConfig,
+		ctx,
+		keyPath: []
+	});
+	ensureNoUnknownKeys({
+		record: root,
+		allowedKeys: [
+			"paths",
+			"git",
+			"github",
+			"hooks",
+			"locks",
+			"list",
+			"selector"
+		],
+		ctx,
+		keyPath: []
+	});
+	const partial = {};
+	if (root.paths !== void 0) {
+		const paths = expectRecord({
+			value: root.paths,
+			ctx,
+			keyPath: ["paths"]
+		});
+		ensureNoUnknownKeys({
+			record: paths,
+			allowedKeys: ["worktreeRoot"],
+			ctx,
+			keyPath: ["paths"]
+		});
+		partial.paths = {};
+		if (paths.worktreeRoot !== void 0) partial.paths.worktreeRoot = parseNonEmptyString({
+			value: paths.worktreeRoot,
+			ctx,
+			keyPath: ["paths", "worktreeRoot"]
+		});
+	}
+	if (root.git !== void 0) {
+		const git = expectRecord({
+			value: root.git,
+			ctx,
+			keyPath: ["git"]
+		});
+		ensureNoUnknownKeys({
+			record: git,
+			allowedKeys: ["baseBranch", "baseRemote"],
+			ctx,
+			keyPath: ["git"]
+		});
+		partial.git = {};
+		if (git.baseBranch !== void 0) {
+			if (git.baseBranch !== null && typeof git.baseBranch !== "string") throwInvalidConfig({
+				file: ctx.file,
+				keyPath: toKeyPath(["git", "baseBranch"]),
+				reason: "must be a string or null"
+			});
+			partial.git.baseBranch = git.baseBranch === null ? null : parseNonEmptyString({
+				value: git.baseBranch,
+				ctx,
+				keyPath: ["git", "baseBranch"]
+			});
+		}
+		if (git.baseRemote !== void 0) partial.git.baseRemote = parseNonEmptyString({
+			value: git.baseRemote,
+			ctx,
+			keyPath: ["git", "baseRemote"]
+		});
+	}
+	if (root.github !== void 0) {
+		const github = expectRecord({
+			value: root.github,
+			ctx,
+			keyPath: ["github"]
+		});
+		ensureNoUnknownKeys({
+			record: github,
+			allowedKeys: ["enabled"],
+			ctx,
+			keyPath: ["github"]
+		});
+		partial.github = {};
+		if (github.enabled !== void 0) partial.github.enabled = parseBoolean({
+			value: github.enabled,
+			ctx,
+			keyPath: ["github", "enabled"]
+		});
+	}
+	if (root.hooks !== void 0) {
+		const hooks = expectRecord({
+			value: root.hooks,
+			ctx,
+			keyPath: ["hooks"]
+		});
+		ensureNoUnknownKeys({
+			record: hooks,
+			allowedKeys: ["enabled", "timeoutMs"],
+			ctx,
+			keyPath: ["hooks"]
+		});
+		partial.hooks = {};
+		if (hooks.enabled !== void 0) partial.hooks.enabled = parseBoolean({
+			value: hooks.enabled,
+			ctx,
+			keyPath: ["hooks", "enabled"]
+		});
+		if (hooks.timeoutMs !== void 0) partial.hooks.timeoutMs = parsePositiveInteger({
+			value: hooks.timeoutMs,
+			ctx,
+			keyPath: ["hooks", "timeoutMs"]
+		});
+	}
+	if (root.locks !== void 0) {
+		const locks = expectRecord({
+			value: root.locks,
+			ctx,
+			keyPath: ["locks"]
+		});
+		ensureNoUnknownKeys({
+			record: locks,
+			allowedKeys: ["timeoutMs", "staleLockTTLSeconds"],
+			ctx,
+			keyPath: ["locks"]
+		});
+		partial.locks = {};
+		if (locks.timeoutMs !== void 0) partial.locks.timeoutMs = parsePositiveInteger({
+			value: locks.timeoutMs,
+			ctx,
+			keyPath: ["locks", "timeoutMs"]
+		});
+		if (locks.staleLockTTLSeconds !== void 0) partial.locks.staleLockTTLSeconds = parsePositiveInteger({
+			value: locks.staleLockTTLSeconds,
+			ctx,
+			keyPath: ["locks", "staleLockTTLSeconds"]
+		});
+	}
+	if (root.list !== void 0) {
+		const list = expectRecord({
+			value: root.list,
+			ctx,
+			keyPath: ["list"]
+		});
+		ensureNoUnknownKeys({
+			record: list,
+			allowedKeys: ["table"],
+			ctx,
+			keyPath: ["list"]
+		});
+		partial.list = {};
+		if (list.table !== void 0) {
+			const table = expectRecord({
+				value: list.table,
+				ctx,
+				keyPath: ["list", "table"]
+			});
+			ensureNoUnknownKeys({
+				record: table,
+				allowedKeys: ["columns", "path"],
+				ctx,
+				keyPath: ["list", "table"]
+			});
+			partial.list.table = {};
+			if (table.columns !== void 0) partial.list.table.columns = parseColumns({
+				value: table.columns,
+				ctx,
+				keyPath: [
+					"list",
+					"table",
+					"columns"
+				]
+			});
+			if (table.path !== void 0) {
+				const pathConfig = expectRecord({
+					value: table.path,
+					ctx,
+					keyPath: [
+						"list",
+						"table",
+						"path"
+					]
+				});
+				ensureNoUnknownKeys({
+					record: pathConfig,
+					allowedKeys: ["truncate", "minWidth"],
+					ctx,
+					keyPath: [
+						"list",
+						"table",
+						"path"
+					]
+				});
+				partial.list.table.path = {};
+				if (pathConfig.truncate !== void 0) partial.list.table.path.truncate = parseListPathTruncate({
+					value: pathConfig.truncate,
+					ctx,
+					keyPath: [
+						"list",
+						"table",
+						"path",
+						"truncate"
+					]
+				});
+				if (pathConfig.minWidth !== void 0) {
+					const minWidth = parsePositiveInteger({
+						value: pathConfig.minWidth,
+						ctx,
+						keyPath: [
+							"list",
+							"table",
+							"path",
+							"minWidth"
+						]
+					});
+					if (minWidth < 8 || minWidth > 200) throwInvalidConfig({
+						file: ctx.file,
+						keyPath: toKeyPath([
+							"list",
+							"table",
+							"path",
+							"minWidth"
+						]),
+						reason: "must be in range 8..200"
+					});
+					partial.list.table.path.minWidth = minWidth;
+				}
+			}
+		}
+	}
+	if (root.selector !== void 0) {
+		const selector = expectRecord({
+			value: root.selector,
+			ctx,
+			keyPath: ["selector"]
+		});
+		ensureNoUnknownKeys({
+			record: selector,
+			allowedKeys: ["cd"],
+			ctx,
+			keyPath: ["selector"]
+		});
+		partial.selector = {};
+		if (selector.cd !== void 0) {
+			const cd = expectRecord({
+				value: selector.cd,
+				ctx,
+				keyPath: ["selector", "cd"]
+			});
+			ensureNoUnknownKeys({
+				record: cd,
+				allowedKeys: [
+					"prompt",
+					"surface",
+					"tmuxPopupOpts",
+					"fzf"
+				],
+				ctx,
+				keyPath: ["selector", "cd"]
+			});
+			partial.selector.cd = {};
+			if (cd.prompt !== void 0) partial.selector.cd.prompt = parseNonEmptyString({
+				value: cd.prompt,
+				ctx,
+				keyPath: [
+					"selector",
+					"cd",
+					"prompt"
+				]
+			});
+			if (cd.surface !== void 0) partial.selector.cd.surface = parseSelectorSurface({
+				value: cd.surface,
+				ctx,
+				keyPath: [
+					"selector",
+					"cd",
+					"surface"
+				]
+			});
+			if (cd.tmuxPopupOpts !== void 0) partial.selector.cd.tmuxPopupOpts = parseNonEmptyString({
+				value: cd.tmuxPopupOpts,
+				ctx,
+				keyPath: [
+					"selector",
+					"cd",
+					"tmuxPopupOpts"
+				]
+			});
+			if (cd.fzf !== void 0) {
+				const fzf = expectRecord({
+					value: cd.fzf,
+					ctx,
+					keyPath: [
+						"selector",
+						"cd",
+						"fzf"
+					]
+				});
+				ensureNoUnknownKeys({
+					record: fzf,
+					allowedKeys: ["extraArgs"],
+					ctx,
+					keyPath: [
+						"selector",
+						"cd",
+						"fzf"
+					]
+				});
+				partial.selector.cd.fzf = {};
+				if (fzf.extraArgs !== void 0) partial.selector.cd.fzf.extraArgs = parseStringArray({
+					value: fzf.extraArgs,
+					ctx,
+					keyPath: [
+						"selector",
+						"cd",
+						"fzf",
+						"extraArgs"
+					]
+				});
+			}
+		}
+	}
+	return partial;
+};
+const mergeConfig = (base, partial) => {
+	return {
+		paths: { worktreeRoot: partial.paths?.worktreeRoot ?? base.paths.worktreeRoot },
+		git: {
+			baseBranch: partial.git?.baseBranch === void 0 ? base.git.baseBranch : partial.git.baseBranch,
+			baseRemote: partial.git?.baseRemote ?? base.git.baseRemote
+		},
+		github: { enabled: partial.github?.enabled ?? base.github.enabled },
+		hooks: {
+			enabled: partial.hooks?.enabled ?? base.hooks.enabled,
+			timeoutMs: partial.hooks?.timeoutMs ?? base.hooks.timeoutMs
+		},
+		locks: {
+			timeoutMs: partial.locks?.timeoutMs ?? base.locks.timeoutMs,
+			staleLockTTLSeconds: partial.locks?.staleLockTTLSeconds ?? base.locks.staleLockTTLSeconds
+		},
+		list: { table: {
+			columns: partial.list?.table?.columns ? [...partial.list.table.columns] : [...base.list.table.columns],
+			path: {
+				truncate: partial.list?.table?.path?.truncate ?? base.list.table.path.truncate,
+				minWidth: partial.list?.table?.path?.minWidth ?? base.list.table.path.minWidth
+			}
+		} },
+		selector: { cd: {
+			prompt: partial.selector?.cd?.prompt ?? base.selector.cd.prompt,
+			surface: partial.selector?.cd?.surface ?? base.selector.cd.surface,
+			tmuxPopupOpts: partial.selector?.cd?.tmuxPopupOpts ?? base.selector.cd.tmuxPopupOpts,
+			fzf: { extraArgs: partial.selector?.cd?.fzf?.extraArgs ? [...partial.selector.cd.fzf.extraArgs] : [...base.selector.cd.fzf.extraArgs] }
+		} }
+	};
+};
+const configPathExists = async (filePath) => {
+	try {
+		await access(filePath, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const resolveLocalConfigPath = (directory) => {
+	return join(directory, ...LOCAL_CONFIG_PATH_SEGMENTS);
+};
+const resolveGlobalConfigPath = () => {
+	const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+	if (typeof xdgConfigHome === "string" && xdgConfigHome.length > 0) return join(resolve(xdgConfigHome), ...GLOBAL_CONFIG_PATH_SEGMENTS);
+	return join(homedir(), ".config", ...GLOBAL_CONFIG_PATH_SEGMENTS);
+};
+const resolveExistingConfigFiles = async ({ cwd, repoRoot }) => {
+	const localCandidates = (await collectConfigSearchDirectories(cwd)).map((directory) => resolveLocalConfigPath(directory));
+	const repoRootCandidate = resolveLocalConfigPath(repoRoot);
+	const lowToHighCandidates = [
+		resolveGlobalConfigPath(),
+		repoRootCandidate,
+		...localCandidates
+	];
+	const deduped = /* @__PURE__ */ new Map();
+	for (const [order, candidate] of lowToHighCandidates.entries()) {
+		if (await configPathExists(candidate) !== true) continue;
+		const canonical = await realpath(candidate).catch(() => resolve(candidate));
+		deduped.set(canonical, {
+			path: candidate,
+			order
+		});
+	}
+	return [...deduped.values()].sort((a, b) => a.order - b.order).map((entry) => entry.path);
+};
+const isPathInsideOrEqual$1 = ({ parentPath, childPath }) => {
+	const rel = relative(parentPath, childPath);
+	if (rel.length === 0) return true;
+	return rel !== ".." && rel.startsWith(`..${sep}`) !== true;
+};
+const validateWorktreeRoot = async ({ repoRoot, config }) => {
+	const rawWorktreeRoot = config.paths.worktreeRoot;
+	const resolvedWorktreeRoot = isAbsolute(rawWorktreeRoot) ? resolve(rawWorktreeRoot) : resolve(repoRoot, rawWorktreeRoot);
+	if (isPathInsideOrEqual$1({
+		parentPath: resolve(repoRoot, ".git"),
+		childPath: resolvedWorktreeRoot
+	})) throwInvalidConfig({
+		file: "<resolved>",
+		keyPath: "paths.worktreeRoot",
+		reason: "must not point inside .git"
+	});
+	try {
+		if ((await lstat(resolvedWorktreeRoot)).isDirectory() !== true) throwInvalidConfig({
+			file: "<resolved>",
+			keyPath: "paths.worktreeRoot",
+			reason: "must not point to an existing file"
+		});
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+};
+const parseConfigFile = async (file) => {
+	const rawContent = await readFile(file, "utf8");
+	let parsed;
+	try {
+		parsed = parse(rawContent);
+	} catch (error) {
+		throwInvalidConfig({
+			file,
+			keyPath: "<root>",
+			reason: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return validatePartialConfig({
+		rawConfig: parsed,
+		ctx: { file }
+	});
+};
+const cloneDefaultConfig = () => {
+	return mergeConfig(DEFAULT_CONFIG, {});
+};
+const loadResolvedConfig = async ({ cwd, repoRoot }) => {
+	const files = await resolveExistingConfigFiles({
+		cwd,
+		repoRoot
+	});
+	let config = cloneDefaultConfig();
+	for (const file of files) {
+		const partial = await parseConfigFile(file);
+		config = mergeConfig(config, partial);
+	}
+	await validateWorktreeRoot({
+		repoRoot,
+		config
+	});
+	return {
+		config,
+		loadedFiles: files
+	};
+};
+
 //#endregion
 //#region src/git/exec.ts
 const runGitCommand = async ({ cwd, args, reject = true }) => {
@@ -175,6 +862,7 @@ const doesGitRefExist = async (cwd, ref) => {
 //#endregion
 //#region src/core/paths.ts
 const GIT_DIR_NAME = ".git";
+const DEFAULT_WORKTREE_ROOT = ".worktree";
 const WORKTREE_ID_HASH_LENGTH = 12;
 const WORKTREE_ID_SLUG_MAX_LENGTH = 48;
 const resolveRepoRootFromCommonDir = ({ currentWorktreeRoot, gitCommonDir }) => {
@@ -212,8 +900,9 @@ const resolveRepoContext = async (cwd) => {
 		gitCommonDir
 	};
 };
-const getWorktreeRootPath = (repoRoot) => {
-	return join(repoRoot, ".worktree");
+const getWorktreeRootPath = (repoRoot, configuredWorktreeRoot = DEFAULT_WORKTREE_ROOT) => {
+	if (isAbsolute(configuredWorktreeRoot)) return resolve(configuredWorktreeRoot);
+	return resolve(repoRoot, configuredWorktreeRoot);
 };
 const getWorktreeMetaRootPath = (repoRoot) => {
 	return join(repoRoot, ".vde", "worktree");
@@ -233,25 +922,33 @@ const getStateDirectoryPath = (repoRoot) => {
 const branchToWorktreeId = (branch) => {
 	return `${branch.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, WORKTREE_ID_SLUG_MAX_LENGTH) || "branch"}--${createHash("sha256").update(branch).digest("hex").slice(0, WORKTREE_ID_HASH_LENGTH)}`;
 };
-const branchToWorktreePath = (repoRoot, branch) => {
-	const worktreeRoot = getWorktreeRootPath(repoRoot);
-	return ensurePathInsideRepo({
-		repoRoot: worktreeRoot,
-		path: join(worktreeRoot, ...branch.split("/"))
+const branchToWorktreePath = (repoRoot, branch, configuredWorktreeRoot = DEFAULT_WORKTREE_ROOT) => {
+	const worktreeRoot = getWorktreeRootPath(repoRoot, configuredWorktreeRoot);
+	return ensurePathInsideRoot({
+		rootPath: worktreeRoot,
+		path: join(worktreeRoot, ...branch.split("/")),
+		message: "Path is outside managed worktree root"
 	});
 };
-const ensurePathInsideRepo = ({ repoRoot, path }) => {
-	const rel = relative(repoRoot, path);
+const ensurePathInsideRoot = ({ rootPath, path, message = "Path is outside allowed root" }) => {
+	const rel = relative(rootPath, path);
 	if (rel === "") return path;
 	if (rel === ".." || rel.startsWith(`..${sep}`)) throw createCliError("PATH_OUTSIDE_REPO", {
-		message: "Path is outside repository root",
+		message,
 		details: {
-			repoRoot,
+			rootPath,
 			path
 		}
 	});
 	return path;
 };
+const ensurePathInsideRepo = ({ repoRoot, path }) => {
+	return ensurePathInsideRoot({
+		rootPath: repoRoot,
+		path,
+		message: "Path is outside repository root"
+	});
+};
 const resolveRepoRelativePath = ({ repoRoot, relativePath }) => {
 	if (isAbsolute(relativePath)) throw createCliError("ABSOLUTE_PATH_NOT_ALLOWED", {
 		message: "Absolute path is not allowed",
@@ -266,6 +963,11 @@ const resolvePathFromCwd = ({ cwd, path }) => {
 	if (isAbsolute(path)) return path;
 	return resolve(cwd, path);
 };
+const isManagedWorktreePath = ({ worktreePath, managedWorktreeRoot }) => {
+	const rel = relative(managedWorktreeRoot, worktreePath);
+	if (rel === "" || rel === "." || rel === "..") return false;
+	return rel.startsWith(`..${sep}`) !== true;
+};
 
 //#endregion
 //#region src/core/hooks.ts
@@ -414,7 +1116,7 @@ const invokeHook = async ({ hookName, args, context }) => {
 
 //#endregion
 //#region src/core/init.ts
-const MANAGED_EXCLUDE_BLOCK = `# vde-worktree (managed)\n.worktree/\n.vde/worktree/\n`;
+const EXCLUDE_MARKER = "# vde-worktree (managed)";
 const DEFAULT_HOOKS = [{
 	name: "post-new",
 	lines: [
@@ -448,7 +1150,27 @@ const createHookTemplate = async (hooksDir, name, lines) => {
 		await chmod(targetPath, 493);
 	}
 };
-const ensureExcludeBlock = async (repoRoot) => {
+const isPathInsideOrEqual = ({ rootPath, candidatePath }) => {
+	const rel = relative(rootPath, candidatePath);
+	if (rel.length === 0) return true;
+	return rel !== ".." && rel.startsWith(`..${sep}`) !== true;
+};
+const toExcludeEntry = ({ repoRoot, managedWorktreeRoot }) => {
+	if (isPathInsideOrEqual({
+		rootPath: repoRoot,
+		candidatePath: managedWorktreeRoot
+	}) !== true) return null;
+	const rel = relative(repoRoot, managedWorktreeRoot).split(sep).join("/");
+	const normalized = rel.length === 0 ? "." : rel;
+	return normalized.endsWith("/") ? normalized : `${normalized}/`;
+};
+const ensureExcludeBlock = async ({ repoRoot, managedWorktreeRoot }) => {
+	const managedEntry = toExcludeEntry({
+		repoRoot,
+		managedWorktreeRoot
+	});
+	if (managedEntry === null) return;
+	const managedExcludeBlock = `${EXCLUDE_MARKER}\n${managedEntry}\n.vde/worktree/\n`;
 	const excludePath = join(repoRoot, ".git", "info", "exclude");
 	let current = "";
 	try {
@@ -456,8 +1178,8 @@ const ensureExcludeBlock = async (repoRoot) => {
 	} 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");
+	if (current.includes(managedExcludeBlock)) return;
+	await writeFile(excludePath, `${current.endsWith("\n") || current.length === 0 ? current : `${current}\n`}${managedExcludeBlock}`, "utf8");
 };
 const isInitialized = async (repoRoot) => {
 	try {
@@ -467,14 +1189,17 @@ const isInitialized = async (repoRoot) => {
 		return false;
 	}
 };
-const initializeRepository = async (repoRoot) => {
+const initializeRepository = async ({ repoRoot, managedWorktreeRoot }) => {
 	const wasInitialized = await isInitialized(repoRoot);
-	await mkdir(getWorktreeRootPath(repoRoot), { recursive: true });
+	await mkdir(managedWorktreeRoot, { 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);
+	await ensureExcludeBlock({
+		repoRoot,
+		managedWorktreeRoot
+	});
 	for (const hook of DEFAULT_HOOKS) await createHookTemplate(getHooksDirectoryPath(repoRoot), hook.name, hook.lines);
 	return { alreadyInitialized: wasInitialized };
 };
@@ -853,8 +1578,11 @@ const toTargetBranches = ({ branches, baseBranch }) => {
 	}
 	return [...uniqueBranches];
 };
-const buildUnknownPrStatusMap = (branches) => {
-	return new Map(branches.map((branch) => [branch, "unknown"]));
+const buildUnknownPrStateMap = (branches) => {
+	return new Map(branches.map((branch) => [branch, {
+		status: "unknown",
+		url: null
+	}]));
 };
 const parseUpdatedAtMillis = (value) => {
 	if (typeof value !== "string" || value.length === 0) return Number.NEGATIVE_INFINITY;
@@ -870,7 +1598,11 @@ const toPrStatus = (record) => {
 	if (state === "CLOSED") return "closed_unmerged";
 	return "unknown";
 };
-const parsePrStatusByBranch = ({ raw, targetBranches }) => {
+const toPrUrl = (record) => {
+	if (typeof record.url === "string" && record.url.length > 0) return record.url;
+	return null;
+};
+const parsePrStateByBranch = ({ raw, targetBranches }) => {
 	try {
 		const parsed = JSON.parse(raw);
 		if (Array.isArray(parsed) !== true) return null;
@@ -882,31 +1614,43 @@ const parsePrStatusByBranch = ({ raw, targetBranches }) => {
 			if (targetBranchSet.has(record.headRefName) !== true) continue;
 			const updatedAtMillis = parseUpdatedAtMillis(record.updatedAt);
 			const status = toPrStatus(record);
+			const url = toPrUrl(record);
 			const current = latestByBranch.get(record.headRefName);
 			if (current === void 0 || updatedAtMillis > current.updatedAtMillis || updatedAtMillis === current.updatedAtMillis && index > current.index) latestByBranch.set(record.headRefName, {
 				updatedAtMillis,
 				index,
-				status
+				status,
+				url
 			});
 		}
 		const result = /* @__PURE__ */ new Map();
 		for (const branch of targetBranches) {
 			const latest = latestByBranch.get(branch);
-			result.set(branch, latest?.status ?? "none");
+			if (latest === void 0) {
+				result.set(branch, {
+					status: "none",
+					url: null
+				});
+				continue;
+			}
+			result.set(branch, {
+				status: latest.status,
+				url: latest.url
+			});
 		}
 		return result;
 	} catch {
 		return null;
 	}
 };
-const resolvePrStatusByBranchBatch = async ({ repoRoot, baseBranch, branches, enabled = true, runGh = defaultRunGh }) => {
+const resolvePrStateByBranchBatch = async ({ repoRoot, baseBranch, branches, enabled = true, runGh = defaultRunGh }) => {
 	if (baseBranch === null) return /* @__PURE__ */ new Map();
 	const targetBranches = toTargetBranches({
 		branches,
 		baseBranch
 	});
 	if (targetBranches.length === 0) return /* @__PURE__ */ new Map();
-	if (enabled !== true) return buildUnknownPrStatusMap(targetBranches);
+	if (enabled !== true) return buildUnknownPrStateMap(targetBranches);
 	try {
 		const result = await runGh({
 			cwd: repoRoot,
@@ -922,19 +1666,19 @@ const resolvePrStatusByBranchBatch = async ({ repoRoot, baseBranch, branches, en
 				"--limit",
 				"1000",
 				"--json",
-				"headRefName,state,mergedAt,updatedAt"
+				"headRefName,state,mergedAt,updatedAt,url"
 			]
 		});
-		if (result.exitCode !== 0) return buildUnknownPrStatusMap(targetBranches);
-		const prStatusByBranch = parsePrStatusByBranch({
+		if (result.exitCode !== 0) return buildUnknownPrStateMap(targetBranches);
+		const prStatusByBranch = parsePrStateByBranch({
 			raw: result.stdout,
 			targetBranches
 		});
-		if (prStatusByBranch === null) return buildUnknownPrStatusMap(targetBranches);
+		if (prStatusByBranch === null) return buildUnknownPrStateMap(targetBranches);
 		return prStatusByBranch;
 	} catch (error) {
-		if (error.code === "ENOENT") return buildUnknownPrStatusMap(targetBranches);
-		return buildUnknownPrStatusMap(targetBranches);
+		if (error.code === "ENOENT") return buildUnknownPrStateMap(targetBranches);
+		return buildUnknownPrStateMap(targetBranches);
 	}
 };
 
@@ -999,36 +1743,6 @@ const listGitWorktrees = async (repoRoot) => {
 
 //#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,
@@ -1133,7 +1847,7 @@ const resolveLifecycleFromReflog = async ({ repoRoot, branch, baseBranch }) => {
 		divergedHead: latestWorkHead
 	};
 };
-const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, prStatusByBranch }) => {
+const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, prStateByBranch }) => {
 	if (branch === null) return {
 		byAncestry: null,
 		byPR: null,
@@ -1154,7 +1868,7 @@ const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, prStatus
 		if (result.exitCode === 0) byAncestry = true;
 		else if (result.exitCode === 1) byAncestry = false;
 	}
-	const prStatus = branch === baseBranch ? null : prStatusByBranch.get(branch) ?? null;
+	const prStatus = branch === baseBranch ? null : prStateByBranch.get(branch)?.status ?? null;
 	let byPR = null;
 	if (prStatus === "merged") byPR = true;
 	else if (prStatus === "none" || prStatus === "open" || prStatus === "closed_unmerged") byPR = false;
@@ -1208,9 +1922,16 @@ const resolveMergedState = async ({ repoRoot, branch, head, baseBranch, prStatus
 		})
 	};
 };
-const resolvePrState = ({ branch, baseBranch, prStatusByBranch }) => {
-	if (branch === null || branch === baseBranch) return { status: null };
-	return { status: prStatusByBranch.get(branch) ?? null };
+const resolveWorktreePrState = ({ branch, baseBranch, prStateByBranch }) => {
+	if (branch === null || branch === baseBranch) return {
+		status: null,
+		url: null
+	};
+	const prState = prStateByBranch.get(branch);
+	return {
+		status: prState?.status ?? null,
+		url: prState?.url ?? null
+	};
 };
 const resolveMergedOverall = ({ byAncestry, byPR, byLifecycle }) => {
 	if (byPR === true || byLifecycle === true) return true;
@@ -1258,7 +1979,7 @@ const resolveUpstreamState = async (worktreePath) => {
 		remote: upstreamRef.stdout.trim()
 	};
 };
-const enrichWorktree = async ({ repoRoot, worktree, baseBranch, prStatusByBranch }) => {
+const enrichWorktree = async ({ repoRoot, worktree, baseBranch, prStateByBranch }) => {
 	const [dirty, locked, merged, upstream] = await Promise.all([
 		resolveDirty(worktree.path),
 		resolveLockState({
@@ -1270,14 +1991,14 @@ const enrichWorktree = async ({ repoRoot, worktree, baseBranch, prStatusByBranch
 			branch: worktree.branch,
 			head: worktree.head,
 			baseBranch,
-			prStatusByBranch
+			prStateByBranch
 		}),
 		resolveUpstreamState(worktree.path)
 	]);
-	const pr = resolvePrState({
+	const pr = resolveWorktreePrState({
 		branch: worktree.branch,
 		baseBranch,
-		prStatusByBranch
+		prStateByBranch
 	});
 	return {
 		branch: worktree.branch,
@@ -1290,17 +2011,13 @@ const enrichWorktree = async ({ repoRoot, worktree, baseBranch, prStatusByBranch
 		upstream
 	};
 };
-const collectWorktreeSnapshot = async (repoRoot, { noGh = false } = {}) => {
-	const [baseBranch, worktrees, enableGh] = await Promise.all([
-		resolveBaseBranch$1(repoRoot),
-		listGitWorktrees(repoRoot),
-		resolveEnableGh(repoRoot)
-	]);
-	const prStatusByBranch = await resolvePrStatusByBranchBatch({
+const collectWorktreeSnapshot = async (repoRoot, { baseBranch = null, ghEnabled = true, noGh = false } = {}) => {
+	const worktrees = await listGitWorktrees(repoRoot);
+	const prStateByBranch = await resolvePrStateByBranchBatch({
 		repoRoot,
 		baseBranch,
 		branches: worktrees.map((worktree) => worktree.branch),
-		enabled: enableGh && noGh !== true
+		enabled: ghEnabled && noGh !== true
 	});
 	return {
 		repoRoot,
@@ -1310,7 +2027,7 @@ const collectWorktreeSnapshot = async (repoRoot, { noGh = false } = {}) => {
 				repoRoot,
 				worktree,
 				baseBranch,
-				prStatusByBranch
+				prStateByBranch
 			});
 		}))
 	};
@@ -1324,7 +2041,8 @@ const RESERVED_FZF_ARGS = new Set([
 	"prompt",
 	"layout",
 	"height",
-	"border"
+	"border",
+	"tmux"
 ]);
 const ANSI_ESCAPE_SEQUENCE_PATTERN = String.raw`\u001B\[[0-?]*[ -/]*[@-~]`;
 const ANSI_ESCAPE_SEQUENCE_REGEX = new RegExp(ANSI_ESCAPE_SEQUENCE_PATTERN, "g");
@@ -1364,6 +2082,13 @@ const defaultCheckFzfAvailability = async () => {
 		throw error;
 	}
 };
+const defaultCheckFzfTmuxSupport = async () => {
+	try {
+		return (await execa(FZF_BINARY, ["--help"], { timeout: FZF_CHECK_TIMEOUT_MS })).stdout.includes("--tmux");
+	} catch {
+		return false;
+	}
+};
 const defaultRunFzf = async ({ args, input, cwd, env }) => {
 	return { stdout: (await execa(FZF_BINARY, args, {
 		input,
@@ -1376,20 +2101,46 @@ 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 }) => {
+const shouldTryTmuxPopup = async ({ surface, env, checkFzfTmuxSupport }) => {
+	if (surface === "inline") return false;
+	if (surface === "tmux-popup") return true;
+	if (typeof env.TMUX !== "string" || env.TMUX.length === 0) return false;
+	try {
+		return await checkFzfTmuxSupport();
+	} catch {
+		return false;
+	}
+};
+const isTmuxUnknownOptionError = (error) => {
+	const execaError = error;
+	const text = [
+		execaError.message,
+		execaError.shortMessage,
+		execaError.stderr,
+		execaError.stdout
+	].filter((value) => typeof value === "string" && value.length > 0).join("\n");
+	return /unknown option.*--tmux|--tmux.*unknown option/i.test(text);
+};
+const selectPathWithFzf = async ({ candidates, prompt = "worktree> ", surface = "inline", tmuxPopupOpts = "80%,70%", fzfExtraArgs = [], cwd = process.cwd(), env = process.env, isInteractive = () => process.stdout.isTTY === true && process.stderr.isTTY === true, checkFzfAvailability = defaultCheckFzfAvailability, checkFzfTmuxSupport = defaultCheckFzfTmuxSupport, 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({
+	const baseArgs = buildFzfArgs({
 		prompt,
 		fzfExtraArgs
 	});
+	const tryTmuxPopup = await shouldTryTmuxPopup({
+		surface,
+		env,
+		checkFzfTmuxSupport
+	});
+	const args = tryTmuxPopup ? [...baseArgs, `--tmux=${tmuxPopupOpts}`] : baseArgs;
 	const input = buildFzfInput(candidates);
 	if (input.length === 0) throw new Error("All candidates are empty after sanitization");
 	const candidateSet = new Set(input.split("\n").map((candidate) => stripAnsi(candidate)));
-	try {
+	const runWithValidation = async (fzfArgs) => {
 		const selectedPath = stripAnsi(stripTrailingNewlines((await runFzf({
-			args,
+			args: fzfArgs,
 			input,
 			cwd,
 			env
@@ -1400,7 +2151,16 @@ const selectPathWithFzf = async ({ candidates, prompt = "worktree> ", fzfExtraAr
 			status: "selected",
 			path: selectedPath
 		};
+	};
+	try {
+		return await runWithValidation(args);
 	} catch (error) {
+		if (tryTmuxPopup && isTmuxUnknownOptionError(error)) try {
+			return await runWithValidation(baseArgs);
+		} catch (fallbackError) {
+			if (fallbackError.exitCode === 130) return { status: "cancelled" };
+			throw fallbackError;
+		}
 		if (error.exitCode === 130) return { status: "cancelled" };
 		throw error;
 	}
@@ -1488,9 +2248,7 @@ const CD_FZF_EXTRA_ARGS = [
 	"--preview-window=right,60%,wrap",
 	"--ansi"
 ];
-const LIST_TABLE_COLUMN_COUNT = 8;
-const LIST_TABLE_PATH_COLUMN_INDEX = 7;
-const LIST_TABLE_PATH_MIN_WIDTH = 12;
+const DEFAULT_LIST_TABLE_COLUMNS = [...LIST_TABLE_COLUMNS];
 const LIST_TABLE_CELL_HORIZONTAL_PADDING = 2;
 const COMPLETION_SHELLS = ["zsh", "fish"];
 const COMPLETION_FILE_BY_SHELL = {
@@ -1512,6 +2270,10 @@ const CATPPUCCIN_MOCHA = {
 	overlay0: "#6c7086"
 };
 const identityColor = (value) => value;
+const hasDefaultListColumnOrder = (columns) => {
+	if (columns.length !== DEFAULT_LIST_TABLE_COLUMNS.length) return false;
+	return columns.every((column, index) => column === DEFAULT_LIST_TABLE_COLUMNS[index]);
+};
 const createCatppuccinTheme = ({ enabled }) => {
 	if (enabled !== true) return {
 		header: identityColor,
@@ -1665,7 +2427,7 @@ const commandHelpEntries = [
 		details: [
 			"Table output includes branch, path, dirty, lock, merged, PR state, and ahead/behind vs base branch.",
 			"By default, long path values are truncated to fit terminal width.",
-			"JSON output includes PR and upstream metadata fields."
+			"JSON output includes PR status/url and upstream metadata fields."
 		],
 		options: ["--full-path"]
 	},
@@ -1959,85 +2721,29 @@ const ensureArgumentCount = ({ command, args, min, max }) => {
 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({
+const resolveBaseBranch = async ({ repoRoot, config }) => {
+	if (typeof config.git.baseBranch === "string" && config.git.baseBranch.length > 0) return config.git.baseBranch;
+	const remote = config.git.baseRemote;
+	const resolved = 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"
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			`refs/remotes/${remote}/HEAD`
 		],
 		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;
+	if (resolved.exitCode === 0) {
 		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." });
+	throw createCliError("INVALID_ARGUMENT", {
+		message: "Unable to resolve base branch from config.yml (baseRemote/HEAD -> main/master).",
+		details: { remote }
+	});
 };
 const ensureTargetPathWritable = async (targetPath) => {
 	try {
@@ -2230,7 +2936,7 @@ const validateDeleteSafety = ({ target, forceFlags }) => {
 const resolveLinkTargetPath = ({ sourcePath, destinationPath }) => {
 	return relative(dirname(destinationPath), sourcePath);
 };
-const resolveFileCopyTargets = ({ repoRoot, worktreePath, relativePath }) => {
+const resolveFileCopyTargets = ({ repoRoot, targetWorktreeRoot, relativePath }) => {
 	const sourcePath = resolveRepoRelativePath({
 		repoRoot,
 		relativePath
@@ -2238,13 +2944,32 @@ const resolveFileCopyTargets = ({ repoRoot, worktreePath, relativePath }) => {
 	const relativeFromRoot = relative(repoRoot, sourcePath);
 	return {
 		sourcePath,
-		destinationPath: ensurePathInsideRepo({
-			repoRoot,
-			path: resolve(worktreePath, relativeFromRoot)
+		destinationPath: ensurePathInsideRoot({
+			rootPath: targetWorktreeRoot,
+			path: resolve(targetWorktreeRoot, relativeFromRoot),
+			message: "Path is outside target worktree root"
 		}),
 		relativeFromRoot
 	};
 };
+const resolveTargetWorktreeRootForCopyLink = ({ repoContext, snapshot }) => {
+	const rawTarget = process.env.WT_WORKTREE_PATH ?? repoContext.currentWorktreeRoot;
+	const resolvedTarget = resolvePathFromCwd({
+		cwd: repoContext.currentWorktreeRoot,
+		path: rawTarget
+	});
+	const matched = snapshot.worktrees.filter((worktree) => {
+		return worktree.path === resolvedTarget || resolvedTarget.startsWith(`${worktree.path}${sep}`);
+	}).sort((a, b) => b.path.length - a.path.length)[0];
+	if (matched === void 0) throw createCliError("WORKTREE_NOT_FOUND", {
+		message: "copy/link target worktree not found",
+		details: {
+			rawTarget,
+			resolvedTarget
+		}
+	});
+	return matched.path;
+};
 const ensureBranchIsNotPrimary = ({ branch, baseBranch }) => {
 	if (branch !== baseBranch) return;
 	throw createCliError("INVALID_ARGUMENT", {
@@ -2255,12 +2980,14 @@ const ensureBranchIsNotPrimary = ({ branch, baseBranch }) => {
 		}
 	});
 };
-const toManagedWorktreeName = ({ repoRoot, worktreePath }) => {
-	const relativePath = relative(getWorktreeRootPath(repoRoot), worktreePath);
-	if (relativePath.length === 0 || relativePath === "." || relativePath === ".." || relativePath.startsWith(`..${sep}`)) return null;
-	return relativePath.split(sep).join("/");
+const toManagedWorktreeName = ({ managedWorktreeRoot, worktreePath }) => {
+	if (isManagedWorktreePath({
+		worktreePath,
+		managedWorktreeRoot
+	}) !== true) return null;
+	return relative(managedWorktreeRoot, worktreePath).split(sep).join("/");
 };
-const resolveManagedWorktreePathFromName = ({ repoRoot, optionName, worktreeName }) => {
+const resolveManagedWorktreePathFromName = ({ managedWorktreeRoot, optionName, worktreeName }) => {
 	const normalized = worktreeName.trim();
 	if (normalized.length === 0) throw createCliError("INVALID_ARGUMENT", {
 		message: `${optionName} requires non-empty worktree name`,
@@ -2269,18 +2996,10 @@ const resolveManagedWorktreePathFromName = ({ repoRoot, optionName, worktreeName
 			worktreeName
 		}
 	});
-	if (normalized === ".worktree" || normalized.startsWith(".worktree/") || normalized.startsWith(".worktree\\")) throw createCliError("INVALID_ARGUMENT", {
-		message: `${optionName} expects vw-managed worktree name (without .worktree/ prefix)`,
-		details: {
-			optionName,
-			worktreeName
-		}
-	});
-	const worktreeRoot = getWorktreeRootPath(repoRoot);
 	let resolvedPath;
 	try {
 		resolvedPath = resolveRepoRelativePath({
-			repoRoot: worktreeRoot,
+			repoRoot: managedWorktreeRoot,
 			relativePath: normalized
 		});
 	} catch (error) {
@@ -2293,7 +3012,7 @@ const resolveManagedWorktreePathFromName = ({ repoRoot, optionName, worktreeName
 			cause: error
 		});
 	}
-	if (resolvedPath === worktreeRoot) throw createCliError("INVALID_ARGUMENT", {
+	if (resolvedPath === managedWorktreeRoot) throw createCliError("INVALID_ARGUMENT", {
 		message: `${optionName} expects vw-managed worktree name`,
 		details: {
 			optionName,
@@ -2302,16 +3021,16 @@ const resolveManagedWorktreePathFromName = ({ repoRoot, optionName, worktreeName
 	});
 	return resolvedPath;
 };
-const resolveManagedNonPrimaryWorktreeByBranch = ({ repoRoot, branch, worktrees, optionName, worktreeName, role }) => {
+const resolveManagedNonPrimaryWorktreeByBranch = ({ repoRoot, managedWorktreeRoot, branch, worktrees, optionName, worktreeName, role }) => {
 	const managedCandidates = worktrees.filter((worktree) => {
 		return worktree.branch === branch && worktree.path !== repoRoot && toManagedWorktreeName({
-			repoRoot,
+			managedWorktreeRoot,
 			worktreePath: worktree.path
 		}) !== null;
 	});
 	if (typeof worktreeName === "string") {
 		const resolvedPath = resolveManagedWorktreePathFromName({
-			repoRoot,
+			managedWorktreeRoot,
 			optionName,
 			worktreeName
 		});
@@ -2342,7 +3061,7 @@ const resolveManagedNonPrimaryWorktreeByBranch = ({ repoRoot, branch, worktrees,
 			optionName,
 			candidates: managedCandidates.map((worktree) => {
 				return toManagedWorktreeName({
-					repoRoot,
+					managedWorktreeRoot,
 					worktreePath: worktree.path
 				}) ?? worktree.path;
 			})
@@ -2499,19 +3218,24 @@ const resolveListColumnContentWidth = ({ rows, columnIndex }) => {
 		return Math.max(width, stringWidth(cell));
 	}, 0);
 };
-const resolveListPathColumnWidth = ({ rows, disablePathTruncation }) => {
-	if (disablePathTruncation) return null;
+const resolveListPathColumnWidth = ({ rows, columns, truncateMode, fullPath, minWidth }) => {
+	const pathColumnIndex = columns.indexOf("path");
+	if (pathColumnIndex < 0) return null;
+	if (fullPath || truncateMode === "never") return null;
 	if (process.stdout.isTTY !== true) return null;
 	const terminalColumns = process.stdout.columns;
 	if (typeof terminalColumns !== "number" || Number.isFinite(terminalColumns) !== true || terminalColumns <= 0) return null;
-	const measuredNonPathWidth = Array.from({ length: LIST_TABLE_PATH_COLUMN_INDEX }).map((_, index) => resolveListColumnContentWidth({
-		rows,
-		columnIndex: index
-	})).reduce((sum, width) => sum + width, 0);
-	const borderWidth = LIST_TABLE_COLUMN_COUNT + 1;
-	const paddingWidth = LIST_TABLE_COLUMN_COUNT * LIST_TABLE_CELL_HORIZONTAL_PADDING;
+	const measuredNonPathWidth = columns.map((_, index) => {
+		if (index === pathColumnIndex) return 0;
+		return resolveListColumnContentWidth({
+			rows,
+			columnIndex: index
+		});
+	}).reduce((sum, width) => sum + width, 0);
+	const borderWidth = columns.length + 1;
+	const paddingWidth = columns.length * LIST_TABLE_CELL_HORIZONTAL_PADDING;
 	const availablePathWidth = Math.floor(terminalColumns) - borderWidth - paddingWidth - measuredNonPathWidth;
-	return Math.max(LIST_TABLE_PATH_MIN_WIDTH, availablePathWidth);
+	return Math.max(minWidth, availablePathWidth);
 };
 const resolveAheadBehindAgainstBaseBranch = async ({ repoRoot, baseBranch, worktree }) => {
 	if (baseBranch === null) return {
@@ -2852,7 +3576,7 @@ const createCli = (options = {}) => {
 		from: {
 			type: "string",
 			valueHint: "value",
-			description: "For extract: filesystem path. For absorb: managed worktree name without .worktree/ prefix."
+			description: "For extract: filesystem path. For absorb: managed worktree name."
 		},
 		to: {
 			type: "string",
@@ -3001,39 +3725,47 @@ const createCli = (options = {}) => {
 			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 { config: resolvedConfig } = await loadResolvedConfig({
+				cwd: runtimeCwd,
+				repoRoot
+			});
+			const managedWorktreeRoot = getWorktreeRootPath(repoRoot, resolvedConfig.paths.worktreeRoot);
 			const runtime = {
 				command,
 				json: jsonEnabled,
-				hooksEnabled: parsedArgs.hooks !== false && configuredHooksEnabled !== false,
-				ghEnabled: parsedArgs.gh !== false,
+				hooksEnabled: parsedArgs.hooks !== false && resolvedConfig.hooks.enabled,
+				ghEnabled: parsedArgs.gh !== false && resolvedConfig.github.enabled,
 				strictPostHooks: parsedArgs.strictPostHooks === true,
 				hookTimeoutMs: readNumberFromEnvOrDefault({
 					rawValue: toNumberOption({
 						value: parsedArgs.hookTimeoutMs,
 						optionName: "--hook-timeout-ms"
-					}) ?? configuredHookTimeoutMs,
+					}) ?? resolvedConfig.hooks.timeoutMs,
 					defaultValue: DEFAULT_HOOK_TIMEOUT_MS
 				}),
 				lockTimeoutMs: readNumberFromEnvOrDefault({
 					rawValue: toNumberOption({
 						value: parsedArgs.lockTimeoutMs,
 						optionName: "--lock-timeout-ms"
-					}) ?? configuredLockTimeoutMs,
+					}) ?? resolvedConfig.locks.timeoutMs,
 					defaultValue: DEFAULT_LOCK_TIMEOUT_MS
 				}),
 				allowUnsafe,
 				isInteractive: isInteractiveFn()
 			};
 			const staleLockTTLSeconds = readNumberFromEnvOrDefault({
-				rawValue: configuredStaleTTL,
+				rawValue: resolvedConfig.locks.staleLockTTLSeconds,
 				defaultValue: DEFAULT_STALE_LOCK_TTL_SECONDS
 			});
 			const collectWorktreeSnapshot$1 = async (_ignoredRepoRoot) => {
-				return collectWorktreeSnapshot(repoRoot, { noGh: runtime.ghEnabled !== true });
+				return collectWorktreeSnapshot(repoRoot, {
+					baseBranch: await resolveBaseBranch({
+						repoRoot,
+						config: resolvedConfig
+					}),
+					ghEnabled: runtime.ghEnabled,
+					noGh: runtime.ghEnabled !== true
+				});
 			};
 			const runWriteOperation = async (task) => {
 				if (WRITE_COMMANDS.has(command) !== true) return task();
@@ -3065,7 +3797,10 @@ const createCli = (options = {}) => {
 						name: "init",
 						context: hookContext
 					});
-					const initialized = await initializeRepository(repoRoot);
+					const initialized = await initializeRepository({
+						repoRoot,
+						managedWorktreeRoot
+					});
 					await runPostHook({
 						name: "init",
 						context: hookContext
@@ -3101,22 +3836,15 @@ const createCli = (options = {}) => {
 						repoRoot,
 						details: {
 							baseBranch: snapshot.baseBranch,
+							managedWorktreeRoot,
 							worktrees: snapshot.worktrees
 						}
 					})));
 					return EXIT_CODE.OK;
 				}
 				const theme = createCatppuccinTheme({ enabled: shouldUseAnsiColors({ interactive: runtime.isInteractive }) });
-				const rows = [[
-					"branch",
-					"dirty",
-					"merged",
-					"pr",
-					"locked",
-					"ahead",
-					"behind",
-					"path"
-				], ...await Promise.all(snapshot.worktrees.map(async (worktree) => {
+				const columns = resolvedConfig.list.table.columns;
+				const rows = [[...columns], ...await Promise.all(snapshot.worktrees.map(async (worktree) => {
 					const distanceFromBase = await resolveAheadBehindAgainstBaseBranch({
 						repoRoot,
 						baseBranch: snapshot.baseBranch,
@@ -3128,35 +3856,41 @@ const createCli = (options = {}) => {
 						prStatus: worktree.pr.status,
 						isBaseBranch
 					});
-					return [
-						`${worktree.path === repoContext.currentWorktreeRoot ? "*" : " "} ${worktree.branch ?? "(detached)"}`,
-						worktree.dirty ? "dirty" : "clean",
-						mergedState,
-						prState,
-						worktree.locked.value ? "locked" : "-",
-						formatListUpstreamCount(distanceFromBase.ahead),
-						formatListUpstreamCount(distanceFromBase.behind),
-						formatDisplayPath(worktree.path)
-					];
+					const valuesByColumn = {
+						branch: `${worktree.path === repoContext.currentWorktreeRoot ? "*" : " "} ${worktree.branch ?? "(detached)"}`,
+						dirty: worktree.dirty ? "dirty" : "clean",
+						merged: mergedState,
+						pr: prState,
+						locked: worktree.locked.value ? "locked" : "-",
+						ahead: formatListUpstreamCount(distanceFromBase.ahead),
+						behind: formatListUpstreamCount(distanceFromBase.behind),
+						path: formatDisplayPath(worktree.path)
+					};
+					return columns.map((column) => valuesByColumn[column]);
 				}))];
 				const pathColumnWidth = resolveListPathColumnWidth({
 					rows,
-					disablePathTruncation: parsedArgs.fullPath === true
+					columns,
+					truncateMode: resolvedConfig.list.table.path.truncate,
+					fullPath: parsedArgs.fullPath === true,
+					minWidth: resolvedConfig.list.table.path.minWidth
 				});
-				const columnsConfig = pathColumnWidth === null ? void 0 : { [LIST_TABLE_PATH_COLUMN_INDEX]: {
+				const pathColumnIndex = columns.indexOf("path");
+				const columnsConfig = pathColumnWidth === null || pathColumnIndex < 0 ? void 0 : { [pathColumnIndex]: {
 					width: pathColumnWidth,
 					truncate: pathColumnWidth
 				} };
-				const colorized = colorizeListTable({
-					rendered: table(rows, {
-						border: getBorderCharacters("norc"),
-						drawHorizontalLine: (lineIndex, rowCount) => {
-							return lineIndex === 0 || lineIndex === 1 || lineIndex === rowCount;
-						},
-						columns: columnsConfig
-					}),
-					theme
+				const rendered = table(rows, {
+					border: getBorderCharacters("norc"),
+					drawHorizontalLine: (lineIndex, rowCount) => {
+						return lineIndex === 0 || lineIndex === 1 || lineIndex === rowCount;
+					},
+					columns: columnsConfig
 				});
+				const colorized = hasDefaultListColumnOrder(columns) ? colorizeListTable({
+					rendered,
+					theme
+				}) : rendered.trimEnd();
 				for (const line of colorized.split("\n")) stdout(line);
 				return EXIT_CODE.OK;
 			}
@@ -3238,9 +3972,12 @@ const createCli = (options = {}) => {
 						message: `Branch already exists locally: ${branch}`,
 						details: { branch }
 					});
-					const targetPath = branchToWorktreePath(repoRoot, branch);
+					const targetPath = branchToWorktreePath(repoRoot, branch, resolvedConfig.paths.worktreeRoot);
 					await ensureTargetPathWritable(targetPath);
-					const baseBranch = await resolveBaseBranch(repoRoot);
+					const baseBranch = await resolveBaseBranch({
+						repoRoot,
+						config: resolvedConfig
+					});
 					const hookContext = createHookContext({
 						runtime,
 						repoRoot,
@@ -3315,7 +4052,7 @@ const createCli = (options = {}) => {
 							path: existing.path
 						};
 					}
-					const targetPath = branchToWorktreePath(repoRoot, branch);
+					const targetPath = branchToWorktreePath(repoRoot, branch, resolvedConfig.paths.worktreeRoot);
 					await ensureTargetPathWritable(targetPath);
 					const hookContext = createHookContext({
 						runtime,
@@ -3340,7 +4077,10 @@ const createCli = (options = {}) => {
 						]
 					});
 					else {
-						const baseBranch = await resolveBaseBranch(repoRoot);
+						const baseBranch = await resolveBaseBranch({
+							repoRoot,
+							config: resolvedConfig
+						});
 						lifecycleBaseBranch = baseBranch;
 						await runGitCommand({
 							cwd: repoRoot,
@@ -3423,7 +4163,7 @@ const createCli = (options = {}) => {
 						message: `Branch already exists locally: ${newBranch}`,
 						details: { branch: newBranch }
 					});
-					const newPath = branchToWorktreePath(repoRoot, newBranch);
+					const newPath = branchToWorktreePath(repoRoot, newBranch, resolvedConfig.paths.worktreeRoot);
 					await ensureTargetPathWritable(newPath);
 					const hookContext = createHookContext({
 						runtime,
@@ -3517,6 +4257,17 @@ const createCli = (options = {}) => {
 						message: "Cannot delete the primary worktree",
 						details: { path: target.path }
 					});
+					if (isManagedWorktreePath({
+						worktreePath: target.path,
+						managedWorktreeRoot
+					}) !== true) throw createCliError("WORKTREE_NOT_FOUND", {
+						message: "Target branch is not in managed worktree root",
+						details: {
+							branch: target.branch,
+							path: target.path,
+							managedWorktreeRoot
+						}
+					});
 					validateDeleteSafety({
 						target,
 						forceFlags
@@ -3590,7 +4341,10 @@ const createCli = (options = {}) => {
 				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$1(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).map((worktree) => worktree.branch);
+					const candidates = (await collectWorktreeSnapshot$1(repoRoot)).worktrees.filter((worktree) => worktree.branch !== null).filter((worktree) => worktree.path !== repoRoot).filter((worktree) => isManagedWorktreePath({
+						worktreePath: worktree.path,
+						managedWorktreeRoot
+					})).filter((worktree) => worktree.dirty === false).filter((worktree) => worktree.locked.value === false).filter((worktree) => worktree.merged.overall === true).map((worktree) => worktree.branch);
 					if (dryRun) return {
 						deleted: [],
 						candidates,
@@ -3695,7 +4449,7 @@ const createCli = (options = {}) => {
 						repoRoot,
 						action: "get",
 						branch,
-						worktreePath: branchToWorktreePath(repoRoot, branch),
+						worktreePath: branchToWorktreePath(repoRoot, branch, resolvedConfig.paths.worktreeRoot),
 						stderr
 					});
 					await runPreHook({
@@ -3746,7 +4500,7 @@ const createCli = (options = {}) => {
 							path: existing.path
 						};
 					}
-					const targetPath = branchToWorktreePath(repoRoot, branch);
+					const targetPath = branchToWorktreePath(repoRoot, branch, resolvedConfig.paths.worktreeRoot);
 					await ensureTargetPathWritable(targetPath);
 					await runGitCommand({
 						cwd: repoRoot,
@@ -3820,12 +4574,15 @@ const createCli = (options = {}) => {
 						details: { path: sourceWorktree.path }
 					});
 					const branch = sourceWorktree.branch;
-					const baseBranch = await resolveBaseBranch(repoRoot);
+					const baseBranch = await resolveBaseBranch({
+						repoRoot,
+						config: resolvedConfig
+					});
 					ensureBranchIsNotPrimary({
 						branch,
 						baseBranch
 					});
-					const targetPath = branchToWorktreePath(repoRoot, branch);
+					const targetPath = branchToWorktreePath(repoRoot, branch, resolvedConfig.paths.worktreeRoot);
 					await ensureTargetPathWritable(targetPath);
 					const dirty = (await runGitCommand({
 						cwd: repoRoot,
@@ -3946,6 +4703,7 @@ const createCli = (options = {}) => {
 					});
 					const sourceWorktree = resolveManagedNonPrimaryWorktreeByBranch({
 						repoRoot,
+						managedWorktreeRoot,
 						branch,
 						worktrees: (await collectWorktreeSnapshot$1(repoRoot)).worktrees,
 						optionName: "--from",
@@ -4080,6 +4838,7 @@ const createCli = (options = {}) => {
 					});
 					const targetWorktree = resolveManagedNonPrimaryWorktreeByBranch({
 						repoRoot,
+						managedWorktreeRoot,
 						branch,
 						worktrees: (await collectWorktreeSnapshot$1(repoRoot)).worktrees,
 						optionName: "--to",
@@ -4367,17 +5126,14 @@ const createCli = (options = {}) => {
 					min: 1,
 					max: Number.MAX_SAFE_INTEGER
 				});
-				const worktreePath = ensurePathInsideRepo({
-					repoRoot,
-					path: resolvePathFromCwd({
-						cwd: repoContext.currentWorktreeRoot,
-						path: process.env.WT_WORKTREE_PATH ?? "."
-					})
+				const targetWorktreeRoot = resolveTargetWorktreeRootForCopyLink({
+					repoContext,
+					snapshot: await collectWorktreeSnapshot$1(repoRoot)
 				});
 				for (const relativePath of commandArgs) {
 					const { sourcePath, destinationPath } = resolveFileCopyTargets({
 						repoRoot,
-						worktreePath,
+						targetWorktreeRoot,
 						relativePath
 					});
 					await access(sourcePath, constants.F_OK);
@@ -4396,7 +5152,7 @@ const createCli = (options = {}) => {
 						repoRoot,
 						details: {
 							copied: commandArgs,
-							worktreePath
+							worktreePath: targetWorktreeRoot
 						}
 					})));
 					return EXIT_CODE.OK;
@@ -4410,18 +5166,15 @@ const createCli = (options = {}) => {
 					min: 1,
 					max: Number.MAX_SAFE_INTEGER
 				});
-				const worktreePath = ensurePathInsideRepo({
-					repoRoot,
-					path: resolvePathFromCwd({
-						cwd: repoContext.currentWorktreeRoot,
-						path: process.env.WT_WORKTREE_PATH ?? "."
-					})
+				const targetWorktreeRoot = resolveTargetWorktreeRootForCopyLink({
+					repoContext,
+					snapshot: await collectWorktreeSnapshot$1(repoRoot)
 				});
 				const fallbackEnabled = parsedArgs.fallback !== false;
 				for (const relativePath of commandArgs) {
 					const { sourcePath, destinationPath } = resolveFileCopyTargets({
 						repoRoot,
-						worktreePath,
+						targetWorktreeRoot,
 						relativePath
 					});
 					await access(sourcePath, constants.F_OK);
@@ -4459,7 +5212,7 @@ const createCli = (options = {}) => {
 						repoRoot,
 						details: {
 							linked: commandArgs,
-							worktreePath,
+							worktreePath: targetWorktreeRoot,
 							fallback: fallbackEnabled
 						}
 					})));
@@ -4614,16 +5367,25 @@ const createCli = (options = {}) => {
 				}));
 				if (candidates.length === 0) throw createCliError("WORKTREE_NOT_FOUND", { message: "No worktree candidates found" });
 				const promptValue = readStringOption(parsedArgsRecord, "prompt");
+				const prompt = typeof promptValue === "string" && promptValue.length > 0 ? promptValue : resolvedConfig.selector.cd.prompt;
+				const cliFzfExtraArgs = collectOptionValues({
+					args: beforeDoubleDash,
+					optionNames: ["fzfArg", "fzf-arg"]
+				});
+				const mergedConfigFzfArgs = mergeFzfArgs({
+					defaults: resolvedConfig.selector.cd.fzf.extraArgs,
+					extras: cliFzfExtraArgs
+				});
+				const surface = resolvedConfig.selector.cd.surface;
 				const selection = await selectPathWithFzf$1({
 					candidates,
-					prompt: typeof promptValue === "string" && promptValue.length > 0 ? promptValue : "worktree> ",
+					prompt,
 					fzfExtraArgs: mergeFzfArgs({
 						defaults: CD_FZF_EXTRA_ARGS,
-						extras: collectOptionValues({
-							args: beforeDoubleDash,
-							optionNames: ["fzfArg", "fzf-arg"]
-						})
+						extras: mergedConfigFzfArgs
 					}),
+					surface,
+					tmuxPopupOpts: resolvedConfig.selector.cd.tmuxPopupOpts,
 					cwd: repoRoot,
 					isInteractive: () => runtime.isInteractive || process.stderr.isTTY === true
 				}).catch((error) => {