@solaqua/gji 0.5.0 → 0.6.1

package/dist/shell-completion.js

@@ -1,9 +1,14 @@
+import { KNOWN_GLOBAL_CONFIG_KEYS } from './config.js';
 const TOP_LEVEL_COMMANDS = [
     { 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' },
+    { name: 'back', description: 'navigate to the previously visited worktree' },
+    { name: 'history', description: 'show navigation history' },
+    { name: 'open', description: 'open the worktree in an editor' },
     { name: 'go', description: 'print or select a worktree path' },
+    { name: 'jump', description: 'alias of go' },
     { 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' },
@@ -12,20 +17,12 @@ const TOP_LEVEL_COMMANDS = [
     { 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: 'warp', description: 'jump to any worktree across all known repos' },
     { name: 'config', description: 'manage global config defaults' },
 ];
 const SHELL_NAMES = ['bash', 'fish', 'zsh'];
 const HOOK_NAMES = ['afterCreate', 'afterEnter', 'beforeRemove'];
-const CONFIG_KEYS = [
-    'branchPrefix',
-    'syncRemote',
-    'syncDefaultBranch',
-    'syncFiles',
-    'skipInstallPrompt',
-    'installSaveTarget',
-    'hooks',
-    'repos',
-];
+const CONFIG_KEYS = Array.from(KNOWN_GLOBAL_CONFIG_KEYS);
 export function renderShellCompletion(shell) {
     switch (shell) {
         case 'bash':
@@ -59,7 +56,7 @@ _gji_completion() {
 
   case "$command_name" in
     new)
-      COMPREPLY=( $(compgen -W "--detached --dry-run --json --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "--detached --force --open --editor --dry-run --json --help" -- "$cur") )
       ;;
     init)
       COMPREPLY=( $(compgen -W "${shells} --write --help" -- "$cur") )
@@ -70,7 +67,16 @@ _gji_completion() {
     pr)
       COMPREPLY=( $(compgen -W "--dry-run --json --help" -- "$cur") )
       ;;
-    go)
+    back)
+      COMPREPLY=( $(compgen -W "--print --help" -- "$cur") )
+      ;;
+    history)
+      COMPREPLY=( $(compgen -W "--json --help" -- "$cur") )
+      ;;
+    open)
+      COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --editor --save --workspace --help" -- "$cur") )
+      ;;
+    go|jump)
       COMPREPLY=( $(compgen -W "$(__gji_worktree_branches) --print --help" -- "$cur") )
       ;;
     root)
@@ -94,6 +100,9 @@ _gji_completion() {
     trigger-hook)
       COMPREPLY=( $(compgen -W "${hooks} --help" -- "$cur") )
       ;;
+    warp)
+      COMPREPLY=( $(compgen -W "-n --new --print --json --help" -- "$cur") )
+      ;;
     config)
       if [ "$COMP_CWORD" -eq 2 ]; then
         COMPREPLY=( $(compgen -W "get set unset" -- "$cur") )
@@ -149,6 +158,9 @@ complete -c gji -f
 ${commandLines}
 
 complete -c gji -n '__fish_seen_subcommand_from new' -l detached -d 'create a detached worktree without a branch'
+complete -c gji -n '__fish_seen_subcommand_from new' -l force -d 'remove and recreate the worktree if the target path already exists'
+complete -c gji -n '__fish_seen_subcommand_from new' -l open -d 'open the new worktree in an editor after creation'
+complete -c gji -n '__fish_seen_subcommand_from new' -l editor -r -d 'editor CLI to use with --open (code, cursor, zed, …)'
 complete -c gji -n '__fish_seen_subcommand_from new' -l dry-run -d 'show what would be created without executing any git commands or writing files'
 complete -c gji -n '__fish_seen_subcommand_from new' -l json -d 'emit JSON on success or error instead of human-readable output'
 
@@ -162,8 +174,17 @@ complete -c gji -n '__fish_seen_subcommand_from completion' -a 'zsh' -d 'shell'
 complete -c gji -n '__fish_seen_subcommand_from pr' -l dry-run -d 'show what would be created without executing any git commands or writing files'
 complete -c gji -n '__fish_seen_subcommand_from pr' -l json -d 'emit JSON on success or error instead of human-readable output'
 
