@aku11i/phantom 6.2.0 → 6.3.0-0

package/app/.output/server/_ssr/router-C0zvMxvt.mjs

@@ -0,0 +1,3475 @@
+import { a as createRouter, c as createFileRoute, l as createRootRoute, n as Scripts, o as Outlet, r as HeadContent, s as lazyRouteComponent, u as require_jsx_runtime } from "../_libs/@tanstack/react-router+[...].mjs";
+import { a as literal, c as string, i as boolean, n as _enum, o as object, r as array, s as preprocess, t as number } from "../_libs/zod.mjs";
+import path, { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import fs, { copyFile, mkdir, readFile, readdir, realpath, rename, stat, writeFile } from "node:fs/promises";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import readline from "node:readline";
+import { homedir } from "node:os";
+//#region node_modules/.nitro/vite/services/ssr/assets/router-C0zvMxvt.js
+var import_jsx_runtime = require_jsx_runtime();
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var Route$14 = createRootRoute({
+	head: () => ({ meta: [
+		{ charSet: "utf-8" },
+		{
+			name: "viewport",
+			content: "width=device-width, initial-scale=1"
+		},
+		{ title: "Phantom Serve" }
+	] }),
+	component: RootComponent
+});
+function RootComponent() {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RootDocument, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Outlet, {}) });
+}
+function RootDocument({ children }) {
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("html", {
+		lang: "en",
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("head", { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(HeadContent, {}) }), /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("body", { children: [children, /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Scripts, {})] })]
+	});
+}
+var $$splitComponentImporter = () => import("./routes-DpnTz1lw.mjs");
+var Route$13 = createFileRoute("/")({ component: lazyRouteComponent($$splitComponentImporter, "component") });
+function json(data, init) {
+	return Response.json(data, init);
+}
+function jsonError(message, status = 400) {
+	return Response.json({ error: { message } }, { status });
+}
+async function readJsonObject(request) {
+	const body = await request.json().catch(() => void 0);
+	if (!body || typeof body !== "object" || Array.isArray(body)) throw new Error("Expected a JSON object request body");
+	return body;
+}
+function getString$1(body, key) {
+	const value = body[key];
+	return typeof value === "string" ? value : void 0;
+}
+function handleApiError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return jsonError(message, message.includes("not found") || message.includes("Not found") ? 404 : 400);
+}
+var 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,
+			env: options.env || process.env,
+			encoding: "utf8"
+		});
+		return {
+			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: trimStdout ? execError.stdout?.trim() ?? "" : execError.stdout ?? "",
+				stderr: trimStderr ? execError.stderr?.trim() ?? "" : execError.stderr ?? ""
+			};
+		}
+		throw error;
+	}
+}
+async function addWorktree(options) {
+	const { path, branch, base = "HEAD", createBranch = true, cwd } = options;
+	const args = [
+		"worktree",
+		"add",
+		path
+	];
+	if (createBranch) args.push("-b", branch, base);
+	else args.push(branch);
+	await executeGitCommand(args, { cwd });
+}
+/**
+* Creates a successful Result containing the given value.
+*
+* @template T - The type of the success value
+* @param value - The success value to wrap
+* @returns A Result in the Ok state containing the value
+*
+* @example
+* const result = ok(42);
+* // result: Result<number, never> = { ok: true, value: 42 }
+*/
+var ok = (value) => ({
+	ok: true,
+	value
+});
+/**
+* Creates a failed Result containing the given error.
+*
+* @template E - The type of the error value
+* @param error - The error value to wrap
+* @returns A Result in the Err state containing the error
+*
+* @example
+* const result = err(new Error("Something went wrong"));
+* // result: Result<never, Error> = { ok: false, error: Error(...) }
+*/
+var err = (error) => ({
+	ok: false,
+	error
+});
+/**
+* Type guard that checks if a Result is in the Ok state.
+*
+* @template T - The type of the success value
+* @template E - The type of the error value
+* @param result - The Result to check
+* @returns True if the Result is Ok, false otherwise
+*
+* @example
+* if (isOk(result)) {
+*   console.log(result.value); // TypeScript knows result.value exists
+* }
+*/
+var isOk = (result) => result.ok;
+/**
+* Type guard that checks if a Result is in the Err state.
+*
+* @template T - The type of the success value
+* @template E - The type of the error value
+* @param result - The Result to check
+* @returns True if the Result is Err, false otherwise
+*
+* @example
+* if (isErr(result)) {
+*   console.error(result.error); // TypeScript knows result.error exists
+* }
+*/
+var isErr = (result) => !result.ok;
+async function branchExists(gitRoot, branchName) {
+	try {
+		return ok((await executeGitCommand([
+			"branch",
+			"--list",
+			branchName
+		], { cwd: gitRoot })).stdout.trim() !== "");
+	} catch (error) {
+		return err(/* @__PURE__ */ new Error(`Failed to check branch existence: ${error instanceof Error ? error.message : String(error)}`));
+	}
+}
+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;
+}
+async function deleteBranch$1(options) {
+	const { gitRoot, branch, force = true } = options;
+	await executeGitCommand([
+		"branch",
+		force ? "-D" : "-d",
+		branch
+	], { cwd: gitRoot });
+}
+async function getGitRoot(options = {}) {
+	const { cwd = process.cwd() } = options;
+	const { stdout } = await executeGitCommand(["rev-parse", "--git-common-dir"], { cwd });
+	if (stdout.endsWith("/.git") || stdout === ".git") return resolve(cwd, dirname(stdout));
+	const { stdout: toplevel } = await executeGitCommand(["rev-parse", "--show-toplevel"], { cwd });
+	return toplevel;
+}
+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
+	};
+}
+async function listWorktrees$1(gitRoot) {
+	const { stdout } = await executeGitCommand([
+		"worktree",
+		"list",
+		"--porcelain"
+	], { cwd: gitRoot });
+	const worktrees = [];
+	let currentWorktree = {};
+	const lines = stdout.split("\n").filter((line) => line.length > 0);
+	for (const line of lines) if (line.startsWith("worktree ")) {
+		if (currentWorktree.path) worktrees.push(currentWorktree);
+		currentWorktree = {
+			path: line.substring(9),
+			isLocked: false,
+			isPrunable: false
+		};
+	} else if (line.startsWith("HEAD ")) currentWorktree.head = line.substring(5);
+	else if (line.startsWith("branch ")) {
+		const fullBranch = line.substring(7);
+		currentWorktree.branch = fullBranch.startsWith("refs/heads/") ? fullBranch.substring(11) : fullBranch;
+	} else if (line === "detached") currentWorktree.branch = "(detached HEAD)";
+	else if (line === "locked") currentWorktree.isLocked = true;
+	else if (line === "prunable") currentWorktree.isPrunable = true;
+	if (currentWorktree.path) worktrees.push(currentWorktree);
+	return worktrees;
+}
+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 });
+}
+var ConfigValidationError = class extends Error {
+	constructor(message) {
+		super(`Invalid phantom.config.json: ${message}`);
+		this.name = this.constructor.name;
+	}
+};
+var phantomConfigSchema = object({
+	postCreate: object({
+		copyFiles: array(string()).optional(),
+		commands: array(string()).optional()
+	}).passthrough().optional(),
+	preDelete: object({ commands: array(string()).optional() }).passthrough().optional(),
+	directoryNameSeparator: string().optional(),
+	worktreesDirectory: string().optional()
+}).passthrough();
+function validateConfig(config) {
+	const result = phantomConfigSchema.safeParse(config);
+	if (!result.success) {
+		const firstError = result.error.issues[0];
+		const path = firstError.path.join(".");
+		return err(new ConfigValidationError(path ? `${path}: ${firstError.message}` : firstError.message));
+	}
+	return ok(result.data);
+}
+var ConfigNotFoundError = class extends Error {
+	constructor() {
+		super("phantom.config.json not found");
+		this.name = this.constructor.name;
+	}
+};
+var ConfigParseError = class extends Error {
+	constructor(message) {
+		super(`Failed to parse phantom.config.json: ${message}`);
+		this.name = this.constructor.name;
+	}
+};
+async function loadConfig(gitRoot) {
+	const configPath = path.join(gitRoot, "phantom.config.json");
+	try {
+		const content = await fs.readFile(configPath, "utf-8");
+		try {
+			const validationResult = validateConfig(JSON.parse(content));
+			if (!validationResult.ok) return err(validationResult.error);
+			return ok(validationResult.value);
+		} catch (error) {
+			return err(new ConfigParseError(error instanceof Error ? error.message : String(error)));
+		}
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return err(new ConfigNotFoundError());
+		throw error;
+	}
+}
+var PreferencesValidationError = class extends Error {
+	constructor(message) {
+		super(`Invalid phantom preferences: ${message}`);
+		this.name = this.constructor.name;
+	}
+};
+var preferencesSchema = object({
+	editor: string().optional(),
+	ai: string().optional(),
+	worktreesDirectory: string().optional(),
+	directoryNameSeparator: string().optional(),
+	keepBranch: boolean().optional()
+}).passthrough();
+function parsePreferences(output) {
+	if (!output) return {};
+	const records = output.split("\0").filter((record) => record.length > 0);
+	const preferences = {};
+	for (const record of records) {
+		const newlineIndex = record.indexOf("\n");
+		const separatorIndex = newlineIndex >= 0 ? newlineIndex : record.indexOf(" ");
+		if (separatorIndex < 0) continue;
+		const key = record.slice(0, separatorIndex);
+		const value = record.slice(separatorIndex + 1);
+		if (!key.startsWith("phantom.")) continue;
+		const strippedKey = key.slice(8).toLowerCase();
+		if (strippedKey === "editor") preferences.editor = value;
+		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() {
+	return parsePreferences(await configGetRegexp({
+		pattern: "^phantom\\.",
+		global: true,
+		nullSeparated: true
+	}));
+}
+function getWorktreesDirectory(gitRoot, worktreesDirectory) {
+	if (worktreesDirectory) return isAbsolute(worktreesDirectory) ? worktreesDirectory : join(gitRoot, worktreesDirectory);
+	return join(gitRoot, ".git", "phantom", "worktrees");
+}
+function getWorktreePathFromDirectory(worktreeDirectory, name, directoryNameSeparator) {
+	return join(worktreeDirectory, directoryNameSeparator === "/" ? name : name.replaceAll("/", directoryNameSeparator));
+}
+async function createContext(gitRoot) {
+	const configResult = await loadConfig(gitRoot);
+	const config = isOk(configResult) ? configResult.value : null;
+	const preferences = await loadPreferences();
+	const worktreesDirectoryConfig = config?.worktreesDirectory;
+	const worktreesDirectory = preferences.worktreesDirectory ?? worktreesDirectoryConfig;
+	const directoryNameSeparator = preferences.directoryNameSeparator || config?.directoryNameSeparator || "/";
+	return {
+		gitRoot,
+		worktreesDirectory: getWorktreesDirectory(gitRoot, worktreesDirectory),
+		directoryNameSeparator,
+		config,
+		preferences
+	};
+}
+function getPhantomEnv(worktreeName, worktreePath) {
+	return {
+		PHANTOM: "1",
+		PHANTOM_NAME: worktreeName,
+		PHANTOM_PATH: worktreePath
+	};
+}
+var ProcessError = class extends Error {
+	exitCode;
+	constructor(message, exitCode) {
+		super(message);
+		this.name = this.constructor.name;
+		this.exitCode = exitCode;
+	}
+};
+var ProcessExecutionError = class extends ProcessError {
+	constructor(command, exitCode) {
+		super(`Command '${command}' failed with exit code ${exitCode}`, exitCode);
+		this.name = "ProcessExecutionError";
+	}
+};
+var ProcessSignalError = class extends ProcessError {
+	constructor(signal) {
+		const exitCode = 128 + (signal === "SIGTERM" ? 15 : 1);
+		super(`Command terminated by signal: ${signal}`, exitCode);
+		this.name = "ProcessSignalError";
+	}
+};
+var ProcessSpawnError = class extends ProcessError {
+	constructor(command, details) {
+		super(`Error executing command '${command}': ${details}`);
+		this.name = "ProcessSpawnError";
+	}
+};
+async function spawnProcess(config) {
+	return new Promise((resolve) => {
+		const { command, args = [], options = {} } = config;
+		const childProcess = spawn(command, args, {
+			stdio: "inherit",
+			...options
+		});
+		childProcess.on("error", (error) => {
+			resolve(err(new ProcessSpawnError(command, error.message)));
+		});
+		childProcess.on("exit", (code, signal) => {
+			if (signal) resolve(err(new ProcessSignalError(signal)));
+			else {
+				const exitCode = code ?? 0;
+				if (exitCode === 0) resolve(ok({ exitCode }));
+				else resolve(err(new ProcessExecutionError(command, exitCode)));
+			}
+		});
+	});
+}
+var WorktreeError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+	}
+};
+var WorktreeNotFoundError = class extends WorktreeError {
+	constructor(name) {
+		super(`Worktree '${name}' not found`);
+		this.name = "WorktreeNotFoundError";
+	}
+};
+var WorktreeAlreadyExistsError = class extends WorktreeError {
+	constructor(name) {
+		super(`Worktree '${name}' already exists`);
+		this.name = "WorktreeAlreadyExistsError";
+	}
+};
+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";
+	}
+};
+async function getWorktreeStatus(worktreePath) {
+	try {
+		return (await getStatus({ cwd: worktreePath })).isClean;
+	} catch {
+		return true;
+	}
+}
+async function listWorktrees(gitRoot, options = {}) {
+	try {
+		const gitWorktrees = await listWorktrees$1(gitRoot);
+		const excludeDefault = options.excludeDefault ?? false;
+		const filteredWorktrees = excludeDefault ? gitWorktrees.filter((worktree) => worktree.path !== gitRoot) : gitWorktrees;
+		if (filteredWorktrees.length === 0) return ok({
+			worktrees: [],
+			message: excludeDefault && gitWorktrees.length > 0 ? "No sub worktrees found" : "No worktrees found"
+		});
+		return ok({ worktrees: await Promise.all(filteredWorktrees.map(async (gitWorktree) => {
+			const shortHead = gitWorktree.head?.slice(0, 7) ?? "HEAD";
+			const branchName = gitWorktree.branch && gitWorktree.branch !== "(detached HEAD)" ? gitWorktree.branch : shortHead;
+			const isClean = await getWorktreeStatus(gitWorktree.path);
+			const pathToDisplay = relative(process.cwd(), gitWorktree.path) || ".";
+			return {
+				name: branchName,
+				path: gitWorktree.path,
+				pathToDisplay,
+				branch: branchName,
+				isClean
+			};
+		})) });
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to list worktrees: ${errorMessage}`);
+	}
+}
+async function validateWorktreeExists(gitRoot, _worktreeDirectory, name, options = {}) {
+	const worktreesResult = await listWorktrees(gitRoot, options);
+	if (isErr(worktreesResult)) return err(new WorktreeNotFoundError(name));
+	const worktree = worktreesResult.value.worktrees.find((wt) => wt.name === name);
+	if (!worktree) return err(new WorktreeNotFoundError(name));
+	return ok({ path: worktree.path });
+}
+async function validateWorktreeDoesNotExist(gitRoot, _worktreeDirectory, name) {
+	const worktreesResult = await listWorktrees(gitRoot);
+	if (isErr(worktreesResult)) return err(new WorktreeAlreadyExistsError(name));
+	if (worktreesResult.value.worktrees.find((wt) => wt.name === name)) return err(new WorktreeAlreadyExistsError(name));
+	return ok(void 0);
+}
+async function validateWorktreeDirectoryExists(worktreeDirectory) {
+	try {
+		await fs.access(worktreeDirectory);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function validateWorktreeName(name) {
+	if (!name || name.trim() === "") return err(/* @__PURE__ */ new Error("Phantom name cannot be empty"));
+	if (!/^[a-zA-Z0-9\-_./]+$/.test(name)) return err(/* @__PURE__ */ new Error("Phantom name can only contain letters, numbers, hyphens, underscores, dots, and slashes"));
+	if (name.includes("..")) return err(/* @__PURE__ */ new Error("Phantom name cannot contain consecutive dots"));
+	return ok(void 0);
+}
+async function execInWorktree(gitRoot, worktreeDirectory, worktreeName, command, options) {
+	const validation = await validateWorktreeExists(gitRoot, worktreeDirectory, worktreeName);
+	if (isErr(validation)) return err(validation.error);
+	const worktreePath = validation.value.path;
+	const [cmd, ...args] = command;
+	return spawnProcess({
+		command: cmd,
+		args,
+		options: {
+			cwd: worktreePath,
+			stdio: options?.interactive ? "inherit" : [
+				"ignore",
+				"inherit",
+				"inherit"
+			]
+		}
+	});
+}
+promisify(execFile);
+number().int().positive();
+number().int().positive();
+promisify(execFile);
+object({
+	owner: string(),
+	repo: string()
+});
+async function executePostCreateCommands(options) {
+	const { gitRoot, worktreesDirectory, worktreeName, commands, logger } = options;
+	const executedCommands = [];
+	for (const command of commands) {
+		logger?.log(`Executing: ${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 post-create command "${command}": ${errorMessage}`));
+		}
+		if (cmdResult.value.exitCode !== 0) return err(/* @__PURE__ */ new Error(`Post-create command failed with exit code ${cmdResult.value.exitCode}: ${command}`));
+		executedCommands.push(command);
+	}
+	return ok({ executedCommands });
+}
+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
+	});
+}
+async function shellInWorktree(gitRoot, worktreeDirectory, worktreeName) {
+	const validation = await validateWorktreeExists(gitRoot, worktreeDirectory, worktreeName);
+	if (isErr(validation)) return err(validation.error);
+	const worktreePath = validation.value.path;
+	return spawnProcess({
+		command: process.env.SHELL || "/bin/sh",
+		args: [],
+		options: {
+			cwd: worktreePath,
+			env: {
+				...process.env,
+				...getPhantomEnv(worktreeName, worktreePath)
+			}
+		}
+	});
+}
+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({});
+}
+var FileCopyError = class extends Error {
+	file;
+	constructor(file, message) {
+		super(`Failed to copy ${file}: ${message}`);
+		this.name = "FileCopyError";
+		this.file = file;
+	}
+};
+async function copyFiles(sourceDir, targetDir, files) {
+	const copiedFiles = [];
+	const skippedFiles = [];
+	for (const file of files) {
+		const sourcePath = path.join(sourceDir, file);
+		const targetPath = path.join(targetDir, file);
+		try {
+			if (!(await stat(sourcePath)).isFile()) {
+				skippedFiles.push(file);
+				continue;
+			}
+			await mkdir(path.dirname(targetPath), { recursive: true });
+			await copyFile(sourcePath, targetPath);
+			copiedFiles.push(file);
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") skippedFiles.push(file);
+			else return err(new FileCopyError(file, error instanceof Error ? error.message : String(error)));
+		}
+	}
+	return ok({
+		copiedFiles,
+		skippedFiles
+	});
+}
+var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+		if (pack || arguments.length === 2) {
+			for (var i = 0, l = from.length, ar; i < l; i++) if (ar || !(i in from)) {
+				if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+				ar[i] = from[i];
+			}
+		}
+		return to.concat(ar || Array.prototype.slice.call(from));
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.minLength = exports.maxLength = exports.poolSize = exports.humanId = exports.adverbs = exports.verbs = exports.nouns = exports.adjectives = void 0;
+	exports.adjectives = [
+		"afraid",
+		"all",
+		"beige",
+		"better",
+		"big",
+		"blue",
+		"bold",
+		"brave",
+		"breezy",
+		"bright",
+		"brown",
+		"bumpy",
+		"busy",
+		"calm",
+		"chatty",
+		"chilly",
+		"chubby",
+		"clean",
+		"clear",
+		"clever",
+		"cold",
+		"common",
+		"cool",
+		"cozy",
+		"crisp",
+		"cuddly",
+		"curly",
+		"curvy",
+		"cute",
+		"cyan",
+		"dark",
+		"deep",
+		"dirty",
+		"dry",
+		"dull",
+		"eager",
+		"early",
+		"easy",
+		"eight",
+		"eighty",
+		"eleven",
+		"empty",
+		"every",
+		"fair",
+		"famous",
+		"fancy",
+		"fast",
+		"few",
+		"fiery",
+		"fifty",
+		"fine",
+		"five",
+		"flat",
+		"floppy",
+		"fluffy",
+		"forty",
+		"four",
+		"frank",
+		"free",
+		"fresh",
+		"fruity",
+		"full",
+		"funky",
+		"funny",
+		"fuzzy",
+		"gentle",
+		"giant",
+		"gold",
+		"good",
+		"goofy",
+		"great",
+		"green",
+		"grumpy",
+		"happy",
+		"heavy",
+		"hip",
+		"honest",
+		"hot",
+		"huge",
+		"humble",
+		"hungry",
+		"icy",
+		"itchy",
+		"jolly",
+		"khaki",
+		"kind",
+		"large",
+		"late",
+		"lazy",
+		"legal",
+		"lemon",
+		"light",
+		"little",
+		"long",
+		"loose",
+		"loud",
+		"lovely",
+		"lucky",
+		"major",
+		"many",
+		"metal",
+		"mighty",
+		"modern",
+		"moody",
+		"neat",
+		"new",
+		"nice",
+		"nine",
+		"ninety",
+		"odd",
+		"old",
+		"olive",
+		"open",
+		"orange",
+		"perky",
+		"petite",
+		"pink",
+		"plain",
+		"plenty",
+		"polite",
+		"pretty",
+		"proud",
+		"public",
+		"puny",
+		"purple",
+		"quick",
+		"quiet",
+		"rare",
+		"ready",
+		"real",
+		"red",
+		"rich",
+		"ripe",
+		"salty",
+		"seven",
+		"shaggy",
+		"shaky",
+		"sharp",
+		"shiny",
+		"short",
+		"shy",
+		"silent",
+		"silly",
+		"silver",
+		"six",
+		"sixty",
+		"slick",
+		"slimy",
+		"slow",
+		"small",
+		"smart",
+		"smooth",
+		"social",
+		"soft",
+		"solid",
+		"some",
+		"sour",
+		"sparkly",
+		"spicy",
+		"spotty",
+		"stale",
+		"strict",
+		"strong",
+		"sunny",
+		"sweet",
+		"swift",
+		"tall",
+		"tame",
+		"tangy",
+		"tasty",
+		"ten",
+		"tender",
+		"thick",
+		"thin",
+		"thirty",
+		"three",
+		"tidy",
+		"tiny",
+		"tired",
+		"tough",
+		"tricky",
+		"true",
+		"twelve",
+		"twenty",
+		"two",
+		"upset",
+		"vast",
+		"violet",
+		"wacky",
+		"warm",
+		"wet",
+		"whole",
+		"wicked",
+		"wide",
+		"wild",
+		"wise",
+		"witty",
+		"yellow",
+		"young",
+		"yummy"
+	];
+	exports.nouns = [
+		"actors",
+		"ads",
+		"adults",
+		"aliens",
+		"animals",
+		"ants",
+		"apes",
+		"apples",
+		"areas",
+		"baboons",
+		"badgers",
+		"bags",
+		"balloons",
+		"bananas",
+		"banks",
+		"bars",
+		"baths",
+		"bats",
+		"beans",
+		"bears",
+		"beds",
+		"beers",
+		"bees",
+		"berries",
+		"bikes",
+		"birds",
+		"boats",
+		"bobcats",
+		"books",
+		"bottles",
+		"boxes",
+		"breads",
+		"brooms",
+		"buckets",
+		"bugs",
+		"buses",
+		"bushes",
+		"buttons",
+		"camels",
+		"cameras",
+		"candies",
+		"candles",
+		"canyons",
+		"carpets",
+		"carrots",
+		"cars",
+		"cases",
+		"cats",
+		"chairs",
+		"chefs",
+		"chicken",
+		"cities",
+		"clocks",
+		"cloths",
+		"clouds",
+		"clowns",
+		"clubs",
+		"coats",
+		"cobras",
+		"coins",
+		"colts",
+		"comics",
+		"cooks",
+		"corners",
+		"cougars",
+		"cows",
+		"crabs",
+		"crews",
+		"cups",
+		"cycles",
+		"dancers",
+		"days",
+		"deer",
+		"deserts",
+		"dingos",
+		"dodos",
+		"dogs",
+		"dolls",
+		"donkeys",
+		"donuts",
+		"doodles",
+		"doors",
+		"dots",
+		"dragons",
+		"drinks",
+		"dryers",
+		"ducks",
+		"eagles",
+		"ears",
+		"eels",
+		"eggs",
+		"emus",
+		"ends",
+		"experts",
+		"eyes",
+		"facts",
+		"falcons",
+		"fans",
+		"feet",
+		"files",
+		"flies",
+		"flowers",
+		"forks",
+		"foxes",
+		"friends",
+		"frogs",
+		"games",
+		"garlics",
+		"geckos",
+		"geese",
+		"ghosts",
+		"gifts",
+		"glasses",
+		"goats",
+		"grapes",
+		"groups",
+		"guests",
+		"hairs",
+		"hands",
+		"hats",
+		"heads",
+		"hoops",
+		"hornets",
+		"horses",
+		"hotels",
+		"hounds",
+		"houses",
+		"humans",
+		"icons",
+		"ideas",
+		"impalas",
+		"insects",
+		"islands",
+		"items",
+		"jars",
+		"jeans",
+		"jobs",
+		"jokes",
+		"keys",
+		"kids",
+		"kings",
+		"kiwis",
+		"knives",
+		"lamps",
+		"lands",
+		"laws",
+		"lemons",
+		"lies",
+		"lights",
+		"lilies",
+		"lines",
+		"lions",
+		"lizards",
+		"llamas",
+		"loops",
+		"mails",
+		"mammals",
+		"mangos",
+		"maps",
+		"masks",
+		"meals",
+		"melons",
+		"memes",
+		"meteors",
+		"mice",
+		"mirrors",
+		"moles",
+		"moments",
+		"monkeys",
+		"months",
+		"moons",
+		"moose",
+		"mugs",
+		"nails",
+		"needles",
+		"news",
+		"nights",
+		"numbers",
+		"olives",
+		"onions",
+		"oranges",
+		"otters",
+		"owls",
+		"pandas",
+		"pans",
+		"pants",
+		"papayas",
+		"papers",
+		"parents",
+		"parks",
+		"parrots",
+		"parts",
+		"paths",
+		"paws",
+		"peaches",
+		"pears",
+		"peas",
+		"pens",
+		"pets",
+		"phones",
+		"pianos",
+		"pigs",
+		"pillows",
+		"places",
+		"planes",
+		"planets",
+		"plants",
+		"plums",
+		"poems",
+		"poets",
+		"points",
+		"pots",
+		"pugs",
+		"pumas",
+		"queens",
+		"rabbits",
+		"radios",
+		"rats",
+		"ravens",
+		"readers",
+		"regions",
+		"results",
+		"rice",
+		"rings",
+		"rivers",
+		"rockets",
+		"rocks",
+		"rooms",
+		"roses",
+		"rules",
+		"sails",
+		"schools",
+		"seals",
+		"seas",
+		"sheep",
+		"shirts",
+		"shoes",
+		"showers",
+		"shrimps",
+		"sides",
+		"signs",
+		"singers",
+		"sites",
+		"sloths",
+		"snails",
+		"snakes",
+		"socks",
+		"spiders",
+		"spies",
+		"spoons",
+		"squids",
+		"stamps",
+		"stars",
+		"states",
+		"steaks",
+		"streets",
+		"suits",
+		"suns",
+		"swans",
+		"symbols",
+		"tables",
+		"taxes",
+		"taxis",
+		"teams",
+		"teeth",
+		"terms",
+		"things",
+		"ties",
+		"tigers",
+		"times",
+		"tips",
+		"tires",
+		"toes",
+		"tools",
+		"towns",
+		"toys",
+		"trains",
+		"trams",
+		"trees",
+		"turkeys",
+		"turtles",
+		"vans",
+		"views",
+		"walls",
+		"wasps",
+		"waves",
+		"ways",
+		"webs",
+		"weeks",
+		"windows",
+		"wings",
+		"wolves",
+		"wombats",
+		"words",
+		"worlds",
+		"worms",
+		"yaks",
+		"years",
+		"zebras",
+		"zoos"
+	];
+	exports.verbs = [
+		"accept",
+		"act",
+		"add",
+		"admire",
+		"agree",
+		"allow",
+		"appear",
+		"argue",
+		"arrive",
+		"ask",
+		"attack",
+		"attend",
+		"bake",
+		"bathe",
+		"battle",
+		"beam",
+		"beg",
+		"begin",
+		"behave",
+		"bet",
+		"boil",
+		"bow",
+		"brake",
+		"brush",
+		"build",
+		"burn",
+		"buy",
+		"call",
+		"camp",
+		"care",
+		"carry",
+		"change",
+		"cheat",
+		"check",
+		"cheer",
+		"chew",
+		"clap",
+		"clean",
+		"cough",
+		"count",
+		"cover",
+		"crash",
+		"create",
+		"cross",
+		"cry",
+		"cut",
+		"dance",
+		"decide",
+		"deny",
+		"design",
+		"dig",
+		"divide",
+		"do",
+		"double",
+		"doubt",
+		"draw",
+		"dream",
+		"dress",
+		"drive",
+		"drop",
+		"drum",
+		"eat",
+		"end",
+		"enjoy",
+		"enter",
+		"exist",
+		"fail",
+		"fall",
+		"feel",
+		"fetch",
+		"film",
+		"find",
+		"fix",
+		"flash",
+		"float",
+		"flow",
+		"fly",
+		"fold",
+		"follow",
+		"fry",
+		"give",
+		"glow",
+		"go",
+		"grab",
+		"greet",
+		"grin",
+		"grow",
+		"guess",
+		"hammer",
+		"hang",
+		"happen",
+		"heal",
+		"hear",
+		"help",
+		"hide",
+		"hope",
+		"hug",
+		"hunt",
+		"invent",
+		"invite",
+		"itch",
+		"jam",
+		"jog",
+		"join",
+		"joke",
+		"judge",
+		"juggle",
+		"jump",
+		"kick",
+		"kiss",
+		"kneel",
+		"knock",
+		"know",
+		"laugh",
+		"lay",
+		"lead",
+		"learn",
+		"leave",
+		"lick",
+		"lie",
+		"like",
+		"listen",
+		"live",
+		"look",
+		"lose",
+		"love",
+		"make",
+		"march",
+		"marry",
+		"mate",
+		"matter",
+		"melt",
+		"mix",
+		"move",
+		"nail",
+		"notice",
+		"obey",
+		"occur",
+		"open",
+		"own",
+		"pay",
+		"peel",
+		"pick",
+		"play",
+		"poke",
+		"post",
+		"press",
+		"prove",
+		"pull",
+		"pump",
+		"punch",
+		"push",
+		"raise",
+		"read",
+		"refuse",
+		"relate",
+		"relax",
+		"remain",
+		"repair",
+		"repeat",
+		"reply",
+		"report",
+		"rescue",
+		"rest",
+		"retire",
+		"return",
+		"rhyme",
+		"ring",
+		"roll",
+		"rule",
+		"run",
+		"rush",
+		"say",
+		"scream",
+		"search",
+		"see",
+		"sell",
+		"send",
+		"serve",
+		"shake",
+		"share",
+		"shave",
+		"shine",
+		"shop",
+		"shout",
+		"show",
+		"sin",
+		"sing",
+		"sink",
+		"sip",
+		"sit",
+		"sleep",
+		"slide",
+		"smash",
+		"smell",
+		"smile",
+		"smoke",
+		"sneeze",
+		"sniff",
+		"sort",
+		"speak",
+		"spend",
+		"stand",
+		"stare",
+		"start",
+		"stay",
+		"stick",
+		"stop",
+		"strive",
+		"study",
+		"swim",
+		"switch",
+		"take",
+		"talk",
+		"tan",
+		"tap",
+		"taste",
+		"teach",
+		"tease",
+		"tell",
+		"thank",
+		"think",
+		"throw",
+		"tickle",
+		"tie",
+		"trade",
+		"train",
+		"travel",
+		"try",
+		"turn",
+		"type",
+		"unite",
+		"vanish",
+		"visit",
+		"wait",
+		"walk",
+		"warn",
+		"wash",
+		"watch",
+		"wave",
+		"wear",
+		"win",
+		"wink",
+		"wish",
+		"wonder",
+		"work",
+		"worry",
+		"write",
+		"yawn",
+		"yell"
+	];
+	exports.adverbs = [
+		"bravely",
+		"brightly",
+		"busily",
+		"daily",
+		"freely",
+		"hungrily",
+		"joyously",
+		"knowingly",
+		"lazily",
+		"noisily",
+		"oddly",
+		"politely",
+		"quickly",
+		"quietly",
+		"rapidly",
+		"safely",
+		"sleepily",
+		"slowly",
+		"truly",
+		"yearly"
+	];
+	function random(arr) {
+		return arr[Math.floor(Math.random() * arr.length)];
+	}
+	function longest(arr) {
+		return arr.reduce(function(a, b) {
+			return a.length > b.length ? a : b;
+		});
+	}
+	function shortest(arr) {
+		return arr.reduce(function(a, b) {
+			return a.length < b.length ? a : b;
+		});
+	}
+	function humanId(options) {
+		if (options === void 0) options = {};
+		if (typeof options === "string") options = { separator: options };
+		if (typeof options === "boolean") options = { capitalize: options };
+		var _a = options.separator, separator = _a === void 0 ? "" : _a, _b = options.capitalize, capitalize = _b === void 0 ? true : _b, _c = options.adjectiveCount, adjectiveCount = _c === void 0 ? 1 : _c, _d = options.addAdverb, addAdverb = _d === void 0 ? false : _d;
+		var res = __spreadArray(__spreadArray(__spreadArray([], __spreadArray([], Array(adjectiveCount), true).map(function(_) {
+			return random(exports.adjectives);
+		}), true), [random(exports.nouns), random(exports.verbs)], false), addAdverb ? [random(exports.adverbs)] : [], true);
+		if (capitalize) res = res.map(function(r) {
+			return r.charAt(0).toUpperCase() + r.substr(1);
+		});
+		return res.join(separator);
+	}
+	exports.humanId = humanId;
+	function poolSize(options) {
+		if (options === void 0) options = {};
+		var _a = options.adjectiveCount, adjectiveCount = _a === void 0 ? 1 : _a, _b = options.addAdverb, addAdverb = _b === void 0 ? false : _b;
+		return exports.adjectives.length * adjectiveCount * exports.nouns.length * exports.verbs.length * (addAdverb ? exports.adverbs.length : 1);
+	}
+	exports.poolSize = poolSize;
+	function maxLength(options) {
+		if (options === void 0) options = {};
+		var _a = options.adjectiveCount, adjectiveCount = _a === void 0 ? 1 : _a, _b = options.addAdverb, addAdverb = _b === void 0 ? false : _b, _c = options.separator, separator = _c === void 0 ? "" : _c;
+		return longest(exports.adjectives).length * adjectiveCount + adjectiveCount * separator.length + longest(exports.nouns).length + separator.length + longest(exports.verbs).length + (addAdverb ? longest(exports.adverbs).length + separator.length : 0);
+	}
+	exports.maxLength = maxLength;
+	function minLength(options) {
+		if (options === void 0) options = {};
+		var _a = options.adjectiveCount, adjectiveCount = _a === void 0 ? 1 : _a, _b = options.addAdverb, addAdverb = _b === void 0 ? false : _b, _c = options.separator, separator = _c === void 0 ? "" : _c;
+		return shortest(exports.adjectives).length * adjectiveCount + adjectiveCount * separator.length + shortest(exports.nouns).length + separator.length + shortest(exports.verbs).length + (addAdverb ? shortest(exports.adverbs).length + separator.length : 0);
+	}
+	exports.minLength = minLength;
+	exports.default = humanId;
+})))();
+var MAX_RETRIES = 10;
+function generate() {
+	return (0, import_dist.humanId)({
+		separator: "-",
+		capitalize: false
+	});
+}
+async function generateUniqueName(gitRoot, worktreesDirectory, directoryNameSeparator) {
+	for (let i = 0; i < MAX_RETRIES; i++) {
+		const name = generate();
+		if (isErr(validateWorktreeName(name))) continue;
+		if (await validateWorktreeDirectoryExists(getWorktreePathFromDirectory(worktreesDirectory, name, directoryNameSeparator))) continue;
+		const result = await branchExists(gitRoot, name);
+		if (isErr(result)) return err(result.error);
+		if (result.value) continue;
+		return ok(name);
+	}
+	return err(/* @__PURE__ */ new Error("Failed to generate a unique worktree name after maximum retries"));
+}
+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,
+			cwd: gitRoot
+		});
+		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(options.gitRoot ?? 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)));
+	}
+}
+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)}`));
+	}
+}
+function getCodexBin() {
+	return process.env.PHANTOM_SERVE_CODEX_BIN ?? "codex";
+}
+function createUserInput(text, options = {}) {
+	const input = [{
+		type: "text",
+		text,
+		text_elements: []
+	}];
+	for (const skill of options.skills ?? []) input.push({
+		type: "skill",
+		name: skill.name,
+		path: skill.path
+	});
+	for (const file of options.files ?? []) input.push({
+		type: "mention",
+		name: file.name,
+		path: file.path
+	});
+	return input;
+}
+var CodexBridge = class {
+	proc = null;
+	initialized = null;
+	nextId = 1;
+	stderr = "";
+	pendingRequests = /* @__PURE__ */ new Map();
+	serverRequests = /* @__PURE__ */ new Map();
+	notificationHandlers = /* @__PURE__ */ new Set();
+	serverRequestHandlers = /* @__PURE__ */ new Set();
+	processExitHandlers = /* @__PURE__ */ new Set();
+	constructor(codexBin = getCodexBin(), spawnCodexProcess = spawn) {
+		this.codexBin = codexBin;
+		this.spawnCodexProcess = spawnCodexProcess;
+	}
+	onNotification(handler) {
+		this.notificationHandlers.add(handler);
+		return () => this.notificationHandlers.delete(handler);
+	}
+	onServerRequest(handler) {
+		this.serverRequestHandlers.add(handler);
+		return () => this.serverRequestHandlers.delete(handler);
+	}
+	onProcessExit(handler) {
+		this.processExitHandlers.add(handler);
+		return () => this.processExitHandlers.delete(handler);
+	}
+	async ensureStarted() {
+		if (this.initialized) return this.initialized;
+		this.initialized = this.start();
+		return this.initialized;
+	}
+	async request(method, params) {
+		await this.ensureStarted();
+		return this.sendRequest(method, params);
+	}
+	async notify(method, params) {
+		await this.ensureStarted();
+		this.write({
+			method,
+			params: params ?? {}
+		});
+	}
+	respondToServerRequest(requestId, result) {
+		const serverRequestId = this.resolveServerRequestId(requestId);
+		if (serverRequestId === null) throw new Error(`Codex server request '${requestId}' was not found`);
+		this.serverRequests.delete(serverRequestId);
+		this.write({
+			id: serverRequestId,
+			result
+		});
+	}
+	async readAccount() {
+		return this.request("account/read", { refreshToken: false });
+	}
+	async listModels() {
+		return this.request("model/list", {
+			limit: 50,
+			includeHidden: false
+		});
+	}
+	async listSkills(cwds) {
+		return this.request("skills/list", {
+			cwds,
+			forceReload: false
+		});
+	}
+	async searchFiles(query, roots) {
+		return this.request("fuzzyFileSearch", {
+			query,
+			roots,
+			cancellationToken: null
+		});
+	}
+	async startThread(cwd, options = {}) {
+		return this.request("thread/start", {
+			cwd,
+			model: options.model,
+			serviceName: "phantom_serve",
+			experimentalRawEvents: false,
+			persistExtendedHistory: true
+		});
+	}
+	async resumeThread(threadId, cwd) {
+		return this.request("thread/resume", {
+			threadId,
+			cwd,
+			excludeTurns: true,
+			persistExtendedHistory: true
+		});
+	}
+	async startTurn(threadId, text, cwd, options = {}) {
+		return this.request("turn/start", {
+			threadId,
+			cwd,
+			input: createUserInput(text, options),
+			model: options.model,
+			effort: options.effort
+		});
+	}
+	async steerTurn(threadId, turnId, text, options = {}) {
+		return this.request("turn/steer", {
+			threadId,
+			expectedTurnId: turnId,
+			input: createUserInput(text, options),
+			model: options.model,
+			effort: options.effort
+		});
+	}
+	async interruptTurn(threadId, turnId) {
+		return this.request("turn/interrupt", {
+			threadId,
+			turnId
+		});
+	}
+	async start() {
+		this.stderr = "";
+		this.proc = this.spawnCodexProcess(this.codexBin, ["app-server"], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		const proc = this.proc;
+		proc.stderr.on("data", (chunk) => {
+			this.stderr += chunk.toString("utf8");
+			if (this.stderr.length > 8e3) this.stderr = this.stderr.slice(-8e3);
+		});
+		proc.on("error", (error) => {
+			this.handleProcessExit(proc, error);
+		});
+		proc.on("exit", (code, signal) => {
+			const suffix = this.stderr.trim() ? `: ${this.stderr.trim()}` : "";
+			this.handleProcessExit(proc, /* @__PURE__ */ new Error(`Codex App Server exited with ${signal ? `signal ${signal}` : `code ${code ?? 0}`}${suffix}`));
+		});
+		readline.createInterface({ input: proc.stdout }).on("line", (line) => this.handleLine(line));
+		await this.sendRequest("initialize", {
+			clientInfo: {
+				name: "phantom_serve",
+				title: "Phantom Serve",
+				version: "0.1.0"
+			},
+			capabilities: { experimentalApi: true }
+		});
+		this.write({
+			method: "initialized",
+			params: {}
+		});
+	}
+	sendRequest(method, params) {
+		const id = this.nextId++;
+		const promise = new Promise((resolve, reject) => {
+			this.pendingRequests.set(id, {
+				resolve,
+				reject
+			});
+		});
+		this.write({
+			id,
+			method,
+			params
+		});
+		return promise;
+	}
+	write(message) {
+		if (!this.proc?.stdin.writable) throw new Error("Codex App Server is not running");
+		this.proc.stdin.write(`${JSON.stringify(message)}\n`);
+	}
+	resolveServerRequestId(requestId) {
+		if (this.serverRequests.has(requestId)) return requestId;
+		if (typeof requestId === "number") return null;
+		const numericRequestId = Number(requestId);
+		if (Number.isFinite(numericRequestId) && this.serverRequests.has(numericRequestId)) return numericRequestId;
+		return null;
+	}
+	handleLine(line) {
+		let message;
+		try {
+			message = JSON.parse(line);
+		} catch {
+			return;
+		}
+		if (message.id !== void 0 && !message.method) {
+			const pending = this.pendingRequests.get(message.id);
+			if (!pending) return;
+			this.pendingRequests.delete(message.id);
+			if (message.error) pending.reject(new Error(message.error.message));
+			else pending.resolve(message.result);
+			return;
+		}
+		if (message.id !== void 0 && message.method) {
+			this.serverRequests.set(message.id, message);
+			for (const handler of this.serverRequestHandlers) handler(message);
+			return;
+		}
+		for (const handler of this.notificationHandlers) handler(message);
+	}
+	rejectPending(error) {
+		for (const pending of this.pendingRequests.values()) pending.reject(error);
+		this.pendingRequests.clear();
+	}
+	handleProcessExit(proc, error) {
+		if (this.proc !== proc) return;
+		this.rejectPending(error);
+		this.serverRequests.clear();
+		this.proc = null;
+		this.initialized = null;
+		for (const handler of this.processExitHandlers) handler(error);
+	}
+};
+function getParamObject(params) {
+	return params && typeof params === "object" && !Array.isArray(params) ? params : null;
+}
+function extractThreadId(result) {
+	const threadId = getParamObject(getParamObject(result)?.thread)?.id;
+	if (typeof threadId !== "string") throw new Error("Codex response did not include a thread id");
+	return threadId;
+}
+function extractTurnId(result) {
+	const turnId = getParamObject(getParamObject(result)?.turn)?.id;
+	return typeof turnId === "string" ? turnId : null;
+}
+function extractThreadIdFromParams(params) {
+	const object = getParamObject(params);
+	if (!object) return null;
+	if (typeof object.threadId === "string") return object.threadId;
+	const thread = getParamObject(object.thread);
+	return typeof thread?.id === "string" ? thread.id : null;
+}
+function extractTurnIdFromParams(params) {
+	const object = getParamObject(params);
+	if (!object) return null;
+	if (typeof object.turnId === "string") return object.turnId;
+	const turn = getParamObject(object.turn);
+	return typeof turn?.id === "string" ? turn.id : null;
+}
+function getServerRequestId(requestId) {
+	if (typeof requestId === "string" || typeof requestId === "number") return requestId;
+	return null;
+}
+function extractServerRequestIdFromParams(params) {
+	const object = getParamObject(params);
+	if (!object) return null;
+	return getServerRequestId(object.requestId) ?? getServerRequestId(object.serverRequestId) ?? getServerRequestId(object.id);
+}
+function mapCodexMethodToEvent(method) {
+	if (method === "thread/started") return "agent.thread.started";
+	if (method === "turn/started") return "agent.turn.started";
+	if (method === "turn/completed") return "agent.turn.completed";
+	if (method.startsWith("item/") && method.endsWith("/requestApproval")) return "agent.approval.requested";
+	if (method.startsWith("item/")) return method.includes("delta") ? "agent.item.delta" : "agent.item.updated";
+	if (method === "serverRequest/resolved") return "agent.approval.resolved";
+	if (method === "account/updated") return "auth.updated";
+	if (method === "error") return "agent.error";
+	return "agent.event";
+}
+function summarizeCodexEvent(method, params) {
+	const object = getParamObject(params);
+	if (method === "item/started" || method === "item/completed") {
+		const item = getParamObject(object?.item);
+		return `${method}: ${typeof item?.type === "string" ? item.type : "item"}`;
+	}
+	if (method === "turn/completed") {
+		const turn = getParamObject(object?.turn);
+		return `turn completed: ${typeof turn?.status === "string" ? turn.status : "unknown"}`;
+	}
+	if (method === "error") {
+		const error = getParamObject(object?.error);
+		return typeof error?.message === "string" ? error.message : "Codex error";
+	}
+	return method;
+}
+async function listCodexSessionsForWorktree({ branchName, codexHome = getDefaultCodexHome(), projectId, worktreeName, worktreePath }) {
+	return await listCodexSessionsForWorktrees({
+		codexHome,
+		projectId,
+		worktrees: [{
+			branchName,
+			worktreeName,
+			worktreePath
+		}]
+	});
+}
+async function listCodexSessionsForWorktrees({ codexHome = getDefaultCodexHome(), projectId, worktrees }) {
+	const files = await listCodexSessionFiles(codexHome);
+	const worktreeByPath = new Map(worktrees.map((worktree) => [worktree.worktreePath, worktree]));
+	const parsedSessionsById = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const session = await parseCodexSession(file);
+		if (!session || !worktreeByPath.has(session.worktreePath)) continue;
+		const existingSession = parsedSessionsById.get(session.sessionId);
+		if (!existingSession || existingSession.updatedAt.localeCompare(session.updatedAt) < 0) parsedSessionsById.set(session.sessionId, session);
+	}
+	return Array.from(parsedSessionsById.values()).map((session) => createImportedCodexSession({
+		projectId,
+		session,
+		worktree: worktreeByPath.get(session.worktreePath)
+	})).sort((left, right) => right.chat.updatedAt.localeCompare(left.chat.updatedAt));
+}
+function getDefaultCodexHome() {
+	return process.env.CODEX_HOME ?? join(homedir(), ".codex");
+}
+async function listCodexSessionFiles(codexHome) {
+	const roots = [join(codexHome, "sessions"), join(codexHome, "archived_sessions")];
+	return (await Promise.all(roots.map((root) => listJsonlFiles(root)))).flat();
+}
+async function listJsonlFiles(root) {
+	let entries;
+	try {
+		entries = await readdir(root, { withFileTypes: true });
+	} catch (error) {
+		if (isIgnorableHistoryRootError(error)) return [];
+		throw error;
+	}
+	return (await Promise.all(entries.map(async (entry) => {
+		const path = join(root, entry.name);
+		if (entry.isDirectory()) return await listJsonlFiles(path);
+		return entry.isFile() && entry.name.endsWith(".jsonl") ? [path] : [];
+	}))).flat();
+}
+async function parseCodexSession(path) {
+	let content;
+	try {
+		content = await readFile(path, "utf8");
+	} catch (error) {
+		if (isIgnorableHistoryFileError(error)) return null;
+		throw error;
+	}
+	let sessionId = sessionIdFromPath(path);
+	let worktreePath = null;
+	let createdAt = null;
+	let updatedAt = null;
+	let title = null;
+	let isSubagentSession = false;
+	const messages = [];
+	for (const line of content.split(/\n/)) {
+		if (!line.trim()) continue;
+		const event = parseJsonObject(line);
+		const timestamp = getString(event?.timestamp);
+		if (timestamp) {
+			createdAt ??= timestamp;
+			updatedAt = timestamp;
+		}
+		if (event?.type === "session_meta") {
+			const payload = getObject(event.payload);
+			sessionId = getString(payload?.id) ?? sessionId;
+			worktreePath = getString(payload?.cwd) ?? worktreePath;
+			createdAt = getString(payload?.timestamp) ?? createdAt;
+			isSubagentSession = Boolean(getObject(payload?.source)?.subagent);
+			continue;
+		}
+		if (event?.type === "event_msg") {
+			const payload = getObject(event.payload);
+			if (payload?.type === "thread_name_updated") title = getString(payload.thread_name) ?? title;
+			continue;
+		}
+		if (event?.type !== "response_item") continue;
+		const payload = getObject(event.payload);
+		if (payload?.type !== "message") continue;
+		const role = payload.role;
+		if (role !== "assistant" && role !== "user") continue;
+		const text = role === "user" ? stripCodexContextPreamble(extractMessageText(payload.content)) : extractMessageText(payload.content);
+		if (!text) continue;
+		messages.push({
+			createdAt: timestamp ?? updatedAt ?? createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+			role,
+			text
+		});
+		title ??= role === "user" ? truncateTitle(text) : null;
+	}
+	if (isSubagentSession || !sessionId || !worktreePath) return null;
+	return {
+		createdAt: createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+		messages,
+		sessionId,
+		title: title ?? sessionId.slice(0, 8),
+		updatedAt: updatedAt ?? createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+		worktreePath
+	};
+}
+function createImportedCodexSession({ projectId, session, worktree }) {
+	const chatId = createImportedChatId(session.sessionId);
+	return {
+		chat: {
+			id: chatId,
+			projectId,
+			worktreeName: worktree.worktreeName,
+			worktreePath: worktree.worktreePath,
+			branchName: worktree.branchName,
+			codexThreadId: session.sessionId,
+			title: session.title,
+			status: "idle",
+			activeTurnId: null,
+			createdAt: session.createdAt,
+			updatedAt: session.updatedAt
+		},
+		messages: session.messages.map((message, index) => ({
+			id: `${chatId}_msg_${index}`,
+			chatId,
+			role: message.role,
+			text: message.text,
+			createdAt: message.createdAt
+		}))
+	};
+}
+function createImportedChatId(sessionId) {
+	return `chat_codex_${sessionId}`;
+}
+function sessionIdFromPath(path) {
+	return basename(path).replace(/^rollout-/, "").replace(/\.jsonl$/, "");
+}
+function extractMessageText(content) {
+	if (!Array.isArray(content)) return "";
+	return content.map((item) => {
+		return getString(getObject(item)?.text) ?? "";
+	}).filter(Boolean).join("\n\n").trim();
+}
+function stripCodexContextPreamble(text) {
+	let strippedText = text.trimStart();
+	while (true) {
+		if (strippedText.startsWith("# AGENTS.md instructions")) {
+			const instructionsEnd = strippedText.indexOf("</INSTRUCTIONS>");
+			if (instructionsEnd === -1) return "";
+			strippedText = strippedText.slice(instructionsEnd + 15).trimStart();
+			continue;
+		}
+		if (strippedText.startsWith("<environment_context>")) {
+			const contextEnd = strippedText.indexOf("</environment_context>");
+			if (contextEnd === -1) return "";
+			strippedText = strippedText.slice(contextEnd + 22).trimStart();
+			continue;
+		}
+		return strippedText.trim();
+	}
+}
+function truncateTitle(text) {
+	const firstLine = text.trim().split(/\n/)[0] ?? "";
+	return firstLine.length > 32 ? `${firstLine.slice(0, 31)}...` : firstLine;
+}
+function parseJsonObject(line) {
+	try {
+		return getObject(JSON.parse(line));
+	} catch {
+		return null;
+	}
+}
+function getObject(value) {
+	return value && typeof value === "object" ? value : null;
+}
+function getString(value) {
+	return typeof value === "string" ? value : null;
+}
+function isIgnorableHistoryFileError(error) {
+	return Boolean(error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES" || error.code === "EPERM"));
+}
+function isIgnorableHistoryRootError(error) {
+	return Boolean(error && typeof error === "object" && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "EACCES" || error.code === "EPERM"));
+}
+var chatStatusSchema = _enum([
+	"idle",
+	"running",
+	"waitingForApproval",
+	"failed",
+	"archived"
+]);
+var projectRecordBaseSchema = object({
+	id: string(),
+	name: string(),
+	rootPath: string(),
+	createdAt: string(),
+	updatedAt: string(),
+	lastOpenedAt: string()
+});
+var chatMessageRecordBaseSchema = object({
+	id: string(),
+	chatId: string(),
+	role: _enum([
+		"user",
+		"assistant",
+		"event",
+		"error"
+	]),
+	text: string(),
+	eventType: string().optional(),
+	itemId: string().optional(),
+	createdAt: string()
+});
+var chatRecordBaseSchema = object({
+	id: string(),
+	projectId: string(),
+	worktreeName: string(),
+	worktreePath: string(),
+	branchName: string(),
+	codexThreadId: string().nullable(),
+	title: string(),
+	status: chatStatusSchema,
+	activeTurnId: string().nullable().optional(),
+	createdAt: string(),
+	updatedAt: string()
+});
+var nullableStringFromUnknownSchema = preprocess((value) => typeof value === "string" ? value : null, string().nullable());
+object({
+	version: literal(1),
+	projects: array(projectRecordBaseSchema),
+	chats: array(chatRecordBaseSchema),
+	messages: array(chatMessageRecordBaseSchema),
+	selectedProjectId: nullableStringFromUnknownSchema,
+	selectedChatId: nullableStringFromUnknownSchema
+});
+var projectRecordSchema = projectRecordBaseSchema.passthrough();
+var chatMessageRecordSchema = chatMessageRecordBaseSchema.passthrough();
+var chatRecordSchema = chatRecordBaseSchema.passthrough();
+var serveStateSchema = object({
+	version: literal(1),
+	projects: array(projectRecordSchema),
+	chats: array(chatRecordSchema),
+	messages: array(chatMessageRecordSchema),
+	selectedProjectId: nullableStringFromUnknownSchema,
+	selectedChatId: nullableStringFromUnknownSchema
+}).passthrough();
+var STATE_FILE_NAME = "state.json";
+function now() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createEmptyState() {
+	return {
+		version: 1,
+		projects: [],
+		chats: [],
+		messages: [],
+		selectedProjectId: null,
+		selectedChatId: null
+	};
+}
+function getDefaultServeDataDir(env = process.env) {
+	const stateHome = env.XDG_STATE_HOME;
+	return join(stateHome && isAbsolute(stateHome) ? stateHome : join(homedir(), ".local", "state"), "phantom");
+}
+function getServeDataDir() {
+	return process.env.PHANTOM_SERVE_DATA_DIR ?? getDefaultServeDataDir();
+}
+function getStatePath(dataDir) {
+	return join(dataDir, STATE_FILE_NAME);
+}
+function validateState(value) {
+	if (!value || typeof value !== "object") throw new Error("Serve state is not a JSON object");
+	if (value.version !== 1) throw new Error("Unsupported serve state version");
+	const result = serveStateSchema.safeParse(value);
+	if (!result.success) throw new Error("Serve state has an invalid shape");
+	return result.data;
+}
+var ServeStateStore = class {
+	state = null;
+	updateChain = Promise.resolve();
+	constructor(dataDir = getServeDataDir()) {
+		this.dataDir = dataDir;
+	}
+	async loadOrCreateState() {
+		if (this.state) return this.state;
+		const statePath = getStatePath(this.dataDir);
+		try {
+			const content = await readFile(statePath, "utf8");
+			const state = validateState(JSON.parse(content));
+			this.state = state;
+			return state;
+		} catch (error) {
+			if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+				const state = createEmptyState();
+				await this.save(state);
+				return state;
+			} else throw error;
+		}
+	}
+	async load() {
+		if (this.state) return this.state;
+		const nextLoad = this.updateChain.then(() => this.loadOrCreateState());
+		this.updateChain = nextLoad.catch(() => void 0);
+		return nextLoad;
+	}
+	async save(state) {
+		const statePath = getStatePath(this.dataDir);
+		const temporaryPath = `${statePath}.tmp-${process.pid}-${Date.now()}`;
+		await mkdir(dirname(statePath), { recursive: true });
+		await writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}\n`);
+		await rename(temporaryPath, statePath);
+		this.state = state;
+	}
+	async update(updater) {
+		const nextUpdate = this.updateChain.then(async () => {
+			const state = await this.loadOrCreateState();
+			const nextState = await updater({
+				...state,
+				projects: [...state.projects],
+				chats: [...state.chats],
+				messages: [...state.messages]
+			});
+			await this.save(nextState);
+			return nextState;
+		});
+		this.updateChain = nextUpdate.catch(() => void 0);
+		return nextUpdate;
+	}
+};
+function touchProject(project) {
+	const timestamp = now();
+	return {
+		...project,
+		updatedAt: timestamp,
+		lastOpenedAt: timestamp
+	};
+}
+function createRecordId(prefix) {
+	return `${prefix}_${crypto.randomUUID()}`;
+}
+function createTimestamp() {
+	return now();
+}
+var DEFAULT_REPLAY_LIMIT = 300;
+var HEARTBEAT_MS = 15e3;
+function encodeSseEvent(event) {
+	return [
+		`id: ${event.id}`,
+		`event: ${event.type}`,
+		`data: ${JSON.stringify(event)}`,
+		"",
+		""
+	].join("\n");
+}
+var EventHub = class {
+	nextId = 1;
+	events = [];
+	listeners = /* @__PURE__ */ new Set();
+	constructor(replayLimit = DEFAULT_REPLAY_LIMIT) {
+		this.replayLimit = replayLimit;
+	}
+	emit(type, data, options = {}) {
+		const event = {
+			id: this.nextId++,
+			type,
+			scope: options.scope ?? (options.chatId ? "chat" : "global"),
+			chatId: options.chatId,
+			data,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.events.push(event);
+		if (this.events.length > this.replayLimit) this.events.shift();
+		for (const listener of this.listeners) if (listener.filter(event)) listener.send(event);
+		return event;
+	}
+	subscribe(filter, lastEventId) {
+		const encoder = new TextEncoder();
+		let heartbeat;
+		let listener;
+		return new ReadableStream({
+			start: (controller) => {
+				const write = (chunk) => {
+					controller.enqueue(encoder.encode(chunk));
+				};
+				if (lastEventId !== null) {
+					for (const event of this.events) if (event.id > lastEventId && filter(event)) write(encodeSseEvent(event));
+				}
+				listener = {
+					filter,
+					send: (event) => write(encodeSseEvent(event))
+				};
+				this.listeners.add(listener);
+				heartbeat = setInterval(() => {
+					write(": heartbeat\n\n");
+				}, HEARTBEAT_MS);
+			},
+			cancel: () => {
+				if (heartbeat) clearInterval(heartbeat);
+				if (listener) this.listeners.delete(listener);
+			}
+		});
+	}
+	listenerCount() {
+		return this.listeners.size;
+	}
+};
+function createSseResponse(stream) {
+	return new Response(stream, { headers: {
+		"Cache-Control": "no-cache, no-transform",
+		Connection: "keep-alive",
+		"Content-Type": "text/event-stream",
+		"X-Accel-Buffering": "no"
+	} });
+}
+function parseLastEventId(request) {
+	const header = request.headers.get("Last-Event-ID");
+	if (!header) return null;
+	const value = Number.parseInt(header, 10);
+	return Number.isFinite(value) ? value : null;
+}
+var ServeServices = class {
+	eventHub;
+	store;
+	codex;
+	codexHome;
+	loadedThreadIds = /* @__PURE__ */ new Set();
+	approvalRequests = /* @__PURE__ */ new Map();
+	pendingTurnEvents = /* @__PURE__ */ new Map();
+	pendingChatTurns = /* @__PURE__ */ new Set();
+	constructor(options = {}) {
+		this.eventHub = options.eventHub ?? new EventHub();
+		this.store = options.store ?? new ServeStateStore();
+		this.codex = options.codex ?? new CodexBridge();
+		this.codexHome = options.codexHome;
+		this.codex.onNotification((message) => {
+			this.handleCodexNotification(message);
+		});
+		this.codex.onServerRequest((message) => {
+			this.handleCodexServerRequest(message);
+		});
+		this.codex.onProcessExit((error) => {
+			this.handleCodexProcessExit(error);
+		});
+	}
+	async getHealth() {
+		const state = await this.store.load();
+		return {
+			ok: true,
+			projectCount: state.projects.length,
+			chatCount: state.chats.length,
+			codexBin: getCodexBin(),
+			dataDir: process.env.PHANTOM_SERVE_DATA_DIR ?? null
+		};
+	}
+	async listProjects() {
+		return (await this.store.load()).projects;
+	}
+	async addProject(path) {
+		if (!isAbsolute(path)) throw new Error("Project path must be absolute");
+		const rootPath = await getGitRoot({ cwd: await realpath(path) });
+		const timestamp = createTimestamp();
+		let createdProject = null;
+		await this.store.update((state) => {
+			const existingProject = state.projects.find((project) => project.rootPath === rootPath);
+			if (existingProject) {
+				createdProject = touchProject(existingProject);
+				return {
+					...state,
+					projects: state.projects.map((project) => project.id === existingProject.id ? createdProject : project),
+					selectedProjectId: existingProject.id
+				};
+			}
+			createdProject = {
+				id: createRecordId("proj"),
+				name: basename(rootPath),
+				rootPath,
+				createdAt: timestamp,
+				updatedAt: timestamp,
+				lastOpenedAt: timestamp
+			};
+			return {
+				...state,
+				projects: [...state.projects, createdProject],
+				selectedProjectId: createdProject.id
+			};
+		});
+		this.eventHub.emit("project.created", createdProject);
+		return createdProject;
+	}
+	async removeProject(projectId) {
+		await this.store.update((state) => {
+			const removedChatIds = new Set(state.chats.filter((chat) => chat.projectId === projectId).map((chat) => chat.id));
+			return {
+				...state,
+				projects: state.projects.filter((project) => project.id !== projectId),
+				chats: state.chats.filter((chat) => chat.projectId !== projectId),
+				messages: state.messages.filter((message) => !removedChatIds.has(message.chatId)),
+				selectedProjectId: state.selectedProjectId === projectId ? null : state.selectedProjectId,
+				selectedChatId: removedChatIds.has(state.selectedChatId ?? "") ? null : state.selectedChatId
+			};
+		});
+		this.eventHub.emit("project.removed", { projectId });
+	}
+	async listChats(projectId) {
+		return (await this.store.load()).chats.filter((chat) => chat.projectId === projectId);
+	}
+	async listProjectWorktrees(projectId, options = {}) {
+		const state = await this.store.load();
+		if (options.sync === false) return projectWorktreesFromPersistedChats(state, projectId);
+		const project = this.requireProject(state, projectId);
+		let result;
+		try {
+			result = await listWorktrees(project.rootPath);
+		} catch {
+			return projectWorktreesFromPersistedChats(state, projectId);
+		}
+		if (!result.ok) return projectWorktreesFromPersistedChats(state, projectId);
+		const { worktrees } = result.value;
+		const timestamp = createTimestamp();
+		const importedSessions = await listCodexSessionsForWorktrees({
+			codexHome: this.codexHome,
+			projectId,
+			worktrees: worktrees.map((worktree) => ({
+				branchName: worktree.branch,
+				worktreeName: worktree.name,
+				worktreePath: worktree.path
+			}))
+		});
+		if (shouldSyncProjectWorktreeChats({
+			importedSessions,
+			projectId,
+			state,
+			worktrees
+		})) await this.store.update((nextState) => {
+			const existingChatsByPath = new Map(nextState.chats.filter((chat) => chat.projectId === projectId).map((chat) => [chat.worktreePath, chat]));
+			const importedWorktreePaths = new Set(importedSessions.map((session) => session.chat.worktreePath));
+			const chatsToAdd = worktrees.filter((worktree) => !existingChatsByPath.has(worktree.path) && !importedWorktreePaths.has(worktree.path)).map((worktree) => ({
+				id: createRecordId("chat"),
+				projectId,
+				worktreeName: worktree.name,
+				worktreePath: worktree.path,
+				branchName: worktree.branch,
+				codexThreadId: null,
+				title: worktree.name,
+				status: "idle",
+				activeTurnId: null,
+				createdAt: timestamp,
+				updatedAt: timestamp
+			}));
+			const importableSessions = importedSessions.filter((session) => !nextState.chats.some((chat) => shouldPreferExistingChatOverImport(chat, session.chat)));
+			const importableMessages = importableSessions.flatMap((session) => session.messages);
+			if (chatsToAdd.length === 0 && importableSessions.length === 0) return nextState;
+			const chatsToRemove = nextState.chats.filter((chat) => !shouldPreserveChatDuringImport(chat, projectId, importableSessions));
+			const chatIdsToRemove = new Set(chatsToRemove.map((chat) => chat.id));
+			const selectedReplacement = findImportedReplacement(nextState.selectedChatId, chatsToRemove, importableSessions);
+			return {
+				...nextState,
+				chats: [
+					...nextState.chats.filter((chat) => !chatIdsToRemove.has(chat.id)),
+					...importableSessions.map((session) => session.chat),
+					...chatsToAdd
+				],
+				messages: [...nextState.messages.filter((message) => !chatIdsToRemove.has(message.chatId)), ...importableMessages],
+				selectedChatId: nextState.selectedChatId && chatIdsToRemove.has(nextState.selectedChatId) ? selectedReplacement?.chat.id ?? nextState.selectedChatId : nextState.selectedChatId
+			};
+		});
+		const syncedState = await this.store.load();
+		const syncedChatsByPath = /* @__PURE__ */ new Map();
+		for (const chat of syncedState.chats.filter((candidate) => candidate.projectId === projectId)) syncedChatsByPath.set(chat.worktreePath, [...syncedChatsByPath.get(chat.worktreePath) ?? [], chat]);
+		return worktrees.map((worktree) => {
+			const chat = latestChatForWorktree(syncedChatsByPath.get(worktree.path) ?? []);
+			return {
+				name: worktree.name,
+				path: worktree.path,
+				pathToDisplay: worktree.pathToDisplay,
+				branch: worktree.branch,
+				isClean: worktree.isClean,
+				chatId: chat?.id ?? null,
+				chatStatus: chat?.status ?? null,
+				chatTitle: chat?.title ?? worktree.name
+			};
+		});
+	}
+	async createChat(projectId, input) {
+		const state = await this.store.load();
+		const project = this.requireProject(state, projectId);
+		const createResult = await runCreateWorktree({
+			gitRoot: project.rootPath,
+			name: input.name,
+			base: input.base
+		});
+		if (!createResult.ok) throw createResult.error;
+		let importedSessions;
+		try {
+			importedSessions = await listCodexSessionsForWorktree({
+				branchName: createResult.value.name,
+				codexHome: this.codexHome,
+				projectId,
+				worktreeName: createResult.value.name,
+				worktreePath: createResult.value.path
+			});
+		} catch (error) {
+			try {
+				await rollbackCreatedWorktree(project.rootPath, createResult.value.path, createResult.value.name);
+			} catch (rollbackError) {
+				throw new Error(`Failed to import Codex history: ${toErrorMessage(error)}. Rollback failed: ${toErrorMessage(rollbackError)}`);
+			}
+			throw error instanceof Error ? error : new Error(String(error));
+		}
+		const latestImportedSession = importedSessions[0];
+		if (latestImportedSession) {
+			let selectedImportedChat = latestImportedSession.chat;
+			await this.store.update((nextState) => {
+				selectedImportedChat = findExistingChatForImportedSession(nextState.chats, projectId, latestImportedSession.chat) ?? latestImportedSession.chat;
+				return {
+					...mergeImportedSessionsForProject(nextState, projectId, importedSessions),
+					selectedProjectId: projectId,
+					selectedChatId: selectedImportedChat.id
+				};
+			});
+			this.eventHub.emit("chat.created", selectedImportedChat, { chatId: selectedImportedChat.id });
+			return selectedImportedChat;
+		}
+		let codexThreadId;
+		try {
+			codexThreadId = extractThreadId(await this.codex.startThread(createResult.value.path));
+		} catch (error) {
+			try {
+				await rollbackCreatedWorktree(project.rootPath, createResult.value.path, createResult.value.name);
+			} catch (rollbackError) {
+				throw new Error(`Failed to start Codex thread: ${toErrorMessage(error)}. Rollback failed: ${toErrorMessage(rollbackError)}`);
+			}
+			throw error instanceof Error ? error : new Error(String(error));
+		}
+		this.loadedThreadIds.add(codexThreadId);
+		const timestamp = createTimestamp();
+		const chat = {
+			id: createRecordId("chat"),
+			projectId,
+			worktreeName: createResult.value.name,
+			worktreePath: createResult.value.path,
+			branchName: createResult.value.name,
+			codexThreadId,
+			title: createResult.value.name,
+			status: "idle",
+			activeTurnId: null,
+			createdAt: timestamp,
+			updatedAt: timestamp
+		};
+		await this.store.update((nextState) => ({
+			...nextState,
+			chats: [...nextState.chats, chat],
+			selectedProjectId: projectId,
+			selectedChatId: chat.id
+		}));
+		this.eventHub.emit("chat.created", chat, { chatId: chat.id });
+		return chat;
+	}
+	async getChat(chatId) {
+		const state = await this.store.load();
+		return this.requireChat(state, chatId);
+	}
+	async getMessages(chatId) {
+		const state = await this.store.load();
+		this.requireChat(state, chatId);
+		return state.messages.filter((message) => message.chatId === chatId);
+	}
+	async sendMessage(chatId, input) {
+		return this.submitMessage(chatId, input, { requireActiveTurn: false });
+	}
+	async steerMessage(chatId, input) {
+		return this.submitMessage(chatId, input, { requireActiveTurn: true });
+	}
+	async submitMessage(chatId, input, options) {
+		const text = input.text.trim();
+		if (!text) throw new Error("Message text cannot be empty");
+		const state = await this.store.load();
+		const chat = this.requireChat(state, chatId);
+		if (chat.status === "waitingForApproval") throw new Error("Chat is waiting for approval");
+		const previousMessageIds = new Set(state.messages.filter((message) => message.chatId === chatId).map((message) => message.id));
+		const isSteeringActiveTurn = chat.status === "running" && Boolean(chat.activeTurnId);
+		if (options.requireActiveTurn && !isSteeringActiveTurn) throw new Error("Chat does not have an active Codex turn");
+		const turnOptions = await this.createCodexTurnOptions(input, chat);
+		if (!isSteeringActiveTurn) {
+			if (this.pendingChatTurns.has(chatId)) throw new Error("Chat already has an active Codex turn");
+			this.pendingChatTurns.add(chatId);
+		}
+		const userMessage = createMessage(chat.id, "user", text);
+		let nextStatus = null;
+		let nextActiveTurnId;
+		let pendingTurnThreadId = null;
+		let userMessageStored = false;
+		try {
+			await this.store.update((nextState) => ({
+				...nextState,
+				messages: [...nextState.messages, userMessage]
+			}));
+			userMessageStored = true;
+			try {
+				const threadId = await this.ensureThread(chat);
+				const activeTurnId = chat.activeTurnId;
+				if (chat.status === "running" && activeTurnId) if (turnOptions) await this.codex.steerTurn(threadId, activeTurnId, text, turnOptions);
+				else await this.codex.steerTurn(threadId, activeTurnId, text);
+				else {
+					const existingPendingTurn = this.pendingTurnEvents.get(threadId);
+					if (existingPendingTurn) {
+						if (existingPendingTurn.discard) throw new Error("Chat is waiting for failed Codex turn cleanup");
+						throw new Error("Chat already has an active Codex turn");
+					}
+					pendingTurnThreadId = threadId;
+					this.pendingTurnEvents.set(threadId, {
+						chatId,
+						discard: false,
+						events: []
+					});
+					const turnId = extractTurnId(turnOptions ? await this.codex.startTurn(threadId, text, chat.worktreePath, turnOptions) : await this.codex.startTurn(threadId, text, chat.worktreePath));
+					if (turnId) {
+						nextStatus = "running";
+						nextActiveTurnId = turnId;
+					}
+				}
+			} catch (error) {
+				if (pendingTurnThreadId) this.discardPendingTurnEvents(pendingTurnThreadId);
+				await this.store.update((nextState) => ({
+					...nextState,
+					messages: userMessageStored ? nextState.messages.filter((message) => message.id !== userMessage.id && (isSteeringActiveTurn || message.chatId !== chatId || previousMessageIds.has(message.id))) : nextState.messages,
+					chats: isSteeringActiveTurn ? nextState.chats : nextState.chats.map((candidate) => candidate.id === chatId ? {
+						...candidate,
+						status: "failed",
+						activeTurnId: chat.activeTurnId ?? null,
+						updatedAt: createTimestamp()
+					} : candidate)
+				}));
+				this.eventHub.emit("agent.error", { message: toErrorMessage(error) }, { chatId });
+				throw error instanceof Error ? error : new Error(String(error));
+			}
+			await this.store.update((nextState) => ({
+				...nextState,
+				chats: nextState.chats.map((candidate) => candidate.id === chatId && nextStatus ? {
+					...candidate,
+					status: nextStatus,
+					activeTurnId: nextActiveTurnId,
+					updatedAt: createTimestamp()
+				} : candidate)
+			}));
+			this.eventHub.emit("chat.message.created", userMessage, { chatId });
+			if (pendingTurnThreadId) await this.flushPendingTurnEvents(pendingTurnThreadId);
+			return await this.getChat(chatId);
+		} finally {
+			if (!isSteeringActiveTurn) this.pendingChatTurns.delete(chatId);
+		}
+	}
+	async interruptChat(chatId) {
+		const chat = await this.getChat(chatId);
+		if (!chat.codexThreadId || !chat.activeTurnId) throw new Error("Chat does not have an active Codex turn");
+		await this.codex.interruptTurn(chat.codexThreadId, chat.activeTurnId);
+	}
+	async answerApproval(chatId, requestId, input) {
+		const chat = await this.getChat(chatId);
+		const pendingApproval = this.approvalRequests.get(requestId);
+		if (!pendingApproval) throw new Error(`Approval request '${requestId}' was not found`);
+		if (pendingApproval.chatId !== chat.id) throw new Error(`Approval request '${requestId}' does not belong to chat '${chatId}'`);
+		if (pendingApproval.responded) throw new Error(`Approval request '${requestId}' was already answered`);
+		this.codex.respondToServerRequest(pendingApproval.serverRequestId, { decision: input.decision });
+		this.approvalRequests.set(requestId, {
+			...pendingApproval,
+			responded: true
+		});
+		this.eventHub.emit("agent.approval.answered", {
+			requestId,
+			decision: input.decision
+		}, { chatId: chat.id });
+	}
+	declineApprovalRequest(requestId) {
+		try {
+			this.codex.respondToServerRequest(requestId, { decision: "decline" });
+		} catch (error) {
+			this.eventHub.emit("agent.error", {
+				message: "Failed to decline unmapped Codex approval request",
+				requestId,
+				error: toErrorMessage(error)
+			});
+		}
+	}
+	async readAuth() {
+		return this.codex.readAccount();
+	}
+	async listModels() {
+		return normalizeModelRecords(await this.codex.listModels());
+	}
+	async listSkills(chatId) {
+		const chat = await this.getChat(chatId);
+		return normalizeSkillRecords(await this.codex.listSkills([chat.worktreePath]));
+	}
+	async searchFiles(chatId, query) {
+		const trimmedQuery = query.trim();
+		if (!trimmedQuery) return [];
+		const chat = await this.getChat(chatId);
+		return normalizeFileRecords(await this.codex.searchFiles(trimmedQuery, [chat.worktreePath]));
+	}
+	async createCodexTurnOptions(input, chat) {
+		const files = await normalizeFileContextItems(input.files, chat.worktreePath);
+		const skills = await this.normalizeSkillContextItems(input.skills, chat.worktreePath);
+		if (!input.effort && !input.model && files.length === 0 && skills.length === 0) return;
+		return {
+			effort: input.effort,
+			files: files.length > 0 ? files : void 0,
+			model: input.model,
+			skills: skills.length > 0 ? skills : void 0
+		};
+	}
+	async normalizeSkillContextItems(items, worktreePath) {
+		const normalized = normalizeTurnContextItems(items);
+		if (normalized.length === 0) return [];
+		const availableSkills = normalizeSkillRecords(await this.codex.listSkills([worktreePath]));
+		const skillsByPath = new Map(availableSkills.filter((skill) => skill.enabled).map((skill) => [skill.path, skill]));
+		return normalized.map((item) => {
+			const skill = skillsByPath.get(item.path);
+			if (!skill) throw new Error(`Skill context path is not available: ${item.path}`);
+			return {
+				name: skill.name,
+				path: skill.path
+			};
+		});
+	}
+	async ensureThread(chat) {
+		if (chat.codexThreadId) {
+			if (!this.loadedThreadIds.has(chat.codexThreadId)) {
+				await this.codex.resumeThread(chat.codexThreadId, chat.worktreePath);
+				this.loadedThreadIds.add(chat.codexThreadId);
+			}
+			return chat.codexThreadId;
+		}
+		const threadId = extractThreadId(await this.codex.startThread(chat.worktreePath));
+		this.loadedThreadIds.add(threadId);
+		await this.store.update((state) => ({
+			...state,
+			chats: state.chats.map((candidate) => candidate.id === chat.id ? {
+				...candidate,
+				codexThreadId: threadId,
+				updatedAt: createTimestamp()
+			} : candidate)
+		}));
+		return threadId;
+	}
+	async handleCodexProcessExit(error) {
+		this.loadedThreadIds.clear();
+		this.approvalRequests.clear();
+		this.pendingTurnEvents.clear();
+		this.pendingChatTurns.clear();
+		const affectedChatIds = [];
+		await this.store.update((state) => ({
+			...state,
+			chats: state.chats.map((chat) => {
+				if (!(chat.status === "running" || chat.status === "waitingForApproval" || Boolean(chat.activeTurnId))) return chat;
+				affectedChatIds.push(chat.id);
+				return {
+					...chat,
+					status: "failed",
+					activeTurnId: null,
+					updatedAt: createTimestamp()
+				};
+			})
+		}));
+		for (const chatId of affectedChatIds) this.eventHub.emit("agent.error", {
+			message: "Codex App Server exited; chat turn state was reset",
+			error: error.message
+		}, { chatId });
+	}
+	async handleCodexNotification(message) {
+		const threadId = extractThreadIdFromParams(message.params);
+		if (threadId && this.bufferPendingTurnEvent(threadId, {
+			kind: "notification",
+			message
+		})) return;
+		await this.processCodexNotification(message);
+	}
+	async processCodexNotification(message) {
+		const method = message.method ?? "unknown";
+		const threadId = extractThreadIdFromParams(message.params);
+		const chat = threadId ? await this.findChatByThreadId(threadId) : null;
+		const eventType = mapCodexMethodToEvent(method);
+		if (chat) {
+			if (!await this.applyCodexStateChange(chat.id, method, message.params)) return;
+			await this.addMessageFromCodexEvent(chat.id, method, message.params);
+			this.eventHub.emit(eventType, message, { chatId: chat.id });
+		} else {
+			if (method === "serverRequest/resolved") return;
+			this.eventHub.emit(eventType, message);
+		}
+	}
+	async handleCodexServerRequest(message) {
+		const threadId = extractThreadIdFromParams(message.params);
+		if (threadId && this.bufferPendingTurnEvent(threadId, {
+			kind: "serverRequest",
+			message
+		})) return;
+		await this.processCodexServerRequest(message);
+	}
+	async processCodexServerRequest(message) {
+		const threadId = extractThreadIdFromParams(message.params);
+		const chat = threadId ? await this.findChatByThreadId(threadId) : null;
+		const serverRequestId = getServerRequestId(message.id);
+		if (!chat) {
+			if (serverRequestId !== null) this.declineApprovalRequest(serverRequestId);
+			this.eventHub.emit("agent.error", {
+				message: "Codex approval request could not be mapped to a chat",
+				method: message.method,
+				requestId: serverRequestId
+			});
+			return;
+		}
+		if (serverRequestId === null) {
+			this.eventHub.emit("agent.error", {
+				message: "Codex approval request did not include a request id",
+				method: message.method
+			}, { chatId: chat.id });
+			return;
+		}
+		if (!chat.activeTurnId) {
+			this.declineApprovalRequest(serverRequestId);
+			this.eventHub.emit("agent.error", {
+				message: "Codex approval request did not belong to an active turn",
+				method: message.method,
+				requestId: serverRequestId
+			}, { chatId: chat.id });
+			return;
+		}
+		const requestTurnId = extractTurnIdFromParams(message.params);
+		if (requestTurnId !== null && requestTurnId !== chat.activeTurnId) {
+			this.declineApprovalRequest(serverRequestId);
+			this.eventHub.emit("agent.error", {
+				message: "Codex approval request belonged to a stale turn",
+				method: message.method,
+				requestId: serverRequestId,
+				turnId: requestTurnId
+			}, { chatId: chat.id });
+			return;
+		}
+		const approvalRequestId = createRecordId("approval");
+		this.approvalRequests.set(approvalRequestId, {
+			chatId: chat.id,
+			serverRequestId,
+			responded: false
+		});
+		await this.updateChatStatus(chat.id, "waitingForApproval", chat.activeTurnId);
+		this.eventHub.emit("agent.approval.requested", {
+			requestId: approvalRequestId,
+			method: message.method,
+			params: message.params
+		}, { chatId: chat.id });
+	}
+	async flushPendingTurnEvents(threadId) {
+		const pendingTurnEvents = this.pendingTurnEvents.get(threadId);
+		if (!pendingTurnEvents || pendingTurnEvents.discard) {
+			this.pendingTurnEvents.delete(threadId);
+			return;
+		}
+		while (!pendingTurnEvents.discard && pendingTurnEvents.events.length > 0) {
+			const pendingEvent = pendingTurnEvents.events.shift();
+			if (!pendingEvent) continue;
+			if (pendingEvent.kind === "notification") await this.processCodexNotification(pendingEvent.message);
+			else await this.processCodexServerRequest(pendingEvent.message);
+		}
+		if (this.pendingTurnEvents.get(threadId) === pendingTurnEvents) this.pendingTurnEvents.delete(threadId);
+	}
+	bufferPendingTurnEvent(threadId, event) {
+		const pendingTurnEvents = this.pendingTurnEvents.get(threadId);
+		if (!pendingTurnEvents) return false;
+		if (pendingTurnEvents.discard) {
+			if (event.kind === "serverRequest") {
+				const serverRequestId = getServerRequestId(event.message.id);
+				if (serverRequestId !== null) this.declineApprovalRequest(serverRequestId);
+			}
+			return true;
+		}
+		pendingTurnEvents.events.push(event);
+		return true;
+	}
+	discardPendingTurnEvents(threadId) {
+		const pendingTurnEvents = this.pendingTurnEvents.get(threadId);
+		if (!pendingTurnEvents) return;
+		for (const pendingEvent of pendingTurnEvents.events) {
+			if (pendingEvent.kind !== "serverRequest") continue;
+			const serverRequestId = getServerRequestId(pendingEvent.message.id);
+			if (serverRequestId !== null) this.declineApprovalRequest(serverRequestId);
+		}
+		pendingTurnEvents.discard = true;
+		pendingTurnEvents.events = [];
+		setTimeout(() => {
+			if (this.pendingTurnEvents.get(threadId) === pendingTurnEvents) this.pendingTurnEvents.delete(threadId);
+		}, 3e4).unref?.();
+	}
+	async findChatByThreadId(threadId) {
+		return (await this.store.load()).chats.find((chat) => chat.codexThreadId === threadId) ?? null;
+	}
+	async applyCodexStateChange(chatId, method, params) {
+		if (method === "turn/started") {
+			await this.updateChatStatus(chatId, "running", extractTurnId({ turn: getParamObject(params)?.turn }));
+			return true;
+		}
+		if (method === "turn/completed") {
+			const turn = getParamObject(params)?.turn;
+			await this.updateChatStatus(chatId, turn?.status === "failed" ? "failed" : "idle", null);
+			return true;
+		}
+		if (method === "serverRequest/resolved") {
+			const serverRequestId = extractServerRequestIdFromParams(params);
+			if (serverRequestId === null) return false;
+			if (!this.deleteApprovalRequestByServerId(chatId, serverRequestId)) return false;
+			await this.updateChatStatus(chatId, "running", void 0);
+		}
+		return true;
+	}
+	deleteApprovalRequestByServerId(chatId, serverRequestId) {
+		let wasTracked = false;
+		for (const [approvalRequestId, approvalRequest] of this.approvalRequests) if (approvalRequest.chatId === chatId && approvalRequest.serverRequestId === serverRequestId) {
+			this.approvalRequests.delete(approvalRequestId);
+			wasTracked = true;
+		}
+		return wasTracked;
+	}
+	async updateChatStatus(chatId, status, activeTurnId) {
+		await this.store.update((state) => ({
+			...state,
+			chats: state.chats.map((chat) => chat.id === chatId ? {
+				...chat,
+				status,
+				activeTurnId: activeTurnId === void 0 ? chat.activeTurnId : activeTurnId,
+				updatedAt: createTimestamp()
+			} : chat)
+		}));
+	}
+	async addMessageFromCodexEvent(chatId, method, params) {
+		const paramObject = getParamObject(params);
+		if (!paramObject) return;
+		if (method === "item/agentMessage/delta") {
+			const itemId = typeof paramObject.itemId === "string" ? paramObject.itemId : void 0;
+			const delta = typeof paramObject.delta === "string" ? paramObject.delta : "";
+			if (!itemId || !delta) return;
+			await this.store.update((state) => {
+				const existingMessage = state.messages.find((message) => message.chatId === chatId && message.itemId === itemId);
+				if (!existingMessage) return {
+					...state,
+					messages: [...state.messages, createMessage(chatId, "assistant", delta, method, itemId)]
+				};
+				return {
+					...state,
+					messages: state.messages.map((message) => message.id === existingMessage.id ? {
+						...message,
+						text: `${message.text}${delta}`
+					} : message)
+				};
+			});
+			return;
+		}
+		if (method === "item/started" || method === "item/completed" || method === "turn/completed" || method === "error") {
+			const role = method === "error" ? "error" : "event";
+			await this.store.update((state) => ({
+				...state,
+				messages: [...state.messages, createMessage(chatId, role, summarizeCodexEvent(method, params), method)]
+			}));
+		}
+	}
+	requireProject(state, projectId) {
+		const project = state.projects.find((candidate) => candidate.id === projectId);
+		if (!project) throw new Error(`Project '${projectId}' not found`);
+		return project;
+	}
+	requireChat(state, chatId) {
+		const chat = state.chats.find((candidate) => candidate.id === chatId);
+		if (!chat) throw new Error(`Chat '${chatId}' not found`);
+		return chat;
+	}
+};
+function createMessage(chatId, role, text, eventType, itemId) {
+	return {
+		id: createRecordId("msg"),
+		chatId,
+		role,
+		text,
+		eventType,
+		itemId,
+		createdAt: createTimestamp()
+	};
+}
+function latestChatForWorktree(chats) {
+	const sortedChats = [...chats].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+	return sortedChats.find((chat) => chat.codexThreadId) ?? sortedChats[0] ?? null;
+}
+function projectWorktreesFromPersistedChats(state, projectId) {
+	const chatsByPath = /* @__PURE__ */ new Map();
+	for (const chat of state.chats.filter((chat) => chat.projectId === projectId)) chatsByPath.set(chat.worktreePath, [...chatsByPath.get(chat.worktreePath) ?? [], chat]);
+	return Array.from(chatsByPath.values()).map((chats) => latestChatForWorktree(chats)).filter((chat) => Boolean(chat)).sort((left, right) => left.worktreeName.localeCompare(right.worktreeName)).map((chat) => ({
+		name: chat.worktreeName,
+		path: chat.worktreePath,
+		pathToDisplay: chat.worktreePath,
+		branch: chat.branchName,
+		isClean: true,
+		chatId: chat.id,
+		chatStatus: chat.status,
+		chatTitle: chat.title
+	}));
+}
+function shouldSyncProjectWorktreeChats({ importedSessions, projectId, state, worktrees }) {
+	const existingChatsByPath = new Map(state.chats.filter((chat) => chat.projectId === projectId).map((chat) => [chat.worktreePath, chat]));
+	const importedWorktreePaths = new Set(importedSessions.map((session) => session.chat.worktreePath));
+	return worktrees.some((worktree) => !existingChatsByPath.has(worktree.path) && !importedWorktreePaths.has(worktree.path)) || importedSessions.some((session) => !state.chats.some((chat) => shouldPreferExistingChatOverImport(chat, session.chat)));
+}
+function shouldPreferExistingChatOverImport(chat, importedChat) {
+	if (chat.projectId !== importedChat.projectId) return false;
+	if (chat.codexThreadId !== null && chat.codexThreadId === importedChat.codexThreadId) return true;
+	if (chat.codexThreadId !== null) return false;
+	return Boolean(chat.activeTurnId || chat.status === "running" || chat.status === "waitingForApproval") && chat.worktreePath === importedChat.worktreePath;
+}
+function findExistingChatForImportedSession(chats, projectId, importedChat) {
+	return chats.find((chat) => chat.projectId === projectId && (chat.id === importedChat.id || shouldPreferExistingChatOverImport(chat, importedChat))) ?? null;
+}
+function mergeImportedSessionsForProject(state, projectId, importedSessions) {
+	const importableSessions = importedSessions.filter((session) => !state.chats.some((chat) => shouldPreferExistingChatOverImport(chat, session.chat)));
+	const chatsToRemove = state.chats.filter((chat) => !shouldPreserveChatDuringImport(chat, projectId, importableSessions));
+	const chatIdsToRemove = new Set(chatsToRemove.map((chat) => chat.id));
+	return {
+		...state,
+		chats: [...state.chats.filter((chat) => !chatIdsToRemove.has(chat.id)), ...importableSessions.map((session) => session.chat)],
+		messages: [...state.messages.filter((message) => !chatIdsToRemove.has(message.chatId)), ...importableSessions.flatMap((session) => session.messages)]
+	};
+}
+function shouldPreserveChatDuringImport(chat, projectId, importedSessions) {
+	if (chat.projectId !== projectId) return true;
+	if (chat.activeTurnId || chat.status === "running" || chat.status === "waitingForApproval") return true;
+	return !importedSessions.some((session) => {
+		const importedChat = session.chat;
+		return chat.id === importedChat.id || chat.codexThreadId !== null && chat.codexThreadId === importedChat.codexThreadId || chat.codexThreadId === null && chat.worktreePath === importedChat.worktreePath;
+	});
+}
+function findImportedReplacement(selectedChatId, removedChats, importedSessions) {
+	const removedChat = removedChats.find((chat) => chat.id === selectedChatId);
+	if (!removedChat) return null;
+	return importedSessions.find((session) => {
+		const importedChat = session.chat;
+		return removedChat.codexThreadId === importedChat.codexThreadId || removedChat.worktreePath === importedChat.worktreePath;
+	}) ?? null;
+}
+function normalizeTurnContextItems(items) {
+	return (items ?? []).map((item) => ({
+		name: item.name.trim(),
+		path: item.path.trim()
+	})).filter((item) => item.name && item.path);
+}
+async function normalizeFileContextItems(items, worktreePath) {
+	const normalized = normalizeTurnContextItems(items);
+	if (normalized.length === 0) return [];
+	const realWorktreePath = await realpath(worktreePath);
+	return await Promise.all(normalized.map(async (item) => {
+		const resolvedPath = resolve(item.path);
+		if (!isPathInside(worktreePath, resolvedPath)) throw new Error(`File context path must be within the chat worktree: ${item.path}`);
+		let realFilePath;
+		try {
+			realFilePath = await realpath(resolvedPath);
+		} catch {
+			throw new Error(`File context path is not an existing file: ${item.path}`);
+		}
+		if (!isPathInside(realWorktreePath, realFilePath)) throw new Error(`File context path must resolve within the chat worktree: ${item.path}`);
+		if (!(await stat(realFilePath)).isFile()) throw new Error(`File context path is not a file: ${item.path}`);
+		return {
+			name: item.name,
+			path: resolvedPath
+		};
+	}));
+}
+function isPathInside(rootPath, candidatePath) {
+	const relativePath = relative(resolve(rootPath), resolve(candidatePath));
+	return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+}
+function normalizeModelRecords(value) {
+	return (getRecordArray(value, "data") ?? getRecordArray(value, "models") ?? []).map((model) => {
+		const id = getRecordString(model, "id") ?? getRecordString(model, "model");
+		if (!id) return null;
+		return {
+			id,
+			model: getRecordString(model, "model") ?? id,
+			displayName: getRecordString(model, "displayName") ?? id,
+			description: getRecordString(model, "description") ?? "",
+			defaultReasoningEffort: getRecordString(model, "defaultReasoningEffort") ?? null,
+			inputModalities: getStringArray(model.inputModalities),
+			isDefault: model.isDefault === true,
+			supportedReasoningEfforts: getReasoningEfforts(model)
+		};
+	}).filter((model) => Boolean(model));
+}
+function normalizeSkillRecords(value) {
+	return (getRecordArray(value, "data") ?? getRecordArray(value, "skills") ?? []).flatMap((entry) => {
+		if (Array.isArray(entry.skills)) return entry.skills.filter(isRecord);
+		return isRecord(entry) ? [entry] : [];
+	}).map((skill) => {
+		const name = getRecordString(skill, "name");
+		const path = getRecordString(skill, "path");
+		if (!name || !path) return null;
+		const skillInterface = isRecord(skill.interface) ? skill.interface : null;
+		const shortDescription = getRecordString(skillInterface, "shortDescription") ?? getRecordString(skill, "shortDescription") ?? null;
+		return {
+			name,
+			path,
+			displayName: getRecordString(skillInterface, "displayName") ?? name,
+			description: getRecordString(skill, "description") ?? "",
+			shortDescription,
+			enabled: skill.enabled !== false
+		};
+	}).filter((skill) => Boolean(skill));
+}
+function normalizeFileRecords(value) {
+	return (getRecordArray(value, "files") ?? []).map((file) => {
+		const matchType = getRecordString(file, "match_type");
+		if (matchType && matchType !== "file") return null;
+		const root = getRecordString(file, "root");
+		const relativePath = getRecordString(file, "path");
+		if (!root || !relativePath) return null;
+		return {
+			name: getRecordString(file, "file_name") ?? relativePath.split("/").pop() ?? relativePath,
+			path: join(root, relativePath),
+			relativePath,
+			root,
+			score: typeof file.score === "number" && Number.isFinite(file.score) ? file.score : 0
+		};
+	}).filter((file) => Boolean(file));
+}
+function getReasoningEfforts(model) {
+	const supported = model.supportedReasoningEfforts;
+	if (!Array.isArray(supported)) return [];
+	return supported.map((effort) => typeof effort === "string" ? effort : getRecordString(effort, "reasoningEffort")).filter((effort) => Boolean(effort));
+}
+function getRecordArray(value, key) {
+	if (!isRecord(value)) return;
+	const candidate = value[key];
+	if (!Array.isArray(candidate)) return;
+	return candidate.filter(isRecord);
+}
+function getRecordString(value, key) {
+	if (!isRecord(value)) return;
+	const candidate = value[key];
+	return typeof candidate === "string" ? candidate : void 0;
+}
+function getStringArray(value) {
+	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function isRecord(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function rollbackCreatedWorktree(gitRoot, worktreePath, branchName) {
+	const errors = [];
+	try {
+		await removeWorktree(gitRoot, worktreePath, true);
+	} catch (error) {
+		errors.push(`worktree remove failed: ${toErrorMessage(error)}`);
+	}
+	const branchResult = await deleteBranch(gitRoot, branchName);
+	if (!branchResult.ok) errors.push(`branch delete failed: ${branchResult.error.message}`);
+	if (errors.length > 0) throw new Error(errors.join("; "));
+}
+var services = null;
+function getServeServices() {
+	services ??= new ServeServices();
+	return services;
+}
+var Route$12 = createFileRoute("/api/projects")({ server: { handlers: {
+	GET: async () => {
+		try {
+			return json({ projects: await getServeServices().listProjects() });
+		} catch (error) {
+			return handleApiError(error);
+		}
+	},
+	POST: async ({ request }) => {
+		try {
+			const path = getString$1(await readJsonObject(request), "path");
+			if (!path) throw new Error("Project path is required");
+			return json({ project: await getServeServices().addProject(path) }, { status: 201 });
+		} catch (error) {
+			return handleApiError(error);
+		}
+	}
+} } });
+var Route$11 = createFileRoute("/api/models")({ server: { handlers: { GET: async () => {
+	try {
+		return json({ models: await getServeServices().listModels() });
+	} catch (error) {
+		return handleApiError(error);
+	}
+} } } });
+var Route$10 = createFileRoute("/api/health")({ server: { handlers: { GET: async () => {
+	try {
+		return json(await getServeServices().getHealth());
+	} catch (error) {
+		return handleApiError(error);
+	}
+} } } });
+var Route$9 = createFileRoute("/api/events")({ server: { handlers: { GET: async ({ request }) => {
+	return createSseResponse(getServeServices().eventHub.subscribe((event) => event.scope === "global", parseLastEventId(request)));
+} } } });
+var Route$8 = createFileRoute("/api/auth")({ server: { handlers: { GET: async () => {
+	try {
+		return json({ auth: await getServeServices().readAuth() });
+	} catch (error) {
+		return handleApiError(error);
+	}
+} } } });
+var Route$7 = createFileRoute("/api/projects/$projectId")({ server: { handlers: { DELETE: async ({ params }) => {
+	try {
+		if (!params.projectId) throw new Error("Project id is required");
+		await getServeServices().removeProject(params.projectId);
+		return json({});
+	} catch (error) {
+		return handleApiError(error);
+	}
+} } } });
+var Route$6 = createFileRoute("/api/chats/$chatId")({ server: { handlers: { GET: async ({ request, params }) => {
+	try {
+		if (!params.chatId) throw new Error("Chat id is required");
+		const services = getServeServices();
+		const searchParams = new URL(request.url).searchParams;
+		if (searchParams.get("context") === "skills") return json({ skills: await services.listSkills(params.chatId) });
+		const fileQuery = searchParams.get("fileQuery");
+		if (fileQuery !== null) return json({ files: await services.searchFiles(params.chatId, fileQuery) });
+		return json({ chat: await services.getChat(params.chatId) });
+	} catch (error) {
+		return handleApiError(error);
+	}
+} } } });
+var Route$5 = createFileRoute("/api/projects/$projectId/chats")({ server: { handlers: {
+	GET: async ({ request, params }) => {
+		try {
+			if (!params.projectId) throw new Error("Project id is required");
+			const services = getServeServices();
+			const shouldSync = new URL(request.url).searchParams.get("sync") === "1";
+			const worktrees = await services.listProjectWorktrees(params.projectId, { sync: shouldSync });
+			return json({
+				chats: await services.listChats(params.projectId),
+				worktrees
+			});
+		} catch (error) {
+			return handleApiError(error);
+		}
+	},
+	POST: async ({ request, params }) => {
+		try {
+			if (!params.projectId) throw new Error("Project id is required");
+			const body = await readJsonObject(request);
+			return json({ chat: await getServeServices().createChat(params.projectId, {
+				name: getString$1(body, "name"),
+				base: getString$1(body, "base")
+			}) }, { status: 201 });
+		} catch (error) {
+			return handleApiError(error);
+		}
+	}
+} } });
+var Route$4 = createFileRoute("/api/chats/$chatId/steer")({ server: { handlers: { POST: async ({ request, params }) => {
+	try {
+		if (!params.chatId) throw new Error("Chat id is required");
+		const text = getString$1(await readJsonObject(request), "text");
+		if (!text) throw new Error("Message text is required");
+		return json({ chat: await getServeServices().steerMessage(params.chatId, { text }) });
+	} catch (error) {
+		return handleApiError(error);
+	}
+} } } });
+var Route$3 = createFileRoute("/api/chats/$chatId/messages")({ server: { handlers: {
+	GET: async ({ params }) => {
+		try {
+			if (!params.chatId) throw new Error("Chat id is required");
+			return json({ messages: await getServeServices().getMessages(params.chatId) });
+		} catch (error) {
+			return handleApiError(error);
+		}
+	},
+	POST: async ({ request, params }) => {
+		try {
+			if (!params.chatId) throw new Error("Chat id is required");
+			const body = await readJsonObject(request);
+			const text = getString$1(body, "text");
+			if (!text) throw new Error("Message text is required");
+			return json({ chat: await getServeServices().sendMessage(params.chatId, {
+				effort: getString$1(body, "effort"),
+				files: getContextItems(body, "files"),
+				model: getString$1(body, "model"),
+				skills: getContextItems(body, "skills"),
+				text
+			}) });
+		} catch (error) {
+			return handleApiError(error);
+		}
+	}
+} } });
+function getContextItems(body, key) {
+	const value = body[key];
+	if (!Array.isArray(value)) return;
+	return value.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return null;
+		const record = item;
+		return {
+			name: typeof record.name === "string" ? record.name : "",
+			path: typeof record.path === "string" ? record.path : ""
+		};
+	}).filter((item) => Boolean(item?.name && item.path));
+}
+var Route$2 = createFileRoute("/api/chats/$chatId/interrupt")({ server: { handlers: { POST: async ({ params }) => {
+	try {
+		if (!params.chatId) throw new Error("Chat id is required");
+		await getServeServices().interruptChat(params.chatId);
+		return json({});
+	} catch (error) {
+		return handleApiError(error);
+	}
+} } } });
+var Route$1 = createFileRoute("/api/chats/$chatId/events")({ server: { handlers: { GET: async ({ request, params }) => {
+	const chatId = params.chatId;
+	return createSseResponse(getServeServices().eventHub.subscribe((event) => event.scope === "global" || Boolean(chatId) && event.chatId === chatId, parseLastEventId(request)));
+} } } });
+var allowedDecisions = new Set([
+	"accept",
+	"acceptForSession",
+	"decline",
+	"cancel"
+]);
+var Route = createFileRoute("/api/chats/$chatId/approvals/$requestId")({ server: { handlers: { POST: async ({ request, params }) => {
+	try {
+		if (!params.chatId || !params.requestId) throw new Error("Chat id and request id are required");
+		const decision = getString$1(await readJsonObject(request), "decision");
+		if (!decision || !allowedDecisions.has(decision)) throw new Error("Approval decision is invalid");
+		await getServeServices().answerApproval(params.chatId, params.requestId, { decision });
+		return json({});
+	} catch (error) {
+		return handleApiError(error);
+	}
+} } } });
+var IndexRoute = Route$13.update({
+	id: "/",
+	path: "/",
+	getParentRoute: () => Route$14
+});
+var ApiProjectsRoute = Route$12.update({
+	id: "/api/projects",
+	path: "/api/projects",
+	getParentRoute: () => Route$14
+});
+var ApiModelsRoute = Route$11.update({
+	id: "/api/models",
+	path: "/api/models",
+	getParentRoute: () => Route$14
+});
+var ApiHealthRoute = Route$10.update({
+	id: "/api/health",
+	path: "/api/health",
+	getParentRoute: () => Route$14
+});
+var ApiEventsRoute = Route$9.update({
+	id: "/api/events",
+	path: "/api/events",
+	getParentRoute: () => Route$14
+});
+var ApiAuthRoute = Route$8.update({
+	id: "/api/auth",
+	path: "/api/auth",
+	getParentRoute: () => Route$14
+});
+var ApiProjectsProjectIdRoute = Route$7.update({
+	id: "/$projectId",
+	path: "/$projectId",
+	getParentRoute: () => ApiProjectsRoute
+});
+var ApiChatsChatIdRoute = Route$6.update({
+	id: "/api/chats/$chatId",
+	path: "/api/chats/$chatId",
+	getParentRoute: () => Route$14
+});
+var ApiProjectsProjectIdChatsRoute = Route$5.update({
+	id: "/chats",
+	path: "/chats",
+	getParentRoute: () => ApiProjectsProjectIdRoute
+});
+var ApiChatsChatIdSteerRoute = Route$4.update({
+	id: "/steer",
+	path: "/steer",
+	getParentRoute: () => ApiChatsChatIdRoute
+});
+var ApiChatsChatIdMessagesRoute = Route$3.update({
+	id: "/messages",
+	path: "/messages",
+	getParentRoute: () => ApiChatsChatIdRoute
+});
+var ApiChatsChatIdInterruptRoute = Route$2.update({
+	id: "/interrupt",
+	path: "/interrupt",
+	getParentRoute: () => ApiChatsChatIdRoute
+});
+var ApiChatsChatIdEventsRoute = Route$1.update({
+	id: "/events",
+	path: "/events",
+	getParentRoute: () => ApiChatsChatIdRoute
+});
+var ApiChatsChatIdApprovalsRequestIdRoute = Route.update({
+	id: "/approvals/$requestId",
+	path: "/approvals/$requestId",
+	getParentRoute: () => ApiChatsChatIdRoute
+});
+var ApiProjectsProjectIdRouteChildren = { ApiProjectsProjectIdChatsRoute };
+var ApiProjectsRouteChildren = { ApiProjectsProjectIdRoute: ApiProjectsProjectIdRoute._addFileChildren(ApiProjectsProjectIdRouteChildren) };
+var ApiProjectsRouteWithChildren = ApiProjectsRoute._addFileChildren(ApiProjectsRouteChildren);
+var ApiChatsChatIdRouteChildren = {
+	ApiChatsChatIdEventsRoute,
+	ApiChatsChatIdInterruptRoute,
+	ApiChatsChatIdMessagesRoute,
+	ApiChatsChatIdSteerRoute,
+	ApiChatsChatIdApprovalsRequestIdRoute
+};
+var rootRouteChildren = {
+	IndexRoute,
+	ApiAuthRoute,
+	ApiEventsRoute,
+	ApiHealthRoute,
+	ApiModelsRoute,
+	ApiProjectsRoute: ApiProjectsRouteWithChildren,
+	ApiChatsChatIdRoute: ApiChatsChatIdRoute._addFileChildren(ApiChatsChatIdRouteChildren)
+};
+var routeTree = Route$14._addFileChildren(rootRouteChildren)._addFileTypes();
+function getRouter() {
+	return createRouter({
+		routeTree,
+		scrollRestoration: true
+	});
+}
+//#endregion
+export { getRouter };