@solaqua/gji 0.6.2 → 0.7.0

package/dist/gji-bundle.mjs

@@ -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 join9 = __require("path").join;
+    var join10 = __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)
         [
-          join9(etc, name, "config"),
-          join9(etc, name + "rc")
+          join10(etc, name, "config"),
+          join10(etc, name + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join9(home, ".config", name, "config"),
-          join9(home, ".config", name),
-          join9(home, "." + name, "config"),
-          join9(home, "." + name + "rc")
+          join10(home, ".config", name, "config"),
+          join10(home, ".config", name),
+          join10(home, "." + name, "config"),
+          join10(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
       if (env4.config) addConfigFile(env4.config);
@@ -9422,225 +9422,7 @@ var require_picocolors = __commonJS({
 });
 
 // src/index.ts
-import { homedir as homedir6 } from "node:os";
-
-// src/config.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-var CONFIG_FILE_NAME = ".gji.json";
-var GLOBAL_CONFIG_DIRECTORY = ".config/gji";
-var GLOBAL_CONFIG_NAME = "config.json";
-var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "branchPrefix",
-  "editor",
-  "hooks",
-  "installSaveTarget",
-  "shellIntegration",
-  "skipInstallPrompt",
-  "syncDefaultBranch",
-  "syncFiles",
-  "syncRemote",
-  "worktreePath"
-]);
-var KNOWN_GLOBAL_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  ...KNOWN_CONFIG_KEYS,
-  "repos"
-]);
-var DEFAULT_CONFIG = Object.freeze({});
-async function loadConfig(root) {
-  const path9 = join(root, CONFIG_FILE_NAME);
-  return loadConfigFile(path9);
-}
-async function loadEffectiveConfig(root, home = homedir(), onWarning) {
-  const [globalConfig, localConfig] = await Promise.all([
-    loadGlobalConfig(home),
-    loadConfig(root)
-  ]);
-  const repos = globalConfig.config.repos;
-  const perRepoConfig = isPlainObject(repos) ? findPerRepoConfig(repos, root, home) : {};
-  const globalBase = { ...globalConfig.config };
-  delete globalBase.repos;
-  if (onWarning) {
-    if (globalConfig.exists) {
-      warnUnknownKeys(globalBase, globalConfig.path, KNOWN_GLOBAL_CONFIG_KEYS, onWarning);
-      if (Object.keys(perRepoConfig).length > 0) {
-        warnUnknownKeys(perRepoConfig, globalConfig.path, KNOWN_CONFIG_KEYS, onWarning);
-      }
-    }
-    if (localConfig.exists) {
-      warnUnknownKeys(localConfig.config, localConfig.path, KNOWN_CONFIG_KEYS, onWarning);
-    }
-  }
-  const merged = mergeConfig(globalBase, perRepoConfig, localConfig.config);
-  const worktreePathValue = merged.worktreePath;
-  if (onWarning && typeof worktreePathValue === "string" && worktreePathValue.length > 0 && !worktreePathValue.startsWith("/") && !worktreePathValue.startsWith("~")) {
-    onWarning(
-      `gji: "worktreePath" must be an absolute path or start with ~, got "${worktreePathValue}" \u2014 using default
-`
-    );
-  }
-  const globalHooks = isPlainObject(globalBase.hooks) ? globalBase.hooks : {};
-  const perRepoHooks = isPlainObject(perRepoConfig.hooks) ? perRepoConfig.hooks : {};
-  const localHooks = isPlainObject(localConfig.config.hooks) ? localConfig.config.hooks : {};
-  if (Object.keys(globalHooks).length > 0 || Object.keys(perRepoHooks).length > 0 || Object.keys(localHooks).length > 0) {
-    merged.hooks = { ...globalHooks, ...perRepoHooks, ...localHooks };
-  }
-  return merged;
-}
-async function loadGlobalConfig(home = homedir()) {
-  return loadConfigFile(GLOBAL_CONFIG_FILE_PATH(home));
-}
-async function saveLocalConfig(root, config) {
-  const path9 = join(root, CONFIG_FILE_NAME);
-  await writeFile(path9, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-  return path9;
-}
-async function updateLocalConfigKey(root, key, value) {
-  const loaded = await loadConfig(root);
-  const nextConfig = {
-    ...loaded.config,
-    [key]: value
-  };
-  await saveLocalConfig(root, nextConfig);
-  return nextConfig;
-}
-async function saveGlobalConfig(config, home = homedir()) {
-  const path9 = GLOBAL_CONFIG_FILE_PATH(home);
-  await mkdir(dirname(path9), { recursive: true });
-  await writeFile(path9, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-  return path9;
-}
-async function unsetGlobalConfigKey(key, home = homedir()) {
-  const loaded = await loadGlobalConfig(home);
-  const nextConfig = { ...loaded.config };
-  delete nextConfig[key];
-  await saveGlobalConfig(nextConfig, home);
-  return nextConfig;
-}
-async function updateGlobalConfigKey(key, value, home = homedir()) {
-  const loaded = await loadGlobalConfig(home);
-  const nextConfig = {
-    ...loaded.config,
-    [key]: value
-  };
-  await saveGlobalConfig(nextConfig, home);
-  return nextConfig;
-}
-async function updateGlobalRepoConfigKey(repoRoot, key, value, home = homedir()) {
-  const loaded = await loadGlobalConfig(home);
-  const repos = isPlainObject(loaded.config.repos) ? { ...loaded.config.repos } : {};
-  const existing = isPlainObject(repos[repoRoot]) ? repos[repoRoot] : {};
-  repos[repoRoot] = { ...existing, [key]: value };
-  const nextConfig = { ...loaded.config, repos };
-  await saveGlobalConfig(nextConfig, home);
-  return nextConfig;
-}
-function GLOBAL_CONFIG_FILE_PATH(home = homedir()) {
-  const configDir = process.env.GJI_CONFIG_DIR;
-  if (configDir) {
-    return join(resolve(configDir), GLOBAL_CONFIG_NAME);
-  }
-  return join(home, GLOBAL_CONFIG_DIRECTORY, GLOBAL_CONFIG_NAME);
-}
-function parseConfigValue(value) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-}
-function resolveConfigString(config, key) {
-  const value = config[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-async function loadConfigFile(path9) {
-  try {
-    const rawConfig = await readFile(path9, "utf8");
-    const parsedConfig = JSON.parse(rawConfig);
-    return {
-      config: mergeConfig(parsedConfig),
-      exists: true,
-      path: path9
-    };
-  } catch (error) {
-    if (isMissingFileError(error)) {
-      return {
-        config: DEFAULT_CONFIG,
-        exists: false,
-        path: path9
-      };
-    }
-    throw error;
-  }
-}
-function mergeConfig(...values) {
-  return values.reduce(
-    (config, value) => ({
-      ...config,
-      ...value
-    }),
-    { ...DEFAULT_CONFIG }
-  );
-}
-function findPerRepoConfig(repos, repoRoot, home) {
-  for (const [key, value] of Object.entries(repos)) {
-    const expandedKey = expandTilde(key, home);
-    if (expandedKey === repoRoot && isPlainObject(value)) {
-      return value;
-    }
-  }
-  return {};
-}
-function expandTilde(value, home) {
-  if (value === "~") return home;
-  if (value.startsWith("~/")) return join(home, value.slice(2));
-  return value;
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isMissingFileError(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function warnUnknownKeys(config, filePath, knownKeys, onWarning) {
-  for (const key of Object.keys(config)) {
-    if (!knownKeys.has(key)) {
-      const suggestion = closestKey(key, knownKeys);
-      const hint = suggestion ? ` (did you mean "${suggestion}"?)` : "";
-      onWarning(`gji: unknown config key "${key}" in ${filePath}${hint}
-`);
-    }
-  }
-}
-function closestKey(unknown, knownKeys) {
-  let best = null;
-  let bestDist = Infinity;
-  for (const key of knownKeys) {
-    const dist = levenshtein(unknown, key);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = key;
-    }
-  }
-  return bestDist <= Math.max(2, Math.floor(unknown.length / 2)) ? best : null;
-}
-function levenshtein(a, b3) {
-  const m2 = a.length;
-  const n = b3.length;
-  const dp = Array.from(
-    { length: m2 + 1 },
-    (_3, i) => Array.from({ length: n + 1 }, (_4, j2) => i === 0 ? j2 : j2 === 0 ? i : 0)
-  );
-  for (let i = 1; i <= m2; i++) {
-    for (let j2 = 1; j2 <= n; j2++) {
-      dp[i][j2] = a[i - 1] === b3[j2 - 1] ? dp[i - 1][j2 - 1] : 1 + Math.min(dp[i - 1][j2], dp[i][j2 - 1], dp[i - 1][j2 - 1]);
-    }
-  }
-  return dp[m2][n];
-}
+import { homedir as homedir7 } from "node:os";
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -13032,20 +12814,293 @@ function updateNotifier(options) {
 import { access } from "node:fs/promises";
 import { basename as basename2 } from "node:path";
 
-// src/hooks.ts
-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);
+// src/config.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+var CONFIG_FILE_NAME = ".gji.json";
+var GLOBAL_CONFIG_DIRECTORY = ".config/gji";
+var GLOBAL_CONFIG_NAME = "config.json";
+var KNOWN_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "branchPrefix",
+  "editor",
+  "hooks",
+  "installSaveTarget",
+  "shellIntegration",
+  "skipInstallPrompt",
+  "syncDefaultBranch",
+  "syncFiles",
+  "syncRemote",
+  "worktreePath"
+]);
+var KNOWN_GLOBAL_CONFIG_KEYS = /* @__PURE__ */ new Set([
+  ...KNOWN_CONFIG_KEYS,
+  "repos"
+]);
+var DEFAULT_CONFIG = Object.freeze({});
+async function loadConfig(root) {
+  const path9 = join(root, CONFIG_FILE_NAME);
+  return loadConfigFile(path9);
 }
-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");
+async function loadEffectiveConfig(root, home = homedir(), onWarning) {
+  const [globalConfig, localConfig] = await Promise.all([
+    loadGlobalConfig(home),
+    loadConfig(root)
+  ]);
+  const repos = globalConfig.config.repos;
+  const perRepoConfig = isPlainObject(repos) ? findPerRepoConfig(repos, root, home) : {};
+  const globalBase = { ...globalConfig.config };
+  delete globalBase.repos;
+  if (onWarning) {
+    if (globalConfig.exists) {
+      warnUnknownKeys(
+        globalBase,
+        globalConfig.path,
+        KNOWN_GLOBAL_CONFIG_KEYS,
+        onWarning
+      );
+      if (Object.keys(perRepoConfig).length > 0) {
+        warnUnknownKeys(
+          perRepoConfig,
+          globalConfig.path,
+          KNOWN_CONFIG_KEYS,
+          onWarning
+        );
+      }
+    }
+    if (localConfig.exists) {
+      warnUnknownKeys(
+        localConfig.config,
+        localConfig.path,
+        KNOWN_CONFIG_KEYS,
+        onWarning
+      );
+    }
+  }
+  const merged = mergeConfig(globalBase, perRepoConfig, localConfig.config);
+  const worktreePathValue = merged.worktreePath;
+  if (onWarning && typeof worktreePathValue === "string" && worktreePathValue.length > 0 && !worktreePathValue.startsWith("/") && !worktreePathValue.startsWith("~")) {
+    onWarning(
+      `gji: "worktreePath" must be an absolute path or start with ~, got "${worktreePathValue}" \u2014 using default
+`
+    );
+  }
+  const globalHooks = isPlainObject(globalBase.hooks) ? globalBase.hooks : {};
+  const perRepoHooks = isPlainObject(perRepoConfig.hooks) ? perRepoConfig.hooks : {};
+  const localHooks = isPlainObject(localConfig.config.hooks) ? localConfig.config.hooks : {};
+  if (Object.keys(globalHooks).length > 0 || Object.keys(perRepoHooks).length > 0 || Object.keys(localHooks).length > 0) {
+    merged.hooks = { ...globalHooks, ...perRepoHooks, ...localHooks };
+  }
+  return merged;
+}
+async function loadGlobalConfig(home = homedir()) {
+  return loadConfigFile(GLOBAL_CONFIG_FILE_PATH(home));
+}
+async function saveLocalConfig(root, config) {
+  const path9 = join(root, CONFIG_FILE_NAME);
+  await writeFile(path9, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return path9;
+}
+async function updateLocalConfigKey(root, key, value) {
+  const loaded = await loadConfig(root);
+  const nextConfig = {
+    ...loaded.config,
+    [key]: value
+  };
+  await saveLocalConfig(root, nextConfig);
+  return nextConfig;
+}
+async function saveGlobalConfig(config, home = homedir()) {
+  const path9 = GLOBAL_CONFIG_FILE_PATH(home);
+  await mkdir(dirname(path9), { recursive: true });
+  await writeFile(path9, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return path9;
+}
+async function unsetGlobalConfigKey(key, home = homedir()) {
+  const loaded = await loadGlobalConfig(home);
+  const nextConfig = { ...loaded.config };
+  delete nextConfig[key];
+  await saveGlobalConfig(nextConfig, home);
+  return nextConfig;
+}
+async function updateGlobalConfigKey(key, value, home = homedir()) {
+  const loaded = await loadGlobalConfig(home);
+  const nextConfig = {
+    ...loaded.config,
+    [key]: value
+  };
+  await saveGlobalConfig(nextConfig, home);
+  return nextConfig;
+}
+async function updateGlobalRepoConfigKey(repoRoot, key, value, home = homedir()) {
+  const loaded = await loadGlobalConfig(home);
+  const repos = isPlainObject(loaded.config.repos) ? { ...loaded.config.repos } : {};
+  const existing = isPlainObject(repos[repoRoot]) ? repos[repoRoot] : {};
+  repos[repoRoot] = { ...existing, [key]: value };
+  const nextConfig = { ...loaded.config, repos };
+  await saveGlobalConfig(nextConfig, home);
+  return nextConfig;
+}
+function GLOBAL_CONFIG_FILE_PATH(home = homedir()) {
+  const configDir = process.env.GJI_CONFIG_DIR;
+  if (configDir) {
+    return join(resolve(configDir), GLOBAL_CONFIG_NAME);
+  }
+  return join(home, GLOBAL_CONFIG_DIRECTORY, GLOBAL_CONFIG_NAME);
+}
+function parseConfigValue(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function resolveConfigString(config, key) {
+  const value = config[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+async function loadConfigFile(path9) {
+  try {
+    const rawConfig = await readFile(path9, "utf8");
+    const parsedConfig = JSON.parse(rawConfig);
+    return {
+      config: mergeConfig(parsedConfig),
+      exists: true,
+      path: path9
+    };
+  } catch (error) {
+    if (isMissingFileError(error)) {
+      return {
+        config: DEFAULT_CONFIG,
+        exists: false,
+        path: path9
+      };
+    }
+    throw error;
+  }
+}
+function mergeConfig(...values) {
+  return values.reduce(
+    (config, value) => ({
+      ...config,
+      ...value
+    }),
+    { ...DEFAULT_CONFIG }
+  );
+}
+function findPerRepoConfig(repos, repoRoot, home) {
+  for (const [key, value] of Object.entries(repos)) {
+    const expandedKey = expandTilde(key, home);
+    if (expandedKey === repoRoot && isPlainObject(value)) {
+      return value;
+    }
+  }
+  return {};
+}
+function expandTilde(value, home) {
+  if (value === "~") return home;
+  if (value.startsWith("~/")) return join(home, value.slice(2));
+  return value;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissingFileError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function warnUnknownKeys(config, filePath, knownKeys, onWarning) {
+  for (const key of Object.keys(config)) {
+    if (!knownKeys.has(key)) {
+      const suggestion = closestKey(key, knownKeys);
+      const hint = suggestion ? ` (did you mean "${suggestion}"?)` : "";
+      onWarning(`gji: unknown config key "${key}" in ${filePath}${hint}
+`);
+    }
+  }
+}
+function closestKey(unknown, knownKeys) {
+  let best = null;
+  let bestDist = Infinity;
+  for (const key of knownKeys) {
+    const dist = levenshtein(unknown, key);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = key;
+    }
+  }
+  return bestDist <= Math.max(2, Math.floor(unknown.length / 2)) ? best : null;
+}
+function levenshtein(a, b3) {
+  const m2 = a.length;
+  const n = b3.length;
+  const dp = Array.from(
+    { length: m2 + 1 },
+    (_3, i) => Array.from({ length: n + 1 }, (_4, j2) => i === 0 ? j2 : j2 === 0 ? i : 0)
+  );
+  for (let i = 1; i <= m2; i++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      dp[i][j2] = a[i - 1] === b3[j2 - 1] ? dp[i - 1][j2 - 1] : 1 + Math.min(dp[i - 1][j2], dp[i][j2 - 1], dp[i - 1][j2 - 1]);
+    }
+  }
+  return dp[m2][n];
+}
+
+// src/history.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+var HISTORY_FILE_NAME = "history.json";
+var MAX_HISTORY_ENTRIES = 50;
+function HISTORY_FILE_PATH(home = homedir2()) {
+  const configDir = process.env.GJI_CONFIG_DIR;
+  if (configDir) {
+    return join2(resolve2(configDir), HISTORY_FILE_NAME);
+  }
+  return join2(home, GLOBAL_CONFIG_DIRECTORY, HISTORY_FILE_NAME);
+}
+async function loadHistory(home = homedir2()) {
+  const path9 = HISTORY_FILE_PATH(home);
+  try {
+    const raw = await readFile2(path9, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isHistoryEntry);
+  } catch {
+    return [];
+  }
+}
+async function appendHistory(path9, branch, home = homedir2()) {
+  const historyPath = HISTORY_FILE_PATH(home);
+  const existing = await loadHistory(home);
+  if (existing.length > 0 && existing[0].path === path9) {
+    return;
+  }
+  const entry = { branch, path: path9, timestamp: Date.now() };
+  const next = [entry, ...existing].slice(0, MAX_HISTORY_ENTRIES);
+  await mkdir2(dirname2(historyPath), { recursive: true });
+  await writeFile2(historyPath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+}
+function isHistoryEntry(value) {
+  return typeof value === "object" && value !== null && "path" in value && typeof value.path === "string" && "timestamp" in value && typeof value.timestamp === "number";
+}
+
+// src/hooks.ts
+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((resolve6) => {
@@ -13060,8 +13115,10 @@ async function runArgvHook(hookCmd, cwd, context, stderr) {
     });
     child.on("close", (code) => {
       if (code !== 0) {
-        stderr(`gji: hook exited with code ${code}: ${formatArgvHook(command, args)}
-`);
+        stderr(
+          `gji: hook exited with code ${code}: ${formatArgvHook(command, args)}
+`
+        );
       }
       resolve6();
     });
@@ -13132,49 +13189,9 @@ function parseHookCommand(value) {
   return void 0;
 }
 
-// src/history.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
-var HISTORY_FILE_NAME = "history.json";
-var MAX_HISTORY_ENTRIES = 50;
-function HISTORY_FILE_PATH(home = homedir2()) {
-  const configDir = process.env.GJI_CONFIG_DIR;
-  if (configDir) {
-    return join2(resolve2(configDir), HISTORY_FILE_NAME);
-  }
-  return join2(home, GLOBAL_CONFIG_DIRECTORY, HISTORY_FILE_NAME);
-}
-async function loadHistory(home = homedir2()) {
-  const path9 = HISTORY_FILE_PATH(home);
-  try {
-    const raw = await readFile2(path9, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(isHistoryEntry);
-  } catch {
-    return [];
-  }
-}
-async function appendHistory(path9, branch, home = homedir2()) {
-  const historyPath = HISTORY_FILE_PATH(home);
-  const existing = await loadHistory(home);
-  if (existing.length > 0 && existing[0].path === path9) {
-    return;
-  }
-  const entry = { branch, path: path9, timestamp: Date.now() };
-  const next = [entry, ...existing].slice(0, MAX_HISTORY_ENTRIES);
-  await mkdir2(dirname2(historyPath), { recursive: true });
-  await writeFile2(historyPath, `${JSON.stringify(next, null, 2)}
-`, "utf8");
-}
-function isHistoryEntry(value) {
-  return typeof value === "object" && value !== null && "path" in value && typeof value.path === "string" && "timestamp" in value && typeof value.timestamp === "number";
-}
-
 // src/repo.ts
-import { basename, dirname as dirname3, isAbsolute, join as join3, resolve as resolve3 } from "node:path";
 import { homedir as homedir3 } from "node:os";
+import { basename, dirname as dirname3, isAbsolute, join as join3, resolve as resolve3 } from "node:path";
 
 // src/git.ts
 import { execFile } from "node:child_process";
@@ -13190,7 +13207,11 @@ async function runGit(cwd, args) {
   }
 }
 async function readWorktreeHealth(cwd) {
-  const { stdout } = await execFileAsync("git", ["status", "--porcelain=v2", "--branch"], { cwd });
+  const { stdout } = await execFileAsync(
+    "git",
+    ["status", "--porcelain=v2", "--branch"],
+    { cwd }
+  );
   return parseWorktreeHealth(stdout);
 }
 async function isDirtyWorktree(cwd) {
@@ -13199,7 +13220,9 @@ async function isDirtyWorktree(cwd) {
 }
 async function isBranchMergedInto(cwd, branch, base = "HEAD") {
   try {
-    await execFileAsync("git", ["merge-base", "--is-ancestor", branch, base], { cwd });
+    await execFileAsync("git", ["merge-base", "--is-ancestor", branch, base], {
+      cwd
+    });
     return true;
   } catch (error) {
     if (hasExitCode(error, 1)) {
@@ -13209,7 +13232,11 @@ async function isBranchMergedInto(cwd, branch, base = "HEAD") {
   }
 }
 async function resolveRemoteDefaultBranch(cwd, remote) {
-  const { stdout } = await execFileAsync("git", ["ls-remote", "--symref", remote, "HEAD"], { cwd });
+  const { stdout } = await execFileAsync(
+    "git",
+    ["ls-remote", "--symref", remote, "HEAD"],
+    { cwd }
+  );
   const refLine = stdout.split("\n").find((line) => line.startsWith("ref: refs/heads/"));
   if (!refLine) {
     return null;
@@ -13219,7 +13246,11 @@ async function resolveRemoteDefaultBranch(cwd, remote) {
 }
 async function readBranchLastCommitTimestamp(cwd, branch) {
   try {
-    const { stdout } = await execFileAsync("git", ["log", "-1", "--format=%ct", branch], { cwd });
+    const { stdout } = await execFileAsync(
+      "git",
+      ["log", "-1", "--format=%ct", branch],
+      { cwd }
+    );
     const timestamp = Number(stdout.trim());
     return Number.isFinite(timestamp) ? timestamp : null;
   } catch {
@@ -13283,7 +13314,9 @@ function resolveWorktreePath(repoRoot, branch, basePath) {
     throw new Error("Branch name must not be empty.");
   }
   if (segments.some((segment) => segment === "." || segment === "..")) {
-    throw new Error(`Branch name '${branch}' contains an invalid path segment.`);
+    throw new Error(
+      `Branch name '${branch}' contains an invalid path segment.`
+    );
   }
   const base = basePath ? expandTildeInPath(basePath) : join3(dirname3(repoRoot), "worktrees", basename(repoRoot));
   return join3(base, ...segments);
@@ -13403,17 +13436,27 @@ async function runBackCommand(options) {
   }
   if (!target) {
     options.stderr("gji back: no previous worktree in history\n");
-    options.stderr("Hint: Use 'gji go', 'gji new', or 'gji pr' to navigate between worktrees\n");
+    options.stderr(
+      "Hint: Use 'gji go', 'gji new', or 'gji pr' to navigate between worktrees\n"
+    );
     return 1;
   }
   try {
     const repository = await detectRepository(target.path);
-    const config = await loadEffectiveConfig(repository.repoRoot, options.home, options.stderr);
+    const config = await loadEffectiveConfig(
+      repository.repoRoot,
+      options.home,
+      options.stderr
+    );
     const hooks = extractHooks(config);
     await runHook(
       hooks.afterEnter,
       target.path,
-      { branch: target.branch ?? void 0, path: target.path, repo: basename2(repository.repoRoot) },
+      {
+        branch: target.branch ?? void 0,
+        path: target.path,
+        repo: basename2(repository.repoRoot)
+      },
       options.stderr
     );
   } catch {
@@ -13427,7 +13470,9 @@ function formatHistoryList(history, cwd) {
     "BRANCH".length,
     ...history.map((e2) => (e2.branch ?? "(detached)").length)
   );
-  const lines = ["  " + "BRANCH".padEnd(branchWidth) + " WHEN       PATH"];
+  const lines = [
+    "  " + "BRANCH".padEnd(branchWidth) + " WHEN       PATH"
+  ];
   for (const entry of history) {
     const isCurrent = entry.path === cwd;
     const branch = (entry.branch ?? "(detached)").padEnd(branchWidth);
@@ -14121,7 +14166,10 @@ function formatLastCommit(timestampSeconds) {
   return timestampSeconds === null ? "n/a" : formatRelativeAge(timestampSeconds);
 }
 function formatRelativeAge(timestampSeconds) {
-  const ageSeconds = Math.max(0, Math.floor(Date.now() / 1e3) - timestampSeconds);
+  const ageSeconds = Math.max(
+    0,
+    Math.floor(Date.now() / 1e3) - timestampSeconds
+  );
   const units = [
     { label: "y", seconds: 365 * 24 * 60 * 60 },
     { label: "mo", seconds: 30 * 24 * 60 * 60 },
@@ -14154,16 +14202,28 @@ async function loadLinkedWorktrees(cwd) {
   };
 }
 async function removeWorktree(repoRoot, worktreePath) {
-  await execFileAsync2("git", ["worktree", "remove", worktreePath], { cwd: repoRoot, env: GIT_ENV });
+  await execFileAsync2("git", ["worktree", "remove", worktreePath], {
+    cwd: repoRoot,
+    env: GIT_ENV
+  });
 }
 async function forceRemoveWorktree(repoRoot, worktreePath) {
-  await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath], { cwd: repoRoot, env: GIT_ENV });
+  await execFileAsync2("git", ["worktree", "remove", "--force", worktreePath], {
+    cwd: repoRoot,
+    env: GIT_ENV
+  });
 }
 async function deleteBranch(repoRoot, branch) {
-  await execFileAsync2("git", ["branch", "-d", branch], { cwd: repoRoot, env: GIT_ENV });
+  await execFileAsync2("git", ["branch", "-d", branch], {
+    cwd: repoRoot,
+    env: GIT_ENV
+  });
 }
 async function forceDeleteBranch(repoRoot, branch) {
-  await execFileAsync2("git", ["branch", "-D", branch], { cwd: repoRoot, env: GIT_ENV });
+  await execFileAsync2("git", ["branch", "-D", branch], {
+    cwd: repoRoot,
+    env: GIT_ENV
+  });
 }
 function isWorktreeDirtyError(error) {
   return hasStderr(error) && error.stderr.includes("contains modified or untracked files");
@@ -14202,12 +14262,18 @@ function createCleanCommand(dependencies = {}) {
   const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ?? defaultConfirmForceRemoveWorktree;
   const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
   return async function runCleanCommand2(options) {
-    const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd);
+    const { linkedWorktrees, repository } = await loadLinkedWorktrees(
+      options.cwd
+    );
     const linkedCleanupCandidates = linkedWorktrees.filter(
       (worktree) => worktree.path !== repository.currentRoot
     );
     const staleBaseRef = options.stale ? await resolveStaleBaseRef(repository.repoRoot, options.stderr) : null;
-    const cleanupCandidates = options.stale ? await filterStaleCleanupCandidates(repository.repoRoot, linkedCleanupCandidates, staleBaseRef) : linkedCleanupCandidates;
+    const cleanupCandidates = options.stale ? await filterStaleCleanupCandidates(
+      repository.repoRoot,
+      linkedCleanupCandidates,
+      staleBaseRef
+    ) : linkedCleanupCandidates;
     if (cleanupCandidates.length === 0) {
       if (options.stale) {
         emitNoStaleCandidates(options);
@@ -14221,8 +14287,10 @@ function createCleanCommand(dependencies = {}) {
       if (options.json) {
         emitError(options, message);
       } else {
-        options.stderr(`gji clean: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`);
+        options.stderr(
+          `gji clean: ${message} in non-interactive mode (GJI_NO_TUI=1)
+`
+        );
       }
       return 1;
     }
@@ -14232,7 +14300,10 @@ function createCleanCommand(dependencies = {}) {
       options.stderr("Aborted\n");
       return 1;
     }
-    const selectedWorktrees = resolveSelectedWorktrees(cleanupCandidates, selections);
+    const selectedWorktrees = resolveSelectedWorktrees(
+      cleanupCandidates,
+      selections
+    );
     if (selectedWorktrees.length !== selections.length) {
       options.stderr("Selected worktree no longer exists\n");
       return 1;
@@ -14247,13 +14318,19 @@ function createCleanCommand(dependencies = {}) {
     }
     if (options.dryRun) {
       if (options.json) {
-        const removed = selectedWorktreeInfos.map((info) => serializeWorktreeInfo(info));
-        options.stdout(`${JSON.stringify({ removed, dryRun: true }, null, 2)}
-`);
+        const removed = selectedWorktreeInfos.map(
+          (info) => serializeWorktreeInfo(info)
+        );
+        options.stdout(
+          `${JSON.stringify({ removed, dryRun: true }, null, 2)}
+`
+        );
       } else {
         for (const info of selectedWorktreeInfos) {
-          options.stdout(`Would remove worktree at ${info.path} (${formatCleanInfo(info)})
-`);
+          options.stdout(
+            `Would remove worktree at ${info.path} (${formatCleanInfo(info)})
+`
+          );
         }
       }
       return 0;
@@ -14261,9 +14338,15 @@ function createCleanCommand(dependencies = {}) {
     const removedPaths = [];
     const removedWorktrees = [];
     for (const worktree of selectedWorktrees) {
-      if (options.stale && !await isStaleCleanupCandidate(repository.repoRoot, worktree, staleBaseRef)) {
-        options.stderr(`Skipped ${worktree.path}: no longer a safe stale cleanup candidate
-`);
+      if (options.stale && !await isStaleCleanupCandidate(
+        repository.repoRoot,
+        worktree,
+        staleBaseRef
+      )) {
+        options.stderr(
+          `Skipped ${worktree.path}: no longer a safe stale cleanup candidate
+`
+        );
         continue;
       }
       try {
@@ -14273,8 +14356,10 @@ function createCleanCommand(dependencies = {}) {
           throw error;
         }
         if (options.stale) {
-          options.stderr(`Skipped ${worktree.path}: no longer a safe stale cleanup candidate
-`);
+          options.stderr(
+            `Skipped ${worktree.path}: no longer a safe stale cleanup candidate
+`
+          );
           continue;
         }
         if (!options.force && !await confirmForceRemoveWorktree(worktree.path)) {
@@ -14288,7 +14373,10 @@ function createCleanCommand(dependencies = {}) {
           if (!options.json) {
             reportRemovedPaths(removedPaths, options.stderr);
           }
-          emitError(options, `Failed to remove worktree at ${worktree.path}: ${toMessage(forceError)}`);
+          emitError(
+            options,
+            `Failed to remove worktree at ${worktree.path}: ${toMessage(forceError)}`
+          );
           return 1;
         }
       }
@@ -14305,12 +14393,16 @@ function createCleanCommand(dependencies = {}) {
             try {
               await forceDeleteBranch(repository.repoRoot, worktree.branch);
             } catch (forceError) {
-              options.stderr(`Failed to delete branch ${worktree.branch}: ${toMessage(forceError)}
-`);
+              options.stderr(
+                `Failed to delete branch ${worktree.branch}: ${toMessage(forceError)}
+`
+              );
             }
           } else {
-            options.stderr(`Branch ${worktree.branch} was not deleted (has unmerged commits)
-`);
+            options.stderr(
+              `Branch ${worktree.branch} was not deleted (has unmerged commits)
+`
+            );
           }
         }
       }
@@ -14335,19 +14427,30 @@ async function filterStaleCleanupCandidates(repoRoot, worktrees, baseBranch) {
     return [];
   }
   const results = await Promise.all(
-    worktrees.map((worktree) => isStaleCleanupCandidate(repoRoot, worktree, baseBranch))
+    worktrees.map(
+      (worktree) => isStaleCleanupCandidate(repoRoot, worktree, baseBranch)
+    )
   );
   return worktrees.filter((_3, index) => results[index]);
 }
 async function resolveStaleBaseRef(repoRoot, stderr) {
   const config = await loadEffectiveConfig(repoRoot, void 0, stderr);
   const remote = resolveConfiguredString(config.syncRemote) ?? "origin";
-  const configuredDefaultBranch = resolveConfiguredString(config.syncDefaultBranch);
+  const configuredDefaultBranch = resolveConfiguredString(
+    config.syncDefaultBranch
+  );
   if (configuredDefaultBranch) {
-    return await resolveFetchedRemoteRef(repoRoot, remote, configuredDefaultBranch);
+    return await resolveFetchedRemoteRef(
+      repoRoot,
+      remote,
+      configuredDefaultBranch
+    );
   }
   try {
-    const remoteDefaultBranch = await resolveRemoteDefaultBranch(repoRoot, remote);
+    const remoteDefaultBranch = await resolveRemoteDefaultBranch(
+      repoRoot,
+      remote
+    );
     return remoteDefaultBranch === null ? null : await resolveFetchedRemoteRef(repoRoot, remote, remoteDefaultBranch);
   } catch {
     return null;
@@ -14442,14 +14545,22 @@ async function defaultPromptForWorktrees(worktrees) {
   return pD(choice) ? null : choice;
 }
 async function defaultConfirmRemoval(worktrees) {
-  const branchCount = worktrees.filter((worktree) => worktree.branch !== null).length;
+  const branchCount = worktrees.filter(
+    (worktree) => worktree.branch !== null
+  ).length;
   const detachedCount = worktrees.length - branchCount;
-  const messageParts = [`Remove ${worktrees.length} linked worktree${worktrees.length === 1 ? "" : "s"}`];
+  const messageParts = [
+    `Remove ${worktrees.length} linked worktree${worktrees.length === 1 ? "" : "s"}`
+  ];
   if (branchCount > 0) {
-    messageParts.push(`delete ${branchCount} branch${branchCount === 1 ? "" : "es"}`);
+    messageParts.push(
+      `delete ${branchCount} branch${branchCount === 1 ? "" : "es"}`
+    );
   }
   if (detachedCount > 0) {
-    messageParts.push(`remove ${detachedCount} detached worktree${detachedCount === 1 ? "" : "s"}`);
+    messageParts.push(
+      `remove ${detachedCount} detached worktree${detachedCount === 1 ? "" : "s"}`
+    );
   }
   const choice = await ye({
     active: "Yes",
@@ -14460,25 +14571,35 @@ async function defaultConfirmRemoval(worktrees) {
   return !pD(choice) && choice;
 }
 
-// src/history-command.ts
-async function runHistoryCommand(options) {
-  const history = await loadHistory(options.home);
-  if (options.json) {
-    options.stdout(`${JSON.stringify(history, null, 2)}
-`);
-    return 0;
+// src/shell.ts
+function resolveSupportedShell(requestedShell, detectedShell) {
+  const requested = normalizeShell(requestedShell);
+  if (requested) {
+    return requested;
   }
-  if (history.length === 0) {
-    options.stdout("No navigation history.\n");
-    return 0;
+  return normalizeShell(detectedShell);
+}
+function normalizeShell(value) {
+  if (!value) {
+    return null;
+  }
+  const candidate = value.split("/").at(-1)?.toLowerCase();
+  switch (candidate) {
+    case "bash":
+    case "fish":
+    case "zsh":
+      return candidate;
+    default:
+      return null;
   }
-  options.stdout(formatHistoryList(history, options.cwd));
-  return 0;
 }
 
 // src/shell-completion.ts
 var TOP_LEVEL_COMMANDS = [
-  { name: "new", description: "create a new branch or detached linked worktree" },
+  {
+    name: "new",
+    description: "create a new branch or detached linked worktree"
+  },
   { name: "init", description: "print or install shell integration" },
   { name: "completion", description: "print shell completion definitions" },
   { name: "pr", description: "fetch a pull request into a linked worktree" },
@@ -14490,11 +14611,21 @@ var TOP_LEVEL_COMMANDS = [
   { name: "root", description: "print the main repository root path" },
   { name: "status", description: "summarize repository and worktree health" },
   { name: "sync", description: "fetch and update one or all worktrees" },
+  {
+    name: "sync-files",
+    description: "manage local files copied into new worktrees"
+  },
   { name: "ls", description: "list active worktrees" },
   { name: "clean", description: "interactively prune linked worktrees" },
-  { name: "remove", description: "remove a linked worktree and delete its branch when present" },
+  {
+    name: "remove",
+    description: "remove a linked worktree and delete its branch when present"
+  },
   { name: "rm", description: "alias of remove" },
-  { name: "trigger-hook", description: "run a named hook in the current worktree" },
+  {
+    name: "trigger-hook",
+    description: "run a named hook in the current worktree"
+  },
   { name: "warp", description: "jump to any worktree across all known repos" },
   { name: "config", description: "manage global config defaults" }
 ];
@@ -14512,7 +14643,9 @@ function renderShellCompletion(shell) {
   }
 }
 function renderBashCompletion() {
-  const topLevelCommands = TOP_LEVEL_COMMANDS.map((command) => command.name).join(" ");
+  const topLevelCommands = TOP_LEVEL_COMMANDS.map(
+    (command) => command.name
+  ).join(" ");
   const shells = SHELL_NAMES.join(" ");
   const hooks = HOOK_NAMES.join(" ");
   const configKeys = CONFIG_KEYS.join(" ");
@@ -14566,6 +14699,12 @@ _gji_completion() {
     sync)
       COMPREPLY=( $(compgen -W "--all --json --help" -- "$cur") )
       ;;
+    sync-files)
+      if [ "$COMP_CWORD" -eq 2 ]; then
+        COMPREPLY=( $(compgen -W "list add remove rm --json --help" -- "$cur") )
+        return 0
+      fi
+      ;;
     ls)
       COMPREPLY=( $(compgen -W "--compact --json --help" -- "$cur") )
       ;;
@@ -14679,6 +14818,12 @@ complete -c gji -n '__fish_seen_subcommand_from status' -l json -d 'print reposi
 complete -c gji -n '__fish_seen_subcommand_from sync' -l all -d 'sync every worktree in the repository'
 complete -c gji -n '__fish_seen_subcommand_from sync' -l json -d 'emit JSON on success or error instead of human-readable output'
 
+complete -c gji -n '__fish_seen_subcommand_from sync-files' -a 'list add remove rm' -d 'sync-files action'
+complete -c gji -n '__fish_seen_subcommand_from sync-files' -l json -d 'emit JSON instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from list; and __fish_seen_subcommand_from sync-files' -l json -d 'emit JSON instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from add; and __fish_seen_subcommand_from sync-files' -l json -d 'emit JSON instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from remove rm; and __fish_seen_subcommand_from sync-files' -l json -d 'emit JSON instead of human-readable output'
+
 complete -c gji -n '__fish_seen_subcommand_from ls' -l compact -d 'show only branch and path columns'
 complete -c gji -n '__fish_seen_subcommand_from ls' -l json -d 'print active worktrees as JSON'
 
@@ -14760,6 +14905,9 @@ case "\${words[2]}" in
   sync)
     _arguments '--all[sync every worktree in the repository]' '--json[emit JSON on success or error instead of human-readable output]'
     ;;
+  sync-files)
+    _arguments '--json[emit JSON instead of human-readable output]' '2:action:(list add remove rm)' '*:path: '
+    ;;
   ls)
     _arguments '--compact[show only branch and path columns]' '--json[print active worktrees as JSON]'
     ;;
@@ -14806,29 +14954,6 @@ function escapeSingleQuotes(value) {
   return value.replace(/'/g, `'\\''`);
 }
 
-// src/shell.ts
-function resolveSupportedShell(requestedShell, detectedShell) {
-  const requested = normalizeShell(requestedShell);
-  if (requested) {
-    return requested;
-  }
-  return normalizeShell(detectedShell);
-}
-function normalizeShell(value) {
-  if (!value) {
-    return null;
-  }
-  const candidate = value.split("/").at(-1)?.toLowerCase();
-  switch (candidate) {
-    case "bash":
-    case "fish":
-    case "zsh":
-      return candidate;
-    default:
-      return null;
-  }
-}
-
 // src/completion.ts
 async function runCompletionCommand(options) {
   const shell = resolveSupportedShell(options.shell, process.env.SHELL);
@@ -14860,7 +14985,10 @@ async function runConfigCommand(options) {
     }
     case "set":
       if (options.key && options.value !== void 0) {
-        await updateGlobalConfigKey(options.key, parseConfigValue(options.value));
+        await updateGlobalConfigKey(
+          options.key,
+          parseConfigValue(options.value)
+        );
         return 0;
       }
       break;
@@ -14888,19 +15016,72 @@ import { realpath as realpath2 } from "node:fs/promises";
 import { basename as basename5, resolve as resolve5 } from "node:path";
 
 // src/new.ts
+import { execFile as execFile3 } from "node:child_process";
 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/conflict.ts
+import { constants } from "node:fs";
+import { access as access2 } from "node:fs/promises";
+async function pathExists(path9) {
+  try {
+    await access2(path9, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function promptForPathConflict(path9) {
+  const choice = await ve({
+    message: `Target path already exists: ${path9}`,
+    options: [
+      {
+        value: "abort",
+        label: "Abort",
+        hint: "Keep the existing directory untouched"
+      },
+      {
+        value: "reuse",
+        label: "Reuse path",
+        hint: "Print the existing path and stop"
+      }
+    ]
+  });
+  if (pD(choice)) {
+    return "abort";
+  }
+  return choice;
+}
+
 // 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: "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 }
+  {
+    cli: "subl",
+    name: "Sublime Text",
+    newWindowFlag: "--new-window",
+    supportsWorkspace: false
+  }
 ];
 async function defaultSpawnEditor(cli, args) {
   const child = spawn3(cli, args, { detached: true, stdio: "ignore" });
@@ -14915,14 +15096,8 @@ async function defaultSpawnEditor(cli, args) {
 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}`);
-    }
+  for (const pattern of patterns) {
+    const normalized = validateSyncFilePattern(pattern);
     const sourcePath = join4(mainRoot, normalized);
     const destPath = join4(targetPath, normalized);
     const sourceExists = await fileExists(sourcePath);
@@ -14937,6 +15112,20 @@ async function syncFiles(mainRoot, targetPath, patterns) {
     await copyFile(sourcePath, destPath);
   }
 }
+function validateSyncFilePattern(pattern) {
+  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}`
+    );
+  }
+  return normalized;
+}
 async function fileExists(path9) {
   try {
     await stat(path9);
@@ -14956,7 +15145,7 @@ function isNotFoundError(error) {
 import { spawn as spawn4 } from "node:child_process";
 
 // src/package-manager.ts
-import { access as access2, readdir } from "node:fs/promises";
+import { access as access3, readdir } from "node:fs/promises";
 import { join as join5 } from "node:path";
 var ENTRIES = [
   // JavaScript / TypeScript
@@ -14970,10 +15159,22 @@ var ENTRIES = [
   { 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" },
+  {
+    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()'" },
+  {
+    name: "renv",
+    signals: ["renv.lock"],
+    command: "Rscript -e 'renv::restore()'"
+  },
   // Rust
   { name: "cargo", signals: ["Cargo.lock"], command: "cargo build" },
   // Go
@@ -14990,25 +15191,56 @@ var ENTRIES = [
   // 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: "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 },
+  {
+    name: "dotnet",
+    signals: ["*.sln", "*.csproj", "*.fsproj", "*.vbproj"],
+    command: "dotnet restore",
+    glob: true
+  },
   // Swift
-  { name: "swift", signals: ["Package.swift"], command: "swift package resolve" },
+  {
+    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 },
+  {
+    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()'" },
+  {
+    name: "julia",
+    signals: ["Manifest.toml"],
+    command: "julia --project -e 'using Pkg; Pkg.instantiate()'"
+  },
   // Nim
-  { name: "nimble", signals: ["*.nimble"], command: "nimble install", glob: true },
+  {
+    name: "nimble",
+    signals: ["*.nimble"],
+    command: "nimble install",
+    glob: true
+  },
   // Crystal
   { name: "shards", signals: ["shard.yml"], command: "shards install" },
   // Perl
@@ -15017,12 +15249,20 @@ var ENTRIES = [
   { 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 ." },
+  {
+    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" }
+  {
+    name: "terraform",
+    signals: ["terraform.lock.hcl"],
+    command: "terraform init"
+  }
 ];
 async function detectPackageManager(repoRoot) {
   for (const entry of ENTRIES) {
@@ -15036,7 +15276,7 @@ async function detectPackageManager(repoRoot) {
 async function matchesExact(repoRoot, signals) {
   for (const signal of signals) {
     try {
-      await access2(join5(repoRoot, signal));
+      await access3(join5(repoRoot, signal));
       return true;
     } catch {
     }
@@ -15085,8 +15325,10 @@ async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dep
     try {
       await runner(pm.installCommand, worktreePath, stderr);
     } catch (error) {
-      stderr(`gji: install command failed: ${error instanceof Error ? error.message : String(error)}
-`);
+      stderr(
+        `gji: install command failed: ${error instanceof Error ? error.message : String(error)}
+`
+      );
     }
   }
   const saveGlobal = config.installSaveTarget === "global";
@@ -15096,15 +15338,23 @@ async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dep
     try {
       if (saveGlobal) {
         const existingHooks = await loadExistingGlobalRepoHooks(repoRoot);
-        await writeGlobalKey(repoRoot, "hooks", { ...existingHooks, afterCreate: pm.installCommand });
+        await writeGlobalKey(repoRoot, "hooks", {
+          ...existingHooks,
+          afterCreate: pm.installCommand
+        });
       } else {
         const { config: localConfig } = await loadConfig(repoRoot);
         const existingLocalHooks = isPlainObject2(localConfig.hooks) ? localConfig.hooks : {};
-        await writeKey(repoRoot, "hooks", { ...existingLocalHooks, afterCreate: pm.installCommand });
+        await writeKey(repoRoot, "hooks", {
+          ...existingLocalHooks,
+          afterCreate: pm.installCommand
+        });
       }
     } catch (error) {
-      stderr(`gji: failed to save config: ${error instanceof Error ? error.message : String(error)}
-`);
+      stderr(
+        `gji: failed to save config: ${error instanceof Error ? error.message : String(error)}
+`
+      );
     }
   }
   if (choice === "never") {
@@ -15115,14 +15365,20 @@ async function maybeRunInstallPrompt(worktreePath, repoRoot, config, stderr, dep
         await writeKey(repoRoot, "skipInstallPrompt", true);
       }
     } catch (error) {
-      stderr(`gji: failed to save config: ${error instanceof Error ? error.message : String(error)}
-`);
+      stderr(
+        `gji: failed to save config: ${error instanceof Error ? error.message : String(error)}
+`
+      );
     }
   }
 }
 async function defaultRunInstallCommand(command, cwd, stderr) {
   await new Promise((resolve6, reject) => {
-    const child = spawn4(command, { cwd, shell: true, stdio: ["ignore", "inherit", "pipe"] });
+    const child = spawn4(command, {
+      cwd,
+      shell: true,
+      stdio: ["ignore", "inherit", "pipe"]
+    });
     child.stderr.on("data", (chunk) => {
       stderr(chunk.toString());
     });
@@ -15157,7 +15413,11 @@ async function defaultPromptForInstallChoice(pm) {
       { value: "yes", label: "Yes", hint: "run once" },
       { value: "no", label: "No", hint: "skip this time" },
       { value: "always", label: "Always", hint: "save as afterCreate hook" },
-      { value: "never", label: "Never", hint: "disable this prompt for this repo" }
+      {
+        value: "never",
+        label: "Never",
+        hint: "disable this prompt for this repo"
+      }
     ]
   });
   if (pD(choice)) {
@@ -15173,31 +15433,6 @@ function isConfiguredHookCommand(value) {
   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";
-import { constants } from "node:fs";
-async function pathExists(path9) {
-  try {
-    await access3(path9, constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function promptForPathConflict(path9) {
-  const choice = await ve({
-    message: `Target path already exists: ${path9}`,
-    options: [
-      { value: "abort", label: "Abort", hint: "Keep the existing directory untouched" },
-      { value: "reuse", label: "Reuse path", hint: "Print the existing path and stop" }
-    ]
-  });
-  if (pD(choice)) {
-    return "abort";
-  }
-  return choice;
-}
-
 // src/new.ts
 var execFileAsync3 = promisify4(execFile3);
 var NEW_OUTPUT_FILE_ENV = "GJI_NEW_OUTPUT_FILE";
@@ -15208,7 +15443,11 @@ function createNewCommand(dependencies = {}) {
   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 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");
@@ -15219,8 +15458,10 @@ function createNewCommand(dependencies = {}) {
         options.stderr(`${JSON.stringify({ error: message }, null, 2)}
 `);
       } else {
-        options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`);
+        options.stderr(
+          `gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)
+`
+        );
       }
       return 1;
     }
@@ -15238,8 +15479,10 @@ function createNewCommand(dependencies = {}) {
       const branchError = validateBranchName(rawBranch);
       if (branchError) {
         if (options.json) {
-          options.stderr(`${JSON.stringify({ error: branchError }, null, 2)}
-`);
+          options.stderr(
+            `${JSON.stringify({ error: branchError }, null, 2)}
+`
+          );
         } else {
           options.stderr(`gji new: ${branchError}
 `);
@@ -15250,18 +15493,32 @@ function createNewCommand(dependencies = {}) {
     const rawBasePath = resolveConfigString(config, "worktreePath");
     const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~") ? rawBasePath : void 0;
     const worktreeName = options.detached ? rawBranch : applyConfiguredBranchPrefix(rawBranch, config.branchPrefix);
-    const worktreePath = usesGeneratedDetachedName ? await resolveUniqueDetachedWorktreePath(repository.repoRoot, worktreeName, configuredBasePath) : resolveWorktreePath(repository.repoRoot, worktreeName, configuredBasePath);
+    const worktreePath = usesGeneratedDetachedName ? await resolveUniqueDetachedWorktreePath(
+      repository.repoRoot,
+      worktreeName,
+      configuredBasePath
+    ) : resolveWorktreePath(
+      repository.repoRoot,
+      worktreeName,
+      configuredBasePath
+    );
     if (!usesGeneratedDetachedName && await pathExists(worktreePath)) {
       if (options.force) {
         if (!options.dryRun) {
           try {
-            await execFileAsync3("git", ["worktree", "remove", "--force", worktreePath], { cwd: repository.repoRoot });
+            await execFileAsync3(
+              "git",
+              ["worktree", "remove", "--force", worktreePath],
+              { cwd: repository.repoRoot }
+            );
           } catch (err) {
             if (!isNotRegisteredWorktreeError(err)) {
               const msg = `could not remove existing worktree at ${worktreePath}: ${toExecMessage(err)}`;
               if (options.json) {
-                options.stderr(`${JSON.stringify({ warning: msg }, null, 2)}
-`);
+                options.stderr(
+                  `${JSON.stringify({ warning: msg }, null, 2)}
+`
+                );
               } else {
                 options.stderr(`Warning: ${msg}
 `);
@@ -15270,7 +15527,9 @@ function createNewCommand(dependencies = {}) {
           }
           if (!options.detached) {
             try {
-              await execFileAsync3("git", ["branch", "-D", worktreeName], { cwd: repository.repoRoot });
+              await execFileAsync3("git", ["branch", "-D", worktreeName], {
+                cwd: repository.repoRoot
+              });
             } catch {
             }
           }
@@ -15281,12 +15540,18 @@ function createNewCommand(dependencies = {}) {
           options.stderr(`${JSON.stringify({ error: message }, null, 2)}
 `);
         } else {
-          options.stderr(`gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`);
-          options.stderr(`Hint: Use 'gji remove ${worktreeName}' or 'gji clean' to remove the existing worktree
-`);
-          options.stderr(`Hint: Use 'gji trigger-hook afterCreate' inside the worktree to re-run setup hooks
-`);
+          options.stderr(
+            `gji new: ${message} in non-interactive mode (GJI_NO_TUI=1)
+`
+          );
+          options.stderr(
+            `Hint: Use 'gji remove ${worktreeName}' or 'gji clean' to remove the existing worktree
+`
+          );
+          options.stderr(
+            `Hint: Use 'gji trigger-hook afterCreate' inside the worktree to re-run setup hooks
+`
+          );
         }
         return 1;
       } else {
@@ -15296,53 +15561,81 @@ function createNewCommand(dependencies = {}) {
           await writeOutput(worktreePath, options.stdout);
           return 0;
         }
-        options.stderr(`Aborted because target worktree path already exists: ${worktreePath}
-`);
+        options.stderr(
+          `Aborted because target worktree path already exists: ${worktreePath}
+`
+        );
         return 1;
       }
     }
     if (options.dryRun) {
       if (options.json) {
-        options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath, dryRun: true }, null, 2)}
-`);
+        options.stdout(
+          `${JSON.stringify({ branch: worktreeName, path: worktreePath, dryRun: true }, null, 2)}
+`
+        );
       } else {
         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})
-`);
+        options.stdout(
+          `Would create worktree at ${worktreePath} (branch: ${worktreeName}${openNote})
+`
+        );
       }
       return 0;
     }
     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") : [];
+    const syncPatterns = Array.isArray(config.syncFiles) ? config.syncFiles.filter(
+      (p2) => typeof p2 === "string"
+    ) : [];
     for (const pattern of syncPatterns) {
       try {
         await syncFiles(repository.repoRoot, worktreePath, [pattern]);
       } catch (error) {
-        options.stderr(`Warning: failed to sync file "${pattern}": ${error instanceof Error ? error.message : String(error)}
-`);
+        options.stderr(
+          `Warning: failed to sync file "${pattern}": ${error instanceof Error ? error.message : String(error)}
+`
+        );
       }
     }
-    await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
+    await maybeRunInstallPrompt(
+      worktreePath,
+      repository.repoRoot,
+      config,
+      options.stderr,
+      dependencies,
+      !!options.json
+    );
     const hooks = extractHooks(config);
     await runHook(
       hooks.afterCreate,
       worktreePath,
-      { branch: worktreeName, path: worktreePath, repo: basename3(repository.repoRoot) },
+      {
+        branch: worktreeName,
+        path: worktreePath,
+        repo: basename3(repository.repoRoot)
+      },
       options.stderr
     );
     if (options.json) {
-      options.stdout(`${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}
-`);
+      options.stdout(
+        `${JSON.stringify({ branch: worktreeName, path: worktreePath }, null, 2)}
+`
+      );
     } else {
       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);
+      await openWorktree(
+        worktreePath,
+        resolvedEditor,
+        spawnEditor,
+        options.stderr
+      );
     }
     return 0;
   };
@@ -15403,7 +15696,11 @@ async function resolveUniqueDetachedWorktreePath(repoRoot, baseName, basePath) {
   let attempt = 1;
   while (true) {
     const candidateName = attempt === 1 ? baseName : `${baseName}-${attempt}`;
-    const candidatePath = resolveWorktreePath(repoRoot, candidateName, basePath);
+    const candidatePath = resolveWorktreePath(
+      repoRoot,
+      candidateName,
+      basePath
+    );
     if (!await pathExists(candidatePath)) {
       return candidatePath;
     }
@@ -15431,7 +15728,11 @@ function pickRandom(values, random) {
 }
 async function localBranchExists(repoRoot, branchName) {
   try {
-    await execFileAsync3("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoRoot });
+    await execFileAsync3(
+      "git",
+      ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
+      { cwd: repoRoot }
+    );
     return true;
   } catch {
     return false;
@@ -15452,7 +15753,9 @@ function toExecMessage(error) {
 }
 async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
   if (!editorCli) {
-    stderr("gji new: --open requires --editor <cli> or a saved editor in config\n");
+    stderr(
+      "gji new: --open requires --editor <cli> or a saved editor in config\n"
+    );
     return;
   }
   const editorDef = EDITORS.find((e2) => e2.cli === editorCli);
@@ -15566,11 +15869,17 @@ async function runWarpNavigate(options) {
     }
     return 1;
   }
-  const target = await resolveWarpTarget({ ...options, commandName: "gji warp", json: options.json });
+  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)}
-`);
+    options.stdout(
+      `${JSON.stringify({ branch: target.branch, path: target.path }, null, 2)}
+`
+    );
     return 0;
   }
   appendHistory(target.path, target.branch).catch(() => void 0);
@@ -15771,14 +16080,19 @@ function createGoCommand(dependencies = {}) {
         );
         return 1;
       }
-      const target = await resolveWarpTarget({ ...options, commandName: "gji go" });
+      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");
+      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));
@@ -15794,204 +16108,83 @@ function createGoCommand(dependencies = {}) {
       }
       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: basename6(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}
-`);
+    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: basename6(repository.repoRoot)
+      },
+      options.stderr
+    );
+    appendHistory(resolvedPath, chosenWorktree?.branch ?? null).catch(
+      () => void 0
+    );
+    await writeShellOutput(GO_OUTPUT_FILE_ENV, resolvedPath, options.stdout);
     return 0;
   };
 }
-var runOpenCommand = createOpenCommand();
-async function detectInstalledEditors() {
-  const results = await Promise.all(
-    EDITORS.map(async (editor) => ({ editor, available: await isCommandAvailable(editor.cli) }))
+var runGoCommand = createGoCommand();
+async function promptForWorktree(worktrees) {
+  const healthResults = await Promise.allSettled(
+    worktrees.map((w2) => readWorktreeHealth(w2.path))
   );
-  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
-    }))
+    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;
+  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;
+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}`;
 }
-async function ensureWorkspaceFile(worktreePath, repoName) {
-  const workspacePath = join7(worktreePath, `${repoName}.code-workspace`);
-  try {
-    await access4(workspacePath);
-    return workspacePath;
-  } catch {
+
+// src/history-command.ts
+async function runHistoryCommand(options) {
+  const history = await loadHistory(options.home);
+  if (options.json) {
+    options.stdout(`${JSON.stringify(history, null, 2)}
+`);
+    return 0;
   }
-  const workspace = { folders: [{ path: "." }], settings: {} };
-  await writeFile5(workspacePath, `${JSON.stringify(workspace, null, 2)}
-`, "utf8");
-  return workspacePath;
+  if (history.length === 0) {
+    options.stdout("No navigation history.\n");
+    return 0;
+  }
+  options.stdout(formatHistoryList(history, options.cwd));
+  return 0;
 }
 
 // src/init.ts
-import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname7, join as join8 } from "node:path";
+import { dirname as dirname7, join as join7 } from "node:path";
 var START_MARKER = "# >>> gji init >>>";
 var END_MARKER = "# <<< gji init <<<";
 var SHELL_WRAPPED_COMMANDS = [
@@ -16063,7 +16256,7 @@ async function runInitCommand(options) {
   await mkdir6(dirname7(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   const next = upsertShellIntegration(current, script);
-  await writeFile6(rcPath, next, "utf8");
+  await writeFile5(rcPath, next, "utf8");
   options.stdout(`${rcPath}
 `);
   const { config: globalConfig } = await loadGlobalConfig(home);
@@ -16074,7 +16267,11 @@ async function runInitCommand(options) {
     const prompt = options.promptForSetup ?? defaultPromptForSetup;
     const result = await prompt();
     if (result) {
-      await updateGlobalConfigKey("installSaveTarget", result.installSaveTarget, home);
+      await updateGlobalConfigKey(
+        "installSaveTarget",
+        result.installSaveTarget,
+        home
+      );
       await saveWizardConfig(result, options.cwd, home);
     }
   }
@@ -16134,7 +16331,8 @@ async function saveWizardConfig(result, cwd, home) {
   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 (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") {
@@ -16148,11 +16346,11 @@ async function saveWizardConfig(result, cwd, home) {
 function resolveShellConfigPath(shell, home) {
   switch (shell) {
     case "bash":
-      return join8(home, ".bashrc");
+      return join7(home, ".bashrc");
     case "fish":
-      return join8(home, ".config", "fish", "config.fish");
+      return join7(home, ".config", "fish", "config.fish");
     case "zsh":
-      return join8(home, ".zshrc");
+      return join7(home, ".zshrc");
   }
 }
 async function readExistingConfig(path9) {
@@ -16178,7 +16376,9 @@ function isMissingFileError2(error) {
 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 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]
@@ -16230,8 +16430,16 @@ async function defaultPromptForSetup() {
   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" }
+      {
+        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)) {
@@ -16334,10 +16542,22 @@ function formatDetailedWorktreeTable(worktrees) {
     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 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"
   ];
@@ -16360,7 +16580,9 @@ function formatWorktreeTable(worktrees) {
   );
   const lines = ["  " + "BRANCH".padEnd(branchWidth, " ") + " PATH"];
   for (const row of rows) {
-    lines.push(`${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.path}`);
+    lines.push(
+      `${row.isCurrent ? "*" : " "} ${row.branch.padEnd(branchWidth, " ")} ${row.path}`
+    );
   }
   return lines.join("\n");
 }
@@ -16372,10 +16594,172 @@ function sortWorktrees(worktrees) {
   });
 }
 
+// src/open.ts
+import { execFile as execFile4 } from "node:child_process";
+import { access as access4, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join8 } 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 = join8(worktreePath, `${repoName}.code-workspace`);
+  try {
+    await access4(workspacePath);
+    return workspacePath;
+  } catch {
+  }
+  const workspace = { folders: [{ path: "." }], settings: {} };
+  await writeFile6(
+    workspacePath,
+    `${JSON.stringify(workspace, null, 2)}
+`,
+    "utf8"
+  );
+  return workspacePath;
+}
+
 // src/pr.ts
+import { execFile as execFile5 } from "node:child_process";
 import { mkdir as mkdir7 } from "node:fs/promises";
 import { basename as basename7, 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";
@@ -16383,7 +16767,9 @@ function parsePrInput(input) {
   if (/^\d+$/.test(input)) return input;
   const hashMatch = input.match(/^#(\d+)$/);
   if (hashMatch) return hashMatch[1];
-  const urlMatch = input.match(/\/(?:pull|pull-requests|merge_requests)\/(\d+)/);
+  const urlMatch = input.match(
+    /\/(?:pull|pull-requests|merge_requests)\/(\d+)/
+  );
   if (urlMatch) return urlMatch[1];
   return null;
 }
@@ -16403,12 +16789,20 @@ function createPrCommand(dependencies = {}) {
       return 1;
     }
     const repository = await detectRepository(options.cwd);
-    const config = await loadEffectiveConfig(repository.repoRoot, void 0, options.stderr);
+    const config = await loadEffectiveConfig(
+      repository.repoRoot,
+      void 0,
+      options.stderr
+    );
     const branchName = `pr/${prNumber}`;
     const remoteRef = `refs/remotes/origin/pull/${prNumber}/head`;
     const rawBasePath = resolveConfigString(config, "worktreePath");
     const configuredBasePath = rawBasePath?.startsWith("/") || rawBasePath?.startsWith("~") ? rawBasePath : void 0;
-    const worktreePath = resolveWorktreePath(repository.repoRoot, branchName, configuredBasePath);
+    const worktreePath = resolveWorktreePath(
+      repository.repoRoot,
+      branchName,
+      configuredBasePath
+    );
     if (await pathExists(worktreePath)) {
       if (options.json || isHeadless()) {
         const message = `target worktree path already exists: ${worktreePath}`;
@@ -16416,10 +16810,14 @@ function createPrCommand(dependencies = {}) {
           options.stderr(`${JSON.stringify({ error: message }, null, 2)}
 `);
         } else {
-          options.stderr(`gji pr: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`);
-          options.stderr(`Hint: Use 'gji remove pr/${prNumber}' or 'gji clean' to remove the existing worktree
-`);
+          options.stderr(
+            `gji pr: ${message} in non-interactive mode (GJI_NO_TUI=1)
+`
+          );
+          options.stderr(
+            `Hint: Use 'gji remove pr/${prNumber}' or 'gji clean' to remove the existing worktree
+`
+          );
         }
         return 1;
       }
@@ -16429,22 +16827,33 @@ function createPrCommand(dependencies = {}) {
         await writeOutput2(worktreePath, options.stdout);
         return 0;
       }
-      options.stderr(`Aborted because target worktree path already exists: ${worktreePath}
-`);
+      options.stderr(
+        `Aborted because target worktree path already exists: ${worktreePath}
+`
+      );
       return 1;
     }
     if (options.dryRun) {
       if (options.json) {
-        options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath, dryRun: true }, null, 2)}
-`);
+        options.stdout(
+          `${JSON.stringify({ branch: branchName, path: worktreePath, dryRun: true }, null, 2)}
+`
+        );
       } else {
-        options.stdout(`Would create worktree at ${worktreePath} (branch: ${branchName})
-`);
+        options.stdout(
+          `Would create worktree at ${worktreePath} (branch: ${branchName})
+`
+        );
       }
       return 0;
     }
     try {
-      await fetchPullRequestRef(repository.repoRoot, options.number, prNumber, remoteRef);
+      await fetchPullRequestRef(
+        repository.repoRoot,
+        options.number,
+        prNumber,
+        remoteRef
+      );
     } catch {
       const message = `Failed to fetch PR #${prNumber} from origin`;
       if (options.json) {
@@ -16453,35 +16862,57 @@ function createPrCommand(dependencies = {}) {
       } else {
         options.stderr(`${message}
 `);
-        options.stderr(`Hint: Verify the remote is reachable: git fetch origin
-`);
+        options.stderr(
+          `Hint: Verify the remote is reachable: git fetch origin
+`
+        );
       }
       return 1;
     }
     await mkdir7(dirname8(worktreePath), { recursive: true });
-    const branchAlreadyExists = await localBranchExists2(repository.repoRoot, branchName);
+    const branchAlreadyExists = await localBranchExists2(
+      repository.repoRoot,
+      branchName
+    );
     const worktreeArgs = branchAlreadyExists ? ["worktree", "add", worktreePath, branchName] : ["worktree", "add", "-b", branchName, worktreePath, remoteRef];
     await execFileAsync5("git", worktreeArgs, { cwd: repository.repoRoot });
-    const syncPatterns = Array.isArray(config.syncFiles) ? config.syncFiles.filter((p2) => typeof p2 === "string") : [];
+    const syncPatterns = Array.isArray(config.syncFiles) ? config.syncFiles.filter(
+      (p2) => typeof p2 === "string"
+    ) : [];
     for (const pattern of syncPatterns) {
       try {
         await syncFiles(repository.repoRoot, worktreePath, [pattern]);
       } catch (error) {
-        options.stderr(`Warning: failed to sync file "${pattern}": ${error instanceof Error ? error.message : String(error)}
-`);
+        options.stderr(
+          `Warning: failed to sync file "${pattern}": ${error instanceof Error ? error.message : String(error)}
+`
+        );
       }
     }
-    await maybeRunInstallPrompt(worktreePath, repository.repoRoot, config, options.stderr, dependencies, !!options.json);
+    await maybeRunInstallPrompt(
+      worktreePath,
+      repository.repoRoot,
+      config,
+      options.stderr,
+      dependencies,
+      !!options.json
+    );
     const hooks = extractHooks(config);
     await runHook(
       hooks.afterCreate,
       worktreePath,
-      { branch: branchName, path: worktreePath, repo: basename7(repository.repoRoot) },
+      {
+        branch: branchName,
+        path: worktreePath,
+        repo: basename7(repository.repoRoot)
+      },
       options.stderr
     );
     if (options.json) {
-      options.stdout(`${JSON.stringify({ branch: branchName, path: worktreePath }, null, 2)}
-`);
+      options.stdout(
+        `${JSON.stringify({ branch: branchName, path: worktreePath }, null, 2)}
+`
+      );
     } else {
       await appendHistory(worktreePath, branchName);
       await writeOutput2(worktreePath, options.stdout);
@@ -16517,9 +16948,16 @@ async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
   throw new Error(`No pull request ref found for #${prNumber}`);
 }
 function listPullRequestSourceRefs(input, prNumber) {
-  const allForges = ["github", "gitlab", "bitbucket"];
+  const allForges = [
+    "github",
+    "gitlab",
+    "bitbucket"
+  ];
   const preferredForge = detectPullRequestForge(input);
-  const orderedForges = preferredForge === "unknown" ? allForges : [preferredForge, ...allForges.filter((forge) => forge !== preferredForge)];
+  const orderedForges = preferredForge === "unknown" ? allForges : [
+    preferredForge,
+    ...allForges.filter((forge) => forge !== preferredForge)
+  ];
   return orderedForges.map((forge) => sourceRefForForge(forge, prNumber));
 }
 function detectPullRequestForge(input) {
@@ -16557,7 +16995,9 @@ function createRemoveCommand(dependencies = {}) {
   const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ?? defaultConfirmForceRemoveWorktree;
   const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
   return async function runRemoveCommand2(options) {
-    const { linkedWorktrees, repository } = await loadLinkedWorktrees(options.cwd);
+    const { linkedWorktrees, repository } = await loadLinkedWorktrees(
+      options.cwd
+    );
     if (linkedWorktrees.length === 0) {
       emitError2(options, "No linked worktrees to finish");
       return 1;
@@ -16567,8 +17007,10 @@ function createRemoveCommand(dependencies = {}) {
       if (options.json) {
         emitError2(options, message);
       } else {
-        options.stderr(`gji remove: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`);
+        options.stderr(
+          `gji remove: ${message} in non-interactive mode (GJI_NO_TUI=1)
+`
+        );
       }
       return 1;
     }
@@ -16589,8 +17031,10 @@ function createRemoveCommand(dependencies = {}) {
       if (options.json) {
         emitError2(options, message);
       } else {
-        options.stderr(`gji remove: ${message} in non-interactive mode (GJI_NO_TUI=1)
-`);
+        options.stderr(
+          `gji remove: ${message} in non-interactive mode (GJI_NO_TUI=1)
+`
+        );
       }
       return 1;
     }
@@ -16600,8 +17044,10 @@ function createRemoveCommand(dependencies = {}) {
     }
     if (options.dryRun) {
       if (options.json) {
-        options.stdout(`${JSON.stringify({ branch: worktree.branch, path: worktree.path, dryRun: true }, null, 2)}
-`);
+        options.stdout(
+          `${JSON.stringify({ branch: worktree.branch, path: worktree.path, dryRun: true }, null, 2)}
+`
+        );
       } else {
         const desc = worktree.branch ? `branch: ${worktree.branch}` : "detached";
         options.stdout(`Would remove worktree at ${worktree.path} (${desc})
@@ -16609,12 +17055,20 @@ function createRemoveCommand(dependencies = {}) {
       }
       return 0;
     }
-    const config = await loadEffectiveConfig(repository.repoRoot, void 0, options.stderr);
+    const config = await loadEffectiveConfig(
+      repository.repoRoot,
+      void 0,
+      options.stderr
+    );
     const hooks = extractHooks(config);
     await runHook(
       hooks.beforeRemove,
       worktree.path,
-      { branch: worktree.branch ?? void 0, path: worktree.path, repo: basename8(repository.repoRoot) },
+      {
+        branch: worktree.branch ?? void 0,
+        path: worktree.path,
+        repo: basename8(repository.repoRoot)
+      },
       options.stderr
     );
     try {
@@ -16630,7 +17084,10 @@ function createRemoveCommand(dependencies = {}) {
       try {
         await forceRemoveWorktree(repository.repoRoot, worktree.path);
       } catch (forceError) {
-        emitError2(options, `Failed to remove worktree at ${worktree.path}: ${toMessage2(forceError)}`);
+        emitError2(
+          options,
+          `Failed to remove worktree at ${worktree.path}: ${toMessage2(forceError)}`
+        );
         return 1;
       }
     }
@@ -16645,18 +17102,24 @@ function createRemoveCommand(dependencies = {}) {
           try {
             await forceDeleteBranch(repository.repoRoot, worktree.branch);
           } catch (forceError) {
-            options.stderr(`Failed to delete branch ${worktree.branch}: ${toMessage2(forceError)}
-`);
+            options.stderr(
+              `Failed to delete branch ${worktree.branch}: ${toMessage2(forceError)}
+`
+            );
           }
         } else {
-          options.stderr(`Branch ${worktree.branch} was not deleted (has unmerged commits)
-`);
+          options.stderr(
+            `Branch ${worktree.branch} was not deleted (has unmerged commits)
+`
+          );
         }
       }
     }
     if (options.json) {
-      options.stdout(`${JSON.stringify({ branch: worktree.branch, path: worktree.path, deleted: true }, null, 2)}
-`);
+      options.stdout(
+        `${JSON.stringify({ branch: worktree.branch, path: worktree.path, deleted: true }, null, 2)}
+`
+      );
     } else {
       await writeOutput3(repository.repoRoot, options.stdout);
     }
@@ -16705,7 +17168,11 @@ var ROOT_OUTPUT_FILE_ENV = "GJI_ROOT_OUTPUT_FILE";
 async function runRootCommand(options) {
   const repository = await detectRepository(options.cwd);
   if (!options.print && process.env[ROOT_OUTPUT_FILE_ENV]) {
-    await writeShellOutput(ROOT_OUTPUT_FILE_ENV, repository.repoRoot, options.stdout);
+    await writeShellOutput(
+      ROOT_OUTPUT_FILE_ENV,
+      repository.repoRoot,
+      options.stdout
+    );
     return 0;
   }
   options.stdout(`${repository.repoRoot}
@@ -16721,18 +17188,31 @@ async function runStatusCommand(options) {
     worktrees.map(async (worktree) => buildStatusRow(worktree))
   );
   if (options.json) {
-    options.stdout(`${JSON.stringify(formatStatusJson(repository.repoRoot, repository.currentRoot, rows), null, 2)}
-`);
+    options.stdout(
+      `${JSON.stringify(formatStatusJson(repository.repoRoot, repository.currentRoot, rows), null, 2)}
+`
+    );
     return 0;
   }
-  options.stdout(`${formatStatusOutput(repository.repoRoot, repository.currentRoot, rows)}
-`);
+  options.stdout(
+    `${formatStatusOutput(repository.repoRoot, repository.currentRoot, rows)}
+`
+  );
   return 0;
 }
 function formatStatusOutput(repoRoot, currentRoot, rows) {
-  const currentWidth = Math.max("CURRENT".length, ...rows.map((row) => row.current ? 1 : 0));
-  const branchWidth = Math.max("BRANCH".length, ...rows.map((row) => formatBranch(row.branch).length));
-  const statusWidth = Math.max("STATUS".length, ...rows.map((row) => row.status.length));
+  const currentWidth = Math.max(
+    "CURRENT".length,
+    ...rows.map((row) => row.current ? 1 : 0)
+  );
+  const branchWidth = Math.max(
+    "BRANCH".length,
+    ...rows.map((row) => formatBranch(row.branch).length)
+  );
+  const statusWidth = Math.max(
+    "STATUS".length,
+    ...rows.map((row) => row.status.length)
+  );
   const upstreamWidth = Math.max(
     "UPSTREAM".length,
     ...rows.map((row) => formatUpstreamState2(row.upstream).length)
@@ -16768,7 +17248,9 @@ async function buildStatusRow(worktree) {
   };
 }
 function sortWorktreesByPath(worktrees) {
-  return [...worktrees].sort((left, right) => comparePaths(left.path, right.path));
+  return [...worktrees].sort(
+    (left, right) => comparePaths(left.path, right.path)
+  );
 }
 function formatBranch(branch) {
   return branch ?? "(detached)";
@@ -16814,7 +17296,11 @@ function formatUpstreamState2(upstream) {
 // src/sync.ts
 async function runSyncCommand(options) {
   const repository = await detectRepository(options.cwd);
-  const config = await loadEffectiveConfig(repository.repoRoot, void 0, options.stderr);
+  const config = await loadEffectiveConfig(
+    repository.repoRoot,
+    void 0,
+    options.stderr
+  );
   const worktrees = await listWorktrees(options.cwd);
   const remote = resolveConfiguredString2(config.syncRemote) ?? "origin";
   let defaultBranch;
@@ -16823,22 +17309,33 @@ async function runSyncCommand(options) {
   } catch {
     emitError3(options, `Unable to reach remote '${remote}'`);
     if (!options.json) {
-      options.stderr(`Hint: Add the remote with: git remote add ${remote} <url>
-`);
+      options.stderr(
+        `Hint: Add the remote with: git remote add ${remote} <url>
+`
+      );
     }
     return 1;
   }
   if (!defaultBranch) {
     emitError3(options, "Unable to determine the default branch for sync.");
     if (!options.json) {
-      options.stderr(`Hint: Add the remote with: git remote add ${remote} <url>
-`);
+      options.stderr(
+        `Hint: Add the remote with: git remote add ${remote} <url>
+`
+      );
     }
     return 1;
   }
-  const targetWorktrees = selectTargetWorktrees(worktrees, repository.currentRoot, options.all);
+  const targetWorktrees = selectTargetWorktrees(
+    worktrees,
+    repository.currentRoot,
+    options.all
+  );
   if (targetWorktrees === "detached") {
-    emitError3(options, `Cannot sync detached worktree: ${repository.currentRoot}`);
+    emitError3(
+      options,
+      `Cannot sync detached worktree: ${repository.currentRoot}`
+    );
     return 1;
   }
   for (const worktree of targetWorktrees) {
@@ -16852,15 +17349,21 @@ async function runSyncCommand(options) {
   } catch {
     emitError3(options, `Failed to fetch from remote '${remote}'`);
     if (!options.json) {
-      options.stderr(`Hint: Add the remote with: git remote add ${remote} <url>
-`);
+      options.stderr(
+        `Hint: Add the remote with: git remote add ${remote} <url>
+`
+      );
     }
     return 1;
   }
   const updatedWorktrees = [];
   for (const worktree of targetWorktrees) {
     if (worktree.branch === defaultBranch) {
-      await runGit(worktree.path, ["merge", "--ff-only", `${remote}/${defaultBranch}`]);
+      await runGit(worktree.path, [
+        "merge",
+        "--ff-only",
+        `${remote}/${defaultBranch}`
+      ]);
     } else {
       await runGit(worktree.path, ["rebase", `${remote}/${defaultBranch}`]);
     }
@@ -16871,7 +17374,10 @@ async function runSyncCommand(options) {
     }
   }
   if (options.json) {
-    const updated = updatedWorktrees.map((w2) => ({ branch: w2.branch, path: w2.path }));
+    const updated = updatedWorktrees.map((w2) => ({
+      branch: w2.branch,
+      path: w2.path
+    }));
     options.stdout(`${JSON.stringify({ updated }, null, 2)}
 `);
   }
@@ -16890,7 +17396,9 @@ function selectTargetWorktrees(worktrees, currentRoot, all) {
   if (all) {
     return worktrees.filter((worktree) => worktree.branch !== null).sort((left, right) => comparePaths(left.path, right.path));
   }
-  const currentWorktree = worktrees.find((worktree) => worktree.path === currentRoot);
+  const currentWorktree = worktrees.find(
+    (worktree) => worktree.path === currentRoot
+  );
   if (!currentWorktree) {
     return [];
   }
@@ -16903,8 +17411,153 @@ function resolveConfiguredString2(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 
+// src/sync-files-command.ts
+import { homedir as homedir6 } from "node:os";
+import { join as join9 } from "node:path";
+async function runSyncFilesCommand(options) {
+  const repository = await detectRepository(options.cwd);
+  const home = options.home ?? homedir6();
+  const loaded = await loadGlobalConfig(home);
+  const repoEntry = findRepoConfigEntry(
+    loaded.config,
+    repository.repoRoot,
+    home
+  );
+  const repoConfig = repoEntry?.config ?? {};
+  switch (options.action) {
+    case void 0:
+    case "list": {
+      writeSyncFiles(options.stdout, readSyncFiles(repoConfig), !!options.json);
+      return 0;
+    }
+    case "add": {
+      const paths = validatePaths(options.paths ?? [], options);
+      if (!paths) return 1;
+      const nextFiles = mergeSyncFiles(readSyncFiles(repoConfig), paths);
+      await saveRepoSyncFiles(
+        loaded.config,
+        repoEntry?.key ?? repository.repoRoot,
+        nextFiles,
+        home
+      );
+      writeSyncFiles(options.stdout, nextFiles, !!options.json);
+      return 0;
+    }
+    case "remove": {
+      const paths = validatePaths(options.paths ?? [], options);
+      if (!paths) return 1;
+      const existingFiles = readSyncFiles(repoConfig);
+      const nextFiles = removeSyncFiles(existingFiles, paths);
+      if (repoEntry && nextFiles.length !== existingFiles.length) {
+        await saveRepoSyncFiles(loaded.config, repoEntry.key, nextFiles, home);
+      }
+      writeSyncFiles(options.stdout, nextFiles, !!options.json);
+      return 0;
+    }
+  }
+  writeError(options, `unknown action: ${options.action}`);
+  return 1;
+}
+function findRepoConfigEntry(config, repoRoot, home) {
+  const repos = config.repos;
+  if (!isPlainObject3(repos)) return null;
+  for (const [key, value] of Object.entries(repos)) {
+    if (expandTilde2(key, home) === repoRoot && isPlainObject3(value)) {
+      return { config: value, key };
+    }
+  }
+  return null;
+}
+function readSyncFiles(config) {
+  const syncFiles2 = config.syncFiles;
+  if (!Array.isArray(syncFiles2)) return [];
+  return syncFiles2.filter((item) => typeof item === "string");
+}
+function writeSyncFiles(stdout, files, json) {
+  if (json) {
+    stdout(`${JSON.stringify(files, null, 2)}
+`);
+    return;
+  }
+  if (files.length === 0) {
+    stdout("No sync files configured for this repo.\n");
+    return;
+  }
+  stdout(`${files.join("\n")}
+`);
+}
+function validatePaths(paths, options) {
+  if (paths.length === 0) {
+    writeError(options, "at least one path is required");
+    return null;
+  }
+  const validatedPaths = [];
+  for (const path9 of paths) {
+    try {
+      validatedPaths.push(validateSyncFilePattern(path9));
+    } catch (error) {
+      writeError(
+        options,
+        error instanceof Error ? error.message : String(error)
+      );
+      return null;
+    }
+  }
+  return validatedPaths;
+}
+function mergeSyncFiles(existing, additions) {
+  const nextFiles = [...existing];
+  for (const path9 of additions) {
+    if (!nextFiles.includes(path9)) {
+      nextFiles.push(path9);
+    }
+  }
+  return nextFiles;
+}
+function removeSyncFiles(existing, removals) {
+  const removalSet = new Set(removals);
+  return existing.filter((path9) => !removalSet.has(path9));
+}
+async function saveRepoSyncFiles(config, repoKey, syncFiles2, home) {
+  const repos = isPlainObject3(config.repos) ? { ...config.repos } : {};
+  const repoConfig = isPlainObject3(repos[repoKey]) ? repos[repoKey] : {};
+  const nextRepoConfig = { ...repoConfig };
+  if (syncFiles2.length > 0) {
+    nextRepoConfig.syncFiles = syncFiles2;
+  } else {
+    delete nextRepoConfig.syncFiles;
+  }
+  if (Object.keys(nextRepoConfig).length > 0) {
+    repos[repoKey] = nextRepoConfig;
+  } else {
+    delete repos[repoKey];
+  }
+  await saveGlobalConfig({ ...config, repos }, home);
+}
+function isPlainObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function writeError(options, message) {
+  if (options.json) {
+    options.stderr(`${JSON.stringify({ error: message }, null, 2)}
+`);
+    return;
+  }
+  options.stderr(`gji sync-files: ${message}
+`);
+}
+function expandTilde2(value, home) {
+  if (value === "~") return home;
+  if (value.startsWith("~/")) return join9(home, value.slice(2));
+  return value;
+}
+
 // src/trigger-hook.ts
-var VALID_HOOKS = ["afterCreate", "afterEnter", "beforeRemove"];
+var VALID_HOOKS = [
+  "afterCreate",
+  "afterEnter",
+  "beforeRemove"
+];
 function isValidHook(hook) {
   return VALID_HOOKS.includes(hook);
 }
@@ -16918,10 +17571,16 @@ async function runTriggerHookCommand(options) {
   }
   const hookName = options.hook;
   const repository = await detectRepository(options.cwd);
-  const config = await loadEffectiveConfig(repository.repoRoot, void 0, options.stderr);
+  const config = await loadEffectiveConfig(
+    repository.repoRoot,
+    void 0,
+    options.stderr
+  );
   const hooks = extractHooks(config);
   const worktrees = await listWorktrees(options.cwd);
-  const currentWorktree = worktrees.find((w2) => w2.path === repository.currentRoot);
+  const currentWorktree = worktrees.find(
+    (w2) => w2.path === repository.currentRoot
+  );
   await runHook(
     hooks[hookName],
     repository.currentRoot,
@@ -17001,46 +17660,117 @@ 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("--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("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("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("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("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"));
+  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"));
+  const syncFilesCommand = program2.command("sync-files").description("manage local files copied into new worktrees").option("--json", "emit JSON instead of human-readable output").action(notImplemented("sync-files"));
+  syncFilesCommand.command("list").description("list files synced into new worktrees for this repo").option("--json", "emit JSON instead of human-readable output").action(notImplemented("sync-files list"));
+  syncFilesCommand.command("add <paths...>").description("add repo-local sync files to global config").option("--json", "emit JSON instead of human-readable output").action(notImplemented("sync-files add"));
+  syncFilesCommand.command("remove <paths...>").alias("rm").description("remove repo-local sync files from global config").option("--json", "emit JSON instead of human-readable output").action(notImplemented("sync-files remove"));
   program2.command("ls").description("list active worktrees").option("--compact", "show only branch and path columns").option("--json", "print active worktrees as JSON").action(notImplemented("ls"));
-  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"));
+  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"));
   configCommand.command("unset <key>").description("remove a global config value").action(notImplemented("config unset"));
 }
 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, editor: commandOptions.editor, force: commandOptions.force, json: commandOptions.json, open: commandOptions.open });
-    if (exitCode !== 0) {
-      throw commanderExit(exitCode);
+  program2.commands.find((command) => command.name() === "new")?.action(
+    async (branch, commandOptions) => {
+      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);
+      }
     }
-  });
-  program2.commands.find((command) => command.name() === "init")?.action(async (shell, commandOptions) => {
-    const exitCode = await runInitCommand({
-      cwd: options.cwd,
-      shell,
-      stderr: options.stderr,
-      stdout: options.stdout,
-      write: commandOptions.write
-    });
-    if (exitCode !== 0) {
-      throw commanderExit(exitCode);
+  );
+  program2.commands.find((command) => command.name() === "init")?.action(
+    async (shell, commandOptions) => {
+      const exitCode = await runInitCommand({
+        cwd: options.cwd,
+        shell,
+        stderr: options.stderr,
+        stdout: options.stdout,
+        write: commandOptions.write
+      });
+      if (exitCode !== 0) {
+        throw commanderExit(exitCode);
+      }
     }
-  });
+  );
   program2.commands.find((command) => command.name() === "completion")?.action(async (shell) => {
     const exitCode = await runCompletionCommand({
       shell,
@@ -17051,32 +17781,93 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "pr")?.action(async (number, commandOptions) => {
-    const exitCode = await runPrCommand({ cwd: options.cwd, dryRun: commandOptions.dryRun, json: commandOptions.json, number, stderr: options.stderr, stdout: options.stdout });
+  program2.commands.find((command) => command.name() === "pr")?.action(
+    async (number, commandOptions) => {
+      const exitCode = await runPrCommand({
+        cwd: options.cwd,
+        dryRun: commandOptions.dryRun,
+        json: commandOptions.json,
+        number,
+        stderr: options.stderr,
+        stdout: options.stdout
+      });
+      if (exitCode !== 0) {
+        throw commanderExit(exitCode);
+      }
+    }
+  );
+  program2.commands.find((command) => command.name() === "back")?.action(
+    async (n, commandOptions) => {
+      if (n !== void 0 && !/^\d+$/.test(n)) {
+        options.stderr(`gji back: invalid step count: ${n}
+`);
+        throw commanderExit(1);
+      }
+      const steps = n !== void 0 ? parseInt(n, 10) : void 0;
+      const exitCode = await runBackCommand({
+        cwd: options.cwd,
+        n: steps,
+        print: commandOptions.print,
+        stderr: options.stderr,
+        stdout: options.stdout
+      });
+      if (exitCode !== 0) {
+        throw commanderExit(exitCode);
+      }
+    }
+  );
+  program2.commands.find((command) => command.name() === "history")?.action(async (commandOptions) => {
+    const exitCode = await runHistoryCommand({
+      cwd: options.cwd,
+      json: commandOptions.json,
+      stdout: options.stdout
+    });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "back")?.action(async (n, commandOptions) => {
-    if (n !== void 0 && !/^\d+$/.test(n)) {
-      options.stderr(`gji back: invalid step count: ${n}
-`);
-      throw commanderExit(1);
+  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,
+        cwd: options.cwd,
+        print: commandOptions.print,
+        stderr: options.stderr,
+        stdout: options.stdout
+      });
+      if (exitCode !== 0) {
+        throw commanderExit(exitCode);
+      }
     }
-    const steps = n !== void 0 ? parseInt(n, 10) : void 0;
-    const exitCode = await runBackCommand({
+  );
+  program2.commands.find((command) => command.name() === "root")?.action(async (commandOptions) => {
+    const exitCode = await runRootCommand({
       cwd: options.cwd,
-      n: steps,
       print: commandOptions.print,
-      stderr: options.stderr,
       stdout: options.stdout
     });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "history")?.action(async (commandOptions) => {
-    const exitCode = await runHistoryCommand({
+  program2.commands.find((command) => command.name() === "status")?.action(async (commandOptions) => {
+    const exitCode = await runStatusCommand({
       cwd: options.cwd,
       json: commandOptions.json,
       stdout: options.stdout
@@ -17085,25 +17876,26 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "open")?.action(async (branch, commandOptions) => {
-    const exitCode = await runOpenCommand({
-      branch,
+  program2.commands.find((command) => command.name() === "sync")?.action(async (commandOptions) => {
+    const exitCode = await runSyncCommand({
+      all: commandOptions.all,
       cwd: options.cwd,
-      editor: commandOptions.editor,
-      save: commandOptions.save,
+      json: commandOptions.json,
       stderr: options.stderr,
-      stdout: options.stdout,
-      workspace: commandOptions.workspace
+      stdout: options.stdout
     });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "go")?.action(async (branch, commandOptions) => {
-    const exitCode = await runGoCommand({
-      branch,
+  const syncFilesCommand = program2.commands.find(
+    (command) => command.name() === "sync-files"
+  );
+  syncFilesCommand?.action(async (commandOptions) => {
+    const exitCode = await runSyncFilesCommand({
+      action: "list",
       cwd: options.cwd,
-      print: commandOptions.print,
+      json: commandOptions.json,
       stderr: options.stderr,
       stdout: options.stdout
     });
@@ -17111,38 +17903,45 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "root")?.action(async (commandOptions) => {
-    const exitCode = await runRootCommand({
+  syncFilesCommand?.commands.find((command) => command.name() === "list")?.action(async (commandOptions) => {
+    const exitCode = await runSyncFilesCommand({
+      action: "list",
       cwd: options.cwd,
-      print: commandOptions.print,
+      json: commandOptions.json || syncFilesCommand?.opts().json,
+      stderr: options.stderr,
       stdout: options.stdout
     });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "status")?.action(async (commandOptions) => {
-    const exitCode = await runStatusCommand({
+  syncFilesCommand?.commands.find((command) => command.name() === "add")?.action(async (paths, commandOptions) => {
+    const exitCode = await runSyncFilesCommand({
+      action: "add",
       cwd: options.cwd,
-      json: commandOptions.json,
+      json: commandOptions.json || syncFilesCommand?.opts().json,
+      paths,
+      stderr: options.stderr,
       stdout: options.stdout
     });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "sync")?.action(async (commandOptions) => {
-    const exitCode = await runSyncCommand({
-      all: commandOptions.all,
+  const runSyncFilesRemoveCommand = async (paths, commandOptions) => {
+    const exitCode = await runSyncFilesCommand({
+      action: "remove",
       cwd: options.cwd,
-      json: commandOptions.json,
+      json: commandOptions.json || syncFilesCommand?.opts().json,
+      paths,
       stderr: options.stderr,
       stdout: options.stdout
     });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
-  });
+  };
+  syncFilesCommand?.commands.find((command) => command.name() === "remove")?.action(runSyncFilesRemoveCommand);
   program2.commands.find((command) => command.name() === "ls")?.action(async (commandOptions) => {
     const exitCode = await runLsCommand({
       compact: commandOptions.compact,
@@ -17154,20 +17953,22 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "clean")?.action(async (commandOptions) => {
-    const exitCode = await runCleanCommand({
-      cwd: options.cwd,
-      dryRun: commandOptions.dryRun,
-      force: commandOptions.force,
-      json: commandOptions.json,
-      stale: commandOptions.stale,
-      stderr: options.stderr,
-      stdout: options.stdout
-    });
-    if (exitCode !== 0) {
-      throw commanderExit(exitCode);
+  program2.commands.find((command) => command.name() === "clean")?.action(
+    async (commandOptions) => {
+      const exitCode = await runCleanCommand({
+        cwd: options.cwd,
+        dryRun: commandOptions.dryRun,
+        force: commandOptions.force,
+        json: commandOptions.json,
+        stale: commandOptions.stale,
+        stderr: options.stderr,
+        stdout: options.stdout
+      });
+      if (exitCode !== 0) {
+        throw commanderExit(exitCode);
+      }
     }
-  });
+  );
   const runRemovalCommand = async (branch, commandOptions = {}) => {
     const exitCode = await runRemoveCommand({
       branch,
@@ -17193,23 +17994,27 @@ 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);
+  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");
+  );
+  const configCommand = program2.commands.find(
+    (command) => command.name() === "config"
+  );
   configCommand?.action(async () => {
     const exitCode = await runConfigCommand({
       cwd: options.cwd,
@@ -17291,7 +18096,7 @@ async function main() {
 }
 async function warnIfMissingShellIntegration() {
   try {
-    const { config } = await loadGlobalConfig(homedir6());
+    const { config } = await loadGlobalConfig(homedir7());
     if (!config.shellIntegration) {
       const shellBin = (process.env.SHELL ?? "").split("/").at(-1);
       const shellArg = shellBin && ["bash", "zsh", "fish"].includes(shellBin) ? ` ${shellBin}` : "";