@solaqua/gji 0.5.0 → 0.6.0

package/dist/gji-bundle.mjs

@@ -3951,8 +3951,8 @@ var require_graceful_fs = __commonJS({
       fs6.createReadStream = createReadStream;
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile4;
-      function readFile4(path9, options, cb) {
+      fs6.readFile = readFile5;
+      function readFile5(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path9, options, cb);
@@ -3968,8 +3968,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile5;
-      function writeFile5(path9, data, options, cb) {
+      fs6.writeFile = writeFile7;
+      function writeFile7(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path9, data, options, cb);
@@ -5386,7 +5386,7 @@ var require_minimist = __commonJS({
 var require_rc = __commonJS({
   "node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports, module) {
     var cc = require_utils();
-    var join7 = __require("path").join;
+    var join9 = __require("path").join;
     var deepExtend = require_deep_extend();
     var etc = "/etc";
     var win = process.platform === "win32";
@@ -5411,15 +5411,15 @@ var require_rc = __commonJS({
       }
       if (!win)
         [
-          join7(etc, name, "config"),
-          join7(etc, name + "rc")
+          join9(etc, name, "config"),
+          join9(etc, name + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join7(home, ".config", name, "config"),
-          join7(home, ".config", name),
-          join7(home, "." + name, "config"),
-          join7(home, "." + name + "rc")
+          join9(home, ".config", name, "config"),
+          join9(home, ".config", name),
+          join9(home, "." + name, "config"),
+          join9(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
       if (env4.config) addConfigFile(env4.config);
@@ -5925,8 +5925,8 @@ var require_graceful_fs2 = __commonJS({
       fs6.createReadStream = createReadStream;
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile4;
-      function readFile4(path9, options, cb) {
+      fs6.readFile = readFile5;
+      function readFile5(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path9, options, cb);
@@ -5942,8 +5942,8 @@ var require_graceful_fs2 = __commonJS({
         }
       }
       var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile5;
-      function writeFile5(path9, data, options, cb) {
+      fs6.writeFile = writeFile7;
+      function writeFile7(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path9, data, options, cb);
@@ -6757,11 +6757,11 @@ var require_util = __commonJS({
           if (files.includes("node_modules") || files.includes("package.json") || files.includes("package.json5") || files.includes("package.yaml") || files.includes("pnpm-workspace.yaml")) {
             return name2;
           }
-          const dirname8 = path9.dirname(name2);
-          if (dirname8 === name2) {
+          const dirname9 = path9.dirname(name2);
+          if (dirname9 === name2) {
             return original;
           }
-          return find(dirname8, original);
+          return find(dirname9, original);
         } catch (error) {
           if (name2 === original) {
             if (error.code === "ENOENT") {
@@ -9422,7 +9422,7 @@ var require_picocolors = __commonJS({
 });
 
 // src/index.ts
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 
 // src/config.ts
 import { mkdir, readFile, writeFile } from "node:fs/promises";
@@ -9433,6 +9433,7 @@ var GLOBAL_CONFIG_DIRECTORY = ".config/gji";
 var GLOBAL_CONFIG_NAME = "config.json";
 var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "branchPrefix",
+  "editor",
   "hooks",
   "installSaveTarget",
   "shellIntegration",
@@ -9739,7 +9740,7 @@ var retryifyAsync = (fn, options) => {
           throw error;
         const delay2 = Math.round(interval * Math.random());
         if (delay2 > 0) {
-          const delayPromise = new Promise((resolve4) => setTimeout(resolve4, delay2));
+          const delayPromise = new Promise((resolve5) => setTimeout(resolve5, delay2));
           return delayPromise.then(() => attempt.apply(void 0, args));
         } else {
           return attempt.apply(void 0, args);
@@ -9998,14 +9999,14 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename7 = path2.basename(filePath);
-    if (basename7.length <= LIMIT_BASENAME_LENGTH)
+    const basename8 = path2.basename(filePath);
+    if (basename8.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
-    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename7);
+    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename8);
     if (!truncable)
       return filePath;
-    const truncationLength = basename7.length - LIMIT_BASENAME_LENGTH;
-    return `${filePath.slice(0, -basename7.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
+    const truncationLength = basename8.length - LIMIT_BASENAME_LENGTH;
+    return `${filePath.slice(0, -basename8.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
   }
 };
 node_default(Temp.purgeSyncAll);
@@ -11305,14 +11306,14 @@ var TimeoutError = class extends Error {
 
 // node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/timeout.js
 async function timeout(request, init, abortController, options) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const timeoutId = setTimeout(() => {
       if (abortController) {
         abortController.abort();
       }
       reject(new TimeoutError(request));
     }, options.timeout);
-    void options.fetch(request, init).then(resolve4).catch(reject).then(() => {
+    void options.fetch(request, init).then(resolve5).catch(reject).then(() => {
       clearTimeout(timeoutId);
     });
   });
@@ -11320,7 +11321,7 @@ async function timeout(request, init, abortController, options) {
 
 // node_modules/.pnpm/ky@1.14.3/node_modules/ky/distribution/utils/delay.js
 async function delay(ms, { signal }) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     if (signal) {
       signal.throwIfAborted();
       signal.addEventListener("abort", abortHandler, { once: true });
@@ -11331,7 +11332,7 @@ async function delay(ms, { signal }) {
     }
     const timeoutId = setTimeout(() => {
       signal?.removeEventListener("abort", abortHandler);
-      resolve4();
+      resolve5();
     }, ms);
   });
 }
@@ -13035,18 +13036,50 @@ import { basename as basename2 } from "node:path";
 import { spawn as spawn2 } from "node:child_process";
 async function runHook(hookCmd, cwd, context, stderr) {
   if (!hookCmd) return;
+  if (Array.isArray(hookCmd)) {
+    await runArgvHook(hookCmd, cwd, context, stderr);
+    return;
+  }
+  await runShellHook(hookCmd, cwd, context, stderr);
+}
+async function runArgvHook(hookCmd, cwd, context, stderr) {
+  const [command, ...args] = hookCmd.map((arg) => interpolate(arg, context));
+  if (!command) {
+    stderr("gji: hook argv command must include a non-empty command\n");
+    return;
+  }
+  await new Promise((resolve5) => {
+    const child = spawn2(command, args, {
+      cwd,
+      shell: false,
+      stdio: ["ignore", "inherit", "pipe"],
+      env: hookEnvironment(context)
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr(chunk.toString());
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        stderr(`gji: hook exited with code ${code}: ${formatArgvHook(command, args)}
+`);
+      }
+      resolve5();
+    });
+    child.on("error", (err) => {
+      stderr(`gji: hook failed to start: ${err.message}
+`);
+      resolve5();
+    });
+  });
+}
+async function runShellHook(hookCmd, cwd, context, stderr) {
   const interpolated = interpolate(hookCmd, context);
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     const child = spawn2(interpolated, {
       cwd,
       shell: true,
       stdio: ["ignore", "inherit", "pipe"],
-      env: {
-        ...process.env,
-        GJI_BRANCH: context.branch ?? "",
-        GJI_PATH: context.path,
-        GJI_REPO: context.repo
-      }
+      env: hookEnvironment(context)
     });
     child.stderr.on("data", (chunk) => {
       stderr(chunk.toString());
@@ -13056,15 +13089,26 @@ async function runHook(hookCmd, cwd, context, stderr) {
         stderr(`gji: hook exited with code ${code}: ${interpolated}
 `);
       }
-      resolve4();
+      resolve5();
     });
     child.on("error", (err) => {
       stderr(`gji: hook failed to start: ${err.message}
 `);
-      resolve4();
+      resolve5();
     });
   });
 }
+function hookEnvironment(context) {
+  return {
+    ...process.env,
+    GJI_BRANCH: context.branch ?? "",
+    GJI_PATH: context.path,
+    GJI_REPO: context.repo
+  };
+}
+function formatArgvHook(command, args) {
+  return JSON.stringify([command, ...args]);
+}
 function interpolate(template, context) {
   return template.replace(/\{\{branch\}\}/g, context.branch ?? "").replace(/\{\{path\}\}/g, context.path).replace(/\{\{repo\}\}/g, context.repo);
 }
@@ -13075,11 +13119,18 @@ function extractHooks(config) {
   }
   const hooks = raw;
   return {
-    afterCreate: typeof hooks.afterCreate === "string" ? hooks.afterCreate : void 0,
-    afterEnter: typeof hooks.afterEnter === "string" ? hooks.afterEnter : void 0,
-    beforeRemove: typeof hooks.beforeRemove === "string" ? hooks.beforeRemove : void 0
+    afterCreate: parseHookCommand(hooks.afterCreate),
+    afterEnter: parseHookCommand(hooks.afterEnter),
+    beforeRemove: parseHookCommand(hooks.beforeRemove)
   };
 }
+function parseHookCommand(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && value.length > 0 && value[0] !== "" && value.every((item) => typeof item === "string")) {
+    return value;
+  }
+  return void 0;
+}
 
 // src/history.ts
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
@@ -14796,635 +14847,209 @@ function writeJson(stdout, value) {
 }
 
 // src/go.ts
-import { basename as basename3 } from "node:path";
-var GO_OUTPUT_FILE_ENV = "GJI_GO_OUTPUT_FILE";
-function createGoCommand(dependencies = {}) {
-  const prompt = dependencies.promptForWorktree ?? promptForWorktree;
-  return async function runGoCommand2(options) {
-    const [worktrees, repository] = await Promise.all([
-      listWorktrees(options.cwd),
-      detectRepository(options.cwd)
-    ]);
-    if (!options.branch && isHeadless()) {
-      options.stderr("gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n");
-      return 1;
-    }
-    const prompted = options.branch ? null : await prompt(sortByCurrentFirst(worktrees));
-    const resolvedPath = options.branch ? worktrees.find((entry) => entry.branch === options.branch)?.path : prompted ?? void 0;
-    if (!resolvedPath) {
-      if (options.branch) {
-        options.stderr(`No worktree found for branch: ${options.branch}
-`);
-        options.stderr(`Hint: Use 'gji ls' to see available worktrees
-`);
-      } else {
-        options.stderr("Aborted\n");
-      }
-      return 1;
-    }
-    const chosenWorktree = worktrees.find((w2) => w2.path === resolvedPath);
-    const config = await loadEffectiveConfig(repository.repoRoot, void 0, options.stderr);
-    const hooks = extractHooks(config);
-    await runHook(
-      hooks.afterEnter,
-      resolvedPath,
-      { branch: chosenWorktree?.branch ?? void 0, path: resolvedPath, repo: basename3(repository.repoRoot) },
-      options.stderr
-    );
-    appendHistory(resolvedPath, chosenWorktree?.branch ?? null).catch(() => void 0);
-    await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
-    return 0;
-  };
-}
-var runGoCommand = createGoCommand();
-async function promptForWorktree(worktrees) {
-  const healthResults = await Promise.allSettled(
-    worktrees.map((w2) => readWorktreeHealth(w2.path))
-  );
-  const choice = await ve({
-    message: "Choose a worktree",
-    options: worktrees.map((worktree, i) => {
-      const health = healthResults[i].status === "fulfilled" ? healthResults[i].value : null;
-      const pathHint = worktree.isCurrent ? `${worktree.path} (current)` : worktree.path;
-      const upstream = health ? formatUpstreamHint(worktree.branch, health) : null;
-      return {
-        value: worktree.path,
-        label: worktree.branch ?? "(detached)",
-        hint: upstream ? `${upstream} \xB7 ${pathHint}` : pathHint
-      };
-    })
+import { basename as basename5 } from "node:path";
+
+// src/new.ts
+import { mkdir as mkdir4 } from "node:fs/promises";
+import { basename as basename3, dirname as dirname5 } from "node:path";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+
+// src/editor.ts
+import { spawn as spawn3 } from "node:child_process";
+var EDITORS = [
+  { cli: "cursor", name: "Cursor", newWindowFlag: "--new-window", supportsWorkspace: true },
+  { cli: "code", name: "VS Code", newWindowFlag: "--new-window", supportsWorkspace: true },
+  { cli: "windsurf", name: "Windsurf", newWindowFlag: "--new-window", supportsWorkspace: true },
+  { cli: "zed", name: "Zed", supportsWorkspace: false },
+  { cli: "subl", name: "Sublime Text", newWindowFlag: "--new-window", supportsWorkspace: false }
+];
+async function defaultSpawnEditor(cli, args) {
+  const child = spawn3(cli, args, { detached: true, stdio: "ignore" });
+  await new Promise((resolve5, reject) => {
+    child.once("error", reject);
+    child.once("spawn", resolve5);
   });
-  if (pD(choice)) {
-    return null;
-  }
-  return choice;
-}
-function formatUpstreamHint(branch, health) {
-  if (branch === null) return null;
-  if (!health.hasUpstream) return "no upstream";
-  if (health.upstreamGone) return "upstream gone";
-  if (health.ahead === 0 && health.behind === 0) return "up to date";
-  if (health.ahead === 0) return `behind ${health.behind}`;
-  if (health.behind === 0) return `ahead ${health.ahead}`;
-  return `ahead ${health.ahead}, behind ${health.behind}`;
+  child.unref();
 }
 
-// src/init.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, join as join4 } from "node:path";
-var START_MARKER = "# >>> gji init >>>";
-var END_MARKER = "# <<< gji init <<<";
-var SHELL_WRAPPED_COMMANDS = [
-  {
-    bypassOption: "--help",
-    commandName: "new",
-    envVar: "GJI_NEW_OUTPUT_FILE",
-    names: ["new"],
-    tempPrefix: "gji-new"
-  },
-  {
-    bypassOption: "--help",
-    commandName: "pr",
-    envVar: "GJI_PR_OUTPUT_FILE",
-    names: ["pr"],
-    tempPrefix: "gji-pr"
-  },
-  {
-    bypassOption: "--print",
-    commandName: "back",
-    envVar: "GJI_BACK_OUTPUT_FILE",
-    names: ["back"],
-    tempPrefix: "gji-back"
-  },
-  {
-    bypassOption: "--print",
-    commandName: "go",
-    envVar: "GJI_GO_OUTPUT_FILE",
-    names: ["go"],
-    tempPrefix: "gji-go"
-  },
-  {
-    bypassOption: "--print",
-    commandName: "root",
-    envVar: "GJI_ROOT_OUTPUT_FILE",
-    names: ["root"],
-    tempPrefix: "gji-root"
-  },
-  {
-    bypassOption: "--help",
-    commandName: "remove",
-    envVar: "GJI_REMOVE_OUTPUT_FILE",
-    names: ["remove", "rm"],
-    tempPrefix: "gji-remove"
-  }
-];
-async function runInitCommand(options) {
-  const shell = resolveSupportedShell(options.shell, process.env.SHELL);
-  const home = options.home ?? homedir4();
-  if (!shell) {
-    options.stderr?.(
-      "Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n"
-    );
-    return 1;
-  }
-  const script = renderShellIntegration(shell);
-  if (!options.write) {
-    options.stdout(script);
-    return 0;
-  }
-  const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir3(dirname4(rcPath), { recursive: true });
-  const current = await readExistingConfig(rcPath);
-  const next = upsertShellIntegration(current, script);
-  await writeFile4(rcPath, next, "utf8");
-  options.stdout(`${rcPath}
-`);
-  const { config: globalConfig } = await loadGlobalConfig(home);
-  const alreadyConfigured = "shellIntegration" in globalConfig || "installSaveTarget" in globalConfig;
-  const hasCustomPrompt = options.promptForSetup !== void 0;
-  const canPrompt = hasCustomPrompt || process.stdout.isTTY === true;
-  if (!alreadyConfigured && canPrompt) {
-    const prompt = options.promptForSetup ?? defaultPromptForSetup;
-    const result = await prompt();
-    if (result) {
-      await updateGlobalConfigKey("installSaveTarget", result.installSaveTarget, home);
-      await saveWizardConfig(result, options.cwd, home);
+// src/file-sync.ts
+import { copyFile, mkdir as mkdir3, stat } from "node:fs/promises";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join4, normalize } from "node:path";
+async function syncFiles(mainRoot, targetPath, patterns) {
+  for (const pattern of patterns) {
+    if (isAbsolute2(pattern)) {
+      throw new Error(`syncFiles: pattern must be a relative path, got: ${pattern}`);
+    }
+    const normalized = normalize(pattern);
+    if (normalized.startsWith("..")) {
+      throw new Error(`syncFiles: pattern must not contain '..' segments, got: ${pattern}`);
+    }
+    const sourcePath = join4(mainRoot, normalized);
+    const destPath = join4(targetPath, normalized);
+    const sourceExists = await fileExists(sourcePath);
+    if (!sourceExists) {
+      continue;
+    }
+    const destExists = await fileExists(destPath);
+    if (destExists) {
+      continue;
     }
+    await mkdir3(dirname4(destPath), { recursive: true });
+    await copyFile(sourcePath, destPath);
   }
-  await updateGlobalConfigKey("shellIntegration", true, home);
-  return 0;
-}
-function renderShellIntegration(shell) {
-  const commandBlocks = SHELL_WRAPPED_COMMANDS.map(
-    (command) => shell === "fish" ? renderFishWrapper(command) : renderPosixWrapper(command)
-  ).join("\n\n");
-  switch (shell) {
-    case "fish":
-      return `${START_MARKER}
-function gji --wraps gji --description 'gji shell integration'
-${indentBlock(commandBlocks, 4)}
-
-    command gji $argv
-end
-${END_MARKER}
-`;
-    case "bash":
-    case "zsh":
-      return `${START_MARKER}
-gji() {
-${indentBlock(commandBlocks, 2)}
-
-  command gji "$@"
 }
-${END_MARKER}
-`;
+async function fileExists(path9) {
+  try {
+    await stat(path9);
+    return true;
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return false;
+    }
+    throw error;
   }
 }
-function upsertShellIntegration(existingConfig, script) {
-  const trimmedScript = script.trimEnd();
-  const blockPattern = new RegExp(
-    `${escapeForRegExp(START_MARKER)}[\\s\\S]*?${escapeForRegExp(END_MARKER)}\\n?`,
-    "m"
-  );
-  if (blockPattern.test(existingConfig)) {
-    return ensureTrailingNewline(
-      existingConfig.replace(blockPattern, `${trimmedScript}
-`)
-    );
-  }
-  const prefix = existingConfig.trimEnd();
-  if (prefix.length === 0) {
-    return ensureTrailingNewline(trimmedScript);
-  }
-  return ensureTrailingNewline(`${prefix}
-
-${trimmedScript}`);
+function isNotFoundError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
-async function saveWizardConfig(result, cwd, home) {
-  const values = {};
-  if (result.branchPrefix) values.branchPrefix = result.branchPrefix;
-  if (result.worktreePath) values.worktreePath = result.worktreePath;
-  const hooks = {};
-  if (result.hooks?.afterCreate) hooks.afterCreate = result.hooks.afterCreate;
-  if (result.hooks?.afterEnter) hooks.afterEnter = result.hooks.afterEnter;
-  if (result.hooks?.beforeRemove) hooks.beforeRemove = result.hooks.beforeRemove;
-  if (Object.keys(hooks).length > 0) values.hooks = hooks;
-  if (Object.keys(values).length === 0) return;
-  if (result.installSaveTarget === "local") {
-    const loaded = await loadConfig(cwd);
-    await saveLocalConfig(cwd, { ...loaded.config, ...values });
-  } else {
-    const { config: existing } = await loadGlobalConfig(home);
-    await saveGlobalConfig({ ...existing, ...values }, home);
+
+// src/install-prompt.ts
+import { spawn as spawn4 } from "node:child_process";
+
+// src/package-manager.ts
+import { access as access2, readdir } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var ENTRIES = [
+  // JavaScript / TypeScript
+  { name: "pnpm", signals: ["pnpm-lock.yaml"], command: "pnpm install" },
+  { name: "yarn", signals: ["yarn.lock"], command: "yarn install" },
+  { name: "bun", signals: ["bun.lockb"], command: "bun install" },
+  { name: "npm", signals: ["package-lock.json"], command: "npm install" },
+  { name: "deno", signals: ["deno.json", "deno.jsonc"], command: "deno cache" },
+  // Python
+  { name: "poetry", signals: ["poetry.lock"], command: "poetry install" },
+  { name: "uv", signals: ["uv.lock"], command: "uv sync" },
+  { name: "pipenv", signals: ["Pipfile.lock"], command: "pipenv install" },
+  { name: "pdm", signals: ["pdm.lock"], command: "pdm install" },
+  { name: "conda-lock", signals: ["conda-lock.yml"], command: "conda-lock install" },
+  { name: "conda", signals: ["environment.yml"], command: "conda env update --file environment.yml" },
+  // R
+  { name: "renv", signals: ["renv.lock"], command: "Rscript -e 'renv::restore()'" },
+  // Rust
+  { name: "cargo", signals: ["Cargo.lock"], command: "cargo build" },
+  // Go
+  { name: "go", signals: ["go.sum"], command: "go mod download" },
+  // Ruby
+  { name: "bundler", signals: ["Gemfile.lock"], command: "bundle install" },
+  // PHP
+  { name: "composer", signals: ["composer.lock"], command: "composer install" },
+  // Elixir / Erlang
+  { name: "mix", signals: ["mix.lock"], command: "mix deps.get" },
+  { name: "rebar3", signals: ["rebar.lock"], command: "rebar3 deps" },
+  // Dart / Flutter
+  { name: "dart", signals: ["pubspec.lock"], command: "dart pub get" },
+  // Java / Kotlin / Scala
+  { name: "maven", signals: ["pom.xml"], command: "mvn install" },
+  { name: "gradle", signals: ["gradlew"], command: "./gradlew build" },
+  { name: "gradle", signals: ["build.gradle", "build.gradle.kts"], command: "gradle build" },
+  { name: "sbt", signals: ["build.sbt"], command: "sbt compile" },
+  // .NET (C# / F# / VB)
+  { name: "dotnet", signals: ["*.sln", "*.csproj", "*.fsproj", "*.vbproj"], command: "dotnet restore", glob: true },
+  // Swift
+  { name: "swift", signals: ["Package.swift"], command: "swift package resolve" },
+  // Haskell
+  { name: "stack", signals: ["stack.yaml"], command: "stack build" },
+  { name: "cabal", signals: ["cabal.project"], command: "cabal install --only-dependencies" },
+  { name: "cabal", signals: ["*.cabal"], command: "cabal install --only-dependencies", glob: true },
+  // Clojure
+  { name: "clojure", signals: ["deps.edn"], command: "clojure -P" },
+  { name: "leiningen", signals: ["project.clj"], command: "lein deps" },
+  // OCaml
+  { name: "dune", signals: ["dune-project"], command: "dune build" },
+  // Julia
+  { name: "julia", signals: ["Manifest.toml"], command: "julia --project -e 'using Pkg; Pkg.instantiate()'" },
+  // Nim
+  { name: "nimble", signals: ["*.nimble"], command: "nimble install", glob: true },
+  // Crystal
+  { name: "shards", signals: ["shard.yml"], command: "shards install" },
+  // Perl
+  { name: "cpanm", signals: ["cpanfile"], command: "cpanm --installdeps ." },
+  // Zig
+  { name: "zig", signals: ["build.zig.zon"], command: "zig build" },
+  // C / C++
+  { name: "vcpkg", signals: ["vcpkg.json"], command: "vcpkg install" },
+  { name: "conan", signals: ["conanfile.py", "conanfile.txt"], command: "conan install ." },
+  // Nix
+  { name: "nix", signals: ["flake.nix"], command: "nix develop" },
+  { name: "nix-shell", signals: ["shell.nix"], command: "nix-shell" },
+  // Terraform / OpenTofu
+  { name: "terraform", signals: ["terraform.lock.hcl"], command: "terraform init" }
+];
+async function detectPackageManager(repoRoot) {
+  for (const entry of ENTRIES) {
+    const matched = entry.glob ? await matchesGlob(repoRoot, entry.signals) : await matchesExact(repoRoot, entry.signals);
+    if (matched) {
+      return { name: entry.name, installCommand: entry.command };
+    }
   }
+  return null;
 }
-function resolveShellConfigPath(shell, home) {
-  switch (shell) {
-    case "bash":
-      return join4(home, ".bashrc");
-    case "fish":
-      return join4(home, ".config", "fish", "config.fish");
-    case "zsh":
-      return join4(home, ".zshrc");
+async function matchesExact(repoRoot, signals) {
+  for (const signal of signals) {
+    try {
+      await access2(join5(repoRoot, signal));
+      return true;
+    } catch {
+    }
   }
+  return false;
 }
-async function readExistingConfig(path9) {
+async function matchesGlob(repoRoot, patterns) {
+  let files;
   try {
-    return await readFile3(path9, "utf8");
-  } catch (error) {
-    if (isMissingFileError2(error)) {
-      return "";
-    }
-    throw error;
+    files = await readdir(repoRoot);
+  } catch {
+    return false;
   }
+  const regexes = patterns.map(patternToRegex);
+  return files.some((file) => regexes.some((re) => re.test(file)));
 }
-function ensureTrailingNewline(value) {
-  return value.endsWith("\n") ? value : `${value}
-`;
-}
-function escapeForRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function isMissingFileError2(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function renderFishWrapper(command) {
-  const tests = command.names.map((name) => `test $argv[1] = ${name}`).join("; or ");
-  return `if test (count $argv) -gt 0; and ${tests}
-    set -e argv[1]
-    if test (count $argv) -gt 0; and test $argv[1] = ${command.bypassOption}
-        command gji ${command.commandName} $argv
-        return $status
-    end
-
-    set -l output_file (mktemp -t ${command.tempPrefix}.XXXXXX)
-    or return 1
-    env ${command.envVar}=$output_file command gji ${command.commandName} $argv
-    or begin
-        set -l status_code $status
-        rm -f $output_file
-        return $status_code
-    end
-    set -l target (cat $output_file)
-    rm -f $output_file
-    cd $target
-    return $status
-end`;
+function patternToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*");
+  return new RegExp(`^${escaped}$`);
 }
-function renderPosixWrapper(command) {
-  const tests = command.names.map((name) => `[ "$1" = "${name}" ]`).join(" || ");
-  return `if ${tests}; then
-  shift
-  if [ "\${1:-}" = "${command.bypassOption}" ]; then
-    command gji ${command.commandName} "$@"
-    return $?
-  fi
 
-  local target
-  local output_file
-  output_file="$(mktemp -t ${command.tempPrefix}.XXXXXX)" || return 1
-  ${command.envVar}="$output_file" command gji ${command.commandName} "$@" || { local exit_code=$?; rm -f "$output_file"; return $exit_code; }
-  target="$(cat "$output_file")"
-  rm -f "$output_file"
-  cd "$target" || return $?
-  return 0
-fi`;
-}
-function indentBlock(value, spaces) {
-  const prefix = " ".repeat(spaces);
-  return value.split("\n").map((line) => line.length === 0 ? "" : `${prefix}${line}`).join("\n");
-}
-async function defaultPromptForSetup() {
-  Ie("gji setup");
-  const installSaveTarget = await ve({
-    message: "Where should preferences be saved?",
-    options: [
-      { value: "global", label: "~/.config/gji/config.json", hint: "personal \u2014 never committed" },
-      { value: "local", label: ".gji.json", hint: "repo \u2014 committed with the project" }
-    ]
-  });
-  if (pD(installSaveTarget)) {
-    Se("Setup skipped.");
-    return null;
-  }
-  const branchPrefix = await he({
-    message: "Default branch prefix?",
-    placeholder: "e.g. feat/ or fix/ \u2014 leave blank to skip"
-  });
-  if (pD(branchPrefix)) {
-    Se("Setup skipped.");
-    return null;
+// src/install-prompt.ts
+async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dependencies = {}, nonInteractive = false) {
+  if (isHeadless() || nonInteractive) {
+    return;
   }
-  const worktreePath = await he({
-    message: "Worktree base path?",
-    placeholder: "leave blank to use the default path"
-  });
-  if (pD(worktreePath)) {
-    Se("Setup skipped.");
-    return null;
+  const hooks = isPlainObject2(config.hooks) ? config.hooks : null;
+  if (isConfiguredHookCommand(hooks?.afterCreate)) {
+    return;
   }
-  const afterCreate = await he({
-    message: "afterCreate hook \u2014 run after creating a worktree?",
-    placeholder: "e.g. pnpm install \u2014 leave blank to skip"
-  });
-  if (pD(afterCreate)) {
-    Se("Setup skipped.");
-    return null;
+  if (config.skipInstallPrompt === true) {
+    return;
   }
-  const afterEnter = await he({
-    message: "afterEnter hook \u2014 run after entering a worktree?",
-    placeholder: "e.g. nvm use \u2014 leave blank to skip"
-  });
-  if (pD(afterEnter)) {
-    Se("Setup skipped.");
-    return null;
+  const detect = dependencies.detectInstallPackageManager ?? detectPackageManager;
+  const pm = await detect(worktreePath);
+  if (!pm) {
+    return;
   }
-  const beforeRemove = await he({
-    message: "beforeRemove hook \u2014 run before removing a worktree?",
-    placeholder: "leave blank to skip"
-  });
-  if (pD(beforeRemove)) {
-    Se("Setup skipped.");
-    return null;
+  const prompt = dependencies.promptForInstallChoice ?? defaultPromptForInstallChoice;
+  const choice = await prompt(pm);
+  if (!choice || choice === "no") {
+    return;
   }
-  Se("Setup complete!");
-  const hooks = {};
-  if (afterCreate) hooks.afterCreate = afterCreate;
-  if (afterEnter) hooks.afterEnter = afterEnter;
-  if (beforeRemove) hooks.beforeRemove = beforeRemove;
-  return {
-    branchPrefix: branchPrefix || void 0,
-    hooks: Object.keys(hooks).length > 0 ? hooks : void 0,
-    installSaveTarget,
-    worktreePath: worktreePath || void 0
-  };
-}
-
-// src/paths.ts
-function comparePaths(left, right) {
-  if (left < right) {
-    return -1;
-  }
-  if (left > right) {
-    return 1;
-  }
-  return 0;
-}
-
-// src/ls.ts
-async function runLsCommand(options) {
-  const worktrees = sortWorktrees(await listWorktrees(options.cwd));
-  if (options.compact) {
-    if (options.json) {
-      options.stdout(`${JSON.stringify(worktrees, null, 2)}
-`);
-      return 0;
-    }
-    options.stdout(`${formatWorktreeTable(worktrees)}
-`);
-    return 0;
-  }
-  const infos = await readWorktreeInfos(worktrees);
-  if (options.json) {
-    options.stdout(`${JSON.stringify(infos, null, 2)}
-`);
-    return 0;
-  }
-  options.stdout(`${formatDetailedWorktreeTable(infos)}
-`);
-  return 0;
-}
-function formatDetailedWorktreeTable(worktrees) {
-  const rows = worktrees.map((worktree) => ({
-    branch: worktree.branch ?? "(detached)",
-    isCurrent: worktree.isCurrent,
-    lastCommit: formatLastCommit(worktree.lastCommitTimestamp),
-    path: worktree.path,
-    status: worktree.status,
-    upstream: formatUpstreamState(worktree.upstream)
-  }));
-  const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => row.branch.length));
-  const statusWidth = Math.max("STATUS".length, ...rows.map((row) => row.status.length));
-  const upstreamWidth = Math.max("UPSTREAM".length, ...rows.map((row) => row.upstream.length));
-  const lastCommitWidth = Math.max("LAST".length, ...rows.map((row) => row.lastCommit.length));
-  const lines = [
-    "  " + "BRANCH".padEnd(branchWidth, " ") + " " + "STATUS".padEnd(statusWidth, " ") + " " + "UPSTREAM".padEnd(upstreamWidth, " ") + " " + "LAST".padEnd(lastCommitWidth, " ") + " PATH"
-  ];
-  for (const row of rows) {
-    lines.push(
-      `${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.status.padEnd(statusWidth, " ")} ${row.upstream.padEnd(upstreamWidth, " ")} ${row.lastCommit.padEnd(lastCommitWidth, " ")} ` + row.path
-    );
-  }
-  return lines.join("\n");
-}
-function formatWorktreeTable(worktrees) {
-  const rows = worktrees.map((worktree) => ({
-    branch: worktree.branch ?? "(detached)",
-    isCurrent: worktree.isCurrent,
-    path: worktree.path
-  }));
-  const branchWidth = Math.max(
-    "BRANCH".length,
-    ...rows.map((row) => row.branch.length)
-  );
-  const lines = ["  " + "BRANCH".padEnd(branchWidth, " ") + " PATH"];
-  for (const row of rows) {
-    lines.push(`${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.path}`);
-  }
-  return lines.join("\n");
-}
-function sortWorktrees(worktrees) {
-  return [...worktrees].sort((left, right) => {
-    if (left.isCurrent && !right.isCurrent) return -1;
-    if (!left.isCurrent && right.isCurrent) return 1;
-    return comparePaths(left.path, right.path);
-  });
-}
-
-// src/new.ts
-import { mkdir as mkdir5 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname6 } from "node:path";
-import { execFile as execFile3 } from "node:child_process";
-import { promisify as promisify4 } from "node:util";
-
-// src/file-sync.ts
-import { copyFile, mkdir as mkdir4, stat } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join5, normalize } from "node:path";
-async function syncFiles(mainRoot, targetPath, patterns) {
-  for (const pattern of patterns) {
-    if (isAbsolute2(pattern)) {
-      throw new Error(`syncFiles: pattern must be a relative path, got: ${pattern}`);
-    }
-    const normalized = normalize(pattern);
-    if (normalized.startsWith("..")) {
-      throw new Error(`syncFiles: pattern must not contain '..' segments, got: ${pattern}`);
-    }
-    const sourcePath = join5(mainRoot, normalized);
-    const destPath = join5(targetPath, normalized);
-    const sourceExists = await fileExists(sourcePath);
-    if (!sourceExists) {
-      continue;
-    }
-    const destExists = await fileExists(destPath);
-    if (destExists) {
-      continue;
-    }
-    await mkdir4(dirname5(destPath), { recursive: true });
-    await copyFile(sourcePath, destPath);
-  }
-}
-async function fileExists(path9) {
-  try {
-    await stat(path9);
-    return true;
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return false;
-    }
-    throw error;
-  }
-}
-function isNotFoundError(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-
-// src/install-prompt.ts
-import { spawn as spawn3 } from "node:child_process";
-
-// src/package-manager.ts
-import { access as access2, readdir } from "node:fs/promises";
-import { join as join6 } from "node:path";
-var ENTRIES = [
-  // JavaScript / TypeScript
-  { name: "pnpm", signals: ["pnpm-lock.yaml"], command: "pnpm install" },
-  { name: "yarn", signals: ["yarn.lock"], command: "yarn install" },
-  { name: "bun", signals: ["bun.lockb"], command: "bun install" },
-  { name: "npm", signals: ["package-lock.json"], command: "npm install" },
-  { name: "deno", signals: ["deno.json", "deno.jsonc"], command: "deno cache" },
-  // Python
-  { name: "poetry", signals: ["poetry.lock"], command: "poetry install" },
-  { name: "uv", signals: ["uv.lock"], command: "uv sync" },
-  { name: "pipenv", signals: ["Pipfile.lock"], command: "pipenv install" },
-  { name: "pdm", signals: ["pdm.lock"], command: "pdm install" },
-  { name: "conda-lock", signals: ["conda-lock.yml"], command: "conda-lock install" },
-  { name: "conda", signals: ["environment.yml"], command: "conda env update --file environment.yml" },
-  // R
-  { name: "renv", signals: ["renv.lock"], command: "Rscript -e 'renv::restore()'" },
-  // Rust
-  { name: "cargo", signals: ["Cargo.lock"], command: "cargo build" },
-  // Go
-  { name: "go", signals: ["go.sum"], command: "go mod download" },
-  // Ruby
-  { name: "bundler", signals: ["Gemfile.lock"], command: "bundle install" },
-  // PHP
-  { name: "composer", signals: ["composer.lock"], command: "composer install" },
-  // Elixir / Erlang
-  { name: "mix", signals: ["mix.lock"], command: "mix deps.get" },
-  { name: "rebar3", signals: ["rebar.lock"], command: "rebar3 deps" },
-  // Dart / Flutter
-  { name: "dart", signals: ["pubspec.lock"], command: "dart pub get" },
-  // Java / Kotlin / Scala
-  { name: "maven", signals: ["pom.xml"], command: "mvn install" },
-  { name: "gradle", signals: ["gradlew"], command: "./gradlew build" },
-  { name: "gradle", signals: ["build.gradle", "build.gradle.kts"], command: "gradle build" },
-  { name: "sbt", signals: ["build.sbt"], command: "sbt compile" },
-  // .NET (C# / F# / VB)
-  { name: "dotnet", signals: ["*.sln", "*.csproj", "*.fsproj", "*.vbproj"], command: "dotnet restore", glob: true },
-  // Swift
-  { name: "swift", signals: ["Package.swift"], command: "swift package resolve" },
-  // Haskell
-  { name: "stack", signals: ["stack.yaml"], command: "stack build" },
-  { name: "cabal", signals: ["cabal.project"], command: "cabal install --only-dependencies" },
-  { name: "cabal", signals: ["*.cabal"], command: "cabal install --only-dependencies", glob: true },
-  // Clojure
-  { name: "clojure", signals: ["deps.edn"], command: "clojure -P" },
-  { name: "leiningen", signals: ["project.clj"], command: "lein deps" },
-  // OCaml
-  { name: "dune", signals: ["dune-project"], command: "dune build" },
-  // Julia
-  { name: "julia", signals: ["Manifest.toml"], command: "julia --project -e 'using Pkg; Pkg.instantiate()'" },
-  // Nim
-  { name: "nimble", signals: ["*.nimble"], command: "nimble install", glob: true },
-  // Crystal
-  { name: "shards", signals: ["shard.yml"], command: "shards install" },
-  // Perl
-  { name: "cpanm", signals: ["cpanfile"], command: "cpanm --installdeps ." },
-  // Zig
-  { name: "zig", signals: ["build.zig.zon"], command: "zig build" },
-  // C / C++
-  { name: "vcpkg", signals: ["vcpkg.json"], command: "vcpkg install" },
-  { name: "conan", signals: ["conanfile.py", "conanfile.txt"], command: "conan install ." },
-  // Nix
-  { name: "nix", signals: ["flake.nix"], command: "nix develop" },
-  { name: "nix-shell", signals: ["shell.nix"], command: "nix-shell" },
-  // Terraform / OpenTofu
-  { name: "terraform", signals: ["terraform.lock.hcl"], command: "terraform init" }
-];
-async function detectPackageManager(repoRoot) {
-  for (const entry of ENTRIES) {
-    const matched = entry.glob ? await matchesGlob(repoRoot, entry.signals) : await matchesExact(repoRoot, entry.signals);
-    if (matched) {
-      return { name: entry.name, installCommand: entry.command };
-    }
-  }
-  return null;
-}
-async function matchesExact(repoRoot, signals) {
-  for (const signal of signals) {
-    try {
-      await access2(join6(repoRoot, signal));
-      return true;
-    } catch {
-    }
-  }
-  return false;
-}
-async function matchesGlob(repoRoot, patterns) {
-  let files;
-  try {
-    files = await readdir(repoRoot);
-  } catch {
-    return false;
-  }
-  const regexes = patterns.map(patternToRegex);
-  return files.some((file) => regexes.some((re) => re.test(file)));
-}
-function patternToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*");
-  return new RegExp(`^${escaped}$`);
-}
-
-// src/install-prompt.ts
-async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dependencies = {}, nonInteractive = false) {
-  if (isHeadless() || nonInteractive) {
-    return;
-  }
-  const hooks = isPlainObject2(config.hooks) ? config.hooks : null;
-  if (typeof hooks?.afterCreate === "string" && hooks.afterCreate.length > 0) {
-    return;
-  }
-  if (config.skipInstallPrompt === true) {
-    return;
-  }
-  const detect = dependencies.detectInstallPackageManager ?? detectPackageManager;
-  const pm = await detect(worktreePath);
-  if (!pm) {
-    return;
-  }
-  const prompt = dependencies.promptForInstallChoice ?? defaultPromptForInstallChoice;
-  const choice = await prompt(pm);
-  if (!choice || choice === "no") {
-    return;
-  }
-  if (choice === "yes" || choice === "always") {
-    const runner = dependencies.runInstallCommand ?? defaultRunInstallCommand;
-    try {
-      await runner(pm.installCommand, worktreePath, stderr);
-    } catch (error) {
-      stderr(`gji: install command failed: ${error instanceof Error ? error.message : String(error)}
-`);
-    }
+  if (choice === "yes" || choice === "always") {
+    const runner = dependencies.runInstallCommand ?? defaultRunInstallCommand;
+    try {
+      await runner(pm.installCommand, worktreePath, stderr);
+    } catch (error) {
+      stderr(`gji: install command failed: ${error instanceof Error ? error.message : String(error)}
+`);
+    }
   }
   const saveGlobal = config.installSaveTarget === "global";
   const writeKey = dependencies.writeConfigKey ?? defaultWriteConfigKey;
@@ -15458,8 +15083,8 @@ async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dep
   }
 }
 async function defaultRunInstallCommand(command, cwd, stderr) {
-  await new Promise((resolve4, reject) => {
-    const child = spawn3(command, { cwd, shell: true, stdio: ["ignore", "inherit", "pipe"] });
+  await new Promise((resolve5, reject) => {
+    const child = spawn4(command, { cwd, shell: true, stdio: ["ignore", "inherit", "pipe"] });
     child.stderr.on("data", (chunk) => {
       stderr(chunk.toString());
     });
@@ -15467,7 +15092,7 @@ async function defaultRunInstallCommand(command, cwd, stderr) {
       if (code !== 0) {
         reject(new Error(`exited with code ${code}`));
       } else {
-        resolve4();
+        resolve5();
       }
     });
     child.on("error", (err) => {
@@ -15505,6 +15130,10 @@ async function defaultPromptForInstallChoice(pm) {
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isConfiguredHookCommand(value) {
+  if (typeof value === "string") return value.length > 0;
+  return Array.isArray(value) && value.length > 0 && value[0] !== "" && value.every((item) => typeof item === "string");
+}
 
 // src/conflict.ts
 import { access as access3 } from "node:fs/promises";
@@ -15538,10 +15167,14 @@ function createNewCommand(dependencies = {}) {
   const createBranchPlaceholder = dependencies.createBranchPlaceholder ?? generateBranchPlaceholder;
   const promptForBranch = dependencies.promptForBranch ?? defaultPromptForBranch;
   const prompt = dependencies.promptForPathConflict ?? promptForPathConflict;
+  const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
   return async function runNewCommand2(options) {
     const repository = await detectRepository(options.cwd);
     const config = await loadEffectiveConfig(repository.repoRoot, void 0, options.stderr);
     const usesGeneratedDetachedName = options.detached && options.branch === void 0;
+    if (options.editor && !options.open) {
+      options.stderr("gji new: --editor has no effect without --open\n");
+    }
     if (!options.detached && !options.branch && (options.json || isHeadless())) {
       const message = "branch argument is required";
       if (options.json) {
@@ -15635,12 +15268,14 @@ function createNewCommand(dependencies = {}) {
         options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath, dryRun: true }, null, 2)}
 `);
       } else {
-        options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName})
+        const resolvedEditor = options.open ? options.editor ?? resolveConfigString(config, "editor") : void 0;
+        const openNote = resolvedEditor ? `, then open in ${resolvedEditor}` : "";
+        options.stdout(`Would create worktree at ${worktreePath} (branch: ${worktreeName}${openNote})
 `);
       }
       return 0;
     }
-    await mkdir5(dirname6(worktreePath), { recursive: true });
+    await mkdir4(dirname5(worktreePath), { recursive: true });
     const gitArgs = options.detached ? ["worktree", "add", "--detach", worktreePath] : await localBranchExists(repository.repoRoot, worktreeName) ? ["worktree", "add", worktreePath, worktreeName] : ["worktree", "add", "-b", worktreeName, worktreePath];
     await execFileAsync3("git", gitArgs, { cwd: repository.repoRoot });
     const syncPatterns = Array.isArray(config.syncFiles) ? config.syncFiles.filter((p2) => typeof p2 === "string") : [];
@@ -15657,7 +15292,7 @@ function createNewCommand(dependencies = {}) {
     await runHook(
       hooks.afterCreate,
       worktreePath,
-      { branch: worktreeName, path: worktreePath, repo: basename4(repository.repoRoot) },
+      { branch: worktreeName, path: worktreePath, repo: basename3(repository.repoRoot) },
       options.stderr
     );
     if (options.json) {
@@ -15667,119 +15302,994 @@ function createNewCommand(dependencies = {}) {
       await appendHistory(worktreePath, worktreeName);
       await writeOutput(worktreePath, options.stdout);
     }
+    if (options.open) {
+      const resolvedEditor = options.editor ?? resolveConfigString(config, "editor");
+      await openWorktree(worktreePath, resolvedEditor, spawnEditor, options.stderr);
+    }
     return 0;
   };
 }
-var runNewCommand = createNewCommand();
-function generateBranchPlaceholder(random = Math.random) {
-  const roots = [
-    "socrates",
-    "prometheus",
-    "beethoven",
-    "ada",
-    "turing",
-    "hypatia",
-    "tesla",
-    "curie",
-    "diogenes",
-    "plato",
-    "hephaestus",
-    "athena",
-    "archimedes",
-    "euclid",
-    "heraclitus",
-    "galileo",
-    "newton",
-    "lovelace",
-    "nietzsche",
-    "kafka"
-  ];
-  const antics = [
-    "borrowed-a-bike",
-    "brought-snacks",
-    "missed-the-bus",
-    "lost-the-keys",
-    "spilled-the-coffee",
-    "forgot-the-umbrella",
-    "walked-the-dog",
-    "missed-the-train",
-    "wrote-a-poem",
-    "burned-the-toast",
-    "fed-the-pigeons",
-    "watered-the-plants",
-    "washed-the-dishes",
-    "folded-the-laundry",
-    "took-a-nap"
-  ];
-  return `${pickRandom(roots, random)}-${pickRandom(antics, random)}`;
+var runNewCommand = createNewCommand();
+function generateBranchPlaceholder(random = Math.random) {
+  const roots = [
+    "socrates",
+    "prometheus",
+    "beethoven",
+    "ada",
+    "turing",
+    "hypatia",
+    "tesla",
+    "curie",
+    "diogenes",
+    "plato",
+    "hephaestus",
+    "athena",
+    "archimedes",
+    "euclid",
+    "heraclitus",
+    "galileo",
+    "newton",
+    "lovelace",
+    "nietzsche",
+    "kafka"
+  ];
+  const antics = [
+    "borrowed-a-bike",
+    "brought-snacks",
+    "missed-the-bus",
+    "lost-the-keys",
+    "spilled-the-coffee",
+    "forgot-the-umbrella",
+    "walked-the-dog",
+    "missed-the-train",
+    "wrote-a-poem",
+    "burned-the-toast",
+    "fed-the-pigeons",
+    "watered-the-plants",
+    "washed-the-dishes",
+    "folded-the-laundry",
+    "took-a-nap"
+  ];
+  return `${pickRandom(roots, random)}-${pickRandom(antics, random)}`;
+}
+function applyConfiguredBranchPrefix(branch, branchPrefix) {
+  if (typeof branchPrefix !== "string" || branchPrefix.length === 0) {
+    return branch;
+  }
+  if (branch.startsWith(branchPrefix)) {
+    return branch;
+  }
+  return `${branchPrefix}${branch}`;
+}
+async function resolveUniqueDetachedWorktreePath(repoRoot, baseName, basePath) {
+  let attempt = 1;
+  while (true) {
+    const candidateName = attempt === 1 ? baseName : `${baseName}-${attempt}`;
+    const candidatePath = resolveWorktreePath(repoRoot, candidateName, basePath);
+    if (!await pathExists(candidatePath)) {
+      return candidatePath;
+    }
+    attempt += 1;
+  }
+}
+async function defaultPromptForBranch(placeholder) {
+  const choice = await he({
+    defaultValue: placeholder,
+    message: "Name the new branch",
+    placeholder,
+    validate: (value) => {
+      const trimmed = value.trim();
+      return validateBranchName(trimmed) ?? void 0;
+    }
+  });
+  if (pD(choice)) {
+    return null;
+  }
+  return choice.trim();
+}
+function pickRandom(values, random) {
+  const index = Math.floor(random() * values.length);
+  return values[Math.min(index, values.length - 1)];
+}
+async function localBranchExists(repoRoot, branchName) {
+  try {
+    await execFileAsync3("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeOutput(worktreePath, stdout) {
+  await writeShellOutput(NEW_OUTPUT_FILE_ENV, worktreePath, stdout);
+}
+function isNotRegisteredWorktreeError(error) {
+  const stderr = hasExecStderr(error) ? error.stderr : String(error);
+  return stderr.includes("is not a working tree") || stderr.includes("not a linked working tree");
+}
+function hasExecStderr(error) {
+  return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
+}
+function toExecMessage(error) {
+  return hasExecStderr(error) ? error.stderr.trim() : String(error);
+}
+async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
+  if (!editorCli) {
+    stderr("gji new: --open requires --editor <cli> or a saved editor in config\n");
+    return;
+  }
+  const editorDef = EDITORS.find((e2) => e2.cli === editorCli);
+  const args = [];
+  if (editorDef?.newWindowFlag) {
+    args.push(editorDef.newWindowFlag);
+  }
+  args.push(worktreePath);
+  try {
+    await spawnFn(editorCli, args);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    stderr(`gji new: failed to open editor: ${message}
+`);
+  }
+}
+
+// src/repo-registry.ts
+import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename4, dirname as dirname6, join as join6, resolve as resolve4 } from "node:path";
+var REGISTRY_FILE_NAME = "repos.json";
+var MAX_REGISTRY_ENTRIES = 100;
+function REGISTRY_FILE_PATH(home = homedir4()) {
+  const configDir = process.env.GJI_CONFIG_DIR;
+  if (configDir) {
+    return join6(resolve4(configDir), REGISTRY_FILE_NAME);
+  }
+  return join6(home, GLOBAL_CONFIG_DIRECTORY, REGISTRY_FILE_NAME);
+}
+async function loadRegistry(home = homedir4()) {
+  const path9 = REGISTRY_FILE_PATH(home);
+  try {
+    const raw = await readFile3(path9, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isRegistryEntry);
+  } catch {
+    return [];
+  }
+}
+async function registerRepo(repoPath, home = homedir4()) {
+  const registryPath = REGISTRY_FILE_PATH(home);
+  const existing = await loadRegistry(home);
+  if (existing.length > 0 && existing[0].path === repoPath) return;
+  const entry = {
+    lastUsed: Date.now(),
+    name: basename4(repoPath),
+    path: repoPath
+  };
+  const filtered = existing.filter((e2) => e2.path !== repoPath);
+  const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
+  await mkdir5(dirname6(registryPath), { recursive: true });
+  await writeFile4(registryPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+}
+function isRegistryEntry(value) {
+  return typeof value === "object" && value !== null && "path" in value && typeof value.path === "string" && "name" in value && typeof value.name === "string" && "lastUsed" in value && typeof value.lastUsed === "number";
+}
+
+// src/warp.ts
+var WARP_OUTPUT_FILE_ENV = "GJI_WARP_OUTPUT_FILE";
+async function runWarpCommand(options) {
+  if (options.newWorktree) {
+    const registry = await loadRegistry();
+    if (registry.length === 0) {
+      options.stderr(
+        "gji warp: no repos registered yet.\nUse any gji command in a repository to register it automatically.\n"
+      );
+      return 1;
+    }
+    return runWarpNew(options, registry);
+  }
+  return runWarpNavigate(options);
+}
+async function runWarpNavigate(options) {
+  if ((isHeadless() || options.json) && !options.branch) {
+    const message = "branch argument is required";
+    if (options.json) {
+      options.stderr(`${JSON.stringify({ error: message }, null, 2)}
+`);
+    } else {
+      options.stderr(
+        "gji warp: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n"
+      );
+    }
+    return 1;
+  }
+  const target = await resolveWarpTarget({ ...options, commandName: "gji warp", json: options.json });
+  if (!target) return 1;
+  if (options.json) {
+    options.stdout(`${JSON.stringify({ branch: target.branch, path: target.path }, null, 2)}
+`);
+    return 0;
+  }
+  appendHistory(target.path, target.branch).catch(() => void 0);
+  await writeShellOutput(WARP_OUTPUT_FILE_ENV, target.path, options.stdout);
+  return 0;
+}
+async function runWarpNew(options, registry) {
+  let targetRepoRoot;
+  if (registry.length === 1) {
+    targetRepoRoot = registry[0].path;
+  } else {
+    if (isHeadless()) {
+      options.stderr(
+        "gji warp: repo argument is required in non-interactive mode (GJI_NO_TUI=1)\n"
+      );
+      return 1;
+    }
+    const choice = await ve({
+      message: "Create worktree in which repo?",
+      options: registry.map((entry) => ({
+        value: entry.path,
+        label: entry.name,
+        hint: entry.path
+      }))
+    });
+    if (pD(choice)) {
+      options.stderr("Aborted\n");
+      return 1;
+    }
+    targetRepoRoot = choice;
+  }
+  if (options.json) {
+    return runNewCommand({
+      branch: options.branch,
+      cwd: targetRepoRoot,
+      json: true,
+      stderr: options.stderr,
+      stdout: options.stdout
+    });
+  }
+  let capturedPath = "";
+  const captureStdout = (chunk) => {
+    capturedPath = chunk.trim();
+  };
+  const exitCode = await runNewCommand({
+    branch: options.branch,
+    cwd: targetRepoRoot,
+    stderr: options.stderr,
+    stdout: captureStdout
+  });
+  if (exitCode !== 0) {
+    return exitCode;
+  }
+  if (!capturedPath) {
+    options.stderr("gji warp: could not determine new worktree path\n");
+    return 1;
+  }
+  await writeShellOutput(WARP_OUTPUT_FILE_ENV, capturedPath, options.stdout);
+  return 0;
+}
+function findByQuery(items, query) {
+  const slashIdx = query.indexOf("/");
+  if (slashIdx !== -1) {
+    const repoQuery = query.slice(0, slashIdx);
+    const branchQuery = query.slice(slashIdx + 1);
+    const match = items.find(
+      (item) => item.repoName === repoQuery && item.worktree.branch === branchQuery
+    );
+    if (match) return match;
+  }
+  return items.find((item) => item.worktree.branch === query) ?? null;
+}
+async function resolveWarpTarget(options) {
+  const cmd = options.commandName ?? "gji";
+  const emitError4 = (message, hint) => {
+    if (options.json) {
+      options.stderr(`${JSON.stringify({ error: message }, null, 2)}
+`);
+    } else {
+      options.stderr(`${cmd}: ${message}
+`);
+      if (hint) options.stderr(hint);
+    }
+  };
+  const registry = await loadRegistry();
+  if (registry.length === 0) {
+    emitError4(
+      "not in a git repository and no repos registered yet.",
+      "Use any gji command inside a repository to register it.\n"
+    );
+    return null;
+  }
+  const results = await Promise.allSettled(
+    registry.map(async (entry) => {
+      const worktrees = await listWorktrees(entry.path);
+      return { repoName: entry.name, worktrees };
+    })
+  );
+  const allItems = [];
+  for (const result of results) {
+    if (result.status === "rejected") continue;
+    const { repoName, worktrees } = result.value;
+    for (const worktree of worktrees) {
+      allItems.push({ repoName, worktree });
+    }
+  }
+  if (allItems.length === 0) {
+    emitError4("no accessible worktrees found in any registered repo.");
+    return null;
+  }
+  if (options.branch) {
+    const match = findByQuery(allItems, options.branch);
+    if (!match) {
+      emitError4(`no worktree found matching: ${options.branch}`);
+      return null;
+    }
+    return { branch: match.worktree.branch, path: match.worktree.path };
+  }
+  const path9 = await promptForWarpTarget(allItems);
+  if (!path9) {
+    options.stderr("Aborted\n");
+    return null;
+  }
+  const chosen = allItems.find((item) => item.worktree.path === path9);
+  return { branch: chosen?.worktree.branch ?? null, path: path9 };
+}
+async function promptForWarpTarget(items) {
+  const healthResults = await Promise.allSettled(
+    items.map((item) => readWorktreeHealth(item.worktree.path))
+  );
+  const choice = await ve({
+    message: "Warp to a worktree",
+    options: items.map((item, i) => {
+      const health = healthResults[i].status === "fulfilled" ? healthResults[i].value : null;
+      const upstream = health ? formatHint(item.worktree.branch, health) : null;
+      const label = `${item.repoName} \u203A ${item.worktree.branch ?? "(detached)"}`;
+      const pathHint = item.worktree.isCurrent ? `${item.worktree.path} (current)` : item.worktree.path;
+      const hint = upstream ? `${upstream} \xB7 ${pathHint}` : pathHint;
+      return { hint, label, value: item.worktree.path };
+    })
+  });
+  if (pD(choice)) {
+    return null;
+  }
+  return choice;
+}
+function formatHint(branch, health) {
+  if (branch === null) return null;
+  if (!health.hasUpstream) return "no upstream";
+  if (health.upstreamGone) return "upstream gone";
+  if (health.ahead === 0 && health.behind === 0) return "up to date";
+  if (health.ahead === 0) return `behind ${health.behind}`;
+  if (health.behind === 0) return `ahead ${health.ahead}`;
+  return `ahead ${health.ahead}, behind ${health.behind}`;
+}
+
+// src/go.ts
+var GO_OUTPUT_FILE_ENV = "GJI_GO_OUTPUT_FILE";
+function createGoCommand(dependencies = {}) {
+  const prompt = dependencies.promptForWorktree ?? promptForWorktree;
+  return async function runGoCommand2(options) {
+    let worktrees;
+    let repository;
+    try {
+      [worktrees, repository] = await Promise.all([
+        listWorktrees(options.cwd),
+        detectRepository(options.cwd)
+      ]);
+    } catch {
+      if (isHeadless() && !options.branch) {
+        options.stderr(
+          "gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n"
+        );
+        return 1;
+      }
+      const target = await resolveWarpTarget({ ...options, commandName: "gji go" });
+      if (!target) return 1;
+      appendHistory(target.path, target.branch).catch(() => void 0);
+      await writeShellOutput(GO_OUTPUT_FILE_ENV, target.path, options.stdout);
+      return 0;
+    }
+    if (!options.branch && isHeadless()) {
+      options.stderr("gji go: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n");
+      return 1;
+    }
+    const prompted = options.branch ? null : await prompt(sortByCurrentFirst(worktrees));
+    const resolvedPath = options.branch ? worktrees.find((entry) => entry.branch === options.branch)?.path : prompted ?? void 0;
+    if (!resolvedPath) {
+      if (options.branch) {
+        options.stderr(`No worktree found for branch: ${options.branch}
+`);
+        options.stderr(`Hint: Use 'gji ls' to see available worktrees
+`);
+      } else {
+        options.stderr("Aborted\n");
+      }
+      return 1;
+    }
+    const chosenWorktree = worktrees.find((w2) => w2.path === resolvedPath);
+    const config = await loadEffectiveConfig(repository.repoRoot, void 0, options.stderr);
+    const hooks = extractHooks(config);
+    await runHook(
+      hooks.afterEnter,
+      resolvedPath,
+      { branch: chosenWorktree?.branch ?? void 0, path: resolvedPath, repo: basename5(repository.repoRoot) },
+      options.stderr
+    );
+    appendHistory(resolvedPath, chosenWorktree?.branch ?? null).catch(() => void 0);
+    await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
+    return 0;
+  };
+}
+var runGoCommand = createGoCommand();
+async function promptForWorktree(worktrees) {
+  const healthResults = await Promise.allSettled(
+    worktrees.map((w2) => readWorktreeHealth(w2.path))
+  );
+  const choice = await ve({
+    message: "Choose a worktree",
+    options: worktrees.map((worktree, i) => {
+      const health = healthResults[i].status === "fulfilled" ? healthResults[i].value : null;
+      const pathHint = worktree.isCurrent ? `${worktree.path} (current)` : worktree.path;
+      const upstream = health ? formatUpstreamHint(worktree.branch, health) : null;
+      return {
+        value: worktree.path,
+        label: worktree.branch ?? "(detached)",
+        hint: upstream ? `${upstream} \xB7 ${pathHint}` : pathHint
+      };
+    })
+  });
+  if (pD(choice)) {
+    return null;
+  }
+  return choice;
+}
+function formatUpstreamHint(branch, health) {
+  if (branch === null) return null;
+  if (!health.hasUpstream) return "no upstream";
+  if (health.upstreamGone) return "upstream gone";
+  if (health.ahead === 0 && health.behind === 0) return "up to date";
+  if (health.ahead === 0) return `behind ${health.behind}`;
+  if (health.behind === 0) return `ahead ${health.ahead}`;
+  return `ahead ${health.ahead}, behind ${health.behind}`;
+}
+
+// src/open.ts
+import { execFile as execFile4 } from "node:child_process";
+import { access as access4, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+var execFileAsync4 = promisify5(execFile4);
+function createOpenCommand(dependencies = {}) {
+  const detectEditors = dependencies.detectEditors ?? detectInstalledEditors;
+  const promptForEditor = dependencies.promptForEditor ?? defaultPromptForEditor;
+  const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree;
+  const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
+  return async function runOpenCommand2(options) {
+    const [worktrees, repository] = await Promise.all([
+      listWorktrees(options.cwd),
+      detectRepository(options.cwd)
+    ]);
+    let targetPath;
+    if (options.branch) {
+      const entry = worktrees.find((w2) => w2.branch === options.branch);
+      if (!entry) {
+        options.stderr(`gji open: no worktree found for branch: ${options.branch}
+`);
+        options.stderr(`Hint: Use 'gji ls' to see available worktrees
+`);
+        return 1;
+      }
+      targetPath = entry.path;
+    } else if (isHeadless()) {
+      targetPath = worktrees.find((w2) => w2.isCurrent)?.path ?? options.cwd;
+    } else {
+      const chosen = await promptForWorktree2(sortByCurrentFirst(worktrees));
+      if (!chosen) {
+        options.stderr("Aborted\n");
+        return 1;
+      }
+      targetPath = chosen;
+    }
+    const config = await loadEffectiveConfig(repository.repoRoot, void 0, options.stderr);
+    const savedEditor = resolveConfigString(config, "editor");
+    let editorCli;
+    if (options.editor) {
+      editorCli = options.editor;
+    } else if (savedEditor) {
+      editorCli = savedEditor;
+    } else {
+      const installed = await detectEditors();
+      if (installed.length === 0) {
+        options.stderr(
+          "gji open: no supported editor detected. Use --editor <code|cursor|zed|...> to specify one.\n"
+        );
+        return 1;
+      }
+      if (installed.length === 1 || isHeadless()) {
+        editorCli = installed[0].cli;
+      } else {
+        const chosen = await promptForEditor(installed);
+        if (!chosen) {
+          options.stderr("Aborted\n");
+          return 1;
+        }
+        editorCli = chosen;
+      }
+    }
+    if (options.save && editorCli !== savedEditor) {
+      await updateGlobalConfigKey("editor", editorCli);
+      const displayName2 = EDITORS.find((e2) => e2.cli === editorCli)?.name ?? editorCli;
+      options.stdout(`Saved editor "${displayName2}" to global config
+`);
+    }
+    const editorDef = EDITORS.find((e2) => e2.cli === editorCli);
+    let openTarget = targetPath;
+    if (options.workspace) {
+      if (editorDef?.supportsWorkspace) {
+        openTarget = await ensureWorkspaceFile(targetPath, repository.repoName);
+      } else {
+        const displayName2 = editorDef?.name ?? editorCli;
+        options.stderr(`gji open: --workspace is not supported for ${displayName2}, ignoring
+`);
+      }
+    }
+    const args = [];
+    if (editorDef?.newWindowFlag) {
+      args.push(editorDef.newWindowFlag);
+    }
+    args.push(openTarget);
+    try {
+      await spawnEditor(editorCli, args);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      options.stderr(`gji open: failed to launch editor: ${message}
+`);
+      return 1;
+    }
+    const displayName = editorDef?.name ?? editorCli;
+    options.stdout(`Opened ${targetPath} in ${displayName}
+`);
+    return 0;
+  };
+}
+var runOpenCommand = createOpenCommand();
+async function detectInstalledEditors() {
+  const results = await Promise.all(
+    EDITORS.map(async (editor) => ({ editor, available: await isCommandAvailable(editor.cli) }))
+  );
+  return results.filter((r2) => r2.available).map((r2) => r2.editor);
+}
+async function isCommandAvailable(command) {
+  try {
+    await execFileAsync4("which", [command]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function defaultPromptForWorktree(worktrees) {
+  const choice = await ve({
+    message: "Choose a worktree to open",
+    options: worktrees.map((w2) => ({
+      value: w2.path,
+      label: w2.branch ?? "(detached)",
+      hint: w2.isCurrent ? `${w2.path} (current)` : w2.path
+    }))
+  });
+  if (pD(choice)) return null;
+  return choice;
+}
+async function defaultPromptForEditor(editors) {
+  const choice = await ve({
+    message: "Choose an editor",
+    options: editors.map((e2) => ({ value: e2.cli, label: e2.name }))
+  });
+  if (pD(choice)) return null;
+  return choice;
+}
+async function ensureWorkspaceFile(worktreePath, repoName) {
+  const workspacePath = join7(worktreePath, `${repoName}.code-workspace`);
+  try {
+    await access4(workspacePath);
+    return workspacePath;
+  } catch {
+  }
+  const workspace = { folders: [{ path: "." }], settings: {} };
+  await writeFile5(workspacePath, `${JSON.stringify(workspace, null, 2)}
+`, "utf8");
+  return workspacePath;
+}
+
+// src/init.ts
+import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile6 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname7, join as join8 } from "node:path";
+var START_MARKER = "# >>> gji init >>>";
+var END_MARKER = "# <<< gji init <<<";
+var SHELL_WRAPPED_COMMANDS = [
+  {
+    bypassOptions: ["--help"],
+    commandName: "new",
+    envVar: "GJI_NEW_OUTPUT_FILE",
+    names: ["new"],
+    tempPrefix: "gji-new"
+  },
+  {
+    bypassOptions: ["--help"],
+    commandName: "pr",
+    envVar: "GJI_PR_OUTPUT_FILE",
+    names: ["pr"],
+    tempPrefix: "gji-pr"
+  },
+  {
+    bypassOptions: ["--print"],
+    commandName: "back",
+    envVar: "GJI_BACK_OUTPUT_FILE",
+    names: ["back"],
+    tempPrefix: "gji-back"
+  },
+  {
+    bypassOptions: ["--print"],
+    commandName: "go",
+    envVar: "GJI_GO_OUTPUT_FILE",
+    names: ["go", "jump"],
+    tempPrefix: "gji-go"
+  },
+  {
+    bypassOptions: ["--print"],
+    commandName: "root",
+    envVar: "GJI_ROOT_OUTPUT_FILE",
+    names: ["root"],
+    tempPrefix: "gji-root"
+  },
+  {
+    bypassOptions: ["--help"],
+    commandName: "remove",
+    envVar: "GJI_REMOVE_OUTPUT_FILE",
+    names: ["remove", "rm"],
+    tempPrefix: "gji-remove"
+  },
+  {
+    bypassOptions: ["--print", "--json"],
+    commandName: "warp",
+    envVar: "GJI_WARP_OUTPUT_FILE",
+    names: ["warp"],
+    tempPrefix: "gji-warp"
+  }
+];
+async function runInitCommand(options) {
+  const shell = resolveSupportedShell(options.shell, process.env.SHELL);
+  const home = options.home ?? homedir5();
+  if (!shell) {
+    options.stderr?.(
+      "Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n"
+    );
+    return 1;
+  }
+  const script = renderShellIntegration(shell);
+  if (!options.write) {
+    options.stdout(script);
+    return 0;
+  }
+  const rcPath = resolveShellConfigPath(shell, home);
+  await mkdir6(dirname7(rcPath), { recursive: true });
+  const current = await readExistingConfig(rcPath);
+  const next = upsertShellIntegration(current, script);
+  await writeFile6(rcPath, next, "utf8");
+  options.stdout(`${rcPath}
+`);
+  const { config: globalConfig } = await loadGlobalConfig(home);
+  const alreadyConfigured = "shellIntegration" in globalConfig || "installSaveTarget" in globalConfig;
+  const hasCustomPrompt = options.promptForSetup !== void 0;
+  const canPrompt = hasCustomPrompt || process.stdout.isTTY === true;
+  if (!alreadyConfigured && canPrompt) {
+    const prompt = options.promptForSetup ?? defaultPromptForSetup;
+    const result = await prompt();
+    if (result) {
+      await updateGlobalConfigKey("installSaveTarget", result.installSaveTarget, home);
+      await saveWizardConfig(result, options.cwd, home);
+    }
+  }
+  await updateGlobalConfigKey("shellIntegration", true, home);
+  return 0;
+}
+function renderShellIntegration(shell) {
+  const commandBlocks = SHELL_WRAPPED_COMMANDS.map(
+    (command) => shell === "fish" ? renderFishWrapper(command) : renderPosixWrapper(command)
+  ).join("\n\n");
+  switch (shell) {
+    case "fish":
+      return `${START_MARKER}
+function gji --wraps gji --description 'gji shell integration'
+${indentBlock(commandBlocks, 4)}
+
+    command gji $argv
+end
+${END_MARKER}
+`;
+    case "bash":
+    case "zsh":
+      return `${START_MARKER}
+gji() {
+${indentBlock(commandBlocks, 2)}
+
+  command gji "$@"
+}
+${END_MARKER}
+`;
+  }
+}
+function upsertShellIntegration(existingConfig, script) {
+  const trimmedScript = script.trimEnd();
+  const blockPattern = new RegExp(
+    `${escapeForRegExp(START_MARKER)}[\\s\\S]*?${escapeForRegExp(END_MARKER)}\\n?`,
+    "m"
+  );
+  if (blockPattern.test(existingConfig)) {
+    return ensureTrailingNewline(
+      existingConfig.replace(blockPattern, `${trimmedScript}
+`)
+    );
+  }
+  const prefix = existingConfig.trimEnd();
+  if (prefix.length === 0) {
+    return ensureTrailingNewline(trimmedScript);
+  }
+  return ensureTrailingNewline(`${prefix}
+
+${trimmedScript}`);
+}
+async function saveWizardConfig(result, cwd, home) {
+  const values = {};
+  if (result.branchPrefix) values.branchPrefix = result.branchPrefix;
+  if (result.worktreePath) values.worktreePath = result.worktreePath;
+  const hooks = {};
+  if (result.hooks?.afterCreate) hooks.afterCreate = result.hooks.afterCreate;
+  if (result.hooks?.afterEnter) hooks.afterEnter = result.hooks.afterEnter;
+  if (result.hooks?.beforeRemove) hooks.beforeRemove = result.hooks.beforeRemove;
+  if (Object.keys(hooks).length > 0) values.hooks = hooks;
+  if (Object.keys(values).length === 0) return;
+  if (result.installSaveTarget === "local") {
+    const loaded = await loadConfig(cwd);
+    await saveLocalConfig(cwd, { ...loaded.config, ...values });
+  } else {
+    const { config: existing } = await loadGlobalConfig(home);
+    await saveGlobalConfig({ ...existing, ...values }, home);
+  }
+}
+function resolveShellConfigPath(shell, home) {
+  switch (shell) {
+    case "bash":
+      return join8(home, ".bashrc");
+    case "fish":
+      return join8(home, ".config", "fish", "config.fish");
+    case "zsh":
+      return join8(home, ".zshrc");
+  }
+}
+async function readExistingConfig(path9) {
+  try {
+    return await readFile4(path9, "utf8");
+  } catch (error) {
+    if (isMissingFileError2(error)) {
+      return "";
+    }
+    throw error;
+  }
+}
+function ensureTrailingNewline(value) {
+  return value.endsWith("\n") ? value : `${value}
+`;
+}
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isMissingFileError2(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function renderFishWrapper(command) {
+  const nameTests = command.names.map((name) => `test $argv[1] = ${name}`);
+  const nameCondition = nameTests.length === 1 ? nameTests[0] : `begin; ${nameTests.join("; or ")}; end`;
+  const bypassTests = command.bypassOptions.map((opt) => `test $argv[1] = ${opt}`);
+  const bypassCondition = bypassTests.length === 1 ? bypassTests[0] : `begin; ${bypassTests.join("; or ")}; end`;
+  return `if test (count $argv) -gt 0; and ${nameCondition}
+    set -e argv[1]
+    if test (count $argv) -gt 0; and ${bypassCondition}
+        command gji ${command.commandName} $argv
+        return $status
+    end
+
+    set -l output_file (mktemp -t ${command.tempPrefix}.XXXXXX)
+    or return 1
+    env ${command.envVar}=$output_file command gji ${command.commandName} $argv
+    or begin
+        set -l status_code $status
+        rm -f $output_file
+        return $status_code
+    end
+    set -l target (cat $output_file)
+    rm -f $output_file
+    cd $target
+    return $status
+end`;
+}
+function renderPosixWrapper(command) {
+  const tests = command.names.map((name) => `[ "$1" = "${name}" ]`).join(" || ");
+  const bypassTests = command.bypassOptions.map((opt) => `[ "\${1:-}" = "${opt}" ]`).join(" || ");
+  return `if ${tests}; then
+  shift
+  if ${bypassTests}; then
+    command gji ${command.commandName} "$@"
+    return $?
+  fi
+
+  local target
+  local output_file
+  output_file="$(mktemp -t ${command.tempPrefix}.XXXXXX)" || return 1
+  ${command.envVar}="$output_file" command gji ${command.commandName} "$@" || { local exit_code=$?; rm -f "$output_file"; return $exit_code; }
+  target="$(cat "$output_file")"
+  rm -f "$output_file"
+  cd "$target" || return $?
+  return 0
+fi`;
+}
+function indentBlock(value, spaces) {
+  const prefix = " ".repeat(spaces);
+  return value.split("\n").map((line) => line.length === 0 ? "" : `${prefix}${line}`).join("\n");
 }
-function applyConfiguredBranchPrefix(branch, branchPrefix) {
-  if (typeof branchPrefix !== "string" || branchPrefix.length === 0) {
-    return branch;
+async function defaultPromptForSetup() {
+  Ie("gji setup");
+  const installSaveTarget = await ve({
+    message: "Where should preferences be saved?",
+    options: [
+      { value: "global", label: "~/.config/gji/config.json", hint: "personal \u2014 never committed" },
+      { value: "local", label: ".gji.json", hint: "repo \u2014 committed with the project" }
+    ]
+  });
+  if (pD(installSaveTarget)) {
+    Se("Setup skipped.");
+    return null;
   }
-  if (branch.startsWith(branchPrefix)) {
-    return branch;
+  const branchPrefix = await he({
+    message: "Default branch prefix?",
+    placeholder: "e.g. feat/ or fix/ \u2014 leave blank to skip"
+  });
+  if (pD(branchPrefix)) {
+    Se("Setup skipped.");
+    return null;
   }
-  return `${branchPrefix}${branch}`;
-}
-async function resolveUniqueDetachedWorktreePath(repoRoot, baseName, basePath) {
-  let attempt = 1;
-  while (true) {
-    const candidateName = attempt === 1 ? baseName : `${baseName}-${attempt}`;
-    const candidatePath = resolveWorktreePath(repoRoot, candidateName, basePath);
-    if (!await pathExists(candidatePath)) {
-      return candidatePath;
-    }
-    attempt += 1;
+  const worktreePath = await he({
+    message: "Worktree base path?",
+    placeholder: "leave blank to use the default path"
+  });
+  if (pD(worktreePath)) {
+    Se("Setup skipped.");
+    return null;
   }
-}
-async function defaultPromptForBranch(placeholder) {
-  const choice = await he({
-    defaultValue: placeholder,
-    message: "Name the new branch",
-    placeholder,
-    validate: (value) => {
-      const trimmed = value.trim();
-      return validateBranchName(trimmed) ?? void 0;
-    }
+  const afterCreate = await he({
+    message: "afterCreate hook \u2014 run after creating a worktree?",
+    placeholder: "e.g. pnpm install \u2014 leave blank to skip"
   });
-  if (pD(choice)) {
+  if (pD(afterCreate)) {
+    Se("Setup skipped.");
     return null;
   }
-  return choice.trim();
-}
-function pickRandom(values, random) {
-  const index = Math.floor(random() * values.length);
-  return values[Math.min(index, values.length - 1)];
+  const afterEnter = await he({
+    message: "afterEnter hook \u2014 run after entering a worktree?",
+    placeholder: "e.g. nvm use \u2014 leave blank to skip"
+  });
+  if (pD(afterEnter)) {
+    Se("Setup skipped.");
+    return null;
+  }
+  const beforeRemove = await he({
+    message: "beforeRemove hook \u2014 run before removing a worktree?",
+    placeholder: "leave blank to skip"
+  });
+  if (pD(beforeRemove)) {
+    Se("Setup skipped.");
+    return null;
+  }
+  Se("Setup complete!");
+  const hooks = {};
+  if (afterCreate) hooks.afterCreate = afterCreate;
+  if (afterEnter) hooks.afterEnter = afterEnter;
+  if (beforeRemove) hooks.beforeRemove = beforeRemove;
+  return {
+    branchPrefix: branchPrefix || void 0,
+    hooks: Object.keys(hooks).length > 0 ? hooks : void 0,
+    installSaveTarget,
+    worktreePath: worktreePath || void 0
+  };
 }
-async function localBranchExists(repoRoot, branchName) {
-  try {
-    await execFileAsync3("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });
-    return true;
-  } catch {
-    return false;
+
+// src/paths.ts
+function comparePaths(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
   }
+  return 0;
 }
-async function writeOutput(worktreePath, stdout) {
-  await writeShellOutput(NEW_OUTPUT_FILE_ENV, worktreePath, stdout);
+
+// src/ls.ts
+async function runLsCommand(options) {
+  const worktrees = sortWorktrees(await listWorktrees(options.cwd));
+  if (options.compact) {
+    if (options.json) {
+      options.stdout(`${JSON.stringify(worktrees, null, 2)}
+`);
+      return 0;
+    }
+    options.stdout(`${formatWorktreeTable(worktrees)}
+`);
+    return 0;
+  }
+  const infos = await readWorktreeInfos(worktrees);
+  if (options.json) {
+    options.stdout(`${JSON.stringify(infos, null, 2)}
+`);
+    return 0;
+  }
+  options.stdout(`${formatDetailedWorktreeTable(infos)}
+`);
+  return 0;
 }
-function isNotRegisteredWorktreeError(error) {
-  const stderr = hasExecStderr(error) ? error.stderr : String(error);
-  return stderr.includes("is not a working tree") || stderr.includes("not a linked working tree");
+function formatDetailedWorktreeTable(worktrees) {
+  const rows = worktrees.map((worktree) => ({
+    branch: worktree.branch ?? "(detached)",
+    isCurrent: worktree.isCurrent,
+    lastCommit: formatLastCommit(worktree.lastCommitTimestamp),
+    path: worktree.path,
+    status: worktree.status,
+    upstream: formatUpstreamState(worktree.upstream)
+  }));
+  const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => row.branch.length));
+  const statusWidth = Math.max("STATUS".length, ...rows.map((row) => row.status.length));
+  const upstreamWidth = Math.max("UPSTREAM".length, ...rows.map((row) => row.upstream.length));
+  const lastCommitWidth = Math.max("LAST".length, ...rows.map((row) => row.lastCommit.length));
+  const lines = [
+    "  " + "BRANCH".padEnd(branchWidth, " ") + " " + "STATUS".padEnd(statusWidth, " ") + " " + "UPSTREAM".padEnd(upstreamWidth, " ") + " " + "LAST".padEnd(lastCommitWidth, " ") + " PATH"
+  ];
+  for (const row of rows) {
+    lines.push(
+      `${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.status.padEnd(statusWidth, " ")} ${row.upstream.padEnd(upstreamWidth, " ")} ${row.lastCommit.padEnd(lastCommitWidth, " ")} ` + row.path
+    );
+  }
+  return lines.join("\n");
 }
-function hasExecStderr(error) {
-  return error instanceof Error && "stderr" in error && typeof error.stderr === "string";
+function formatWorktreeTable(worktrees) {
+  const rows = worktrees.map((worktree) => ({
+    branch: worktree.branch ?? "(detached)",
+    isCurrent: worktree.isCurrent,
+    path: worktree.path
+  }));
+  const branchWidth = Math.max(
+    "BRANCH".length,
+    ...rows.map((row) => row.branch.length)
+  );
+  const lines = ["  " + "BRANCH".padEnd(branchWidth, " ") + " PATH"];
+  for (const row of rows) {
+    lines.push(`${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.path}`);
+  }
+  return lines.join("\n");
 }
-function toExecMessage(error) {
-  return hasExecStderr(error) ? error.stderr.trim() : String(error);
+function sortWorktrees(worktrees) {
+  return [...worktrees].sort((left, right) => {
+    if (left.isCurrent && !right.isCurrent) return -1;
+    if (!left.isCurrent && right.isCurrent) return 1;
+    return comparePaths(left.path, right.path);
+  });
 }
 
 // src/pr.ts
-import { mkdir as mkdir6 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname7 } from "node:path";
-import { execFile as execFile4 } from "node:child_process";
-import { promisify as promisify5 } from "node:util";
-var execFileAsync4 = promisify5(execFile4);
+import { mkdir as mkdir7 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname8 } from "node:path";
+import { execFile as execFile5 } from "node:child_process";
+import { promisify as promisify6 } from "node:util";
+var execFileAsync5 = promisify6(execFile5);
 var PR_OUTPUT_FILE_ENV = "GJI_PR_OUTPUT_FILE";
 function parsePrInput(input) {
   if (/^\d+$/.test(input)) return input;
@@ -15860,10 +16370,10 @@ function createPrCommand(dependencies = {}) {
       }
       return 1;
     }
-    await mkdir6(dirname7(worktreePath), { recursive: true });
+    await mkdir7(dirname8(worktreePath), { recursive: true });
     const branchAlreadyExists = await localBranchExists2(repository.repoRoot, branchName);
     const worktreeArgs = branchAlreadyExists ? ["worktree", "add", worktreePath, branchName] : ["worktree", "add", "-b", branchName, worktreePath, remoteRef];
-    await execFileAsync4("git", worktreeArgs, { cwd: repository.repoRoot });
+    await execFileAsync5("git", worktreeArgs, { cwd: repository.repoRoot });
     const syncPatterns = Array.isArray(config.syncFiles) ? config.syncFiles.filter((p2) => typeof p2 === "string") : [];
     for (const pattern of syncPatterns) {
       try {
@@ -15878,7 +16388,7 @@ function createPrCommand(dependencies = {}) {
     await runHook(
       hooks.afterCreate,
       worktreePath,
-      { branch: branchName, path: worktreePath, repo: basename5(repository.repoRoot) },
+      { branch: branchName, path: worktreePath, repo: basename6(repository.repoRoot) },
       options.stderr
     );
     if (options.json) {
@@ -15893,7 +16403,7 @@ function createPrCommand(dependencies = {}) {
 }
 async function localBranchExists2(repoRoot, branchName) {
   try {
-    await execFileAsync4(
+    await execFileAsync5(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
       { cwd: repoRoot }
@@ -15907,7 +16417,7 @@ var runPrCommand = createPrCommand();
 async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
   for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
     try {
-      await execFileAsync4(
+      await execFileAsync5(
         "git",
         ["fetch", "origin", `${sourceRef}:${remoteRef}`],
         { cwd: repoRoot }
@@ -15951,10 +16461,10 @@ async function writeOutput2(worktreePath, stdout) {
 }
 
 // src/remove.ts
-import { basename as basename6 } from "node:path";
+import { basename as basename7 } from "node:path";
 var REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 function createRemoveCommand(dependencies = {}) {
-  const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree;
+  const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree2;
   const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval2;
   const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ?? defaultConfirmForceRemoveWorktree;
   const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
@@ -16016,7 +16526,7 @@ function createRemoveCommand(dependencies = {}) {
     await runHook(
       hooks.beforeRemove,
       worktree.path,
-      { branch: worktree.branch ?? void 0, path: worktree.path, repo: basename6(repository.repoRoot) },
+      { branch: worktree.branch ?? void 0, path: worktree.path, repo: basename7(repository.repoRoot) },
       options.stderr
     );
     try {
@@ -16066,7 +16576,7 @@ function createRemoveCommand(dependencies = {}) {
   };
 }
 var runRemoveCommand = createRemoveCommand();
-async function defaultPromptForWorktree(worktrees) {
+async function defaultPromptForWorktree2(worktrees) {
   const choice = await ve({
     message: "Choose a worktree to finish",
     options: worktrees.map((worktree) => ({
@@ -16355,6 +16865,7 @@ function readPackageMetadata() {
 }
 async function runCli(argv, options = {}) {
   await maybeNotifyForUpdates(argv);
+  maybeRegisterCurrentRepo(options.cwd ?? process.cwd());
   const program2 = createProgram();
   const cwd = options.cwd ?? process.cwd();
   const stdout = options.stdout ?? (() => void 0);
@@ -16398,14 +16909,18 @@ function defaultNotifyForUpdates(pkg) {
   const notifier = updateNotifier({ pkg });
   notifier.notify();
 }
+function maybeRegisterCurrentRepo(cwd) {
+  detectRepository(cwd).then(({ repoRoot }) => registerRepo(repoRoot)).catch(() => void 0);
+}
 function registerCommands(program2) {
-  program2.command("new [branch]").description("create a new branch or detached linked worktree").option("-f, --force", "remove and recreate the worktree if the target path already exists").option("--detached", "create a detached worktree without a branch").option("--dry-run", "show what would be created without executing any git commands or writing files").option("--json", "emit JSON on success or error instead of human-readable output").action(notImplemented("new"));
+  program2.command("new [branch]").description("create a new branch or detached linked worktree").option("-f, --force", "remove and recreate the worktree if the target path already exists").option("--detached", "create a detached worktree without a branch").option("--open", "open the new worktree in an editor after creation").option("--editor <cli>", "editor CLI to use with --open (code, cursor, zed, \u2026)").option("--dry-run", "show what would be created without executing any git commands or writing files").option("--json", "emit JSON on success or error instead of human-readable output").action(notImplemented("new"));
   program2.command("init [shell]").description("print or install shell integration").option("--write", "write the integration to the shell config file").action(notImplemented("init"));
   program2.command("completion [shell]").description("print shell completion definitions").action(notImplemented("completion"));
   program2.command("pr <ref>").description("fetch a pull request by number, #number, or URL into a linked worktree").option("--dry-run", "show what would be created without executing any git commands or writing files").option("--json", "emit JSON on success or error instead of human-readable output").action(notImplemented("pr"));
   program2.command("back [n]").description("navigate to the previously visited worktree, optionally N steps back").option("--print", "print the resolved worktree path explicitly").action(notImplemented("back"));
   program2.command("history").description("show navigation history").option("--json", "print history as JSON").action(notImplemented("history"));
-  program2.command("go [branch]").description("print or select a worktree path").option("--print", "print the resolved worktree path explicitly").action(notImplemented("go"));
+  program2.command("open [branch]").description("open the worktree in an editor").option("--editor <cli>", "editor CLI to use (code, cursor, zed, windsurf, subl, \u2026)").option("--save", "save the chosen editor to global config").option("--workspace", "generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)").action(notImplemented("open"));
+  program2.command("go [branch]").alias("jump").description("print or select a worktree path").option("--print", "print the resolved worktree path explicitly").action(notImplemented("go"));
   program2.command("root").description("print the main repository root path").option("--print", "print the resolved repository root path explicitly").action(notImplemented("root"));
   program2.command("status").description("summarize repository and worktree health").option("--json", "print repository and worktree health as JSON").action(notImplemented("status"));
   program2.command("sync").description("fetch and update one or all worktrees").option("--all", "sync every worktree in the repository").option("--json", "emit JSON on success or error instead of human-readable output").action(notImplemented("sync"));
@@ -16413,6 +16928,7 @@ function registerCommands(program2) {
   program2.command("clean").description("interactively prune linked worktrees").option("-f, --force", "bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches").option("--stale", "only target clean worktrees whose upstream is gone and branch is merged into the default branch").option("--dry-run", "show what would be deleted without removing anything").option("--json", "emit JSON on success or error instead of human-readable output").action(notImplemented("clean"));
   program2.command("remove [branch]").alias("rm").description("remove a linked worktree and delete its branch when present").option("-f, --force", "bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch").option("--dry-run", "show what would be deleted without removing anything").option("--json", "emit JSON on success or error instead of human-readable output").action(notImplemented("remove"));
   program2.command("trigger-hook <hook>").description("run a named hook (afterCreate, afterEnter, beforeRemove) in the current worktree").action(notImplemented("trigger-hook"));
+  program2.command("warp [branch]").description("jump to any worktree across all known repos").option("-n, --new [branch]", "create a new worktree in a registered repo").option("--print", "print the resolved worktree path without changing directory").option("--json", "emit JSON on success or error instead of human-readable output").action(notImplemented("warp"));
   const configCommand = program2.command("config").description("manage global config defaults").action(notImplemented("config"));
   configCommand.command("get [key]").description("print the global config or a single key").action(notImplemented("config get"));
   configCommand.command("set <key> <value>").description("set a global config value").action(notImplemented("config set"));
@@ -16420,7 +16936,7 @@ function registerCommands(program2) {
 }
 function attachCommandActions(program2, options) {
   program2.commands.find((command) => command.name() === "new")?.action(async (branch, commandOptions) => {
-    const exitCode = await runNewCommand({ ...options, branch, detached: commandOptions.detached, dryRun: commandOptions.dryRun, force: commandOptions.force, json: commandOptions.json });
+    const exitCode = await runNewCommand({ ...options, branch, detached: commandOptions.detached, dryRun: commandOptions.dryRun, editor: commandOptions.editor, force: commandOptions.force, json: commandOptions.json, open: commandOptions.open });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
@@ -16481,6 +16997,20 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
+  program2.commands.find((command) => command.name() === "open")?.action(async (branch, commandOptions) => {
+    const exitCode = await runOpenCommand({
+      branch,
+      cwd: options.cwd,
+      editor: commandOptions.editor,
+      save: commandOptions.save,
+      stderr: options.stderr,
+      stdout: options.stdout,
+      workspace: commandOptions.workspace
+    });
+    if (exitCode !== 0) {
+      throw commanderExit(exitCode);
+    }
+  });
   program2.commands.find((command) => command.name() === "go")?.action(async (branch, commandOptions) => {
     const exitCode = await runGoCommand({
       branch,
@@ -16575,6 +17105,22 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
+  program2.commands.find((command) => command.name() === "warp")?.action(async (branch, commandOptions) => {
+    const newFlag = commandOptions.new;
+    const newWorktree = newFlag !== void 0 && newFlag !== false;
+    const newBranch = typeof newFlag === "string" ? newFlag : void 0;
+    const exitCode = await runWarpCommand({
+      branch: newWorktree ? newBranch ?? branch : branch,
+      cwd: options.cwd,
+      json: commandOptions.json,
+      newWorktree,
+      stderr: options.stderr,
+      stdout: options.stdout
+    });
+    if (exitCode !== 0) {
+      throw commanderExit(exitCode);
+    }
+  });
   const configCommand = program2.commands.find((command) => command.name() === "config");
   configCommand?.action(async () => {
     const exitCode = await runConfigCommand({
@@ -16657,7 +17203,7 @@ async function main() {
 }
 async function warnIfMissingShellIntegration() {
   try {
-    const { config } = await loadGlobalConfig(homedir5());
+    const { config } = await loadGlobalConfig(homedir6());
     if (!config.shellIntegration) {
       const shellBin = (process.env.SHELL ?? "").split("/").at(-1);
       const shellArg = shellBin && ["bash", "zsh", "fish"].includes(shellBin) ? ` ${shellBin}` : "";