-complete -c gji -n '__fish_seen_subcommand_from go' -l print -d 'print the resolved worktree path explicitly'
-complete -c gji -n '__fish_seen_subcommand_from go' -a '(__gji_worktree_branches)' -d 'worktree branch'
+complete -c gji -n '__fish_seen_subcommand_from back' -l print -d 'print the resolved worktree path explicitly'
+
+complete -c gji -n '__fish_seen_subcommand_from history' -l json -d 'print history as JSON'
+
+complete -c gji -n '__fish_seen_subcommand_from open' -l editor -r -d 'editor CLI to use (code, cursor, zed, windsurf, subl, …)'
+complete -c gji -n '__fish_seen_subcommand_from open' -l save -d 'save the chosen editor to global config'
+complete -c gji -n '__fish_seen_subcommand_from open' -l workspace -d 'generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)'
+complete -c gji -n '__fish_seen_subcommand_from open' -a '(__gji_worktree_branches)' -d 'worktree branch'
+
+complete -c gji -n '__fish_seen_subcommand_from go jump' -l print -d 'print the resolved worktree path explicitly'
+complete -c gji -n '__fish_seen_subcommand_from go jump' -a '(__gji_worktree_branches)' -d 'worktree branch'
 
 complete -c gji -n '__fish_seen_subcommand_from root' -l print -d 'print the resolved repository root path explicitly'
 
@@ -187,6 +208,10 @@ complete -c gji -n '__fish_seen_subcommand_from remove rm' -a '(__gji_worktree_b
 
 ${hookLines}
 
