@aku11i/phantom 6.1.1-1 → 6.2.0-0

package/phantom.js

@@ -28,15 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-//#region ../shared/src/constants/exit-codes.ts
-const exitCodes = {
-	success: 0,
-	generalError: 1,
-	notFound: 2,
-	validationError: 3
-};
-//#endregion
-//#region ../shared/src/types/result.ts
+//#region ../utils/src/types/result.ts
 /**
 * Creates a successful Result containing the given value.
 *
@@ -4375,6 +4367,8 @@ const execFile$1 = promisify(execFile);
 * Execute a git command with consistent error handling
 */
 async function executeGitCommand(args, options = {}) {
+	const trimStdout = options.trimStdout ?? true;
+	const trimStderr = options.trimStderr ?? true;
 	try {
 		const result = await execFile$1("git", args, {
 			cwd: options.cwd,
@@ -4382,58 +4376,33 @@ async function executeGitCommand(args, options = {}) {
 			encoding: "utf8"
 		});
 		return {
-			stdout: result.stdout.trim(),
-			stderr: result.stderr.trim()
+			stdout: trimStdout ? result.stdout.trim() : result.stdout,
+			stderr: trimStderr ? result.stderr.trim() : result.stderr
 		};
 	} catch (error) {
 		if (error && typeof error === "object" && "stdout" in error && "stderr" in error) {
 			const execError = error;
 			if (execError.stderr?.trim()) throw new Error(execError.stderr.trim());
 			return {
-				stdout: execError.stdout?.trim() || "",
-				stderr: execError.stderr?.trim() || ""
+				stdout: trimStdout ? execError.stdout?.trim() ?? "" : execError.stdout ?? "",
+				stderr: trimStderr ? execError.stderr?.trim() ?? "" : execError.stderr ?? ""
 			};
 		}
 		throw error;
 	}
 }
-/**
-* Execute a git command in a specific directory
-*/
-async function executeGitCommandInDirectory(directory, args) {
-	return executeGitCommand([
-		"-C",
-		directory,
-		...args
-	], {});
-}
 //#endregion
 //#region ../git/src/libs/add-worktree.ts
 async function addWorktree(options) {
-	const { path, branch, base = "HEAD" } = options;
-	await executeGitCommand([
+	const { path, branch, base = "HEAD", createBranch = true, cwd } = options;
+	const args = [
 		"worktree",
 		"add",
-		path,
-		"-b",
-		branch,
-		base
-	]);
-}
-//#endregion
-//#region ../git/src/libs/attach-worktree.ts
-async function attachWorktree(gitRoot, worktreePath, branchName) {
-	try {
-		await executeGitCommand([
-			"worktree",
-			"add",
-			worktreePath,
-			branchName
-		], { cwd: gitRoot });
-		return ok(void 0);
-	} catch (error) {
-		return err(error instanceof Error ? error : /* @__PURE__ */ new Error(`Failed to attach worktree: ${String(error)}`));
-	}
+		path
+	];
+	if (createBranch) args.push("-b", branch, base);
+	else args.push(branch);
+	await executeGitCommand(args, { cwd });
 }
 //#endregion
 //#region ../git/src/libs/branch-exists.ts
@@ -4449,6 +4418,45 @@ async function branchExists(gitRoot, branchName) {
 	}
 }
 //#endregion
+//#region ../git/src/libs/config-get-regexp.ts
+async function configGetRegexp(options) {
+	const { pattern, global = false, nullSeparated = false, cwd } = options;
+	const args = ["config"];
+	if (global) args.push("--global");
+	if (nullSeparated) args.push("--null");
+	args.push("--get-regexp", pattern);
+	const { stdout } = await executeGitCommand(args, { cwd });
+	return stdout;
+}
+//#endregion
+//#region ../git/src/libs/config-set.ts
+async function configSet(options) {
+	const { key, value, global = false, cwd } = options;
+	const args = ["config"];
+	if (global) args.push("--global");
+	args.push(key, value);
+	await executeGitCommand(args, { cwd });
+}
+//#endregion
+//#region ../git/src/libs/config-unset.ts
+async function configUnset(options) {
+	const { key, global = false, cwd } = options;
+	const args = ["config"];
+	if (global) args.push("--global");
+	args.push("--unset", key);
+	await executeGitCommand(args, { cwd });
+}
+//#endregion
+//#region ../git/src/libs/delete-branch.ts
+async function deleteBranch$1(options) {
+	const { gitRoot, branch, force = true } = options;
+	await executeGitCommand([
+		"branch",
+		force ? "-D" : "-d",
+		branch
+	], { cwd: gitRoot });
+}
+//#endregion
 //#region ../git/src/libs/fetch.ts
 async function fetch(options = {}) {
 	const { remote = "origin", refspec, cwd } = options;
@@ -4463,6 +4471,51 @@ async function fetch(options = {}) {
 	}
 }
 //#endregion