+complete -c gji -n '__fish_seen_subcommand_from warp' -s n -l new -d 'create a new worktree in a registered repo'
+complete -c gji -n '__fish_seen_subcommand_from warp' -l print -d 'print the resolved worktree path without changing directory'
+complete -c gji -n '__fish_seen_subcommand_from warp' -l json -d 'emit JSON on success or error instead of human-readable output'
+
 complete -c gji -n '__fish_seen_subcommand_from config; and __gji_should_complete_config_action' -a 'get set unset' -d 'config action'
 ${configKeyLines}`;
 }
@@ -195,89 +220,99 @@ function renderZshCompletion() {
     const configKeys = CONFIG_KEYS.join(' ');
     const shells = SHELL_NAMES.join(' ');
     const hooks = HOOK_NAMES.join(' ');
-    return `__gji_worktree_branches() {
+    return `#compdef gji
+
+__gji_worktree_branches() {
   command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 }
 
-_gji_completion() {
-  local context state line
-  local -a commands worktree_branches
-
-  commands=(
-    ${commandLines}
-  )
+local context state line
+local -a commands worktree_branches
 
-  if (( CURRENT == 2 )); then
-    _describe 'command' commands
-    return
-  fi
+commands=(
+  ${commandLines}
+)
 
-  case "\${words[2]}" in
-    new)
-      _arguments '--detached[create a detached worktree without a branch]' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
-      ;;
-    init)
-      _arguments '--write[write the integration to the shell config file]' '2:shell:(${shells})'
-      ;;
-    completion)
-      _arguments '2:shell:(${shells})'
-      ;;
-    pr)
-      _arguments '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:ref: '
-      ;;
-    go)
-      _arguments '--print[print the resolved worktree path explicitly]' '2:branch:->worktrees'
-      ;;
-    root)
-      _arguments '--print[print the resolved repository root path explicitly]'
-      ;;
-    status)
-      _arguments '--json[print repository and worktree health as JSON]'
-      ;;
-    sync)
-      _arguments '--all[sync every worktree in the repository]' '--json[emit JSON on success or error instead of human-readable output]'
-      ;;
-    ls)
-      _arguments '--compact[show only branch and path columns]' '--json[print active worktrees as JSON]'
-      ;;
-    clean)
-      _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches]' '--stale[only target clean worktrees whose upstream is gone and branch is merged into the default branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]'
-      ;;
-    remove|rm)
-      _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch:->worktrees'
-      ;;
-    trigger-hook)
-      _arguments "2:hook:(${hooks})"
-      ;;
-    config)
-      if (( CURRENT == 3 )); then
-        _values 'config action' get set unset
-        return
-      fi
+if (( CURRENT == 2 )); then
+  _describe 'command' commands
+  return
+fi
 
-      case "\${words[3]}" in
-        get|unset)
-          _arguments '3:key:->config_keys'
-          ;;
-        set)
-          _arguments '3:key:->config_keys' '4:value: '
-          ;;
-      esac
-      ;;
-  esac
+case "\${words[2]}" in
+  new)
+    _arguments '--detached[create a detached worktree without a branch]' '--force[remove and recreate the worktree if the target path already exists]' '--open[open the new worktree in an editor after creation]' '--editor[editor CLI to use with --open (code, cursor, zed, …)]:editor:' '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    ;;
+  init)
+    _arguments '--write[write the integration to the shell config file]' '2:shell:(${shells})'
+    ;;
+  completion)
+    _arguments '2:shell:(${shells})'
+    ;;
+  pr)
+    _arguments '--dry-run[show what would be created without executing any git commands or writing files]' '--json[emit JSON on success or error instead of human-readable output]' '2:ref: '
+    ;;
+  back)
+    _arguments '--print[print the resolved worktree path explicitly]' '2:steps: '
+    ;;
+  history)
+    _arguments '--json[print history as JSON]'
+    ;;
+  open)
+    _arguments '--editor[editor CLI to use (code, cursor, zed, windsurf, subl, …)]:editor:' '--save[save the chosen editor to global config]' '--workspace[generate a .code-workspace file before opening (VS Code / Cursor / Windsurf)]' '2:branch:->worktrees'
+    ;;
+  go|jump)
+    _arguments '--print[print the resolved worktree path explicitly]' '2:branch:->worktrees'
+    ;;
+  root)
+    _arguments '--print[print the resolved repository root path explicitly]'
+    ;;
+  status)
+    _arguments '--json[print repository and worktree health as JSON]'
+    ;;
+  sync)
+    _arguments '--all[sync every worktree in the repository]' '--json[emit JSON on success or error instead of human-readable output]'
+    ;;
+  ls)
+    _arguments '--compact[show only branch and path columns]' '--json[print active worktrees as JSON]'
+    ;;
+  clean)
+    _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove dirty worktrees, and force-delete unmerged branches]' '--stale[only target clean worktrees whose upstream is gone and branch is merged into the default branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]'
+    ;;
+  remove|rm)
+    _arguments '(-f --force)'{-f,--force}'[bypass prompts, force-remove a dirty worktree, and force-delete an unmerged branch]' '--dry-run[show what would be deleted without removing anything]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch:->worktrees'
+    ;;
+  trigger-hook)
+    _arguments "2:hook:(${hooks})"
+    ;;
+  warp)
+    _arguments '(-n --new)'{-n,--new}'[create a new worktree in a registered repo]:branch:' '--print[print the resolved worktree path without changing directory]' '--json[emit JSON on success or error instead of human-readable output]' '2:branch: '
+    ;;
+  config)
+    if (( CURRENT == 3 )); then
+      _values 'config action' get set unset
+      return
+    fi
 
-  case "$state" in
-    worktrees)
-      worktree_branches=(\${(@f)$(__gji_worktree_branches)})
-      _describe 'worktree branch' worktree_branches
-      ;;
-    config_keys)
-      _values 'config key' ${configKeys}
-      ;;
-  esac
-}
+    case "\${words[3]}" in
+      get|unset)
+        _arguments '3:key:->config_keys'
+        ;;
+      set)
+        _arguments '3:key:->config_keys' '4:value: '
+        ;;
+    esac
+    ;;
+esac
 
-compdef _gji_completion gji`;
+case "$state" in
+  worktrees)
+    worktree_branches=(\${(@f)$(__gji_worktree_branches)})
+    _describe 'worktree branch' worktree_branches
+    ;;
+  config_keys)
+    _values 'config key' ${configKeys}
+    ;;
+esac`;
 }
 function escapeSingleQuotes(value) {
     return value.replace(/'/g, `'\\''`);

package/dist/warp.d.ts

@@ -0,0 +1,20 @@
+export interface WarpCommandOptions {
+    branch?: string;
+    cwd: string;
+    json?: boolean;
+    newWorktree?: boolean;
+    stderr: (chunk: string) => void;
+    stdout: (chunk: string) => void;
+}
+export declare function runWarpCommand(options: WarpCommandOptions): Promise<number>;
+export interface WarpTarget {
+    branch: string | null;
+    path: string;
+}
+export declare function resolveWarpTarget(options: {
+    branch?: string;
+    commandName?: string;
+    cwd: string;
+    json?: boolean;
+    stderr: (chunk: string) => void;
+}): Promise<WarpTarget | null>;

package/dist/warp.js

@@ -0,0 +1,196 @@
+import { isCancel, select } from '@clack/prompts';
+import { readWorktreeHealth } from './git.js';
+import { isHeadless } from './headless.js';
+import { appendHistory } from './history.js';
+import { runNewCommand } from './new.js';
+import { loadRegistry } from './repo-registry.js';
+import { listWorktrees } from './repo.js';
+import { writeShellOutput } from './shell-handoff.js';
+const WARP_OUTPUT_FILE_ENV = 'GJI_WARP_OUTPUT_FILE';
+export async function runWarpCommand(options) {
+    if (options.newWorktree) {
+        const registry = await loadRegistry();
+        if (registry.length === 0) {
+            options.stderr('gji warp: no repos registered yet.\n' +
+                'Use any gji command in a repository to register it automatically.\n');
+            return 1;
+        }
+        return runWarpNew(options, registry);
+    }
+    return runWarpNavigate(options);
+}
+async function runWarpNavigate(options) {
+    if ((isHeadless() || options.json) && !options.branch) {
+        const message = 'branch argument is required';
+        if (options.json) {
+            options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+        }
+        else {
+            options.stderr('gji warp: branch argument is required in non-interactive mode (GJI_NO_TUI=1)\n');
+        }
+        return 1;
+    }
+    const target = await resolveWarpTarget({ ...options, commandName: 'gji warp', json: options.json });
+    if (!target)
+        return 1;
+    if (options.json) {
+        // json callers use the output programmatically; skip history and shell handoff.
+        options.stdout(`${JSON.stringify({ branch: target.branch, path: target.path }, null, 2)}\n`);
+        return 0;
+    }
+    appendHistory(target.path, target.branch).catch(() => undefined);
+    await writeShellOutput(WARP_OUTPUT_FILE_ENV, target.path, options.stdout);
+    return 0;
+}
+async function runWarpNew(options, registry) {
+    let targetRepoRoot;
+    if (registry.length === 1) {
+        targetRepoRoot = registry[0].path;
+    }
+    else {
+        if (isHeadless()) {
+            options.stderr('gji warp: repo argument is required in non-interactive mode (GJI_NO_TUI=1)\n');
+            return 1;
+        }
+        const choice = await select({
+            message: 'Create worktree in which repo?',
+            options: registry.map((entry) => ({
+                value: entry.path,
+                label: entry.name,
+                hint: entry.path,
+            })),
+        });
+        if (isCancel(choice)) {
+            options.stderr('Aborted\n');
+            return 1;
+        }
+        targetRepoRoot = choice;
+    }
+    if (options.json) {
+        return runNewCommand({
+            branch: options.branch,
+            cwd: targetRepoRoot,
+            json: true,
+            stderr: options.stderr,
+            stdout: options.stdout,
+        });
+    }
+    // runNewCommand writes the created path to options.stdout via writeShellOutput.
+    // Since GJI_NEW_OUTPUT_FILE is not set in the warp shell context, it falls
+    // through to our captured stdout, giving us the path to hand off.
+    let capturedPath = '';
+    const captureStdout = (chunk) => {
+        capturedPath = chunk.trim();
+    };
+    const exitCode = await runNewCommand({
+        branch: options.branch,
+        cwd: targetRepoRoot,
+        stderr: options.stderr,
+        stdout: captureStdout,
+    });
+    if (exitCode !== 0) {
+        return exitCode;
+    }
+    if (!capturedPath) {
+        options.stderr('gji warp: could not determine new worktree path\n');
+        return 1;
+    }
+    await writeShellOutput(WARP_OUTPUT_FILE_ENV, capturedPath, options.stdout);
+    return 0;
+}
+function findByQuery(items, query) {
+    const slashIdx = query.indexOf('/');
+    if (slashIdx !== -1) {
+        const repoQuery = query.slice(0, slashIdx);
+        const branchQuery = query.slice(slashIdx + 1);
+        const match = items.find((item) => item.repoName === repoQuery && item.worktree.branch === branchQuery);
+        if (match)
+            return match;
+    }
+    return items.find((item) => item.worktree.branch === query) ?? null;
+}
+export async function resolveWarpTarget(options) {
+    const cmd = options.commandName ?? 'gji';
+    const emitError = (message, hint) => {
+        if (options.json) {
+            options.stderr(`${JSON.stringify({ error: message }, null, 2)}\n`);
+        }
+        else {
+            options.stderr(`${cmd}: ${message}\n`);
+            if (hint)
+                options.stderr(hint);
+        }
+    };
+    const registry = await loadRegistry();
+    if (registry.length === 0) {
+        emitError('not in a git repository and no repos registered yet.', 'Use any gji command inside a repository to register it.\n');
+        return null;
+    }
+    const results = await Promise.allSettled(registry.map(async (entry) => {
+        const worktrees = await listWorktrees(entry.path);
+        return { repoName: entry.name, worktrees };
+    }));
+    const allItems = [];
+    for (const result of results) {
+        if (result.status === 'rejected')
+            continue;
+        const { repoName, worktrees } = result.value;
+        for (const worktree of worktrees) {
+            allItems.push({ repoName, worktree });
+        }
+    }
+    if (allItems.length === 0) {
+        emitError('no accessible worktrees found in any registered repo.');
+        return null;
+    }
+    if (options.branch) {
+        const match = findByQuery(allItems, options.branch);
+        if (!match) {
+            emitError(`no worktree found matching: ${options.branch}`);
+            return null;
+        }
+        return { branch: match.worktree.branch, path: match.worktree.path };
+    }
+    const path = await promptForWarpTarget(allItems);
+    if (!path) {
+        options.stderr('Aborted\n');
+        return null;
+    }
+    const chosen = allItems.find((item) => item.worktree.path === path);
+    return { branch: chosen?.worktree.branch ?? null, path };
+}
+async function promptForWarpTarget(items) {
+    const healthResults = await Promise.allSettled(items.map((item) => readWorktreeHealth(item.worktree.path)));
+    const choice = await select({
+        message: 'Warp to a worktree',
+        options: items.map((item, i) => {
+            const health = healthResults[i].status === 'fulfilled' ? healthResults[i].value : null;
+            const upstream = health ? formatHint(item.worktree.branch, health) : null;
+            const label = `${item.repoName} › ${item.worktree.branch ?? '(detached)'}`;
+            const pathHint = item.worktree.isCurrent
+                ? `${item.worktree.path} (current)`
+                : item.worktree.path;
+            const hint = upstream ? `${upstream} · ${pathHint}` : pathHint;
+            return { hint, label, value: item.worktree.path };
+        }),
+    });
+    if (isCancel(choice)) {
+        return null;
+    }
+    return choice;
+}
+function formatHint(branch, health) {
+    if (branch === null)
+        return null;
+    if (!health.hasUpstream)
+        return 'no upstream';
+    if (health.upstreamGone)
+        return 'upstream gone';
+    if (health.ahead === 0 && health.behind === 0)
+        return 'up to date';
+    if (health.ahead === 0)
+        return `behind ${health.behind}`;
+    if (health.behind === 0)
+        return `ahead ${health.ahead}`;
+    return `ahead ${health.ahead}, behind ${health.behind}`;
+}