+//#region ../git/src/libs/get-current-branch.ts
+async function getCurrentBranch(options = {}) {
+	const { stdout } = await executeGitCommand(["branch", "--show-current"], { cwd: options.cwd });
+	return stdout;
+}
+//#endregion
+//#region ../git/src/libs/get-git-root.ts
+async function getGitRoot() {
+	const { stdout } = await executeGitCommand(["rev-parse", "--git-common-dir"]);
+	if (stdout.endsWith("/.git") || stdout === ".git") return resolve(process.cwd(), dirname(stdout));
+	const { stdout: toplevel } = await executeGitCommand(["rev-parse", "--show-toplevel"]);
+	return toplevel;
+}
+//#endregion
+//#region ../git/src/libs/get-status.ts
+function parseStatusLine(line) {
+	const indexStatus = line[0] ?? " ";
+	const workingTreeStatus = line[1] ?? " ";
+	const pathPart = line.slice(3);
+	const renamedPaths = indexStatus === "R" || indexStatus === "C" || workingTreeStatus === "R" || workingTreeStatus === "C" ? pathPart.match(/^(?<originalPath>.+) -> (?<path>.+)$/) : null;
+	return {
+		indexStatus,
+		workingTreeStatus,
+		path: renamedPaths?.groups?.path ?? pathPart,
+		originalPath: renamedPaths?.groups?.originalPath
+	};
+}
+async function getStatus(options) {
+	const { stdout } = await executeGitCommand(["status", "--porcelain"], {
+		cwd: options.cwd,
+		trimStdout: false
+	});
+	const entries = stdout.split("\n").filter((line) => line.length > 0).map(parseStatusLine);
+	return {
+		entries,
+		isClean: entries.length === 0
+	};
+}
+//#endregion
+//#region ../git/src/libs/get-top-level.ts
+async function getTopLevel(options = {}) {
+	const { stdout } = await executeGitCommand(["rev-parse", "--show-toplevel"], { cwd: options.cwd });
+	return stdout;
+}
+//#endregion
 //#region ../git/src/libs/list-worktrees.ts
 async function listWorktrees$1(_gitRoot) {
 	const { stdout } = await executeGitCommand([
@@ -4491,25 +4544,13 @@ async function listWorktrees$1(_gitRoot) {
 	return worktrees;
 }
 //#endregion
-//#region ../git/src/libs/get-current-worktree.ts
-async function getCurrentWorktree(gitRoot) {
-	try {
-		const { stdout: currentPath } = await executeGitCommand(["rev-parse", "--show-toplevel"]);
-		const currentPathTrimmed = currentPath.trim();
-		const currentWorktree = (await listWorktrees$1(gitRoot)).find((wt) => wt.path === currentPathTrimmed);
-		if (!currentWorktree || currentWorktree.path === gitRoot) return null;
-		return currentWorktree.branch;
-	} catch {
-		return null;
-	}
-}
-//#endregion
-//#region ../git/src/libs/get-git-root.ts
-async function getGitRoot() {
-	const { stdout } = await executeGitCommand(["rev-parse", "--git-common-dir"]);
-	if (stdout.endsWith("/.git") || stdout === ".git") return resolve(process.cwd(), dirname(stdout));
-	const { stdout: toplevel } = await executeGitCommand(["rev-parse", "--show-toplevel"]);
-	return toplevel;
+//#region ../git/src/libs/remove-worktree.ts
+async function removeWorktree$1(options) {
+	const { gitRoot, path, force = false } = options;
+	const args = ["worktree", "remove"];
+	if (force) args.push("--force");
+	args.push(path);
+	await executeGitCommand(args, { cwd: gitRoot });
 }
 //#endregion
 //#region ../git/src/libs/set-upstream-branch.ts
@@ -4538,7 +4579,8 @@ const preferencesSchema = object$1({
 	editor: string().optional(),
 	ai: string().optional(),
 	worktreesDirectory: string().optional(),
-	directoryNameSeparator: string().optional()
+	directoryNameSeparator: string().optional(),
+	keepBranch: boolean().optional()
 }).passthrough();
 function parsePreferences(output) {
 	if (!output) return {};
@@ -4556,20 +4598,18 @@ function parsePreferences(output) {
 		else if (strippedKey === "ai") preferences.ai = value;
 		else if (strippedKey === "worktreesdirectory") preferences.worktreesDirectory = value;
 		else if (strippedKey === "directorynameseparator") preferences.directoryNameSeparator = value;
+		else if (strippedKey === "keepbranch") preferences.keepBranch = value === "true" ? true : value === "false" ? false : void 0;
 	}
 	const parsed = preferencesSchema.safeParse(preferences);
 	if (!parsed.success) throw new PreferencesValidationError(parsed.error.issues[0]?.message ?? parsed.error.message);
 	return parsed.data;
 }
 async function loadPreferences() {
-	const { stdout } = await executeGitCommand([
-		"config",
-		"--global",
-		"--null",
-		"--get-regexp",
-		"^phantom\\."
-	]);
-	return parsePreferences(stdout);
+	return parsePreferences(await configGetRegexp({
+		pattern: "^phantom\\.",
+		global: true,
+		nullSeparated: true
+	}));
 }
 //#endregion
 //#region ../core/src/context.ts
@@ -4703,35 +4743,6 @@ async function spawnProcess(config) {
 	});
 }
 //#endregion
-//#region ../process/src/tmux.ts
-async function isInsideTmux() {
-	return process.env.TMUX !== void 0;
-}
-async function executeTmuxCommand(options) {
-	const { direction, command, args, cwd, env, windowName } = options;
-	const tmuxArgs = [];
-	switch (direction) {
-		case "new":
-			tmuxArgs.push("new-window");
-			if (windowName) tmuxArgs.push("-n", windowName);
-			break;
-		case "vertical":
-			tmuxArgs.push("split-window", "-v");
-			break;
-		case "horizontal":
-			tmuxArgs.push("split-window", "-h");
-			break;
-	}
-	if (cwd) tmuxArgs.push("-c", cwd);
-	if (env) for (const [key, value] of Object.entries(env)) tmuxArgs.push("-e", `${key}=${value}`);
-	tmuxArgs.push(command);
-	if (args && args.length > 0) tmuxArgs.push(...args);
-	return await spawnProcess({
-		command: "tmux",
-		args: tmuxArgs
-	});
-}
-//#endregion
 //#region ../core/src/worktree/errors.ts
 var WorktreeError = class extends Error {
 	constructor(message) {
@@ -4757,12 +4768,23 @@ var BranchNotFoundError = class extends WorktreeError {
 		this.name = "BranchNotFoundError";
 	}
 };
+var WorktreeActionConflictError = class extends WorktreeError {
+	constructor() {
+		super("Cannot use --shell, --exec, and --tmux options together");
+		this.name = "WorktreeActionConflictError";
+	}
+};
+var TmuxSessionRequiredError = class extends WorktreeError {
+	constructor() {
+		super("The --tmux option can only be used inside a tmux session");
+		this.name = "TmuxSessionRequiredError";
+	}
+};
 //#endregion
 //#region ../core/src/worktree/list.ts
 async function getWorktreeStatus(worktreePath) {
 	try {
-		const { stdout } = await executeGitCommandInDirectory(worktreePath, ["status", "--porcelain"]);
-		return !stdout;
+		return (await getStatus({ cwd: worktreePath })).isClean;
 	} catch {
 		return true;
 	}
@@ -4862,6 +4884,91 @@ async function shellInWorktree(gitRoot, worktreeDirectory, worktreeName) {
 	});
 }
 //#endregion
+//#region ../tmux/src/tmux.ts
+async function isInsideTmux() {
+	return process.env.TMUX !== void 0;
+}
+async function executeTmuxCommand(options) {
+	const { direction, command, args, cwd, env, windowName } = options;
+	const tmuxArgs = [];
+	switch (direction) {
+		case "new":
+			tmuxArgs.push("new-window");
+			if (windowName) tmuxArgs.push("-n", windowName);
+			break;
+		case "vertical":
+			tmuxArgs.push("split-window", "-v");
+			break;
+		case "horizontal":
+			tmuxArgs.push("split-window", "-h");
+			break;
+	}
+	if (cwd) tmuxArgs.push("-c", cwd);
+	if (env) for (const [key, value] of Object.entries(env)) tmuxArgs.push("-e", `${key}=${value}`);
+	tmuxArgs.push(command);
+	if (args && args.length > 0) tmuxArgs.push(...args);
+	return spawnProcess({
+		command: "tmux",
+		args: tmuxArgs
+	});
+}
+//#endregion
+//#region ../core/src/worktree/action.ts
+function mergeWorktreeCopyFiles(configuredFiles, requestedFiles) {
+	const files = [...new Set([...configuredFiles ?? [], ...requestedFiles ?? []])];
+	return files.length > 0 ? files : void 0;
+}
+function resolveWorktreeAction(options) {
+	const actions = [];
+	if (options?.shell) actions.push({ kind: "shell" });
+	if (options?.exec !== void 0) actions.push({
+		kind: "exec",
+		command: options.exec
+	});
+	if (options?.tmuxDirection) actions.push({
+		kind: "tmux",
+		direction: options.tmuxDirection
+	});
+	if (actions.length > 1) return err(new WorktreeActionConflictError());
+	return ok(actions[0]);
+}
+async function validateWorktreeAction(action) {
+	if (action?.kind === "tmux" && !await isInsideTmux()) return err(new TmuxSessionRequiredError());
+	return ok(void 0);
+}
+async function runWorktreeAction(options) {
+	const { gitRoot, worktreeDirectory, worktreeName, worktreePath, action, logger, exitWithProcessCode = false } = options;
+	if (!action) return ok({});
+	if (action.kind === "shell") {
+		logger?.log(`\nEntering worktree '${worktreeName}' at ${worktreePath}`);
+		logger?.log("Type 'exit' to return to your original directory\n");
+		const shellResult = await shellInWorktree(gitRoot, worktreeDirectory, worktreeName);
+		if (isErr(shellResult)) return err(shellResult.error);
+		return ok({ exitProcessCode: exitWithProcessCode ? shellResult.value.exitCode ?? 0 : void 0 });
+	}
+	if (action.kind === "exec") {
+		logger?.log(`\nExecuting command in worktree '${worktreeName}': ${action.command}`);
+		const execResult = await execInWorktree(gitRoot, worktreeDirectory, worktreeName, [
+			process.env.SHELL || "/bin/sh",
+			"-c",
+			action.command
+		], { interactive: true });
+		if (isErr(execResult)) return err(execResult.error);
+		return ok({ exitProcessCode: exitWithProcessCode ? execResult.value.exitCode ?? 0 : void 0 });
+	}
+	logger?.log(`\nOpening worktree '${worktreeName}' in tmux ${action.direction === "new" ? "window" : "pane"}...`);
+	const shell = process.env.SHELL || "/bin/sh";
+	const tmuxResult = await executeTmuxCommand({
+		direction: action.direction,
+		command: shell,
+		cwd: worktreePath,
+		env: getPhantomEnv(worktreeName, worktreePath),
+		windowName: action.direction === "new" ? worktreeName : void 0
+	});
+	if (isErr(tmuxResult)) return err(tmuxResult.error);
+	return ok({});
+}
+//#endregion
 //#region ../core/src/worktree/file-copier.ts
 var FileCopyError = class extends Error {
 	file;
@@ -4898,10 +5005,10 @@ async function copyFiles(sourceDir, targetDir, files) {
 //#endregion
 //#region ../core/src/worktree/post-create.ts
 async function executePostCreateCommands(options) {
-	const { gitRoot, worktreesDirectory, worktreeName, commands } = options;
+	const { gitRoot, worktreesDirectory, worktreeName, commands, logger } = options;
 	const executedCommands = [];
 	for (const command of commands) {
-		console.log(`Executing: ${command}`);
+		logger?.log(`Executing: ${command}`);
 		const cmdResult = await execInWorktree(gitRoot, worktreesDirectory, worktreeName, [
 			process.env.SHELL || "/bin/sh",
 			"-c",
@@ -4916,14 +5023,9 @@ async function executePostCreateCommands(options) {
 	}
 	return ok({ executedCommands });
 }
-async function copyFilesToWorktree(gitRoot, worktreesDirectory, worktreeName, filesToCopy, directoryNameSeparator) {
-	const copyResult = await copyFiles(gitRoot, getWorktreePathFromDirectory(worktreesDirectory, worktreeName, directoryNameSeparator), filesToCopy);
-	if (isErr(copyResult)) return err(copyResult.error);
-	return ok(void 0);
-}
 //#endregion
 //#region ../core/src/worktree/attach.ts
-async function attachWorktreeCore(gitRoot, worktreeDirectory, name, postCreateCopyFiles, postCreateCommands, directoryNameSeparator) {
+async function attachWorktreeCore(gitRoot, worktreeDirectory, name, postCreateCopyFiles, postCreateCommands, directoryNameSeparator, logger) {
 	const validation = validateWorktreeName(name);
 	if (isErr(validation)) return validation;
 	const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name, directoryNameSeparator);
@@ -4931,170 +5033,59 @@ async function attachWorktreeCore(gitRoot, worktreeDirectory, name, postCreateCo
 	const branchCheckResult = await branchExists(gitRoot, name);
 	if (isErr(branchCheckResult)) return err(branchCheckResult.error);
 	if (!branchCheckResult.value) return err(new BranchNotFoundError(name));
-	const attachResult = await attachWorktree(gitRoot, worktreePath, name);
-	if (isErr(attachResult)) return err(attachResult.error);
+	try {
+		await addWorktree({
+			path: worktreePath,
+			branch: name,
+			createBranch: false,
+			cwd: gitRoot
+		});
+	} catch (error) {
+		return err(error instanceof Error ? error : /* @__PURE__ */ new Error(`Failed to attach worktree: ${String(error)}`));
+	}
 	if (postCreateCopyFiles && postCreateCopyFiles.length > 0) {
-		const copyResult = await copyFilesToWorktree(gitRoot, worktreeDirectory, name, postCreateCopyFiles, directoryNameSeparator);
-		if (isErr(copyResult)) console.warn(`Warning: Failed to copy some files: ${copyResult.error.message}`);
+		const copyResult = await copyFiles(gitRoot, worktreePath, postCreateCopyFiles);
+		if (isErr(copyResult)) logger?.warn?.(`Warning: Failed to copy some files: ${copyResult.error.message}`);
 	}
 	if (postCreateCommands && postCreateCommands.length > 0) {
-		console.log("\nRunning post-create commands...");
+		logger?.log?.("\nRunning post-create commands...");
 		const commandsResult = await executePostCreateCommands({
 			gitRoot,
 			worktreesDirectory: worktreeDirectory,
 			worktreeName: name,
-			commands: postCreateCommands
+			commands: postCreateCommands,
+			logger
 		});
 		if (isErr(commandsResult)) return err(new WorktreeError(commandsResult.error.message));
 	}
 	return ok(worktreePath);
 }
-//#endregion
-//#region ../core/src/worktree/create.ts
-async function createWorktree(gitRoot, worktreeDirectory, name, options, postCreateCopyFiles, postCreateCommands, directoryNameSeparator) {
-	const nameValidation = validateWorktreeName(name);
-	if (isErr(nameValidation)) return nameValidation;
-	const { branch = name, base = "HEAD" } = options;
-	const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name, directoryNameSeparator);
-	try {
-		await fs.access(worktreeDirectory);
-	} catch {
-		await fs.mkdir(worktreeDirectory, { recursive: true });
-	}
-	const validation = await validateWorktreeDoesNotExist(gitRoot, worktreeDirectory, name);
-	if (isErr(validation)) return err(validation.error);
-	try {
-		await addWorktree({
-			path: worktreePath,
-			branch,
-			base
-		});
-		let copiedFiles;
-		let skippedFiles;
-		let copyError;
-		if (options.copyFiles && options.copyFiles.length > 0) {
-			const copyResult = await copyFiles(gitRoot, worktreePath, options.copyFiles);
-			if (isOk(copyResult)) {
-				copiedFiles = copyResult.value.copiedFiles;
-				skippedFiles = copyResult.value.skippedFiles;
-			} else copyError = copyResult.error.message;
-		}
-		if (postCreateCopyFiles && postCreateCopyFiles.length > 0) {
-			const copyResult = await copyFilesToWorktree(gitRoot, worktreeDirectory, name, postCreateCopyFiles, directoryNameSeparator);
-			if (isErr(copyResult)) {
-				if (!copyError) copyError = copyResult.error.message;
-			}
-		}
-		if (postCreateCommands && postCreateCommands.length > 0) {
-			console.log("\nRunning post-create commands...");
-			const commandsResult = await executePostCreateCommands({
-				gitRoot,
-				worktreesDirectory: worktreeDirectory,
-				worktreeName: name,
-				commands: postCreateCommands
-			});
-			if (isErr(commandsResult)) return err(new WorktreeError(commandsResult.error.message));
-		}
-		return ok({
-			message: `Created worktree '${name}' at ${worktreePath}`,
-			path: worktreePath,
-			copiedFiles,
-			skippedFiles,
-			copyError
-		});
-	} catch (error) {
-		return err(new WorktreeError(`worktree add failed: ${error instanceof Error ? error.message : String(error)}`));
-	}
-}
-//#endregion
-//#region ../core/src/worktree/pre-delete.ts
-async function executePreDeleteCommands(options) {
-	const { gitRoot, worktreesDirectory, worktreeName, commands } = options;
-	const executedCommands = [];
-	for (const command of commands) {
-		console.log(`Executing pre-delete command: ${command}`);
-		const cmdResult = await execInWorktree(gitRoot, worktreesDirectory, worktreeName, [
-			process.env.SHELL || "/bin/sh",
-			"-c",
-			command
-		]);
-		if (isErr(cmdResult)) {
-			const errorMessage = cmdResult.error instanceof Error ? cmdResult.error.message : String(cmdResult.error);
-			return err(/* @__PURE__ */ new Error(`Failed to execute pre-delete command "${command}": ${errorMessage}`));
-		}
-		if (cmdResult.value.exitCode !== 0) return err(/* @__PURE__ */ new Error(`Pre-delete command failed with exit code ${cmdResult.value.exitCode}: ${command}`));
-		executedCommands.push(command);
-	}
-	return ok({ executedCommands });
-}
-//#endregion
-//#region ../core/src/worktree/delete.ts
-async function getWorktreeChangesStatus(worktreePath) {
+async function runAttachWorktree(options) {
+	const actionResult = resolveWorktreeAction(options.action);
+	if (isErr(actionResult)) return actionResult;
+	const actionValidation = await validateWorktreeAction(actionResult.value);
+	if (isErr(actionValidation)) return actionValidation;
 	try {
-		const { stdout } = await executeGitCommandInDirectory(worktreePath, ["status", "--porcelain"]);
-		if (stdout) return {
-			hasUncommittedChanges: true,
-			changedFiles: stdout.split("\n").length
-		};
-	} catch {}
-	return {
-		hasUncommittedChanges: false,
-		changedFiles: 0
-	};
-}
-async function removeWorktree(gitRoot, worktreePath, force = false) {
-	const args = ["worktree", "remove"];
-	if (force) args.push("--force");
-	args.push(worktreePath);
-	await executeGitCommand(args, { cwd: gitRoot });
-}
-async function deleteBranch(gitRoot, branchName) {
-	try {
-		await executeGitCommand([
-			"branch",
-			"-D",
-			branchName
-		], { cwd: gitRoot });
-		return ok(true);
-	} catch (error) {
-		return err(new WorktreeError(`branch delete failed: ${error instanceof Error ? error.message : String(error)}`));
-	}
-}
-async function deleteWorktree(gitRoot, worktreeDirectory, name, options, preDeleteCommands) {
-	const { force = false } = options || {};
-	const validation = await validateWorktreeExists(gitRoot, worktreeDirectory, name, { excludeDefault: true });
-	if (isErr(validation)) return err(validation.error);
-	const worktreePath = validation.value.path;
-	const status = await getWorktreeChangesStatus(worktreePath);
-	if (status.hasUncommittedChanges && !force) return err(new WorktreeError(`Worktree '${name}' has uncommitted changes (${status.changedFiles} files). Use --force to delete anyway.`));
-	if (preDeleteCommands && preDeleteCommands.length > 0) {
-		console.log("\nRunning pre-delete commands...");
-		const preDeleteResult = await executePreDeleteCommands({
-			gitRoot,
-			worktreesDirectory: worktreeDirectory,
-			worktreeName: name,
-			commands: preDeleteCommands
+		const context = await createContext(await getGitRoot());
+		const filesToCopy = mergeWorktreeCopyFiles(context.config?.postCreate?.copyFiles, options.copyFiles);
+		const attachResult = await attachWorktreeCore(context.gitRoot, context.worktreesDirectory, options.name, filesToCopy, context.config?.postCreate?.commands, context.directoryNameSeparator, options.logger);
+		if (isErr(attachResult)) return err(attachResult.error);
+		options.logger?.log(`Attached phantom: ${options.name}`);
+		const worktreeActionResult = await runWorktreeAction({
+			gitRoot: context.gitRoot,
+			worktreeDirectory: context.worktreesDirectory,
+			worktreeName: options.name,
+			worktreePath: attachResult.value,
+			action: actionResult.value,
+			logger: options.logger
 		});
-		if (isErr(preDeleteResult)) return err(new WorktreeError(preDeleteResult.error.message));
-	}
-	try {
-		await removeWorktree(gitRoot, worktreePath, force);
-		const branchName = name;
-		const branchResult = await deleteBranch(gitRoot, branchName);
-		let message;
-		if (isOk(branchResult)) message = `Deleted worktree '${name}' and its branch '${branchName}'`;
-		else {
-			message = `Deleted worktree '${name}'`;
-			message += `\nNote: Branch '${branchName}' could not be deleted: ${branchResult.error.message}`;
-		}
-		if (status.hasUncommittedChanges) message = `Warning: Worktree '${name}' had uncommitted changes (${status.changedFiles} files)\n${message}`;
+		if (isErr(worktreeActionResult)) return err(worktreeActionResult.error);
 		return ok({
-			message,
-			hasUncommittedChanges: status.hasUncommittedChanges,
-			changedFiles: status.hasUncommittedChanges ? status.changedFiles : void 0
+			name: options.name,
+			path: attachResult.value
 		});
 	} catch (error) {
-		return err(new WorktreeError(`worktree remove failed: ${error instanceof Error ? error.message : String(error)}`));
+		return err(error instanceof Error ? error : new Error(String(error)));
 	}
 }
 //#endregion
@@ -5956,6 +5947,208 @@ async function generateUniqueName(gitRoot, worktreesDirectory, directoryNameSepa
 	return err(/* @__PURE__ */ new Error("Failed to generate a unique worktree name after maximum retries"));
 }
 //#endregion
+//#region ../core/src/worktree/create.ts
+async function createWorktree(gitRoot, worktreeDirectory, name, options, postCreateCopyFiles, postCreateCommands, directoryNameSeparator) {
+	const nameValidation = validateWorktreeName(name);
+	if (isErr(nameValidation)) return nameValidation;
+	const { branch = name, base = "HEAD", copyFiles: requestedCopyFiles, logger } = options;
+	const worktreePath = getWorktreePathFromDirectory(worktreeDirectory, name, directoryNameSeparator);
+	try {
+		await fs.access(worktreeDirectory);
+	} catch {
+		await fs.mkdir(worktreeDirectory, { recursive: true });
+	}
+	const validation = await validateWorktreeDoesNotExist(gitRoot, worktreeDirectory, name);
+	if (isErr(validation)) return err(validation.error);
+	try {
+		await addWorktree({
+			path: worktreePath,
+			branch,
+			base
+		});
+		let copiedFiles;
+		let skippedFiles;
+		let copyError;
+		const filesToCopy = mergeWorktreeCopyFiles(requestedCopyFiles, postCreateCopyFiles);
+		if (filesToCopy) {
+			const copyResult = await copyFiles(gitRoot, worktreePath, filesToCopy);
+			if (isOk(copyResult)) {
+				copiedFiles = copyResult.value.copiedFiles;
+				skippedFiles = copyResult.value.skippedFiles;
+			} else copyError = copyResult.error.message;
+		}
+		if (postCreateCommands && postCreateCommands.length > 0) {
+			logger?.log?.("\nRunning post-create commands...");
+			const commandsResult = await executePostCreateCommands({
+				gitRoot,
+				worktreesDirectory: worktreeDirectory,
+				worktreeName: name,
+				commands: postCreateCommands,
+				logger
+			});
+			if (isErr(commandsResult)) return err(new WorktreeError(commandsResult.error.message));
+		}
+		return ok({
+			message: `Created worktree '${name}' at ${worktreePath}`,
+			path: worktreePath,
+			copiedFiles,
+			skippedFiles,
+			copyError
+		});
+	} catch (error) {
+		return err(new WorktreeError(`worktree add failed: ${error instanceof Error ? error.message : String(error)}`));
+	}
+}
+async function runCreateWorktree(options) {
+	const actionResult = resolveWorktreeAction(options.action);
+	if (isErr(actionResult)) return actionResult;
+	const actionValidation = await validateWorktreeAction(actionResult.value);
+	if (isErr(actionValidation)) return actionValidation;
+	try {
+		const context = await createContext(await getGitRoot());
+		let worktreeName = options.name;
+		if (!worktreeName) {
+			const nameResult = await generateUniqueName(context.gitRoot, context.worktreesDirectory, context.directoryNameSeparator);
+			if (isErr(nameResult)) return err(nameResult.error);
+			worktreeName = nameResult.value;
+		}
+		const filesToCopy = mergeWorktreeCopyFiles(context.config?.postCreate?.copyFiles, options.copyFiles);
+		const createResult = await createWorktree(context.gitRoot, context.worktreesDirectory, worktreeName, {
+			base: options.base,
+			copyFiles: filesToCopy,
+			logger: options.logger
+		}, void 0, context.config?.postCreate?.commands, context.directoryNameSeparator);
+		if (isErr(createResult)) return err(createResult.error);
+		options.logger?.log(createResult.value.message);
+		if (createResult.value.copyError) options.logger?.warn?.(`\nWarning: Failed to copy some files: ${createResult.value.copyError}`);
+		const worktreeActionResult = await runWorktreeAction({
+			gitRoot: context.gitRoot,
+			worktreeDirectory: context.worktreesDirectory,
+			worktreeName,
+			worktreePath: createResult.value.path,
+			action: actionResult.value,
+			logger: options.logger,
+			exitWithProcessCode: true
+		});
+		if (isErr(worktreeActionResult)) return err(worktreeActionResult.error);
+		return ok({
+			name: worktreeName,
+			path: createResult.value.path,
+			message: createResult.value.message,
+			copyError: createResult.value.copyError,
+			exitProcessCode: worktreeActionResult.value.exitProcessCode
+		});
+	} catch (error) {
+		return err(error instanceof Error ? error : new Error(String(error)));
+	}
+}
+//#endregion
+//#region ../core/src/worktree/current.ts
+async function getCurrentWorktreeName(gitRoot) {
+	try {
+		const currentTopLevel = await getTopLevel();
+		if (currentTopLevel === gitRoot) return null;
+		return await getCurrentBranch({ cwd: currentTopLevel }) || null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region ../core/src/worktree/pre-delete.ts
+async function executePreDeleteCommands(options) {
+	const { gitRoot, worktreesDirectory, worktreeName, commands } = options;
+	const executedCommands = [];
+	for (const command of commands) {
+		console.log(`Executing pre-delete command: ${command}`);
+		const cmdResult = await execInWorktree(gitRoot, worktreesDirectory, worktreeName, [
+			process.env.SHELL || "/bin/sh",
+			"-c",
+			command
+		]);
+		if (isErr(cmdResult)) {
+			const errorMessage = cmdResult.error instanceof Error ? cmdResult.error.message : String(cmdResult.error);
+			return err(/* @__PURE__ */ new Error(`Failed to execute pre-delete command "${command}": ${errorMessage}`));
+		}
+		if (cmdResult.value.exitCode !== 0) return err(/* @__PURE__ */ new Error(`Pre-delete command failed with exit code ${cmdResult.value.exitCode}: ${command}`));
+		executedCommands.push(command);
+	}
+	return ok({ executedCommands });
+}
+//#endregion
+//#region ../core/src/worktree/delete.ts
+async function getWorktreeChangesStatus(worktreePath) {
+	try {
+		const status = await getStatus({ cwd: worktreePath });
+		if (!status.isClean) return {
+			hasUncommittedChanges: true,
+			changedFiles: status.entries.length
+		};
+	} catch {}
+	return {
+		hasUncommittedChanges: false,
+		changedFiles: 0
+	};
+}
+async function removeWorktree(gitRoot, worktreePath, force = false) {
+	await removeWorktree$1({
+		gitRoot,
+		path: worktreePath,
+		force
+	});
+}
+async function deleteBranch(gitRoot, branchName) {
+	try {
+		await deleteBranch$1({
+			gitRoot,
+			branch: branchName
+		});
+		return ok(true);
+	} catch (error) {
+		return err(new WorktreeError(`branch delete failed: ${error instanceof Error ? error.message : String(error)}`));
+	}
+}
+async function deleteWorktree(gitRoot, worktreeDirectory, name, options, preDeleteCommands) {
+	const { force = false } = options || {};
+	const keepBranch = options?.keepBranch ?? false;
+	const validation = await validateWorktreeExists(gitRoot, worktreeDirectory, name, { excludeDefault: true });
+	if (isErr(validation)) return err(validation.error);
+	const worktreePath = validation.value.path;
+	const status = await getWorktreeChangesStatus(worktreePath);
+	if (status.hasUncommittedChanges && !force) return err(new WorktreeError(`Worktree '${name}' has uncommitted changes (${status.changedFiles} files). Use --force to delete anyway.`));
+	if (preDeleteCommands && preDeleteCommands.length > 0) {
+		console.log("\nRunning pre-delete commands...");
+		const preDeleteResult = await executePreDeleteCommands({
+			gitRoot,
+			worktreesDirectory: worktreeDirectory,
+			worktreeName: name,
+			commands: preDeleteCommands
+		});
+		if (isErr(preDeleteResult)) return err(new WorktreeError(preDeleteResult.error.message));
+	}
+	try {
+		await removeWorktree(gitRoot, worktreePath, force);
+		const branchName = name;
+		let message;
+		if (keepBranch) message = `Deleted worktree '${name}' and kept its branch '${branchName}'`;
+		else {
+			const branchResult = await deleteBranch(gitRoot, branchName);
+			if (isOk(branchResult)) message = `Deleted worktree '${name}' and its branch '${branchName}'`;
+			else {
+				message = `Deleted worktree '${name}'`;
+				message += `\nNote: Branch '${branchName}' could not be deleted: ${branchResult.error.message}`;
+			}
+		}
+		if (status.hasUncommittedChanges) message = `Warning: Worktree '${name}' had uncommitted changes (${status.changedFiles} files)\n${message}`;
+		return ok({
+			message,
+			hasUncommittedChanges: status.hasUncommittedChanges,
+			changedFiles: status.hasUncommittedChanges ? status.changedFiles : void 0
+		});
+	} catch (error) {
+		return err(new WorktreeError(`worktree remove failed: ${error instanceof Error ? error.message : String(error)}`));
+	}
+}
+//#endregion
 //#region ../core/src/worktree/select.ts
 async function selectWorktreeWithFzf(gitRoot, options = {}) {
 	const listResult = await listWorktrees(gitRoot, { excludeDefault: options.excludeDefault });
@@ -6000,6 +6193,14 @@ async function whereWorktree(gitRoot, worktreeDirectory, name) {
 	return ok({ path: validation.value.path });
 }
 //#endregion
+//#region src/constants/exit-codes.ts
+const exitCodes = {
+	success: 0,
+	generalError: 1,
+	notFound: 2,
+	validationError: 3
+};
+//#endregion
 //#region src/output.ts
 const output = {
 	log: (message) => {
@@ -6021,6 +6222,10 @@ const output = {
 };
 //#endregion
 //#region src/errors.ts
+function getProcessExitCode(error) {
+	if (!error || typeof error !== "object" || !("exitCode" in error) || typeof error.exitCode !== "number") return;
+	return error.exitCode;
+}
 function exitWithSuccess() {
 	process.exit(exitCodes.success);
 }
@@ -6105,54 +6310,23 @@ async function attachHandler(args) {
 			}
 		}
 	});
-	if (positionals.length === 0) exitWithError("Missing required argument: branch name", exitCodes.validationError);
 	const [branchName] = positionals;
-	const tmuxOption = values.tmux || values["tmux-vertical"] || values["tmux-v"] || values["tmux-horizontal"] || values["tmux-h"];
-	const copyFileOptions = values["copy-file"];
+	if (!branchName) exitWithError("Missing required argument: branch name", exitCodes.validationError);
 	const tmuxDirection = values.tmux ? "new" : values["tmux-vertical"] || values["tmux-v"] ? "vertical" : values["tmux-horizontal"] || values["tmux-h"] ? "horizontal" : void 0;
-	if ([
-		values.shell,
-		values.exec,
-		tmuxOption
-	].filter(Boolean).length > 1) exitWithError("Cannot use --shell, --exec, and --tmux options together", exitCodes.validationError);
-	const context = await createContext(await getGitRoot());
-	let copyFiles = context.config?.postCreate?.copyFiles ?? [];
-	if (copyFileOptions && copyFileOptions.length > 0) {
-		const cliCopyFiles = Array.isArray(copyFileOptions) ? copyFileOptions : [copyFileOptions];
-		copyFiles = [...new Set([...copyFiles, ...cliCopyFiles])];
-	}
-	const postCreateCopyFiles = copyFiles.length > 0 ? copyFiles : void 0;
-	if (tmuxOption && !await isInsideTmux()) exitWithError("The --tmux option can only be used inside a tmux session", exitCodes.validationError);
-	const result = await attachWorktreeCore(context.gitRoot, context.worktreesDirectory, branchName, postCreateCopyFiles, context.config?.postCreate?.commands, context.directoryNameSeparator);
+	const result = await runAttachWorktree({
+		name: branchName,
+		copyFiles: values["copy-file"],
+		action: {
+			shell: values.shell ?? false,
+			exec: values.exec,
+			tmuxDirection
+		},
+		logger: output
+	});
 	if (isErr(result)) {
-		const error = result.error;
-		if (error instanceof WorktreeAlreadyExistsError) exitWithError(error.message, exitCodes.validationError);
-		if (error instanceof BranchNotFoundError) exitWithError(error.message, exitCodes.notFound);
-		exitWithError(error.message, exitCodes.generalError);
-	}
-	output.log(`Attached phantom: ${branchName}`);
-	const worktreePath = result.value;
-	if (values.shell) {
-		const shellResult = await shellInWorktree(context.gitRoot, context.worktreesDirectory, branchName);
-		if (isErr(shellResult)) exitWithError(shellResult.error.message, exitCodes.generalError);
-	} else if (values.exec) {
-		const shell = process.env.SHELL || "/bin/sh";
-		const execResult = await execInWorktree(context.gitRoot, context.worktreesDirectory, branchName, [
-			shell,
-			"-c",
-			values.exec
-		], { interactive: true });
-		if (isErr(execResult)) exitWithError(execResult.error.message, exitCodes.generalError);
-	} else if (tmuxDirection) {
-		output.log(`Opening worktree '${branchName}' in tmux ${tmuxDirection === "new" ? "window" : "pane"}...`);
-		const tmuxResult = await executeTmuxCommand({
-			direction: tmuxDirection,
-			command: process.env.SHELL || "/bin/sh",
-			cwd: worktreePath,
-			env: getPhantomEnv(branchName, worktreePath),
-			windowName: tmuxDirection === "new" ? branchName : void 0
-		});
-		if (isErr(tmuxResult)) exitWithError(tmuxResult.error.message, exitCodes.generalError);
+		if (result.error instanceof WorktreeAlreadyExistsError || result.error instanceof WorktreeActionConflictError || result.error instanceof TmuxSessionRequiredError) exitWithError(result.error.message, exitCodes.validationError);
+		if (result.error instanceof BranchNotFoundError) exitWithError(result.error.message, exitCodes.notFound);
+		exitWithError(result.error.message, getProcessExitCode(result.error) ?? exitCodes.generalError);
 	}
 }
 //#endregion
@@ -6305,7 +6479,7 @@ _phantom_completion() {
             ;;
         delete)
             if [[ "\${cur}" == -* ]]; then
-                local opts="--force --current --fzf"
+                local opts="--force --keep-branch --current --fzf"
                 COMPREPLY=( $(compgen -W "\${opts}" -- "\${cur}") )
             else
                 local worktrees=$(_phantom_list_worktrees_no_default)
@@ -6431,19 +6605,19 @@ _phantom_completion() {
                 return 0
             elif [[ \${words[2]} == "get" ]]; then
                 if [[ \${cword} -eq 3 ]]; then
-                    local keys="editor ai worktreesDirectory directoryNameSeparator"
+                    local keys="editor ai worktreesDirectory directoryNameSeparator keepBranch"
                     COMPREPLY=( $(compgen -W "\${keys}" -- "\${cur}") )
                     return 0
                 fi
             elif [[ \${words[2]} == "set" ]]; then
                 if [[ \${cword} -eq 3 ]]; then
-                    local keys="editor ai worktreesDirectory directoryNameSeparator"
+                    local keys="editor ai worktreesDirectory directoryNameSeparator keepBranch"
                     COMPREPLY=( $(compgen -W "\${keys}" -- "\${cur}") )
                     return 0
                 fi
             elif [[ \${words[2]} == "remove" ]]; then
                 if [[ \${cword} -eq 3 ]]; then
-                    local keys="editor ai worktreesDirectory directoryNameSeparator"
+                    local keys="editor ai worktreesDirectory directoryNameSeparator keepBranch"
                     COMPREPLY=( $(compgen -W "\${keys}" -- "\${cur}") )
                     return 0
                 fi
@@ -6639,6 +6813,7 @@ complete -c phantom -n "__phantom_using_command where" -a "(__phantom_list_workt
 
 # delete command options
 complete -c phantom -n "__phantom_using_command delete" -l force -d "Force deletion even if worktree has uncommitted changes (-f)"
+complete -c phantom -n "__phantom_using_command delete" -l keep-branch -d "Delete the worktree but keep its branch"
 complete -c phantom -n "__phantom_using_command delete" -l current -d "Delete the current worktree"
 complete -c phantom -n "__phantom_using_command delete" -l fzf -d "Use fzf for interactive selection"
 complete -c phantom -n "__phantom_using_command delete" -a "(__phantom_list_worktrees_no_default)"
@@ -6663,9 +6838,9 @@ complete -c phantom -n "__phantom_using_command ai" -a "(__phantom_list_worktree
 
 # preferences command
 complete -c phantom -n "__phantom_using_command preferences" -a "get set remove" -d "Manage preferences"
-complete -c phantom -n "__phantom_using_command preferences get" -a "editor ai worktreesDirectory directoryNameSeparator" -d "Preference key"
-complete -c phantom -n "__phantom_using_command preferences set" -a "editor ai worktreesDirectory directoryNameSeparator" -d "Preference key"
-complete -c phantom -n "__phantom_using_command preferences remove" -a "editor ai worktreesDirectory directoryNameSeparator" -d "Preference key"
+complete -c phantom -n "__phantom_using_command preferences get" -a "editor ai worktreesDirectory directoryNameSeparator keepBranch" -d "Preference key"
+complete -c phantom -n "__phantom_using_command preferences set" -a "editor ai worktreesDirectory directoryNameSeparator keepBranch" -d "Preference key"
+complete -c phantom -n "__phantom_using_command preferences remove" -a "editor ai worktreesDirectory directoryNameSeparator keepBranch" -d "Preference key"
 
 # shell command options
 complete -c phantom -n "__phantom_using_command shell" -l fzf -d "Use fzf for interactive selection"
@@ -6787,6 +6962,7 @@ _phantom() {
                         worktrees=(\${(f)"$(phantom list --names --no-default 2>/dev/null)"})
                         _arguments \
                             '--force[Force deletion even if worktree has uncommitted changes (-f)]' \
+                            '--keep-branch[Delete the worktree but keep its branch]' \
                             '--current[Delete the current worktree]' \
                             '--fzf[Use fzf for interactive selection]' \
                             '*:worktree:(\${(q)worktrees[@]})'
@@ -6819,7 +6995,7 @@ _phantom() {
                 preferences)
                     _arguments \
                         '1:subcommand:(get set remove)' \
-                        '2:key:(editor ai worktreesDirectory directoryNameSeparator)'
+                        '2:key:(editor ai worktreesDirectory directoryNameSeparator keepBranch)'
                     ;;
                 completion)
                     _arguments \
@@ -6910,89 +7086,24 @@ async function createHandler(args) {
 		strict: true,
 		allowPositionals: true
 	});
-	let worktreeName = positionals[0];
-	const openShell = values.shell ?? false;
-	const execCommand = values.exec;
-	const copyFileOptions = values["copy-file"];
-	const baseOption = values.base;
-	const tmuxOption = values.tmux || values["tmux-vertical"] || values["tmux-v"] || values["tmux-horizontal"] || values["tmux-h"];
-	let tmuxDirection;
-	if (values.tmux) tmuxDirection = "new";
-	else if (values["tmux-vertical"] || values["tmux-v"]) tmuxDirection = "vertical";
-	else if (values["tmux-horizontal"] || values["tmux-h"]) tmuxDirection = "horizontal";
-	if ([
-		openShell,
-		execCommand !== void 0,
-		tmuxOption
-	].filter(Boolean).length > 1) exitWithError("Cannot use --shell, --exec, and --tmux options together", exitCodes.validationError);
-	if (tmuxOption && !await isInsideTmux()) exitWithError("The --tmux option can only be used inside a tmux session", exitCodes.validationError);
-	try {
-		const gitRoot = await getGitRoot();
-		const context = await createContext(gitRoot);
-		if (!worktreeName) {
-			const nameResult = await generateUniqueName(gitRoot, context.worktreesDirectory, context.directoryNameSeparator);
-			if (isErr(nameResult)) exitWithError(nameResult.error.message, exitCodes.generalError);
-			worktreeName = nameResult.value;
-		}
-		let filesToCopy = [];
-		if (context.config?.postCreate?.copyFiles) filesToCopy = [...context.config.postCreate.copyFiles];
-		if (copyFileOptions && copyFileOptions.length > 0) {
-			const cliFiles = Array.isArray(copyFileOptions) ? copyFileOptions : [copyFileOptions];
-			filesToCopy = [...new Set([...filesToCopy, ...cliFiles])];
-		}
-		const result = await createWorktree(context.gitRoot, context.worktreesDirectory, worktreeName, {
-			copyFiles: filesToCopy.length > 0 ? filesToCopy : void 0,
-			base: baseOption
-		}, filesToCopy.length > 0 ? filesToCopy : void 0, context.config?.postCreate?.commands, context.directoryNameSeparator);
-		if (isErr(result)) {
-			const exitCode = result.error instanceof WorktreeAlreadyExistsError ? exitCodes.validationError : exitCodes.generalError;
-			exitWithError(result.error.message, exitCode);
-		}
-		output.log(result.value.message);
-		if (result.value.copyError) output.error(`\nWarning: Failed to copy some files: ${result.value.copyError}`);
-		if (execCommand && isOk(result)) {
-			output.log(`\nExecuting command in worktree '${worktreeName}': ${execCommand}`);
-			const shell = process.env.SHELL || "/bin/sh";
-			const execResult = await execInWorktree(context.gitRoot, context.worktreesDirectory, worktreeName, [
-				shell,
-				"-c",
-				execCommand
-			], { interactive: true });
-			if (isErr(execResult)) {
-				output.error(execResult.error.message);
-				exitWithError("", "exitCode" in execResult.error ? execResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError);
-			}
-			return process.exit(execResult.value.exitCode ?? 0);
-		}
-		if (openShell && isOk(result)) {
-			output.log(`\nEntering worktree '${worktreeName}' at ${result.value.path}`);
-			output.log("Type 'exit' to return to your original directory\n");
-			const shellResult = await shellInWorktree(context.gitRoot, context.worktreesDirectory, worktreeName);
-			if (isErr(shellResult)) {
-				output.error(shellResult.error.message);
-				exitWithError("", "exitCode" in shellResult.error ? shellResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError);
-			}
-			return process.exit(shellResult.value.exitCode ?? 0);
-		}
-		if (tmuxDirection && isOk(result)) {
-			output.log(`\nOpening worktree '${worktreeName}' in tmux ${tmuxDirection === "new" ? "window" : "pane"}...`);
-			const shell = process.env.SHELL || "/bin/sh";
-			const tmuxResult = await executeTmuxCommand({
-				direction: tmuxDirection,
-				command: shell,
-				cwd: result.value.path,
-				env: getPhantomEnv(worktreeName, result.value.path),
-				windowName: tmuxDirection === "new" ? worktreeName : void 0
-			});
-			if (isErr(tmuxResult)) {
-				output.error(tmuxResult.error.message);
-				exitWithError("", "exitCode" in tmuxResult.error ? tmuxResult.error.exitCode ?? exitCodes.generalError : exitCodes.generalError);
-			}
-		}
-		exitWithSuccess();
-	} catch (error) {
-		exitWithError(error instanceof Error ? error.message : String(error), exitCodes.generalError);
+	const tmuxDirection = values.tmux ? "new" : values["tmux-vertical"] || values["tmux-v"] ? "vertical" : values["tmux-horizontal"] || values["tmux-h"] ? "horizontal" : void 0;
+	const result = await runCreateWorktree({
+		name: positionals[0],
+		base: values.base,
+		copyFiles: values["copy-file"],
+		action: {
+			shell: values.shell ?? false,
+			exec: values.exec,
+			tmuxDirection
+		},
+		logger: output
+	});
+	if (isErr(result)) {
+		const exitCode = result.error instanceof WorktreeAlreadyExistsError || result.error instanceof WorktreeActionConflictError || result.error instanceof TmuxSessionRequiredError ? exitCodes.validationError : getProcessExitCode(result.error) ?? exitCodes.generalError;
+		exitWithError(result.error.message, exitCode);
 	}
+	if (result.value.exitProcessCode !== void 0) return process.exit(result.value.exitProcessCode);
+	exitWithSuccess();
 }
 //#endregion
 //#region src/handlers/delete.ts
@@ -7004,6 +7115,7 @@ async function deleteHandler(args) {
 				type: "boolean",
 				short: "f"
 			},
+			"keep-branch": { type: "boolean" },
 			current: { type: "boolean" },
 			fzf: {
 				type: "boolean",
@@ -7022,9 +7134,10 @@ async function deleteHandler(args) {
 	try {
 		const gitRoot = await getGitRoot();
 		const context = await createContext(gitRoot);
+		const keepBranch = values["keep-branch"] ?? context.preferences.keepBranch ?? false;
 		const worktreeNames = [];
 		if (deleteCurrent) {
-			const currentWorktree = await getCurrentWorktree(gitRoot);
+			const currentWorktree = await getCurrentWorktreeName(gitRoot);
 			if (!currentWorktree) exitWithError("Not in a worktree directory. The --current option can only be used from within a worktree.", exitCodes.validationError);
 			worktreeNames.push(currentWorktree);
 		} else if (useFzf) {
@@ -7034,7 +7147,10 @@ async function deleteHandler(args) {
 			worktreeNames.push(selectResult.value.name);
 		} else worktreeNames.push(...positionals);
 		for (const worktreeName of worktreeNames) {
-			const result = await deleteWorktree(context.gitRoot, context.worktreesDirectory, worktreeName, { force: forceDelete }, context.config?.preDelete?.commands);
+			const result = await deleteWorktree(context.gitRoot, context.worktreesDirectory, worktreeName, {
+				force: forceDelete,
+				keepBranch
+			}, context.config?.preDelete?.commands);
 			if (isErr(result)) {
 				const exitCode = result.error instanceof WorktreeNotFoundError ? exitCodes.validationError : result.error instanceof WorktreeError && result.error.message.includes("uncommitted changes") ? exitCodes.validationError : exitCodes.generalError;
 				exitWithError(result.error.message, exitCode);
@@ -24381,7 +24497,7 @@ var StdioServerTransport = class {
 };
 //#endregion
 //#region ../mcp/package.json
-var version$1 = "6.1.1-1";
+var version$1 = "6.2.0-0";
 const createWorktreeTool = {
 	name: "phantom_create_worktree",
 	description: "Create a new Git worktree (phantom)",
@@ -24393,8 +24509,9 @@ const createWorktreeTool = {
 		const context = await createContext(await getGitRoot());
 		const result = await createWorktree(context.gitRoot, context.worktreesDirectory, name, {
 			branch: name,
-			base: baseBranch
-		}, context.config?.postCreate?.copyFiles, context.config?.postCreate?.commands, context.directoryNameSeparator);
+			base: baseBranch,
+			copyFiles: context.config?.postCreate?.copyFiles
+		}, void 0, context.config?.postCreate?.commands, context.directoryNameSeparator);
 		if (!isOk(result)) throw new Error(result.error.message);
 		return { content: [{
 			type: "text",
@@ -24412,11 +24529,15 @@ const deleteWorktreeTool = {
 	description: "Delete a Git worktree (phantom)",
 	inputSchema: object$1({
 		name: string().describe("Name of the worktree to delete"),
-		force: boolean().optional().describe("Force deletion even if there are uncommitted changes")
+		force: boolean().optional().describe("Force deletion even if there are uncommitted changes"),
+		keepBranch: boolean().optional().describe("Keep the branch after deleting the worktree")
 	}),
-	handler: async ({ name, force }) => {
+	handler: async ({ name, force, keepBranch }) => {
 		const context = await createContext(await getGitRoot());
-		const result = await deleteWorktree(context.gitRoot, context.worktreesDirectory, name, { force }, context.config?.preDelete?.commands);
+		const result = await deleteWorktree(context.gitRoot, context.worktreesDirectory, name, {
+			force,
+			keepBranch: keepBranch ?? context.preferences.keepBranch
+		}, context.config?.preDelete?.commands);
 		if (!isOk(result)) throw new Error(result.error.message);
 		return { content: [{
 			type: "text",
@@ -24576,6 +24697,10 @@ const preferencesHelp = {
 			command: "phantom preferences set directoryNameSeparator \"-\"",
 			description: "Store a separator for flattening worktree directory names while keeping branch names unchanged"
 		},
+		{
+			command: "phantom preferences set keepBranch true",
+			description: "Keep branches by default when deleting worktrees with phantom delete or MCP"
+		},
 		{
 			command: "phantom preferences remove editor",
 			description: "Remove the editor preference (fallback to env/default)"
@@ -24592,7 +24717,8 @@ const preferencesHelp = {
 		"  editor - used by 'phantom edit', preferred over $EDITOR",
 		"  ai - used by 'phantom ai'",
 		"  worktreesDirectory - path relative to the Git repo root for storing worktrees (defaults to .git/phantom/worktrees)",
-		"  directoryNameSeparator - replaces '/' in worktree directory names only (defaults to / for nested directories)"
+		"  directoryNameSeparator - replaces '/' in worktree directory names only (defaults to / for nested directories)",
+		"  keepBranch - keeps the branch when deleting a worktree (defaults to false)"
 	]
 };
 const preferencesGetHelp = {
@@ -24615,9 +24741,13 @@ const preferencesGetHelp = {
 		{
 			command: "phantom preferences get directoryNameSeparator",
 			description: "Show the preferred worktree directory name separator"
+		},
+		{
+			command: "phantom preferences get keepBranch",
+			description: "Show whether delete keeps branches by default"
 		}
 	],
-	notes: ["Supported keys: editor, ai, worktreesDirectory, directoryNameSeparator"]
+	notes: ["Supported keys: editor, ai, worktreesDirectory, directoryNameSeparator, keepBranch"]
 };
 const preferencesSetHelp = {
 	name: "preferences set",
@@ -24639,12 +24769,17 @@ const preferencesSetHelp = {
 		{
 			command: "phantom preferences set directoryNameSeparator \"-\"",
 			description: "Flatten worktree directory names such as feature/test to feature-test"
+		},
+		{
+			command: "phantom preferences set keepBranch true",
+			description: "Keep branches when deleting worktrees by default"
 		}
 	],
 	notes: [
-		"Supported keys: editor, ai, worktreesDirectory, directoryNameSeparator",
+		"Supported keys: editor, ai, worktreesDirectory, directoryNameSeparator, keepBranch",
 		"For worktreesDirectory, provide a path relative to the Git repository root; defaults to .git/phantom/worktrees when unset",
-		"For directoryNameSeparator, '/' keeps nested directories; any other string replaces '/' only in the directory path"
+		"For directoryNameSeparator, '/' keeps nested directories; any other string replaces '/' only in the directory path",
+		"For keepBranch, use true to preserve branches on delete or false to keep the default branch deletion behavior"
 	]
 };
 const preferencesRemoveHelp = {
@@ -24667,9 +24802,13 @@ const preferencesRemoveHelp = {
 		{
 			command: "phantom preferences remove directoryNameSeparator",
 			description: "Restore nested worktree directories that follow branch slashes"
+		},
+		{
+			command: "phantom preferences remove keepBranch",
+			description: "Restore the default behavior of deleting branches with worktrees"
 		}
 	],
-	notes: ["Supported keys: editor, ai, worktreesDirectory, directoryNameSeparator"]
+	notes: ["Supported keys: editor, ai, worktreesDirectory, directoryNameSeparator, keepBranch"]
 };
 //#endregion
 //#region src/handlers/preferences.ts
@@ -24686,7 +24825,8 @@ const supportedKeys$2 = [
 	"editor",
 	"ai",
 	"worktreesDirectory",
-	"directoryNameSeparator"
+	"directoryNameSeparator",
+	"keepBranch"
 ];
 async function preferencesGetHandler(args) {
 	const { positionals } = parseArgs({
@@ -24700,7 +24840,7 @@ async function preferencesGetHandler(args) {
 	if (!supportedKeys$2.includes(inputKey)) exitWithError(`Unknown preference '${inputKey}'. Supported keys: ${supportedKeys$2.join(", ")}`, exitCodes.validationError);
 	try {
 		const preferences = await loadPreferences();
-		const value = inputKey === "editor" ? preferences.editor : inputKey === "ai" ? preferences.ai : inputKey === "worktreesDirectory" ? preferences.worktreesDirectory : inputKey === "directoryNameSeparator" ? preferences.directoryNameSeparator : void 0;
+		const value = inputKey === "editor" ? preferences.editor : inputKey === "ai" ? preferences.ai : inputKey === "worktreesDirectory" ? preferences.worktreesDirectory : inputKey === "directoryNameSeparator" ? preferences.directoryNameSeparator : inputKey === "keepBranch" ? preferences.keepBranch?.toString() : void 0;
 		if (value === void 0) output.log(`Preference '${inputKey}' is not set (git config --global phantom.${inputKey})`);
 		else output.log(value);
 		exitWithSuccess();
@@ -24714,7 +24854,8 @@ const supportedKeys$1 = [
 	"editor",
 	"ai",
 	"worktreesDirectory",
-	"directoryNameSeparator"
+	"directoryNameSeparator",
+	"keepBranch"
 ];
 async function preferencesRemoveHandler(args) {
 	const { positionals } = parseArgs({
@@ -24727,12 +24868,10 @@ async function preferencesRemoveHandler(args) {
 	const inputKey = positionals[0];
 	if (!supportedKeys$1.includes(inputKey)) exitWithError(`Unknown preference '${inputKey}'. Supported keys: ${supportedKeys$1.join(", ")}`, exitCodes.validationError);
 	try {
-		await executeGitCommand([
-			"config",
-			"--global",
-			"--unset",
-			`phantom.${inputKey}`
-		]);
+		await configUnset({
+			key: `phantom.${inputKey}`,
+			global: true
+		});
 		output.log(`Removed phantom.${inputKey} from global git config`);
 		exitWithSuccess();
 	} catch (error) {
@@ -24745,7 +24884,8 @@ const supportedKeys = [
 	"editor",
 	"ai",
 	"worktreesDirectory",
-	"directoryNameSeparator"
+	"directoryNameSeparator",
+	"keepBranch"
 ];
 async function preferencesSetHandler(args) {
 	if (args.length < 2) exitWithError("Usage: phantom preferences set <key> <value>", exitCodes.validationError);
@@ -24753,13 +24893,13 @@ async function preferencesSetHandler(args) {
 	if (!supportedKeys.includes(inputKey)) exitWithError(`Unknown preference '${inputKey}'. Supported keys: ${supportedKeys.join(", ")}`, exitCodes.validationError);
 	const value = valueParts.join(" ");
 	if (!value) exitWithError(`Preference '${inputKey}' requires a value`, exitCodes.validationError);
+	if (inputKey === "keepBranch" && value !== "true" && value !== "false") exitWithError("Preference 'keepBranch' must be 'true' or 'false'", exitCodes.validationError);
 	try {
-		await executeGitCommand([
-			"config",
-			"--global",
-			`phantom.${inputKey}`,
-			value
-		]);
+		await configSet({
+			key: `phantom.${inputKey}`,
+			value,
+			global: true
+		});
 		output.log(`Set phantom.${inputKey} (global) to '${value}'`);
 		exitWithSuccess();
 	} catch (error) {
@@ -24838,7 +24978,7 @@ async function shellHandler(args) {
 }
 //#endregion
 //#region package.json
-var version = "6.1.1-1";
+var version = "6.2.0-0";
 //#endregion
 //#region src/version.ts
 function getVersion() {
@@ -25184,6 +25324,11 @@ const commands = [
 					type: "boolean",
 					description: "Delete the current worktree"
 				},
+				{
+					name: "--keep-branch",
+					type: "boolean",
+					description: "Delete the worktree but keep its branch"
+				},
 				{
 					name: "--fzf",
 					type: "boolean",
@@ -25207,6 +25352,10 @@ const commands = [
 					description: "Delete the current worktree",
 					command: "phantom delete --current"
 				},
+				{
+					description: "Delete a worktree while keeping its branch",
+					command: "phantom delete feature-auth --keep-branch"
+				},
 				{
 					description: "Delete a worktree with interactive fzf selection",
 					command: "phantom delete --fzf"
@@ -25216,6 +25365,7 @@ const commands = [
 				"By default, deletion will fail if the worktree has uncommitted changes",
 				"You can pass multiple worktree names to delete them at once",
 				"The associated branch will also be deleted if it's not checked out elsewhere",
+				"Use --keep-branch to delete only the worktree and preserve the branch",
 				"With --fzf, you can interactively select the worktree to delete"
 			]
 		}