package/man/man1/gji-back.1

@@ -1,4 +1,4 @@
-.TH GJI\-BACK 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-BACK 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-back \- navigate to the previously visited worktree, optionally N steps back
 .SH SYNOPSIS

package/man/man1/gji-clean.1

@@ -1,4 +1,4 @@
-.TH GJI\-CLEAN 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-CLEAN 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-clean \- interactively prune linked worktrees
 .SH SYNOPSIS

package/man/man1/gji-completion.1

@@ -1,4 +1,4 @@
-.TH GJI\-COMPLETION 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-COMPLETION 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-completion \- print shell completion definitions
 .SH SYNOPSIS

package/man/man1/gji-config.1

@@ -1,4 +1,4 @@
-.TH GJI\-CONFIG 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-CONFIG 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-config \- manage global config defaults
 .SH SYNOPSIS

package/man/man1/gji-go.1

@@ -1,4 +1,4 @@
-.TH GJI\-GO 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-GO 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-go \- print or select a worktree path
 .SH SYNOPSIS

package/man/man1/gji-history.1

@@ -1,4 +1,4 @@
-.TH GJI\-HISTORY 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-HISTORY 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-history \- show navigation history
 .SH SYNOPSIS

package/man/man1/gji-init.1

@@ -1,4 +1,4 @@
-.TH GJI\-INIT 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-INIT 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-init \- print or install shell integration
 .SH SYNOPSIS

package/man/man1/gji-ls.1

@@ -1,4 +1,4 @@
-.TH GJI\-LS 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-LS 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-ls \- list active worktrees
 .SH SYNOPSIS

package/man/man1/gji-new.1

@@ -1,4 +1,4 @@
-.TH GJI\-NEW 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-NEW 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-new \- create a new branch or detached linked worktree
 .SH SYNOPSIS
@@ -13,6 +13,12 @@ remove and recreate the worktree if the target path already exists
 .B \-\-detached
 create a detached worktree without a branch
 .TP
+.B \-\-open
+open the new worktree in an editor after creation
+.TP
+.B \-\-editor <cli>
+editor CLI to use with \-\-open (code, cursor, zed, …)
+.TP
 .B \-\-dry\-run
 show what would be created without executing any git commands or writing files
 .TP

package/man/man1/gji-open.1

@@ -0,0 +1,19 @@
+.TH GJI\-OPEN 1 "May 2026" "gji 0.6.1" "User Commands"
+.SH NAME
+gji\-open \- open the worktree in an editor
+.SH SYNOPSIS
+.B gji open [\fIoptions\fR] [options] [branch]
+.SH DESCRIPTION
+open the worktree in an editor
+.SH OPTIONS
+.TP
+.B \-\-editor <cli>
+editor CLI to use (code, cursor, zed, windsurf, subl, …)
+.TP
+.B \-\-save
+save the chosen editor to global config
+.TP
+.B \-\-workspace
+generate a .code\-workspace file before opening (VS Code / Cursor / Windsurf)
+.SH "SEE ALSO"
+.BR gji (1)

package/man/man1/gji-pr.1

@@ -1,4 +1,4 @@
-.TH GJI\-PR 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-PR 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-pr \- fetch a pull request by number, #number, or URL into a linked worktree
 .SH SYNOPSIS

package/man/man1/gji-remove.1

@@ -1,4 +1,4 @@
-.TH GJI\-REMOVE 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-REMOVE 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-remove \- remove a linked worktree and delete its branch when present
 .SH SYNOPSIS

package/man/man1/gji-root.1

@@ -1,4 +1,4 @@
-.TH GJI\-ROOT 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-ROOT 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-root \- print the main repository root path
 .SH SYNOPSIS

package/man/man1/gji-status.1

@@ -1,4 +1,4 @@
-.TH GJI\-STATUS 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-STATUS 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-status \- summarize repository and worktree health
 .SH SYNOPSIS

package/man/man1/gji-sync.1

@@ -1,4 +1,4 @@
-.TH GJI\-SYNC 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-SYNC 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-sync \- fetch and update one or all worktrees
 .SH SYNOPSIS

package/man/man1/gji-trigger-hook.1

@@ -1,4 +1,4 @@
-.TH GJI\-TRIGGER\-HOOK 1 "May 2026" "gji 0.5.0" "User Commands"
+.TH GJI\-TRIGGER\-HOOK 1 "May 2026" "gji 0.6.1" "User Commands"
 .SH NAME
 gji\-trigger\-hook \- run a named hook (afterCreate, afterEnter, beforeRemove) in the current worktree
 .SH SYNOPSIS

package/man/man1/gji-warp.1

@@ -0,0 +1,19 @@
+.TH GJI\-WARP 1 "May 2026" "gji 0.6.1" "User Commands"
+.SH NAME
+gji\-warp \- jump to any worktree across all known repos
+.SH SYNOPSIS
+.B gji warp [\fIoptions\fR] [options] [branch]
+.SH DESCRIPTION
+jump to any worktree across all known repos
+.SH OPTIONS
+.TP
+.B \-n, \-\-new [branch]
+create a new worktree in a registered repo
+.TP
+.B \-\-print
+print the resolved worktree path without changing directory
+.TP
+.B \-\-json
+emit JSON on success or error instead of human\-readable output
+.SH "SEE ALSO"
+.BR gji (1)