@solaqua/gji 0.8.1 → 0.9.0

package/dist/gji-bundle.mjs

@@ -3462,10 +3462,10 @@ var require_commander = __commonJS({
 // node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
 var require_polyfills = __commonJS({
   "node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports, module) {
-    var constants2 = __require("constants");
+    var constants6 = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
-    var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    var platform3 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
       if (!cwd)
         cwd = origCwd.call(process);
@@ -3486,7 +3486,7 @@ var require_polyfills = __commonJS({
     var chdir;
     module.exports = patch;
     function patch(fs5) {
-      if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      if (constants6.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
         patchLchmod(fs5);
       }
       if (!fs5.lutimes) {
@@ -3524,9 +3524,9 @@ var require_polyfills = __commonJS({
         fs5.lchownSync = function() {
         };
       }
-      if (platform2 === "win32") {
+      if (platform3 === "win32") {
         fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
-          function rename(from, to, cb) {
+          function rename2(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
@@ -3546,8 +3546,8 @@ var require_polyfills = __commonJS({
               if (cb) cb(er);
             });
           }
-          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
-          return rename;
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename2, fs$rename);
+          return rename2;
         })(fs5.rename);
       }
       fs5.read = typeof fs5.read !== "function" ? fs5.read : (function(fs$read) {
@@ -3588,7 +3588,7 @@ var require_polyfills = __commonJS({
         fs6.lchmod = function(path9, mode, callback) {
           fs6.open(
             path9,
-            constants2.O_WRONLY | constants2.O_SYMLINK,
+            constants6.O_WRONLY | constants6.O_SYMLINK,
             mode,
             function(err, fd) {
               if (err) {
@@ -3604,7 +3604,7 @@ var require_polyfills = __commonJS({
           );
         };
         fs6.lchmodSync = function(path9, mode) {
-          var fd = fs6.openSync(path9, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
+          var fd = fs6.openSync(path9, constants6.O_WRONLY | constants6.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -3624,9 +3624,9 @@ var require_polyfills = __commonJS({
         };
       }
       function patchLutimes(fs6) {
-        if (constants2.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+        if (constants6.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
           fs6.lutimes = function(path9, at, mt, cb) {
-            fs6.open(path9, constants2.O_SYMLINK, function(er, fd) {
+            fs6.open(path9, constants6.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -3639,7 +3639,7 @@ var require_polyfills = __commonJS({
             });
           };
           fs6.lutimesSync = function(path9, at, mt) {
-            var fd = fs6.openSync(path9, constants2.O_SYMLINK);
+            var fd = fs6.openSync(path9, constants6.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -3951,8 +3951,8 @@ var require_graceful_fs = __commonJS({
       fs6.createReadStream = createReadStream;
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile5;
-      function readFile5(path9, options, cb) {
+      fs6.readFile = readFile6;
+      function readFile6(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path9, options, cb);
@@ -5386,7 +5386,7 @@ var require_minimist = __commonJS({
 var require_rc = __commonJS({
   "node_modules/.pnpm/rc@1.2.8/node_modules/rc/index.js"(exports, module) {
     var cc = require_utils();
-    var join10 = __require("path").join;
+    var join11 = __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)
         [
-          join10(etc, name, "config"),
-          join10(etc, name + "rc")
+          join11(etc, name, "config"),
+          join11(etc, name + "rc")
         ].forEach(addConfigFile);
       if (home)
         [
-          join10(home, ".config", name, "config"),
-          join10(home, ".config", name),
-          join10(home, "." + name, "config"),
-          join10(home, "." + name + "rc")
+          join11(home, ".config", name, "config"),
+          join11(home, ".config", name),
+          join11(home, "." + name, "config"),
+          join11(home, "." + name + "rc")
         ].forEach(addConfigFile);
       addConfigFile(cc.find("." + name + "rc"));
       if (env5.config) addConfigFile(env5.config);
@@ -5436,10 +5436,10 @@ var require_rc = __commonJS({
 // node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js
 var require_polyfills2 = __commonJS({
   "node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js"(exports, module) {
-    var constants2 = __require("constants");
+    var constants6 = __require("constants");
     var origCwd = process.cwd;
     var cwd = null;
-    var platform2 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    var platform3 = process.env.GRACEFUL_FS_PLATFORM || process.platform;
     process.cwd = function() {
       if (!cwd)
         cwd = origCwd.call(process);
@@ -5460,7 +5460,7 @@ var require_polyfills2 = __commonJS({
     var chdir;
     module.exports = patch;
     function patch(fs5) {
-      if (constants2.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      if (constants6.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
         patchLchmod(fs5);
       }
       if (!fs5.lutimes) {
@@ -5498,9 +5498,9 @@ var require_polyfills2 = __commonJS({
         fs5.lchownSync = function() {
         };
       }
-      if (platform2 === "win32") {
+      if (platform3 === "win32") {
         fs5.rename = typeof fs5.rename !== "function" ? fs5.rename : (function(fs$rename) {
-          function rename(from, to, cb) {
+          function rename2(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
@@ -5520,8 +5520,8 @@ var require_polyfills2 = __commonJS({
               if (cb) cb(er);
             });
           }
-          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
-          return rename;
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename2, fs$rename);
+          return rename2;
         })(fs5.rename);
       }
       fs5.read = typeof fs5.read !== "function" ? fs5.read : (function(fs$read) {
@@ -5562,7 +5562,7 @@ var require_polyfills2 = __commonJS({
         fs6.lchmod = function(path9, mode, callback) {
           fs6.open(
             path9,
-            constants2.O_WRONLY | constants2.O_SYMLINK,
+            constants6.O_WRONLY | constants6.O_SYMLINK,
             mode,
             function(err, fd) {
               if (err) {
@@ -5578,7 +5578,7 @@ var require_polyfills2 = __commonJS({
           );
         };
         fs6.lchmodSync = function(path9, mode) {
-          var fd = fs6.openSync(path9, constants2.O_WRONLY | constants2.O_SYMLINK, mode);
+          var fd = fs6.openSync(path9, constants6.O_WRONLY | constants6.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -5598,9 +5598,9 @@ var require_polyfills2 = __commonJS({
         };
       }
       function patchLutimes(fs6) {
-        if (constants2.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
+        if (constants6.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
           fs6.lutimes = function(path9, at, mt, cb) {
-            fs6.open(path9, constants2.O_SYMLINK, function(er, fd) {
+            fs6.open(path9, constants6.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -5613,7 +5613,7 @@ var require_polyfills2 = __commonJS({
             });
           };
           fs6.lutimesSync = function(path9, at, mt) {
-            var fd = fs6.openSync(path9, constants2.O_SYMLINK);
+            var fd = fs6.openSync(path9, constants6.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -5925,8 +5925,8 @@ var require_graceful_fs2 = __commonJS({
       fs6.createReadStream = createReadStream;
       fs6.createWriteStream = createWriteStream;
       var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile5;
-      function readFile5(path9, options, cb) {
+      fs6.readFile = readFile6;
+      function readFile6(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path9, options, cb);
@@ -6757,11 +6757,11 @@ var require_util = __commonJS({
           if (files.includes("node_modules") || files.includes("package.json") || files.includes("package.json5") || files.includes("package.yaml") || files.includes("pnpm-workspace.yaml")) {
             return name2;
           }
-          const dirname9 = path9.dirname(name2);
-          if (dirname9 === name2) {
+          const dirname10 = path9.dirname(name2);
+          if (dirname10 === name2) {
             return original;
           }
-          return find(dirname9, original);
+          return find(dirname10, original);
         } catch (error) {
           if (name2 === original) {
             if (error.code === "ENOENT") {
@@ -7950,20 +7950,20 @@ var require_range = __commonJS({
     };
     var replaceTilde = (comp, options) => {
       const r2 = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-      return comp.replace(r2, (_3, M2, m2, p2, pr) => {
-        debug("tilde", comp, _3, M2, m2, p2, pr);
+      return comp.replace(r2, (_3, M3, m2, p2, pr) => {
+        debug("tilde", comp, _3, M3, m2, p2, pr);
         let ret;
-        if (isX(M2)) {
+        if (isX(M3)) {
           ret = "";
         } else if (isX(m2)) {
-          ret = `>=${M2}.0.0 <${+M2 + 1}.0.0-0`;
+          ret = `>=${M3}.0.0 <${+M3 + 1}.0.0-0`;
         } else if (isX(p2)) {
-          ret = `>=${M2}.${m2}.0 <${M2}.${+m2 + 1}.0-0`;
+          ret = `>=${M3}.${m2}.0 <${M3}.${+m2 + 1}.0-0`;
         } else if (pr) {
           debug("replaceTilde pr", pr);
-          ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${+m2 + 1}.0-0`;
+          ret = `>=${M3}.${m2}.${p2}-${pr} <${M3}.${+m2 + 1}.0-0`;
         } else {
-          ret = `>=${M2}.${m2}.${p2} <${M2}.${+m2 + 1}.0-0`;
+          ret = `>=${M3}.${m2}.${p2} <${M3}.${+m2 + 1}.0-0`;
         }
         debug("tilde return", ret);
         return ret;
@@ -7976,40 +7976,40 @@ var require_range = __commonJS({
       debug("caret", comp, options);
       const r2 = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
       const z2 = options.includePrerelease ? "-0" : "";
-      return comp.replace(r2, (_3, M2, m2, p2, pr) => {
-        debug("caret", comp, _3, M2, m2, p2, pr);
+      return comp.replace(r2, (_3, M3, m2, p2, pr) => {
+        debug("caret", comp, _3, M3, m2, p2, pr);
         let ret;
-        if (isX(M2)) {
+        if (isX(M3)) {
           ret = "";
         } else if (isX(m2)) {
-          ret = `>=${M2}.0.0${z2} <${+M2 + 1}.0.0-0`;
+          ret = `>=${M3}.0.0${z2} <${+M3 + 1}.0.0-0`;
         } else if (isX(p2)) {
-          if (M2 === "0") {
-            ret = `>=${M2}.${m2}.0${z2} <${M2}.${+m2 + 1}.0-0`;
+          if (M3 === "0") {
+            ret = `>=${M3}.${m2}.0${z2} <${M3}.${+m2 + 1}.0-0`;
           } else {
-            ret = `>=${M2}.${m2}.0${z2} <${+M2 + 1}.0.0-0`;
+            ret = `>=${M3}.${m2}.0${z2} <${+M3 + 1}.0.0-0`;
           }
         } else if (pr) {
           debug("replaceCaret pr", pr);
-          if (M2 === "0") {
+          if (M3 === "0") {
             if (m2 === "0") {
-              ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${m2}.${+p2 + 1}-0`;
+              ret = `>=${M3}.${m2}.${p2}-${pr} <${M3}.${m2}.${+p2 + 1}-0`;
             } else {
-              ret = `>=${M2}.${m2}.${p2}-${pr} <${M2}.${+m2 + 1}.0-0`;
+              ret = `>=${M3}.${m2}.${p2}-${pr} <${M3}.${+m2 + 1}.0-0`;
             }
           } else {
-            ret = `>=${M2}.${m2}.${p2}-${pr} <${+M2 + 1}.0.0-0`;
+            ret = `>=${M3}.${m2}.${p2}-${pr} <${+M3 + 1}.0.0-0`;
           }
         } else {
           debug("no pr");
-          if (M2 === "0") {
+          if (M3 === "0") {
             if (m2 === "0") {
-              ret = `>=${M2}.${m2}.${p2}${z2} <${M2}.${m2}.${+p2 + 1}-0`;
+              ret = `>=${M3}.${m2}.${p2}${z2} <${M3}.${m2}.${+p2 + 1}-0`;
             } else {
-              ret = `>=${M2}.${m2}.${p2}${z2} <${M2}.${+m2 + 1}.0-0`;
+              ret = `>=${M3}.${m2}.${p2}${z2} <${M3}.${+m2 + 1}.0-0`;
             }
           } else {
-            ret = `>=${M2}.${m2}.${p2} <${+M2 + 1}.0.0-0`;
+            ret = `>=${M3}.${m2}.${p2} <${+M3 + 1}.0.0-0`;
           }
         }
         debug("caret return", ret);
@@ -8023,9 +8023,9 @@ var require_range = __commonJS({
     var replaceXRange = (comp, options) => {
       comp = comp.trim();
       const r2 = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
-      return comp.replace(r2, (ret, gtlt, M2, m2, p2, pr) => {
-        debug("xRange", comp, ret, gtlt, M2, m2, p2, pr);
-        const xM = isX(M2);
+      return comp.replace(r2, (ret, gtlt, M3, m2, p2, pr) => {
+        debug("xRange", comp, ret, gtlt, M3, m2, p2, pr);
+        const xM = isX(M3);
         const xm = xM || isX(m2);
         const xp = xm || isX(p2);
         const anyX = xp;
@@ -8047,7 +8047,7 @@ var require_range = __commonJS({
           if (gtlt === ">") {
             gtlt = ">=";
             if (xm) {
-              M2 = +M2 + 1;
+              M3 = +M3 + 1;
               m2 = 0;
               p2 = 0;
             } else {
@@ -8057,7 +8057,7 @@ var require_range = __commonJS({
           } else if (gtlt === "<=") {
             gtlt = "<";
             if (xm) {
-              M2 = +M2 + 1;
+              M3 = +M3 + 1;
             } else {
               m2 = +m2 + 1;
             }
@@ -8065,11 +8065,11 @@ var require_range = __commonJS({
           if (gtlt === "<") {
             pr = "-0";
           }
-          ret = `${gtlt + M2}.${m2}.${p2}${pr}`;
+          ret = `${gtlt + M3}.${m2}.${p2}${pr}`;
         } else if (xm) {
-          ret = `>=${M2}.0.0${pr} <${+M2 + 1}.0.0-0`;
+          ret = `>=${M3}.0.0${pr} <${+M3 + 1}.0.0-0`;
         } else if (xp) {
-          ret = `>=${M2}.${m2}.0${pr} <${M2}.${+m2 + 1}.0-0`;
+          ret = `>=${M3}.${m2}.0${pr} <${M3}.${+m2 + 1}.0-0`;
         }
         debug("xRange return", ret);
         return ret;
@@ -8729,7 +8729,7 @@ var require_semver2 = __commonJS({
   "node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js"(exports, module) {
     "use strict";
     var internalRe = require_re();
-    var constants2 = require_constants();
+    var constants6 = require_constants();
     var SemVer = require_semver();
     var identifiers = require_identifiers();
     var parse = require_parse();
@@ -8811,8 +8811,8 @@ var require_semver2 = __commonJS({
       re: internalRe.re,
       src: internalRe.src,
       tokens: internalRe.t,
-      SEMVER_SPEC_VERSION: constants2.SEMVER_SPEC_VERSION,
-      RELEASE_TYPES: constants2.RELEASE_TYPES,
+      SEMVER_SPEC_VERSION: constants6.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants6.RELEASE_TYPES,
       compareIdentifiers: identifiers.compareIdentifiers,
       rcompareIdentifiers: identifiers.rcompareIdentifiers
     };
@@ -9422,7 +9422,7 @@ var require_picocolors = __commonJS({
 });
 
 // src/index.ts
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 
 // src/cli.ts
 import { createRequire } from "node:module";
@@ -9781,14 +9781,14 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename9 = path2.basename(filePath);
-    if (basename9.length <= LIMIT_BASENAME_LENGTH)
+    const basename10 = path2.basename(filePath);
+    if (basename10.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
-    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename9);
+    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename10);
     if (!truncable)
       return filePath;
-    const truncationLength = basename9.length - LIMIT_BASENAME_LENGTH;
-    return `${filePath.slice(0, -basename9.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
+    const truncationLength = basename10.length - LIMIT_BASENAME_LENGTH;
+    return `${filePath.slice(0, -basename10.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
   }
 };
 node_default(Temp.purgeSyncAll);
@@ -14000,6 +14000,29 @@ ${import_picocolors2.default.gray(d2)}  ${t}
 
 `);
 };
+var M2 = { message: (t = "", { symbol: n = import_picocolors2.default.gray(o) } = {}) => {
+  const r2 = [`${import_picocolors2.default.gray(o)}`];
+  if (t) {
+    const [i, ...s] = t.split(`
+`);
+    r2.push(`${n}  ${i}`, ...s.map((c) => `${import_picocolors2.default.gray(o)}  ${c}`));
+  }
+  process.stdout.write(`${r2.join(`
+`)}
+`);
+}, info: (t) => {
+  M2.message(t, { symbol: import_picocolors2.default.blue(q) });
+}, success: (t) => {
+  M2.message(t, { symbol: import_picocolors2.default.green(D) });
+}, step: (t) => {
+  M2.message(t, { symbol: import_picocolors2.default.green(C) });
+}, warn: (t) => {
+  M2.message(t, { symbol: import_picocolors2.default.yellow(U) });
+}, warning: (t) => {
+  M2.warn(t);
+}, error: (t) => {
+  M2.message(t, { symbol: import_picocolors2.default.red(K2) });
+} };
 var J2 = `${import_picocolors2.default.gray(o)}  `;
 
 // src/headless.ts
@@ -14197,16 +14220,394 @@ function hasStderr(error) {
 
 // src/worktree-picker.ts
 import { env as env4, platform, stdin, stdout } from "node:process";
-async function buildWorktreePromptEntries(sources) {
-  const [history, infos] = await Promise.all([
+
+// src/pull-requests.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+var execFileAsync3 = promisify4(execFile3);
+var PULL_REQUEST_QUERY_TIMEOUT_MS = 2500;
+function parsePullRequestRemote(remoteUrl) {
+  const parsed = parseRemoteUrl(remoteUrl.trim());
+  if (parsed === null) return null;
+  const forge = detectForge(parsed.host);
+  if (forge === null) return null;
+  if (forge === "bitbucket" && parsed.host !== "bitbucket.org") return null;
+  const path9 = parsed.path.replace(/^\/+/, "").replace(/\.git$/, "").split("/").filter(Boolean);
+  if (path9.length < 2) return null;
+  if (forge === "gitlab") {
+    const repository2 = path9.at(-1);
+    const namespace2 = path9.slice(0, -1).join("/");
+    if (repository2 === void 0 || namespace2.length === 0) return null;
+    return {
+      forge,
+      host: parsed.host,
+      namespace: namespace2,
+      repository: repository2,
+      webBaseUrl: `https://${parsed.host}`
+    };
+  }
+  const namespace = path9.at(-2);
+  const repository = path9.at(-1);
+  if (namespace === void 0 || repository === void 0) return null;
+  return {
+    forge,
+    host: parsed.host,
+    namespace,
+    repository,
+    webBaseUrl: `https://${parsed.host}`
+  };
+}
+function createPullRequestQuery(dependencies = {}) {
+  const runCommand = dependencies.runCommand ?? defaultRunCommand;
+  const fetcher = dependencies.fetch ?? fetch;
+  return {
+    findOpenPullRequest: (repoRoot, number) => findOpenPullRequest(repoRoot, number, runCommand, fetcher),
+    listOpenPullRequests: (repoRoot, sourceBranch) => listOpenPullRequests(repoRoot, sourceBranch, runCommand, fetcher),
+    listOpenPullRequestsForRepository: (repoRoot) => listOpenPullRequestsForRepository(repoRoot, runCommand, fetcher)
+  };
+}
+async function listOpenPullRequests(repoRoot, sourceBranch, runCommand, fetcher) {
+  const remote = await readPullRequestRemote(repoRoot, runCommand);
+  const cliResult = await queryProviderCli(
+    remote,
+    { kind: "branch", sourceBranch },
+    repoRoot,
+    runCommand
+  );
+  if (cliResult !== null) return sortPullRequests(cliResult);
+  const apiResult = await queryPublicApi(
+    remote,
+    { kind: "branch", sourceBranch },
+    fetcher
+  );
+  return sortPullRequests(apiResult);
+}
+async function listOpenPullRequestsForRepository(repoRoot, runCommand, fetcher) {
+  const remote = await readPullRequestRemote(repoRoot, runCommand);
+  const cliResult = await queryProviderCli(
+    remote,
+    { kind: "repository" },
+    repoRoot,
+    runCommand
+  );
+  if (cliResult !== null) return sortPullRequests(cliResult);
+  const apiResult = await queryPublicApi(
+    remote,
+    { kind: "repository" },
+    fetcher
+  );
+  return sortPullRequests(apiResult);
+}
+async function findOpenPullRequest(repoRoot, number, runCommand, fetcher) {
+  const remote = await readPullRequestRemote(repoRoot, runCommand);
+  const cliResult = await queryProviderCli(
+    remote,
+    { kind: "number", number },
+    repoRoot,
+    runCommand
+  );
+  if (cliResult !== null) return cliResult[0] ?? null;
+  const apiResult = await queryPublicApi(
+    remote,
+    { kind: "number", number },
+    fetcher
+  );
+  return apiResult[0] ?? null;
+}
+async function readPullRequestRemote(repoRoot, runCommand) {
+  const result = await runCommand(
+    "git",
+    ["remote", "get-url", "origin"],
+    commandOptions(repoRoot)
+  );
+  const remote = parsePullRequestRemote(result.stdout);
+  if (remote === null) {
+    throw new Error("origin remote is unsupported or missing");
+  }
+  return remote;
+}
+async function queryProviderCli(remote, query, repoRoot, runCommand) {
+  const providerCommand = providerCliCommand(remote, query);
+  try {
+    const result = await runCommand(
+      providerCommand.command,
+      providerCommand.args,
+      commandOptions(repoRoot)
+    );
+    return parseProviderOutput(remote, result.stdout, query);
+  } catch {
+    return null;
+  }
+}
+async function queryPublicApi(remote, query, fetcher) {
+  const url = publicApiUrl(remote, query);
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(),
+    PULL_REQUEST_QUERY_TIMEOUT_MS
+  );
+  try {
+    const response = await fetcher(url, {
+      headers: { Accept: "application/json" },
+      signal: controller.signal
+    });
+    if (response.status === 404 && query.kind === "number") return [];
+    if (!response.ok) {
+      throw new Error(`public API returned HTTP ${response.status}`);
+    }
+    const payload = await response.json();
+    return parseApiOutput(remote, payload, query);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function parseRemoteUrl(remoteUrl) {
+  const scpMatch = remoteUrl.match(/^[^@]+@([^:]+):(.+)$/);
+  if (scpMatch) {
+    return { host: scpMatch[1].toLowerCase(), path: scpMatch[2] };
+  }
+  try {
+    const url = new URL(remoteUrl);
+    if (!url.hostname) return null;
+    return { host: url.hostname.toLowerCase(), path: url.pathname };
+  } catch {
+    return null;
+  }
+}
+function detectForge(host) {
+  if (host === "github.com" || host.includes("github")) return "github";
+  if (host === "gitlab.com" || host.includes("gitlab")) return "gitlab";
+  if (host === "bitbucket.org" || host.includes("bitbucket")) {
+    return "bitbucket";
+  }
+  return null;
+}
+function providerCliCommand(remote, query) {
+  const coordinate = providerRepositoryCoordinate(remote);
+  const sourceBranch = query.sourceBranch ?? "";
+  switch (remote.forge) {
+    case "github": {
+      if (query.kind === "number") {
+        return {
+          args: [
+            "pr",
+            "view",
+            String(query.number),
+            "--json",
+            "number,url,headRefName,state",
+            "--repo",
+            coordinate
+          ],
+          command: "gh"
+        };
+      }
+      return {
+        args: [
+          "pr",
+          "list",
+          "--state",
+          "open",
+          ...query.kind === "branch" ? ["--head", sourceBranch] : [],
+          "--json",
+          "number,url,headRefName,state",
+          "--limit",
+          "100",
+          "--repo",
+          coordinate
+        ],
+        command: "gh"
+      };
+    }
+    case "gitlab": {
+      if (query.kind === "number") {
+        return {
+          args: [
+            "mr",
+            "view",
+            String(query.number),
+            "--output",
+            "json",
+            "--repo",
+            coordinate
+          ],
+          command: "glab"
+        };
+      }
+      return {
+        args: [
+          "mr",
+          "list",
+          "--state",
+          "opened",
+          ...query.kind === "branch" ? ["--source-branch", sourceBranch] : [],
+          "--output",
+          "json",
+          "--per-page",
+          "100",
+          "--repo",
+          coordinate
+        ],
+        command: "glab"
+      };
+    }
+    case "bitbucket": {
+      if (query.kind === "number") {
+        return {
+          args: [
+            "pr",
+            "view",
+            String(query.number),
+            "--format",
+            "json",
+            "--repo",
+            coordinate
+          ],
+          command: "bb"
+        };
+      }
+      return {
+        args: [
+          "pr",
+          "list",
+          "--state",
+          "OPEN",
+          ...query.kind === "branch" ? ["--source", sourceBranch] : [],
+          "--format",
+          "json",
+          "--repo",
+          coordinate
+        ],
+        command: "bb"
+      };
+    }
+  }
+}
+function providerRepositoryCoordinate(remote) {
+  const coordinate = `${remote.namespace}/${remote.repository}`;
+  return remote.host === "github.com" || remote.host === "bitbucket.org" ? coordinate : `${remote.host}/${coordinate}`;
+}
+function parseProviderOutput(remote, stdout2, query) {
+  const payload = JSON.parse(stdout2);
+  const values = remote.forge === "bitbucket" && isRecord(payload) ? Array.isArray(payload.values) ? payload.values : [] : Array.isArray(payload) ? payload : [payload];
+  return values.map((value) => normalizePullRequest(value, query)).filter((value) => value !== null).filter(
+    (value) => query.kind === "branch" ? value.sourceBranch === query.sourceBranch : query.kind === "number" ? value.number === query.number : true
+  );
+}
+function parseApiOutput(remote, payload, query) {
+  const values = remote.forge === "bitbucket" && isRecord(payload) ? Array.isArray(payload.values) ? payload.values : [] : query.kind === "number" ? [payload] : Array.isArray(payload) ? payload : [];
+  return values.map((value) => normalizePullRequest(value, query)).filter((value) => value !== null).filter(
+    (value) => query.kind === "branch" ? value.sourceBranch === query.sourceBranch : query.kind === "number" ? value.number === query.number : true
+  );
+}
+function normalizePullRequest(value, query) {
+  if (!isRecord(value)) return null;
+  const number = numberValue(value.number ?? value.iid ?? value.id);
+  const head = isRecord(value.head) ? value.head : null;
+  const source = isRecord(value.source) ? value.source : null;
+  const sourceBranch = stringValue(
+    value.headRefName ?? (head !== null ? head.ref : void 0) ?? value.source_branch ?? (source !== null && isRecord(source.branch) ? source.branch.name : void 0)
+  );
+  const url = stringValue(
+    value.html_url ?? value.web_url ?? value.url ?? (isRecord(value.links) && isRecord(value.links.html) ? value.links.html.href : void 0)
+  );
+  const state = stringValue(value.state)?.toLowerCase();
+  if (number === null || url === null) return null;
+  if (query.kind !== "number" && sourceBranch === null) return null;
+  if (query.kind === "number" && number !== query.number) return null;
+  if (state !== void 0 && !["open", "opened"].includes(state)) return null;
+  return {
+    number,
+    sourceBranch: sourceBranch ?? "",
+    url
+  };
+}
+function publicApiUrl(remote, query) {
+  const branch = encodeURIComponent(query.sourceBranch ?? "");
+  const number = query.number === void 0 ? "" : String(query.number);
+  switch (remote.forge) {
+    case "github": {
+      const coordinate = `${encodeURIComponent(remote.namespace)}/${encodeURIComponent(remote.repository)}`;
+      const apiBase = remote.host === "github.com" ? "https://api.github.com" : `https://${remote.host}/api/v3`;
+      if (query.kind === "number") {
+        return `${apiBase}/repos/${coordinate}/pulls/${number}`;
+      }
+      return `${apiBase}/repos/${coordinate}/pulls?state=open&per_page=100`;
+    }
+    case "gitlab": {
+      const project = encodeURIComponent(
+        `${remote.namespace}/${remote.repository}`
+      );
+      if (query.kind === "number") {
+        return `${remote.webBaseUrl}/api/v4/projects/${project}/merge_requests/${number}`;
+      }
+      return query.kind === "branch" ? `${remote.webBaseUrl}/api/v4/projects/${project}/merge_requests?state=opened&source_branch=${branch}&per_page=100` : `${remote.webBaseUrl}/api/v4/projects/${project}/merge_requests?state=opened&per_page=100`;
+    }
+    case "bitbucket": {
+      const coordinate = `${encodeURIComponent(remote.namespace)}/${encodeURIComponent(remote.repository)}`;
+      if (query.kind === "number") {
+        return `https://api.bitbucket.org/2.0/repositories/${coordinate}/pullrequests/${number}`;
+      }
+      return query.kind === "branch" ? `https://api.bitbucket.org/2.0/repositories/${coordinate}/pullrequests?state=OPEN&source.branch.name=${branch}&pagelen=100` : `https://api.bitbucket.org/2.0/repositories/${coordinate}/pullrequests?state=OPEN&pagelen=100`;
+    }
+  }
+}
+function sortPullRequests(pullRequests) {
+  return [...pullRequests].sort((a, b3) => a.number - b3.number);
+}
+function commandOptions(cwd) {
+  return {
+    cwd,
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GH_PROMPT_DISABLED: "1",
+      GLAB_NON_INTERACTIVE: "1"
+    },
+    timeout: PULL_REQUEST_QUERY_TIMEOUT_MS
+  };
+}
+async function defaultRunCommand(command, args, options) {
+  return execFileAsync3(command, args, options);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function numberValue(value) {
+  if (typeof value === "number" && Number.isInteger(value)) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
+  return null;
+}
+
+// src/worktree-picker.ts
+var MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY = 4;
+async function buildWorktreePromptEntries(sources, dependencies = {}) {
+  const pullRequestQuery = createPullRequestQuery();
+  const queryPullRequests = dependencies.queryPullRequests ?? pullRequestQuery.listOpenPullRequests;
+  const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ?? (dependencies.queryPullRequests === void 0 ? pullRequestQuery.listOpenPullRequestsForRepository : void 0);
+  const repositoryPullRequests = queryRepositoryPullRequests === void 0 ? Promise.resolve(null) : readRepositoryPullRequests(sources, queryRepositoryPullRequests);
+  const [history, infos, pullRequestsByRepository] = await Promise.all([
     loadHistory(),
-    readWorktreeInfos(sources.map((source) => source.worktree))
+    readWorktreeInfos(sources.map((source) => source.worktree)),
+    repositoryPullRequests
   ]);
+  const pullRequests = await Promise.all(
+    sources.map(
+      (source) => readSourcePullRequests(
+        source,
+        queryPullRequests,
+        pullRequestsByRepository
+      )
+    )
+  );
   const historyByPath = new Map(history.map((entry) => [entry.path, entry]));
   const entries = sources.map(
     (source, index) => buildWorktreePromptEntry(
       source,
       infos[index],
+      pullRequests[index],
       historyByPath.get(source.worktree.path)?.timestamp ?? null,
       Date.now()
     )
@@ -14304,7 +14705,10 @@ function buildSearchableWorktreeEntry(worktree) {
     searchText: buildPromptSearchText(worktree),
     value: worktree.path,
     worktree: {
-      branch,
+      branch: formatWorktreeBranchLabel(
+        worktree.branch,
+        worktree.pullRequestNumbers
+      ),
       metadata,
       path: worktree.path,
       repoName: worktree.repoName
@@ -14886,14 +15290,19 @@ function buildPromptSearchText(worktree) {
     worktree.branch ?? "detached",
     worktree.path,
     worktree.label,
-    `${worktree.repoName}/${worktree.branch ?? "detached"}`
+    `${worktree.repoName}/${worktree.branch ?? "detached"}`,
+    ...(worktree.pullRequestNumbers ?? []).map((number) => `#${number}`),
+    ...worktree.pullRequestUrls ?? []
   ].join(" ").toLowerCase();
 }
-function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
+function buildWorktreePromptEntry(source, info, pullRequests, lastUsedTimestamp, now) {
   const lastWorkedTimestamp = info.lastCommitTimestamp === null ? null : info.lastCommitTimestamp * 1e3;
   const lastActivityTimestamp = lastUsedTimestamp ?? lastWorkedTimestamp;
   const lastActivityType = lastUsedTimestamp !== null ? "used" : lastWorkedTimestamp !== null ? "worked" : null;
-  const branch = source.worktree.branch ?? "(detached)";
+  const branch = formatWorktreeBranchLabel(
+    source.worktree.branch,
+    pullRequests.map((pullRequest) => pullRequest.number)
+  );
   const badges = buildStatusBadges(info);
   const recency = formatPromptRecency(
     lastActivityTimestamp,
@@ -14918,9 +15327,80 @@ function buildWorktreePromptEntry(source, info, lastUsedTimestamp, now) {
     label,
     lastActivityTimestamp,
     metadata,
+    pullRequestNumbers: pullRequests.map((pullRequest) => pullRequest.number),
+    pullRequestUrls: pullRequests.map((pullRequest) => pullRequest.url),
     repoName: source.repoName
   };
 }
+async function readSourcePullRequests(source, queryPullRequests, pullRequestsByRepository) {
+  if (source.repoRoot === void 0 || source.worktree.branch === null) {
+    return [];
+  }
+  if (pullRequestsByRepository !== null) {
+    return sortSourcePullRequests(
+      pullRequestsByRepository.get(source.repoRoot)?.filter(
+        (pullRequest) => pullRequest.sourceBranch === source.worktree.branch
+      )
+    );
+  }
+  try {
+    const pullRequests = await queryPullRequests(
+      source.repoRoot,
+      source.worktree.branch
+    );
+    return sortSourcePullRequests(pullRequests);
+  } catch {
+    return [];
+  }
+}
+async function readRepositoryPullRequests(sources, queryPullRequests) {
+  const repoRoots = [
+    ...new Set(
+      sources.flatMap(
+        (source) => source.repoRoot === void 0 || source.worktree.branch === null ? [] : [source.repoRoot]
+      )
+    )
+  ];
+  const results = await mapWithConcurrency2(
+    repoRoots,
+    MAX_PULL_REQUEST_REPOSITORY_QUERY_CONCURRENCY,
+    async (repoRoot) => {
+      try {
+        return [
+          repoRoot,
+          sortSourcePullRequests(await queryPullRequests(repoRoot))
+        ];
+      } catch {
+        return [repoRoot, []];
+      }
+    }
+  );
+  return new Map(results);
+}
+async function mapWithConcurrency2(items, limit, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  async function readNext() {
+    for (; ; ) {
+      const index = nextIndex;
+      nextIndex += 1;
+      if (index >= items.length) return;
+      results[index] = await mapper(items[index]);
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, () => readNext())
+  );
+  return results;
+}
+function sortSourcePullRequests(pullRequests) {
+  return [...pullRequests ?? []].sort((a, b3) => a.number - b3.number);
+}
+function formatWorktreeBranchLabel(branch, pullRequestNumbers = []) {
+  const branchLabel = branch ?? "(detached)";
+  if (pullRequestNumbers.length === 0) return branchLabel;
+  return `${branchLabel} (${pullRequestNumbers.map((number) => `#${number}`).join(", ")})`;
+}
 function buildStatusBadges(info) {
   const badges = [];
   if (info.isCurrent) {
@@ -15442,7 +15922,14 @@ var TOP_LEVEL_COMMANDS = [
     name: "new",
     description: "create a new branch or detached linked worktree"
   },
-  { name: "init", description: "print or install shell integration" },
+  {
+    name: "init",
+    description: "set up shell integration interactively or print a shell wrapper"
+  },
+  {
+    name: "doctor",
+    description: "check gji installation and configuration health"
+  },
   { 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" },
@@ -15495,6 +15982,70 @@ function renderBashCompletion() {
   command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 }
 
+__gji_pr_targets_cache=""
+__gji_pr_targets_cache_at=0
+__gji_pr_targets_cache_loaded=0
+__gji_pr_targets_cache_repo=""
+
+__gji_run_bounded() {
+  local output_file pid status attempt
+  output_file=$(mktemp "\${TMPDIR:-/tmp}/gji-completion.XXXXXX") || return 124
+  "$@" >"$output_file" 2>/dev/null &
+  pid=$!
+  for ((attempt = 0; attempt < 20; attempt++)); do
+    if ! kill -0 "$pid" 2>/dev/null; then
+      wait "$pid"
+      status=$?
+      cat "$output_file"
+      rm -f "$output_file"
+      return "$status"
+    fi
+    sleep 0.1
+  done
+  kill "$pid" 2>/dev/null
+  wait "$pid" 2>/dev/null
+  rm -f "$output_file"
+  return 124
+}
+
+__gji_pr_targets() {
+  local now repo_key branches targets
+  now=$(date +%s)
+  repo_key=$(command git rev-parse --show-toplevel 2>/dev/null)
+  if [ "$__gji_pr_targets_cache_loaded" -eq 1 ] && [ "$repo_key" = "$__gji_pr_targets_cache_repo" ] && [ "$((now - __gji_pr_targets_cache_at))" -lt 30 ]; then
+    printf '%s
+' "$__gji_pr_targets_cache"
+    return
+  fi
+
+  branches="$(__gji_worktree_branches)"
+  targets=""
+  if [ -n "$repo_key" ] && command -v gh >/dev/null 2>&1; then
+    targets=$(__gji_run_bounded env GH_PROMPT_DISABLED=1 gh pr list --state open --json number --limit 100 |
+      tr '{},' '\\n' | sed -n 's/.*"number":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')
+  elif [ -n "$repo_key" ] && command -v glab >/dev/null 2>&1; then
+    targets=$(__gji_run_bounded env GLAB_NON_INTERACTIVE=1 glab mr list --state opened --output json --per-page 100 |
+      tr '{},' '\\n' | sed -n 's/.*"iid":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')
+  elif [ -n "$repo_key" ] && command -v bb >/dev/null 2>&1; then
+    targets=$(__gji_run_bounded bb pr list --state OPEN --format json |
+      tr '{},' '\\n' | sed -n 's/.*"id":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')
+  fi
+
+  __gji_pr_targets_cache="$branches"
+  if [ -n "$targets" ]; then
+    if [ -n "$__gji_pr_targets_cache" ]; then
+      __gji_pr_targets_cache+=$'
+'
+    fi
+    __gji_pr_targets_cache+="$targets"
+  fi
+  __gji_pr_targets_cache_at="$now"
+  __gji_pr_targets_cache_loaded=1
+  __gji_pr_targets_cache_repo="$repo_key"
+  printf '%s
+' "$__gji_pr_targets_cache"
+}
+
 _gji_completion() {
   local cur command_name
   COMPREPLY=()
@@ -15512,13 +16063,37 @@ _gji_completion() {
       COMPREPLY=( $(compgen -W "--detached --force --open --editor --dry-run --json --help" -- "$cur") )
       ;;
     init)
-      COMPREPLY=( $(compgen -W "${shells} --write --help" -- "$cur") )
+      COMPREPLY=( $(compgen -W "${shells} --write --json --help" -- "$cur") )
+      ;;
+    doctor)
+      COMPREPLY=( $(compgen -W "--fix --yes --json --help" -- "$cur") )
       ;;
     completion)
       COMPREPLY=( $(compgen -W "${shells} --help" -- "$cur") )
       ;;
     pr)
-      COMPREPLY=( $(compgen -W "--dry-run --json --help" -- "$cur") )
+      if [ "$COMP_CWORD" -eq 2 ]; then
+        COMPREPLY=( $(compgen -W "open --dry-run --json --help" -- "$cur") )
+      elif [ "\${COMP_WORDS[2]}" = "open" ]; then
+        local has_select=0 has_target=0 word
+        for word in "\${COMP_WORDS[@]:3:$((COMP_CWORD - 3))}"; do
+          if [ "$word" = "--select" ]; then has_select=1; fi
+          if [[ "$word" != -* && "$word" != "" ]]; then has_target=1; fi
+        done
+        if [[ "$cur" == -* ]]; then
+          if [[ "$has_select" -eq 1 || "$has_target" -eq 1 ]]; then
+            COMPREPLY=( $(compgen -W "--help" -- "$cur") )
+          else
+            COMPREPLY=( $(compgen -W "--select --help" -- "$cur") )
+          fi
+        elif [[ "$has_select" -eq 1 || "$has_target" -eq 1 ]]; then
+          COMPREPLY=()
+        else
+          COMPREPLY=( $(compgen -W "$(__gji_pr_targets) --select --help" -- "$cur") )
+        fi
+      else
+        COMPREPLY=( $(compgen -W "--dry-run --json --help" -- "$cur") )
+      fi
       ;;
     back)
       COMPREPLY=( $(compgen -W "--print --help" -- "$cur") )
@@ -15603,6 +16178,103 @@ function renderFishCompletion() {
     command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 end
 
+set -g __gji_pr_targets_cache
+set -g __gji_pr_targets_cache_at 0
+set -g __gji_pr_targets_cache_loaded 0
+set -g __gji_pr_targets_cache_repo
+
+function __gji_run_bounded
+    set -l output_file (mktemp "$TMPDIR/gji-completion.XXXXXX" 2>/dev/null)
+    if test -z "$output_file"
+        set output_file (mktemp "/tmp/gji-completion.XXXXXX" 2>/dev/null)
+    end
+    if test -z "$output_file"
+        return 124
+    end
+
+    command $argv >$output_file 2>/dev/null &
+    set -l pid $last_pid
+    for attempt in (seq 1 20)
+        if not kill -0 $pid 2>/dev/null
+            wait $pid
+            set -l exit_status $status
+            command cat $output_file
+            command rm -f $output_file
+            return $exit_status
+        end
+        sleep 0.1
+    end
+    kill $pid 2>/dev/null
+    wait $pid 2>/dev/null
+    command rm -f $output_file
+    return 124
+end
+
+function __gji_pr_targets
+    set -l now (date +%s)
+    set -l repo_key (command git rev-parse --show-toplevel 2>/dev/null)
+    if test $__gji_pr_targets_cache_loaded -eq 1; and test "$repo_key" = "$__gji_pr_targets_cache_repo"; and test (math $now - $__gji_pr_targets_cache_at) -lt 30
+        printf '%s
+' $__gji_pr_targets_cache
+        return
+    end
+
+    set -l branches (__gji_worktree_branches)
+    set -l targets
+    if test -n "$repo_key"; and command -q gh
+        set targets (__gji_run_bounded env GH_PROMPT_DISABLED=1 gh pr list --state open --json number --limit 100 |
+            string replace -a -r '[{},]' '\\n' |
+            string match -r '"number"[[:space:]]*:[[:space:]]*[0-9]+' | string replace -r '.*:[[:space:]]*' '')
+    else if test -n "$repo_key"; and command -q glab
+        set targets (__gji_run_bounded env GLAB_NON_INTERACTIVE=1 glab mr list --state opened --output json --per-page 100 |
+            string replace -a -r '[{},]' '\\n' |
+            string match -r '"iid"[[:space:]]*:[[:space:]]*[0-9]+' | string replace -r '.*:[[:space:]]*' '')
+    else if test -n "$repo_key"; and command -q bb
+        set targets (__gji_run_bounded bb pr list --state OPEN --format json |
+            string replace -a -r '[{},]' '\\n' |
+            string match -r '"id"[[:space:]]*:[[:space:]]*[0-9]+' | string replace -r '.*:[[:space:]]*' '')
+    end
+
+    set -g __gji_pr_targets_cache $branches $targets
+    set -g __gji_pr_targets_cache_at $now
+    set -g __gji_pr_targets_cache_loaded 1
+    set -g __gji_pr_targets_cache_repo $repo_key
+    printf '%s
+' $__gji_pr_targets_cache
+end
+
+function __gji_should_complete_pr_select
+    set -l tokens (commandline -opc)
+    if test (count $tokens) -lt 3; or test $tokens[2] != pr; or test $tokens[3] != open
+        return 1
+    end
+    for token in $tokens[4..-1]
+        if test $token = --select; or not string match -q -- '-*' $token
+            return 1
+        end
+    end
+    return 0
+end
+
+function __gji_should_complete_pr_target
+    set -l tokens (commandline -opc)
+    if test (count $tokens) -lt 3; or test $tokens[2] != pr; or test $tokens[3] != open
+        return 1
+    end
+    if string match -q -- '-*' (commandline -ct)
+        return 1
+    end
+    for token in $tokens[4..-1]
+        if test $token = --select
+            return 1
+        end
+        if not string match -q -- '-*' $token
+            return 1
+        end
+    end
+    return 0
+end
+
 function __gji_should_complete_config_action
     set -l tokens (commandline -opc)
     test (count $tokens) -eq 2
@@ -15632,14 +16304,22 @@ complete -c gji -n '__fish_seen_subcommand_from new' -l dry-run -d 'show what wo
 complete -c gji -n '__fish_seen_subcommand_from new' -l json -d 'emit JSON on success or error instead of human-readable output'
 
 complete -c gji -n '__fish_seen_subcommand_from init' -l write -d 'write the integration to the shell config file'
+complete -c gji -n '__fish_seen_subcommand_from init' -l json -d 'emit a JSON error in non-interactive mode'
 ${shellLines}
 
+complete -c gji -n '__fish_seen_subcommand_from doctor' -l fix -d 'apply safe automatic fixes after showing the plan'
+complete -c gji -n '__fish_seen_subcommand_from doctor' -l yes -d 'apply --fix without prompting'
+complete -c gji -n '__fish_seen_subcommand_from doctor' -l json -d 'emit diagnostic checks as JSON'
+
 complete -c gji -n '__fish_seen_subcommand_from completion' -a 'bash' -d 'shell'
 complete -c gji -n '__fish_seen_subcommand_from completion' -a 'fish' -d 'shell'
 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 pr; and test (commandline -opc)[3] != open' -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; and test (commandline -opc)[3] != open' -l json -d 'emit JSON on success or error instead of human-readable output'
+complete -c gji -n '__fish_seen_subcommand_from pr' -a 'open' -d 'open a pull request in the default browser'
+complete -c gji -n '__gji_should_complete_pr_select' -l select -d 'choose a pull request from any linked worktree'
+complete -c gji -n '__gji_should_complete_pr_target' -a '(__gji_pr_targets)' -d 'branch or PR number'
 
 complete -c gji -n '__fish_seen_subcommand_from back' -l print -d 'print the resolved worktree path explicitly'
 
@@ -15701,15 +16381,71 @@ __gji_worktree_branches() {
   command gji ls --compact 2>/dev/null | awk 'NR > 1 { branch = ($1 == "*" ? $2 : $1); if (branch != "(detached)") print branch }'
 }
 
+typeset -g __gji_pr_targets_cache=()
+typeset -g __gji_pr_targets_cache_at=0
+typeset -g __gji_pr_targets_cache_loaded=0
+typeset -g __gji_pr_targets_cache_repo=""
+
+__gji_run_bounded() {
+  local output_file pid status attempt
+  output_file=$(mktemp "\${TMPDIR:-/tmp}/gji-completion.XXXXXX") || return 124
+  "$@" >"$output_file" 2>/dev/null &
+  pid=$!
+  for ((attempt = 0; attempt < 20; attempt++)); do
+    if ! kill -0 "$pid" 2>/dev/null; then
+      wait "$pid"
+      status=$?
+      cat "$output_file"
+      rm -f "$output_file"
+      return "$status"
+    fi
+    sleep 0.1
+  done
+  kill "$pid" 2>/dev/null
+  wait "$pid" 2>/dev/null
+  rm -f "$output_file"
+  return 124
+}
+
+__gji_pr_targets() {
+  local now repo_key
+  local -a branches targets
+  now=$(date +%s)
+  repo_key=$(command git rev-parse --show-toplevel 2>/dev/null)
+  if (( __gji_pr_targets_cache_loaded == 1 && "\${repo_key}" == "\${__gji_pr_targets_cache_repo}" && now - __gji_pr_targets_cache_at < 30 )); then
+    print -rl -- "\${__gji_pr_targets_cache[@]}"
+    return
+  fi
+
+  branches=("\${(@f)$(__gji_worktree_branches)}")
+  targets=()
+  if [[ -n "\${repo_key}" && $+commands[gh] -eq 1 ]]; then
+    targets=("\${(@f)$(__gji_run_bounded env GH_PROMPT_DISABLED=1 gh pr list --state open --json number --limit 100 |
+      tr '{},' '\\n' | sed -n 's/.*"number":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')}")
+  elif [[ -n "\${repo_key}" && $+commands[glab] -eq 1 ]]; then
+    targets=("\${(@f)$(__gji_run_bounded env GLAB_NON_INTERACTIVE=1 glab mr list --state opened --output json --per-page 100 |
+      tr '{},' '\\n' | sed -n 's/.*"iid":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')}")
+  elif [[ -n "\${repo_key}" && $+commands[bb] -eq 1 ]]; then
+    targets=("\${(@f)$(__gji_run_bounded bb pr list --state OPEN --format json |
+      tr '{},' '\\n' | sed -n 's/.*"id":[[:space:]]*\\([0-9][0-9]*\\).*/\\1/p')}")
+  fi
+
+  __gji_pr_targets_cache=("\${branches[@]}" "\${targets[@]}")
+  __gji_pr_targets_cache_at="$now"
+  __gji_pr_targets_cache_loaded=1
+  __gji_pr_targets_cache_repo="$repo_key"
+  print -rl -- "\${__gji_pr_targets_cache[@]}"
+}
+
 local context state line
-local -a commands worktree_branches
+local -a command_entries worktree_branches
 
-commands=(
+command_entries=(
   ${commandLines}
 )
 
 if (( CURRENT == 2 )); then
-  _describe 'command' commands
+  _describe 'command' command_entries
   return
 fi
 
@@ -15718,13 +16454,26 @@ case "\${words[2]}" in
     _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, \u2026)]: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})'
+    _arguments '--write[write the integration to the shell config file]' '--json[emit a JSON error in non-interactive mode]' '2:shell:(${shells})'
+    ;;
+  doctor)
+    _arguments '--fix[apply safe automatic fixes after showing the plan]' '--yes[apply --fix without prompting]' '--json[emit diagnostic checks as JSON]'
     ;;
   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: '
+    if [[ "\${words[3]}" == "open" ]]; then
+      if (( \${words[(I)--select]} )); then
+        _arguments
+      elif [[ -n "\${words[4]}" && "\${words[4]}" != -* ]]; then
+        _arguments
+      else
+        _arguments '--select[choose a pull request from any linked worktree]' '4:branch or PR number:->pr_targets'
+      fi
+    else
+      _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:(open)'
+    fi
     ;;
   back)
     _arguments '--print[print the resolved worktree path explicitly]' '2:steps: '
@@ -15787,6 +16536,10 @@ case "$state" in
     worktree_branches=(\${(@f)$(__gji_worktree_branches)})
     _describe 'worktree branch' worktree_branches
     ;;
+  pr_targets)
+    worktree_branches=(\${(@f)$(__gji_pr_targets)})
+    _describe 'branch or PR number' worktree_branches
+    ;;
   config_keys)
     _values 'config key' ${configKeys}
     ;;
@@ -15850,51 +16603,13 @@ function writeJson(stdout2, value) {
 `);
 }
 
-// src/go.ts
-import { basename as basename6 } from "node:path";
-
-// src/warp.ts
-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 { 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/doctor.ts
+import { execFile as execFile4 } from "node:child_process";
+import { constants as constants3 } from "node:fs";
+import { access as access4, readFile as readFile4 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename4, dirname as dirname5, join as join6 } from "node:path";
+import { promisify as promisify5 } from "node:util";
 
 // src/editor.ts
 import { spawn as spawn3 } from "node:child_process";
@@ -15934,14 +16649,774 @@ async function defaultSpawnEditor(cli, args) {
   child.unref();
 }
 
+// src/repo-registry.ts
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import {
+  access as access2,
+  mkdir as mkdir3,
+  readFile as readFile3,
+  realpath,
+  rename,
+  rm as rm2,
+  writeFile as writeFile4
+} from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { basename as basename3, dirname as dirname4, join as join4, resolve as resolve4 } from "node:path";
+var REGISTRY_FILE_NAME = "repos.json";
+var MAX_REGISTRY_ENTRIES = 100;
+var registryLocks = /* @__PURE__ */ new Map();
+function REGISTRY_FILE_PATH(home = homedir4()) {
+  const configDir = process.env.GJI_CONFIG_DIR;
+  if (configDir) {
+    return join4(resolve4(configDir), REGISTRY_FILE_NAME);
+  }
+  return join4(home, GLOBAL_CONFIG_DIRECTORY, REGISTRY_FILE_NAME);
+}
+async function loadRegistry(home = homedir4()) {
+  const path9 = REGISTRY_FILE_PATH(home);
+  try {
+    const raw = await readFile3(path9, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isRegistryEntry);
+  } catch {
+    return [];
+  }
+}
+async function canonicalizeRepoPath(repoPath) {
+  try {
+    return await realpath(repoPath);
+  } catch {
+    return resolve4(repoPath);
+  }
+}
+async function registerRepo(repoPath, home = homedir4()) {
+  const registryPath = REGISTRY_FILE_PATH(home);
+  await withRegistryLock(registryPath, async () => {
+    const existing = await normalizeRegistryForWrite(await loadRegistry(home));
+    const canonicalRepoPath = await canonicalizeRepoPath(repoPath);
+    if (existing.length > 0 && existing[0].path === canonicalRepoPath) return;
+    const entry = {
+      lastUsed: Date.now(),
+      name: basename3(canonicalRepoPath),
+      path: canonicalRepoPath
+    };
+    const filtered = existing.filter((e2) => e2.path !== canonicalRepoPath);
+    const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
+    await writeRegistry(next, registryPath);
+  });
+}
+async function removeMissingRegistryEntries(paths, home = homedir4()) {
+  if (paths.size === 0) return { removedPaths: [], skippedPaths: [] };
+  const registryPath = REGISTRY_FILE_PATH(home);
+  return withRegistryLock(registryPath, async () => {
+    const entries = await loadRegistry(home);
+    const candidates = entries.filter((entry) => paths.has(entry.path));
+    const status = await Promise.all(
+      candidates.map(async (entry) => ({
+        entry,
+        missing: await isMissingPath(entry.path)
+      }))
+    );
+    const removedPaths = status.filter(({ missing }) => missing).map(({ entry }) => entry.path);
+    const skippedPaths = status.filter(({ missing }) => !missing).map(({ entry }) => entry.path);
+    if (removedPaths.length > 0) {
+      await writeRegistry(
+        entries.filter((entry) => !removedPaths.includes(entry.path)),
+        registryPath
+      );
+    }
+    return { removedPaths, skippedPaths };
+  });
+}
+async function withRegistryLock(registryPath, operation) {
+  const previous = registryLocks.get(registryPath);
+  let release;
+  const current = new Promise((resolve6) => {
+    release = resolve6;
+  });
+  registryLocks.set(registryPath, current);
+  if (previous) await previous;
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (registryLocks.get(registryPath) === current) {
+      registryLocks.delete(registryPath);
+    }
+  }
+}
+async function isMissingPath(path9) {
+  try {
+    await access2(path9, constants.F_OK);
+    return false;
+  } catch (error) {
+    return isMissingPathError(error);
+  }
+}
+function isMissingPathError(error) {
+  if (!(error instanceof Error) || !("code" in error)) return false;
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+async function writeRegistry(entries, registryPath) {
+  await mkdir3(dirname4(registryPath), { recursive: true });
+  const temporaryPath = `${registryPath}.tmp-${process.pid}-${randomUUID()}`;
+  try {
+    await writeFile4(
+      temporaryPath,
+      `${JSON.stringify(entries, null, 2)}
+`,
+      "utf8"
+    );
+    await rename(temporaryPath, registryPath);
+  } catch (error) {
+    await rm2(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function normalizeRegistryForWrite(entries) {
+  const normalized = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const canonicalPath = await canonicalizeRepoPath(entry.path);
+    if (seenPaths.has(canonicalPath)) {
+      continue;
+    }
+    seenPaths.add(canonicalPath);
+    normalized.push({
+      ...entry,
+      name: basename3(canonicalPath),
+      path: canonicalPath
+    });
+  }
+  return normalized;
+}
+function isRegistryEntry(value) {
+  return typeof value === "object" && value !== null && "path" in value && typeof value.path === "string" && "name" in value && typeof value.name === "string" && "lastUsed" in value && typeof value.lastUsed === "number";
+}
+
+// src/shell-setup.ts
+import { constants as constants2 } from "node:fs";
+import { access as access3 } from "node:fs/promises";
+import { delimiter, join as join5 } from "node:path";
+var SHELL_INTEGRATION_START_MARKER = "# >>> gji init >>>";
+var SHELL_INTEGRATION_END_MARKER = "# <<< gji init <<<";
+var ONBOARDING_SHELL_INTEGRATION_START_MARKER = "# >>> gji shell integration >>>";
+var ONBOARDING_SHELL_INTEGRATION_END_MARKER = "# <<< gji shell integration <<<";
+async function executableExists(command) {
+  const candidates = command.includes("/") ? [command] : (process.env.PATH ?? "").split(delimiter).filter(Boolean).map((directory) => join5(directory, command));
+  for (const path9 of candidates) {
+    try {
+      await access3(path9, constants2.X_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function resolveShellConfigPath(shell, home) {
+  switch (shell) {
+    case "bash":
+      return join5(home, ".bashrc");
+    case "fish":
+      return join5(home, ".config", "fish", "config.fish");
+    case "zsh":
+      return join5(home, ".zshrc");
+  }
+}
+function resolveCompletionPath(shell, home) {
+  switch (shell) {
+    case "bash":
+      return join5(
+        home,
+        ".local",
+        "share",
+        "bash-completion",
+        "completions",
+        "gji"
+      );
+    case "fish":
+      return join5(home, ".config", "fish", "completions", "gji.fish");
+    case "zsh":
+      return join5(home, ".zsh", "completions", "_gji");
+  }
+}
+function hasShellIntegration(config, shell) {
+  if (config.includes(SHELL_INTEGRATION_START_MARKER) && config.includes(SHELL_INTEGRATION_END_MARKER) || config.includes(ONBOARDING_SHELL_INTEGRATION_START_MARKER) && config.includes(ONBOARDING_SHELL_INTEGRATION_END_MARKER)) {
+    return true;
+  }
+  if (shell === "fish") return false;
+  return new RegExp(
+    `^[\\t ]*eval\\s+["']?\\$\\(\\s*gji\\s+init\\s+${shell}\\s*\\)["']?\\s*(?:#.*)?$`,
+    "m"
+  ).test(config);
+}
+
+// src/doctor.ts
+var execFileAsync4 = promisify5(execFile4);
+var MINIMUM_GIT_VERSION = { major: 2, minor: 17 };
+async function runDoctorCommand(options) {
+  if (options.yes && !options.fix) {
+    const message = "--yes requires --fix";
+    if (options.json) {
+      (options.stderr ?? options.stdout)(
+        `${JSON.stringify({ error: message })}
+`
+      );
+    } else {
+      (options.stderr ?? options.stdout)(`gji doctor: ${message}
+`);
+    }
+    return 1;
+  }
+  const home = options.home ?? homedir5();
+  const shell = resolveSupportedShell(
+    void 0,
+    options.shell ?? process.env.SHELL
+  );
+  let inspection = await collectDoctorInspection(options.cwd, home, shell);
+  let fixes = [];
+  if (options.fix) {
+    fixes = buildDoctorFixes(inspection.missingRegistryPaths);
+    if (fixes.length > 0) {
+      const approval = await requestFixApproval(fixes, options);
+      if (approval === "apply") {
+        fixes = await applyDoctorFixes(fixes, home);
+      } else {
+        fixes = fixes.map((fix) => ({
+          ...fix,
+          status: approval,
+          hint: approval === "pending" ? "re-run with --yes to apply this fix without a prompt" : "run gji doctor --fix again to review this fix"
+        }));
+      }
+    }
+    inspection = await collectDoctorInspection(options.cwd, home, shell);
+  }
+  const problems = inspection.checks.filter(
+    (check) => check.status === "fail"
+  ).length;
+  if (options.json) {
+    const output = options.fix ? { checks: inspection.checks, problems, fixes } : { checks: inspection.checks, problems };
+    options.stdout(`${JSON.stringify(output)}
+`);
+  } else {
+    options.stdout(renderDoctorChecks(inspection.checks, problems));
+    if (options.fix) {
+      options.stdout(renderDoctorFixes(fixes));
+    }
+  }
+  return problems > 0 ? 1 : 0;
+}
+async function collectDoctorInspection(cwd, home, shell) {
+  const repository = await detectRepositoryOrSkip(cwd);
+  const globalConfig = await inspectConfig(
+    GLOBAL_CONFIG_FILE_PATH(home),
+    "global",
+    KNOWN_GLOBAL_CONFIG_KEYS
+  );
+  const localConfig = repository ? await inspectConfig(
+    join6(repository.repoRoot, CONFIG_FILE_NAME),
+    "local",
+    KNOWN_CONFIG_KEYS
+  ) : null;
+  const effectiveConfig = resolveEffectiveConfig(
+    globalConfig.config,
+    localConfig?.config ?? {},
+    repository?.repoRoot,
+    home
+  );
+  const registry = await inspectRegistry(home);
+  return {
+    checks: [
+      await checkGitVersion(),
+      await checkShellIntegration(shell, home),
+      await checkCompletion(shell, home),
+      globalConfig.check,
+      localConfig?.check ?? skippedCheck(
+        "local-config",
+        "local config not checked outside a Git repository"
+      ),
+      await checkWorktreeBase(repository, effectiveConfig, home),
+      registry.check,
+      await checkEditor(effectiveConfig)
+    ],
+    missingRegistryPaths: registry.missingPaths
+  };
+}
+function buildDoctorFixes(missingRegistryPaths) {
+  if (missingRegistryPaths.length === 0) return [];
+  const count = missingRegistryPaths.length;
+  return [
+    {
+      id: "repo-registry",
+      message: `remove ${count} stale ${count === 1 ? "repository entry" : "repository entries"} from the registry`,
+      paths: missingRegistryPaths,
+      status: "pending"
+    }
+  ];
+}
+async function requestFixApproval(fixes, options) {
+  if (options.yes) return "apply";
+  if (!isDoctorInteractive(options)) return "pending";
+  const confirmed = options.confirmFixes ? await options.confirmFixes(fixes) : await ye({
+    initialValue: true,
+    message: `Apply ${fixes.length} automatic ${fixes.length === 1 ? "fix" : "fixes"} (${fixes.flatMap((fix) => fix.paths ?? []).join(", ")})?`
+  });
+  if (pD(confirmed) || !confirmed) return "declined";
+  return "apply";
+}
+function isDoctorInteractive(options) {
+  if (options.json || isHeadless()) return false;
+  if (options.interactive !== void 0) return options.interactive;
+  return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+async function applyDoctorFixes(fixes, home) {
+  return Promise.all(
+    fixes.map(async (fix) => {
+      try {
+        const result = await removeMissingRegistryEntries(
+          new Set(fix.paths ?? []),
+          home
+        );
+        const removedCount = result.removedPaths.length;
+        const skippedCount = result.skippedPaths.length;
+        return {
+          ...fix,
+          message: removedCount === 0 ? "no stale repository entries were removed" : `removed ${removedCount} stale ${removedCount === 1 ? "repository entry" : "repository entries"} from the registry`,
+          status: removedCount === 0 ? "skipped" : "applied",
+          hint: skippedCount > 0 ? `${skippedCount} path(s) were no longer confirmed missing` : void 0
+        };
+      } catch (error) {
+        return {
+          ...fix,
+          status: "failed",
+          hint: error instanceof Error ? error.message : String(error)
+        };
+      }
+    })
+  );
+}
+async function detectRepositoryOrSkip(cwd) {
+  try {
+    return await detectRepository(cwd);
+  } catch {
+    return null;
+  }
+}
+async function inspectConfig(path9, label, knownKeys) {
+  try {
+    const contents = await readFile4(path9, "utf8");
+    const value = JSON.parse(contents);
+    if (!isConfigObject(value)) {
+      return {
+        check: failedCheck(
+          `${label}-config`,
+          `${label} config must contain a JSON object (${path9})`,
+          "replace the file contents with a JSON object"
+        ),
+        config: {}
+      };
+    }
+    const unknownKeys = Object.keys(value).filter((key) => !knownKeys.has(key));
+    const warning = unknownKeys.length > 0 ? `; warning: unknown ${unknownKeys.length === 1 ? "key" : "keys"} ${unknownKeys.map((key) => `"${key}"`).join(", ")}` : "";
+    return {
+      check: okCheck(
+        `${label}-config`,
+        `${label} config valid (${path9}${warning})`
+      ),
+      config: value
+    };
+  } catch (error) {
+    if (isMissingFileError2(error)) {
+      return {
+        check: okCheck(
+          `${label}-config`,
+          `${label} config not found (optional)`
+        ),
+        config: {}
+      };
+    }
+    return {
+      check: failedCheck(
+        `${label}-config`,
+        `${label} config is invalid (${path9})`,
+        "fix the JSON syntax and run gji doctor again"
+      ),
+      config: {}
+    };
+  }
+}
+function isConfigObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissingFileError2(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function resolveEffectiveConfig(globalConfig, localConfig, repoRoot, home) {
+  const globalBase = { ...globalConfig };
+  const repos = globalBase.repos;
+  delete globalBase.repos;
+  return {
+    ...globalBase,
+    ...resolvePerRepoConfig(repos, repoRoot, home),
+    ...localConfig
+  };
+}
+function resolvePerRepoConfig(repos, repoRoot, home) {
+  if (!repoRoot || !isConfigObject(repos)) {
+    return {};
+  }
+  for (const [path9, config] of Object.entries(repos)) {
+    if (expandTilde2(path9, home) === repoRoot && isConfigObject(config)) {
+      return config;
+    }
+  }
+  return {};
+}
+function expandTilde2(path9, home) {
+  if (path9 === "~") return home;
+  if (path9.startsWith("~/")) return join6(home, path9.slice(2));
+  return path9;
+}
+async function checkGitVersion() {
+  try {
+    const { stdout: stdout2 } = await execFileAsync4("git", ["--version"]);
+    const version = parseGitVersion(stdout2);
+    if (!version) {
+      return failedCheck(
+        "git-version",
+        "could not parse the installed Git version",
+        "install Git 2.17 or newer"
+      );
+    }
+    if (isGitVersionSupported(version)) {
+      return okCheck("git-version", `git ${version.raw}`);
+    }
+    return failedCheck(
+      "git-version",
+      `git ${version.raw} is too old (requires Git 2.17 or newer)`,
+      "upgrade Git and run gji doctor again"
+    );
+  } catch {
+    return failedCheck(
+      "git-version",
+      "git is not available on PATH",
+      "install Git 2.17 or newer"
+    );
+  }
+}
+function parseGitVersion(output) {
+  const match = /(?:^|\s)(\d+)\.(\d+)(?:\.(\d+))?/.exec(output);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    raw: match.slice(1).filter(Boolean).join(".")
+  };
+}
+function isGitVersionSupported(version) {
+  return version.major > MINIMUM_GIT_VERSION.major || version.major === MINIMUM_GIT_VERSION.major && version.minor >= MINIMUM_GIT_VERSION.minor;
+}
+async function checkShellIntegration(shell, home) {
+  if (!shell) {
+    return skippedCheck(
+      "shell-integration",
+      "shell integration not checked (unable to detect a supported shell)"
+    );
+  }
+  const rcPath = resolveShellConfigPath(shell, home);
+  try {
+    const contents = await readFile4(rcPath, "utf8");
+    if (hasShellIntegration(contents, shell)) {
+      return okCheck(
+        "shell-integration",
+        `${shell} integration found in ${rcPath}`
+      );
+    }
+  } catch (error) {
+    if (isMissingFileError2(error)) {
+      return failedCheck(
+        "shell-integration",
+        `shell integration not found because ${rcPath} does not exist`,
+        `create ${rcPath}, then add: eval "$(gji init ${shell})"`
+      );
+    }
+    return failedCheck(
+      "shell-integration",
+      `could not read ${rcPath}`,
+      `add: eval "$(gji init ${shell})"`
+    );
+  }
+  return failedCheck(
+    "shell-integration",
+    `shell integration not found in ${rcPath}`,
+    `add: eval "$(gji init ${shell})"`
+  );
+}
+async function checkCompletion(shell, home) {
+  if (!shell) {
+    return skippedCheck(
+      "completion",
+      "shell completion not checked (unable to detect a supported shell)"
+    );
+  }
+  const path9 = resolveCompletionPath(shell, home);
+  if (await pathExists(path9)) {
+    return okCheck("completion", `${shell} completion installed (${path9})`);
+  }
+  return skippedCheck(
+    "completion",
+    `${shell} completion not installed (optional)`,
+    `run: gji completion ${shell} > ${path9}`
+  );
+}
+async function checkWorktreeBase(repository, config, home) {
+  if (!repository) {
+    return skippedCheck(
+      "worktree-base",
+      "worktree base not checked outside a Git repository"
+    );
+  }
+  const basePath = resolveWorktreeBase(repository.repoRoot, config, home);
+  const writablePath = await findNearestExistingPath(basePath);
+  if (!writablePath) {
+    return failedCheck(
+      "worktree-base",
+      `worktree base cannot be created (${basePath})`,
+      "create a writable parent directory or update worktreePath"
+    );
+  }
+  try {
+    await access4(writablePath, constants3.W_OK | constants3.X_OK);
+    return okCheck("worktree-base", `worktree base writable (${basePath})`);
+  } catch {
+    return failedCheck(
+      "worktree-base",
+      `worktree base is not writable (${writablePath})`,
+      "update worktreePath to use a writable directory"
+    );
+  }
+}
+function resolveWorktreeBase(repoRoot, config, home) {
+  const configuredPath = config.worktreePath;
+  if (typeof configuredPath === "string" && (configuredPath.startsWith("/") || configuredPath.startsWith("~"))) {
+    return expandTilde2(configuredPath, home);
+  }
+  return join6(dirname5(repoRoot), "worktrees", basename4(repoRoot));
+}
+async function findNearestExistingPath(path9) {
+  let candidate = path9;
+  while (true) {
+    try {
+      await access4(candidate, constants3.F_OK);
+      return candidate;
+    } catch {
+      const parent = dirname5(candidate);
+      if (parent === candidate) return null;
+      candidate = parent;
+    }
+  }
+}
+async function inspectRegistry(home) {
+  const entries = await loadRegistry(home);
+  const missingEntries = await Promise.all(
+    entries.map(async (entry) => ({
+      entry,
+      status: await inspectRegistryPath(entry.path)
+    }))
+  );
+  const missingCount = missingEntries.filter(
+    ({ status }) => status === "missing"
+  ).length;
+  const unreadableCount = missingEntries.filter(
+    ({ status }) => status === "unreadable"
+  ).length;
+  const missingPaths = missingEntries.filter(({ status }) => status === "missing").map(({ entry }) => entry.path);
+  if (missingCount === 0 && unreadableCount === 0) {
+    return {
+      check: okCheck(
+        "repo-registry",
+        `${entries.length} repos registered, all reachable`
+      ),
+      missingPaths
+    };
+  }
+  const messageParts = [];
+  if (missingCount > 0) {
+    messageParts.push(
+      `${missingCount} ${missingCount === 1 ? "path is" : "paths are"} missing`
+    );
+  }
+  if (unreadableCount > 0) {
+    messageParts.push(
+      `${unreadableCount} ${unreadableCount === 1 ? "path is" : "paths are"} not accessible`
+    );
+  }
+  return {
+    check: failedCheck(
+      "repo-registry",
+      `${entries.length} repos registered, ${messageParts.join(", ")}`,
+      missingCount > 0 ? `remove confirmed stale entries from ${REGISTRY_FILE_PATH(home)}; check permissions for inaccessible paths` : "check permissions for inaccessible paths before removing registry entries"
+    ),
+    missingPaths
+  };
+}
+async function inspectRegistryPath(path9) {
+  try {
+    await access4(path9, constants3.F_OK);
+    return "exists";
+  } catch (error) {
+    if (isMissingPathError2(error)) return "missing";
+    return "unreadable";
+  }
+}
+function isMissingPathError2(error) {
+  if (!(error instanceof Error) || !("code" in error)) return false;
+  const code = error.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+async function pathExists(path9) {
+  try {
+    await access4(path9, constants3.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkEditor(config) {
+  const editor = config.editor;
+  if (typeof editor !== "string" || editor.length === 0) {
+    return skippedCheck("editor", "editor not configured (optional)");
+  }
+  if (await executableExists(editor)) {
+    return okCheck("editor", `editor "${editor}" found on PATH`);
+  }
+  const knownEditor = EDITORS.some(({ cli }) => cli === editor);
+  return failedCheck(
+    "editor",
+    `editor "${editor}" was not found on PATH`,
+    knownEditor ? `install ${editor} or choose another editor with: gji open --save` : "choose another editor with: gji open --save"
+  );
+}
+function okCheck(id, message) {
+  return { id, message, status: "ok" };
+}
+function failedCheck(id, message, hint) {
+  return { hint, id, message, status: "fail" };
+}
+function skippedCheck(id, message, hint) {
+  return { hint, id, message, status: "skip" };
+}
+function renderDoctorChecks(checks, problems) {
+  const lines = ["gji doctor", ""];
+  for (const check of checks) {
+    lines.push(` ${statusSymbol(check.status)} ${check.message}`);
+    if (check.hint) lines.push(`     ${check.hint}`);
+  }
+  lines.push(
+    "",
+    `${problems} ${problems === 1 ? "problem" : "problems"} found.`
+  );
+  return `${lines.join("\n")}
+`;
+}
+function renderDoctorFixes(fixes) {
+  const lines = ["", "Automatic fixes:"];
+  if (fixes.length === 0) {
+    lines.push(" No automatic fixes available.");
+  } else {
+    for (const fix of fixes) {
+      lines.push(` ${fixStatusSymbol(fix.status)} ${fix.message}`);
+      if (fix.paths && fix.paths.length > 0) {
+        for (const path9 of fix.paths) lines.push(`     ${path9}`);
+      }
+      if (fix.hint) lines.push(`     ${fix.hint}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function fixStatusSymbol(status) {
+  switch (status) {
+    case "applied":
+      return "\u2713";
+    case "declined":
+      return "-";
+    case "failed":
+      return "\u2717";
+    case "pending":
+      return "!";
+    case "skipped":
+      return "-";
+  }
+}
+function statusSymbol(status) {
+  switch (status) {
+    case "fail":
+      return "\u2717";
+    case "ok":
+      return "\u2713";
+    case "skip":
+      return "-";
+  }
+}
+
+// src/go.ts
+import { basename as basename7 } from "node:path";
+
+// src/warp.ts
+import { realpath as realpath2 } from "node:fs/promises";
+import { basename as basename6, resolve as resolve5 } from "node:path";
+
+// src/new.ts
+import { execFile as execFile5 } from "node:child_process";
+import { mkdir as mkdir5 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname7 } from "node:path";
+import { promisify as promisify6 } from "node:util";
+
+// src/conflict.ts
+import { constants as constants4 } from "node:fs";
+import { access as access5 } from "node:fs/promises";
+async function pathExists2(path9) {
+  try {
+    await access5(path9, constants4.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/file-sync.ts
-import { copyFile, mkdir as mkdir3, stat } from "node:fs/promises";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join4, normalize } from "node:path";
+import { copyFile, mkdir as mkdir4, stat } from "node:fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join7, normalize } from "node:path";
 async function syncFiles(mainRoot, targetPath, patterns) {
   for (const pattern of patterns) {
     const normalized = validateSyncFilePattern(pattern);
-    const sourcePath = join4(mainRoot, normalized);
-    const destPath = join4(targetPath, normalized);
+    const sourcePath = join7(mainRoot, normalized);
+    const destPath = join7(targetPath, normalized);
     const sourceExists = await fileExists(sourcePath);
     if (!sourceExists) {
       continue;
@@ -15950,7 +17425,7 @@ async function syncFiles(mainRoot, targetPath, patterns) {
     if (destExists) {
       continue;
     }
-    await mkdir3(dirname4(destPath), { recursive: true });
+    await mkdir4(dirname6(destPath), { recursive: true });
     await copyFile(sourcePath, destPath);
   }
 }
@@ -15987,8 +17462,8 @@ function isNotFoundError(error) {
 import { spawn as spawn4 } from "node:child_process";
 
 // src/package-manager.ts
-import { access as access3, readdir } from "node:fs/promises";
-import { join as join5 } from "node:path";
+import { access as access6, readdir } from "node:fs/promises";
+import { join as join8 } from "node:path";
 var ENTRIES = [
   // JavaScript / TypeScript
   { name: "pnpm", signals: ["pnpm-lock.yaml"], command: "pnpm install" },
@@ -16118,7 +17593,7 @@ async function detectPackageManager(repoRoot) {
 async function matchesExact(repoRoot, signals) {
   for (const signal of signals) {
     try {
-      await access3(join5(repoRoot, signal));
+      await access6(join8(repoRoot, signal));
       return true;
     } catch {
     }
@@ -16282,7 +17757,7 @@ function isPlainObject2(value) {
 }
 
 // src/new.ts
-var execFileAsync3 = promisify4(execFile3);
+var execFileAsync5 = promisify6(execFile5);
 var NEW_OUTPUT_FILE_ENV = "GJI_NEW_OUTPUT_FILE";
 function createNewCommand(dependencies = {}) {
   const createBranchPlaceholder = dependencies.createBranchPlaceholder ?? generateBranchPlaceholder;
@@ -16350,11 +17825,11 @@ function createNewCommand(dependencies = {}) {
       worktreeName,
       configuredBasePath
     );
-    if (!usesGeneratedDetachedName && await pathExists(worktreePath)) {
+    if (!usesGeneratedDetachedName && await pathExists2(worktreePath)) {
       if (options.force) {
         if (!options.dryRun) {
           try {
-            await execFileAsync3(
+            await execFileAsync5(
               "git",
               ["worktree", "remove", "--force", worktreePath],
               { cwd: repository.repoRoot }
@@ -16375,7 +17850,7 @@ function createNewCommand(dependencies = {}) {
           }
           if (!options.detached) {
             try {
-              await execFileAsync3("git", ["branch", "-D", worktreeName], {
+              await execFileAsync5("git", ["branch", "-D", worktreeName], {
                 cwd: repository.repoRoot
               });
             } catch {
@@ -16432,9 +17907,9 @@ function createNewCommand(dependencies = {}) {
       }
       return 0;
     }
-    await mkdir4(dirname5(worktreePath), { recursive: true });
+    await mkdir5(dirname7(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 });
+    await execFileAsync5("git", gitArgs, { cwd: repository.repoRoot });
     const syncPatterns = Array.isArray(config.syncFiles) ? config.syncFiles.filter(
       (p2) => typeof p2 === "string"
     ) : [];
@@ -16463,7 +17938,7 @@ function createNewCommand(dependencies = {}) {
       {
         branch: worktreeName,
         path: worktreePath,
-        repo: basename3(repository.repoRoot)
+        repo: basename5(repository.repoRoot)
       },
       options.stderr
     );
@@ -16615,7 +18090,7 @@ async function resolveUniqueDetachedWorktreePath(repoRoot, baseName, basePath) {
       candidateName,
       basePath
     );
-    if (!await pathExists(candidatePath)) {
+    if (!await pathExists2(candidatePath)) {
       return candidatePath;
     }
     attempt += 1;
@@ -16638,7 +18113,7 @@ async function defaultPromptForBranch(placeholder) {
 }
 async function localBranchExists(repoRoot, branchName) {
   try {
-    await execFileAsync3(
+    await execFileAsync5(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
       { cwd: repoRoot }
@@ -16683,74 +18158,6 @@ async function openWorktree(worktreePath, editorCli, spawnFn, stderr) {
   }
 }
 
-// src/repo-registry.ts
-import { mkdir as mkdir5, readFile as readFile3, realpath, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { basename as basename4, dirname as dirname6, join as join6, resolve as resolve4 } from "node:path";
-var REGISTRY_FILE_NAME = "repos.json";
-var MAX_REGISTRY_ENTRIES = 100;
-function REGISTRY_FILE_PATH(home = homedir4()) {
-  const configDir = process.env.GJI_CONFIG_DIR;
-  if (configDir) {
-    return join6(resolve4(configDir), REGISTRY_FILE_NAME);
-  }
-  return join6(home, GLOBAL_CONFIG_DIRECTORY, REGISTRY_FILE_NAME);
-}
-async function loadRegistry(home = homedir4()) {
-  const path9 = REGISTRY_FILE_PATH(home);
-  try {
-    const raw = await readFile3(path9, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter(isRegistryEntry);
-  } catch {
-    return [];
-  }
-}
-async function canonicalizeRepoPath(repoPath) {
-  try {
-    return await realpath(repoPath);
-  } catch {
-    return resolve4(repoPath);
-  }
-}
-async function registerRepo(repoPath, home = homedir4()) {
-  const registryPath = REGISTRY_FILE_PATH(home);
-  const existing = await normalizeRegistryForWrite(await loadRegistry(home));
-  const canonicalRepoPath = await canonicalizeRepoPath(repoPath);
-  if (existing.length > 0 && existing[0].path === canonicalRepoPath) return;
-  const entry = {
-    lastUsed: Date.now(),
-    name: basename4(canonicalRepoPath),
-    path: canonicalRepoPath
-  };
-  const filtered = existing.filter((e2) => e2.path !== canonicalRepoPath);
-  const next = [entry, ...filtered].slice(0, MAX_REGISTRY_ENTRIES);
-  await mkdir5(dirname6(registryPath), { recursive: true });
-  await writeFile4(registryPath, `${JSON.stringify(next, null, 2)}
-`, "utf8");
-}
-async function normalizeRegistryForWrite(entries) {
-  const normalized = [];
-  const seenPaths = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const canonicalPath = await canonicalizeRepoPath(entry.path);
-    if (seenPaths.has(canonicalPath)) {
-      continue;
-    }
-    seenPaths.add(canonicalPath);
-    normalized.push({
-      ...entry,
-      name: basename4(canonicalPath),
-      path: canonicalPath
-    });
-  }
-  return normalized;
-}
-function isRegistryEntry(value) {
-  return typeof value === "object" && value !== null && "path" in value && typeof value.path === "string" && "name" in value && typeof value.name === "string" && "lastUsed" in value && typeof value.lastUsed === "number";
-}
-
 // src/warp.ts
 var WARP_OUTPUT_FILE_ENV = "GJI_WARP_OUTPUT_FILE";
 async function runWarpCommand(options) {
@@ -16782,7 +18189,8 @@ async function runWarpNavigate(options) {
   const target = await resolveWarpTarget({
     ...options,
     commandName: "gji warp",
-    json: options.json
+    json: options.json,
+    queryPullRequests: options.queryPullRequests
   });
   if (!target) return 1;
   if (options.json) {
@@ -16862,7 +18270,7 @@ async function deduplicateRegistryForNew(registry) {
     seenPaths.add(canonicalPath);
     deduplicated.push({
       ...entry,
-      name: basename5(canonicalPath),
+      name: basename6(canonicalPath),
       path: canonicalPath
     });
   }
@@ -16899,15 +18307,16 @@ async function resolveWarpTarget(options) {
   const results = await Promise.allSettled(
     registry.map(async (entry) => {
       const worktrees = await listWorktrees(entry.path);
-      return { repoName: entry.name, worktrees };
+      return { repoName: entry.name, repoRoot: entry.path, worktrees };
     })
   );
   const allItems = [];
   for (const result of results) {
     if (result.status === "rejected") continue;
-    const { repoName, worktrees } = result.value;
+    const { repoName, repoRoot, worktrees } = result.value;
     for (const worktree of worktrees) {
       allItems.push({
+        repoRoot,
         repoName,
         worktree: {
           ...worktree,
@@ -16921,6 +18330,7 @@ async function resolveWarpTarget(options) {
     return null;
   }
   const promptSources = allItems.map((item) => ({
+    repoRoot: item.repoRoot,
     repoName: item.repoName,
     worktree: item.worktree
   }));
@@ -16932,7 +18342,9 @@ async function resolveWarpTarget(options) {
     }
     return { branch: match.worktree.branch, path: match.worktree.path };
   }
-  const promptEntries = await buildWorktreePromptEntries(promptSources);
+  const promptEntries = await buildWorktreePromptEntries(promptSources, {
+    queryPullRequests: options.queryPullRequests
+  });
   const path9 = await promptForWarpTarget(promptEntries);
   if (!path9) {
     options.stderr("Aborted\n");
@@ -16980,10 +18392,13 @@ function createGoCommand(dependencies = {}) {
       return 1;
     }
     const promptSources = worktrees.map((worktree) => ({
+      repoRoot: repository.repoRoot,
       repoName: repository.repoName,
       worktree
     }));
-    const promptEntries = options.branch ? [] : await buildWorktreePromptEntries(promptSources);
+    const promptEntries = options.branch ? [] : await buildWorktreePromptEntries(promptSources, {
+      queryPullRequests: dependencies.queryPullRequests
+    });
     const queried = options.branch ? resolveWorktreeQuery(promptSources, options.branch) : null;
     const prompted = options.branch ? null : await prompt(promptEntries);
     const resolvedPath = options.branch ? queried?.worktree.path : prompted ?? void 0;
@@ -17011,7 +18426,7 @@ function createGoCommand(dependencies = {}) {
       {
         branch: chosenWorktree?.branch ?? void 0,
         path: resolvedPath,
-        repo: basename6(repository.repoRoot)
+        repo: basename7(repository.repoRoot)
       },
       options.stderr
     );
@@ -17042,11 +18457,11 @@ async function runHistoryCommand(options) {
 }
 
 // src/init.ts
-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 join7 } from "node:path";
-var START_MARKER = "# >>> gji init >>>";
-var END_MARKER = "# <<< gji init <<<";
+import { constants as constants5 } from "node:fs";
+import { access as access7, mkdir as mkdir6, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname8 } from "node:path";
+var ZSH_COMPLETION_PATH_LINE = "fpath=(~/.zsh/completions $fpath)";
 var SHELL_WRAPPED_COMMANDS = [
   {
     bypassOptions: ["--help"],
@@ -17097,10 +18512,256 @@ var SHELL_WRAPPED_COMMANDS = [
     names: ["warp"],
     tempPrefix: "gji-warp"
   }
-];
-async function runInitCommand(options) {
+];
+async function runInitCommand(options) {
+  if (options.shell === void 0) {
+    return runOnboardingInitCommand(options);
+  }
+  return runLegacyInitCommand(options);
+}
+async function runOnboardingInitCommand(options) {
+  if (options.json || isHeadless() || !canRunOnboarding(options)) {
+    return writeNonInteractiveInitError(options);
+  }
+  const home = options.home ?? homedir6();
+  const context = {
+    detectedShell: resolveSupportedShell(void 0, process.env.SHELL),
+    home
+  };
+  if (options.promptForOnboarding === void 0) {
+    return runDefaultOnboarding(context);
+  }
+  const result = await options.promptForOnboarding(context);
+  if (!result) {
+    options.stderr?.("Aborted.\n");
+    return 1;
+  }
+  await applyOnboardingResult(result, home);
+  return 0;
+}
+function canRunOnboarding(options) {
+  return options.interactive ?? (options.promptForOnboarding !== void 0 || process.stdin.isTTY === true && process.stdout.isTTY === true);
+}
+function writeNonInteractiveInitError(options) {
+  const error = "run `gji init <shell> --write` in non-interactive mode";
+  options.stderr?.(
+    options.json ? `${JSON.stringify({ error })}
+` : `${error}
+`
+  );
+  return 1;
+}
+async function runDefaultOnboarding(context) {
+  Ie("gji init");
+  const shell = await ve({
+    message: "Which shell should gji configure?",
+    initialValue: context.detectedShell ?? "zsh",
+    options: [
+      { value: "zsh", label: "zsh" },
+      { value: "bash", label: "bash" },
+      { value: "fish", label: "fish" }
+    ]
+  });
+  if (pD(shell)) return abortDefaultOnboarding();
+  const rcPath = resolveShellConfigPath(shell, context.home);
+  const currentConfig = await readExistingConfig(rcPath);
+  const shellIntegration = await promptForShellIntegration(
+    currentConfig,
+    rcPath,
+    shell
+  );
+  if (shellIntegration === null) return abortDefaultOnboarding();
+  const completionPath = resolveCompletionPath(shell, context.home);
+  const completionAlreadyInstalled = await fileExists2(completionPath);
+  await applyShellIntegration(shell, shellIntegration, context.home);
+  const installCompletion = await promptForCompletion(shell, completionPath);
+  if (installCompletion === null) return abortDefaultOnboarding();
+  if (installCompletion) {
+    await mkdir6(dirname8(completionPath), { recursive: true });
+    await writeFile5(completionPath, renderShellCompletion(shell), "utf8");
+  }
+  if (shell === "zsh" && (completionAlreadyInstalled || installCompletion)) {
+    await ensureZshCompletionPath(rcPath);
+  }
+  const editor = await promptForEditor();
+  if (editor === null) return abortDefaultOnboarding();
+  if (editor) {
+    await updateGlobalConfigKey("editor", editor, context.home);
+  }
+  Se(
+    `Setup complete. Restart your shell or run: source ${rcPath}
+Verify with: gji doctor`
+  );
+  return 0;
+}
+async function applyShellIntegration(shell, choice, home) {
+  if (choice === "install") {
+    await installOnboardingShellIntegration(shell, home);
+  }
+  if (choice !== "skip") {
+    await updateGlobalConfigKey("shellIntegration", true, home);
+  }
+}
+function abortDefaultOnboarding() {
+  Se("Aborted.");
+  return 1;
+}
+async function promptForShellIntegration(currentConfig, rcPath, shell) {
+  if (currentConfig.includes(ONBOARDING_SHELL_INTEGRATION_START_MARKER) && currentConfig.includes(ONBOARDING_SHELL_INTEGRATION_END_MARKER)) {
+    M2.success(`Shell integration marker found in ${rcPath}; refreshing it.`);
+    return "install";
+  }
+  if (hasShellIntegration(currentConfig, shell)) {
+    M2.success(`Shell integration already installed in ${rcPath} \u2713`);
+    return "existing";
+  }
+  const confirmed = await ye({
+    message: `Install shell integration in ${rcPath}?`,
+    initialValue: true
+  });
+  if (pD(confirmed)) return null;
+  return confirmed ? "install" : "skip";
+}
+async function promptForCompletion(shell, completionPath) {
+  if (await fileExists2(completionPath)) {
+    M2.success(`${shell} completion already installed at ${completionPath} \u2713`);
+    return false;
+  }
+  const confirmed = await ye({
+    message: `Install ${shell} completion at ${completionPath}?`,
+    initialValue: true
+  });
+  if (pD(confirmed)) return null;
+  return confirmed;
+}
+async function promptForEditor() {
+  const availableEditors = await findAvailableEditors();
+  if (availableEditors.length === 0) {
+    M2.info("No supported editor CLIs found on PATH; skipping editor setup.");
+    return void 0;
+  }
+  const skipValue = "__gji_skip_editor__";
+  const selected = await ve({
+    message: "Which editor should gji use?",
+    options: [
+      ...availableEditors.map(({ cli, name }) => ({
+        value: cli,
+        label: name,
+        hint: cli
+      })),
+      { value: skipValue, label: "Skip" }
+    ]
+  });
+  if (pD(selected)) return null;
+  return selected === skipValue ? void 0 : selected;
+}
+async function findAvailableEditors() {
+  const availableEditors = [];
+  for (const editor of EDITORS) {
+    if (await executableExists(editor.cli)) {
+      availableEditors.push(editor);
+    }
+  }
+  return availableEditors;
+}
+async function applyOnboardingResult(result, home) {
+  const rcPath = resolveShellConfigPath(result.shell, home);
+  const completionPath = resolveCompletionPath(result.shell, home);
+  const completionAlreadyInstalled = await fileExists2(completionPath);
+  await applyShellIntegration(result.shell, result.shellIntegration, home);
+  if (result.installCompletion) {
+    await mkdir6(dirname8(completionPath), { recursive: true });
+    await writeFile5(
+      completionPath,
+      renderShellCompletion(result.shell),
+      "utf8"
+    );
+  }
+  if (result.shell === "zsh" && (completionAlreadyInstalled || result.installCompletion)) {
+    await ensureZshCompletionPath(rcPath);
+  }
+  if (result.editor) {
+    await updateGlobalConfigKey("editor", result.editor, home);
+  }
+}
+async function installOnboardingShellIntegration(shell, home) {
+  const rcPath = resolveShellConfigPath(shell, home);
+  await mkdir6(dirname8(rcPath), { recursive: true });
+  const current = await readExistingConfig(rcPath);
+  if (shell === "fish") {
+    await writeFile5(
+      rcPath,
+      upsertShellIntegration(current, renderShellIntegration(shell)),
+      "utf8"
+    );
+    return;
+  }
+  await writeFile5(
+    rcPath,
+    upsertOnboardingShellIntegration(current, shell),
+    "utf8"
+  );
+}
+function upsertOnboardingShellIntegration(existingConfig, shell) {
+  const script = renderOnboardingShellIntegration(shell).trimEnd();
+  const blockPattern = new RegExp(
+    `${escapeForRegExp(ONBOARDING_SHELL_INTEGRATION_START_MARKER)}[\\s\\S]*?${escapeForRegExp(ONBOARDING_SHELL_INTEGRATION_END_MARKER)}\\n?`,
+    "m"
+  );
+  if (blockPattern.test(existingConfig)) {
+    return ensureTrailingNewline(
+      existingConfig.replace(blockPattern, `${script}
+`)
+    );
+  }
+  const prefix = existingConfig.trimEnd();
+  if (prefix.length === 0) return ensureTrailingNewline(script);
+  return ensureTrailingNewline(`${prefix}
+
+${script}`);
+}
+function renderOnboardingShellIntegration(shell) {
+  return `${ONBOARDING_SHELL_INTEGRATION_START_MARKER}
+eval "$(gji init ${shell})"
+${ONBOARDING_SHELL_INTEGRATION_END_MARKER}
+`;
+}
+async function ensureZshCompletionPath(rcPath) {
+  const current = await readExistingConfig(rcPath);
+  const next = upsertZshCompletionPath(current);
+  if (next !== current) {
+    await writeFile5(rcPath, next, "utf8");
+  }
+}
+function upsertZshCompletionPath(existingConfig) {
+  const configWithoutCompletionPath = existingConfig.replace(
+    /# >>> gji zsh completion path >>>[\s\S]*?# <<< gji zsh completion path <<<\n?/m,
+    ""
+  ).replace(
+    new RegExp(
+      `^[\\t ]*${escapeForRegExp(ZSH_COMPLETION_PATH_LINE)}[\\t ]*\\n?`,
+      "gm"
+    ),
+    ""
+  );
+  const suffix = configWithoutCompletionPath.replace(/^(?:\r?\n)+/, "").trimEnd();
+  return ensureTrailingNewline(
+    suffix.length === 0 ? ZSH_COMPLETION_PATH_LINE : `${ZSH_COMPLETION_PATH_LINE}
+
+${suffix}`
+  );
+}
+async function fileExists2(path9) {
+  try {
+    await access7(path9, constants5.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runLegacyInitCommand(options) {
   const shell = resolveSupportedShell(options.shell, process.env.SHELL);
-  const home = options.home ?? homedir5();
+  const home = options.home ?? homedir6();
   if (!shell) {
     options.stderr?.(
       "Unable to detect a supported shell. Specify one explicitly: bash, fish, or zsh.\n"
@@ -17113,7 +18774,7 @@ async function runInitCommand(options) {
     return 0;
   }
   const rcPath = resolveShellConfigPath(shell, home);
-  await mkdir6(dirname7(rcPath), { recursive: true });
+  await mkdir6(dirname8(rcPath), { recursive: true });
   const current = await readExistingConfig(rcPath);
   const next = upsertShellIntegration(current, script);
   await writeFile5(rcPath, next, "utf8");
@@ -17122,7 +18783,7 @@ async function runInitCommand(options) {
   const { config: globalConfig } = await loadGlobalConfig(home);
   const alreadyConfigured = "shellIntegration" in globalConfig || "installSaveTarget" in globalConfig;
   const hasCustomPrompt = options.promptForSetup !== void 0;
-  const canPrompt = hasCustomPrompt || process.stdout.isTTY === true;
+  const canPrompt = !isHeadless() && (hasCustomPrompt || process.stdout.isTTY === true);
   if (!alreadyConfigured && canPrompt) {
     const prompt = options.promptForSetup ?? defaultPromptForSetup;
     const result = await prompt();
@@ -17144,30 +18805,30 @@ function renderShellIntegration(shell) {
   ).join("\n\n");
   switch (shell) {
     case "fish":
-      return `${START_MARKER}
+      return `${SHELL_INTEGRATION_START_MARKER}
 function gji --wraps gji --description 'gji shell integration'
 ${indentBlock(commandBlocks, 4)}
 
     command gji $argv
 end
-${END_MARKER}
+${SHELL_INTEGRATION_END_MARKER}
 `;
     case "bash":
     case "zsh":
-      return `${START_MARKER}
+      return `${SHELL_INTEGRATION_START_MARKER}
 gji() {
 ${indentBlock(commandBlocks, 2)}
 
   command gji "$@"
 }
-${END_MARKER}
+${SHELL_INTEGRATION_END_MARKER}
 `;
   }
 }
 function upsertShellIntegration(existingConfig, script) {
   const trimmedScript = script.trimEnd();
   const blockPattern = new RegExp(
-    `${escapeForRegExp(START_MARKER)}[\\s\\S]*?${escapeForRegExp(END_MARKER)}\\n?`,
+    `${escapeForRegExp(SHELL_INTEGRATION_START_MARKER)}[\\s\\S]*?${escapeForRegExp(SHELL_INTEGRATION_END_MARKER)}\\n?`,
     "m"
   );
   if (blockPattern.test(existingConfig)) {
@@ -17205,21 +18866,11 @@ async function saveWizardConfig(result, cwd, home) {
     await saveGlobalConfig({ ...existing, ...values }, home);
   }
 }
-function resolveShellConfigPath(shell, home) {
-  switch (shell) {
-    case "bash":
-      return join7(home, ".bashrc");
-    case "fish":
-      return join7(home, ".config", "fish", "config.fish");
-    case "zsh":
-      return join7(home, ".zshrc");
-  }
-}
 async function readExistingConfig(path9) {
   try {
-    return await readFile4(path9, "utf8");
+    return await readFile5(path9, "utf8");
   } catch (error) {
-    if (isMissingFileError2(error)) {
+    if (isMissingFileError3(error)) {
       return "";
     }
     throw error;
@@ -17232,7 +18883,7 @@ function ensureTrailingNewline(value) {
 function escapeForRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function isMissingFileError2(error) {
+function isMissingFileError3(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function renderFishWrapper(command) {
@@ -17457,14 +19108,14 @@ 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);
+import { execFile as execFile6 } from "node:child_process";
+import { access as access8, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+import { promisify as promisify7 } from "node:util";
+var execFileAsync6 = promisify7(execFile6);
 function createOpenCommand(dependencies = {}) {
   const detectEditors = dependencies.detectEditors ?? detectInstalledEditors;
-  const promptForEditor = dependencies.promptForEditor ?? defaultPromptForEditor;
+  const promptForEditor2 = dependencies.promptForEditor ?? defaultPromptForEditor;
   const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree;
   const spawnEditor = dependencies.spawnEditor ?? defaultSpawnEditor;
   return async function runOpenCommand2(options) {
@@ -17499,9 +19150,11 @@ function createOpenCommand(dependencies = {}) {
     } else {
       const entries = await buildWorktreePromptEntries(
         worktrees.map((worktree) => ({
+          repoRoot: repository.repoRoot,
           repoName: repository.repoName,
           worktree
-        }))
+        })),
+        { queryPullRequests: dependencies.queryPullRequests }
       );
       const chosen = await promptForWorktree2(entries);
       if (!chosen) {
@@ -17533,7 +19186,7 @@ function createOpenCommand(dependencies = {}) {
       if (installed.length === 1 || isHeadless()) {
         editorCli = installed[0].cli;
       } else {
-        const chosen = await promptForEditor(installed);
+        const chosen = await promptForEditor2(installed);
         if (!chosen) {
           options.stderr("Aborted\n");
           return 1;
@@ -17592,7 +19245,7 @@ async function detectInstalledEditors() {
 }
 async function isCommandAvailable(command) {
   try {
-    await execFileAsync4("which", [command]);
+    await execFileAsync6("which", [command]);
     return true;
   } catch {
     return false;
@@ -17610,9 +19263,9 @@ async function defaultPromptForEditor(editors) {
   return choice;
 }
 async function ensureWorkspaceFile(worktreePath, repoName) {
-  const workspacePath = join8(worktreePath, `${repoName}.code-workspace`);
+  const workspacePath = join9(worktreePath, `${repoName}.code-workspace`);
   try {
-    await access4(workspacePath);
+    await access8(workspacePath);
     return workspacePath;
   } catch {
   }
@@ -17627,11 +19280,11 @@ async function ensureWorkspaceFile(worktreePath, repoName) {
 }
 
 // src/pr.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile7 } from "node:child_process";
 import { mkdir as mkdir7 } from "node:fs/promises";
-import { basename as basename7, dirname as dirname8 } from "node:path";
-import { promisify as promisify6 } from "node:util";
-var execFileAsync5 = promisify6(execFile5);
+import { basename as basename8, dirname as dirname9 } from "node:path";
+import { promisify as promisify8 } from "node:util";
+var execFileAsync7 = promisify8(execFile7);
 var PR_OUTPUT_FILE_ENV = "GJI_PR_OUTPUT_FILE";
 function parsePrInput(input) {
   if (/^\d+$/.test(input)) return input;
@@ -17673,7 +19326,7 @@ function createPrCommand(dependencies = {}) {
       branchName,
       configuredBasePath
     );
-    if (await pathExists(worktreePath)) {
+    if (await pathExists2(worktreePath)) {
       if (options.json || isHeadless()) {
         const message = `target worktree path already exists: ${worktreePath}`;
         if (options.json) {
@@ -17739,13 +19392,13 @@ function createPrCommand(dependencies = {}) {
       }
       return 1;
     }
-    await mkdir7(dirname8(worktreePath), { recursive: true });
+    await mkdir7(dirname9(worktreePath), { recursive: true });
     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 });
+    await execFileAsync7("git", worktreeArgs, { cwd: repository.repoRoot });
     const syncPatterns = Array.isArray(config.syncFiles) ? config.syncFiles.filter(
       (p2) => typeof p2 === "string"
     ) : [];
@@ -17774,7 +19427,7 @@ function createPrCommand(dependencies = {}) {
       {
         branch: branchName,
         path: worktreePath,
-        repo: basename7(repository.repoRoot)
+        repo: basename8(repository.repoRoot)
       },
       options.stderr
     );
@@ -17792,7 +19445,7 @@ function createPrCommand(dependencies = {}) {
 }
 async function localBranchExists2(repoRoot, branchName) {
   try {
-    await execFileAsync5(
+    await execFileAsync7(
       "git",
       ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`],
       { cwd: repoRoot }
@@ -17806,7 +19459,7 @@ var runPrCommand = createPrCommand();
 async function fetchPullRequestRef(repoRoot, input, prNumber, remoteRef) {
   for (const sourceRef of listPullRequestSourceRefs(input, prNumber)) {
     try {
-      await execFileAsync5(
+      await execFileAsync7(
         "git",
         ["fetch", "origin", `${sourceRef}:${remoteRef}`],
         { cwd: repoRoot }
@@ -17856,11 +19509,415 @@ async function writeOutput2(worktreePath, stdout2) {
   await writeShellOutput(PR_OUTPUT_FILE_ENV, worktreePath, stdout2);
 }
 
+// src/browser.ts
+import { execFile as execFile8 } from "node:child_process";
+import { platform as platform2 } from "node:process";
+import { promisify as promisify9 } from "node:util";
+var execFileAsync8 = promisify9(execFile8);
+function createBrowserOpener(dependencies = {}) {
+  const currentPlatform = dependencies.platform ?? platform2;
+  const runCommand = dependencies.runCommand ?? defaultRunCommand2;
+  return async function openBrowser2(url) {
+    validateBrowserUrl(url);
+    const command = browserCommand(currentPlatform, url);
+    await runCommand(command.command, command.args);
+  };
+}
+var openBrowser = createBrowserOpener();
+function browserCommand(currentPlatform, url) {
+  if (currentPlatform === "darwin") return { args: [url], command: "open" };
+  if (currentPlatform === "win32") {
+    return { args: [url], command: "explorer.exe" };
+  }
+  return { args: [url], command: "xdg-open" };
+}
+function validateBrowserUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error("browser URL is invalid");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("browser URL must use http or https");
+  }
+}
+async function defaultRunCommand2(command, args) {
+  await execFileAsync8(command, args, { timeout: 1e4 });
+}
+
+// src/pr-open.ts
+function createPrOpenCommand(dependencies = {}) {
+  const query = createPullRequestQuery();
+  const findOpenPullRequest2 = dependencies.findOpenPullRequest ?? query.findOpenPullRequest;
+  const openInBrowser = dependencies.openBrowser ?? openBrowser;
+  const promptForPullRequest = dependencies.promptForPullRequest ?? defaultPromptForPullRequest;
+  const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree2;
+  const queryPullRequests = dependencies.queryPullRequests ?? query.listOpenPullRequests;
+  const queryRepositoryPullRequests = dependencies.queryRepositoryPullRequests ?? (dependencies.queryPullRequests === void 0 ? query.listOpenPullRequestsForRepository : void 0);
+  return async function runPrOpenCommand2(options) {
+    if (options.select && options.target !== void 0) {
+      options.stderr("gji pr open: --select cannot be used with a target\n");
+      return 1;
+    }
+    if (options.select && isHeadless()) {
+      options.stderr(
+        "gji pr open --select: selector is unavailable in non-interactive mode (GJI_NO_TUI=1)\n"
+      );
+      return 1;
+    }
+    const repository = await detectRepository(options.cwd).catch((error) => {
+      options.stderr(
+        `gji pr open: unable to detect the current repository: ${formatError(error)}
+`
+      );
+      return null;
+    });
+    if (repository === null) return 1;
+    if (options.target === void 0) {
+      if (!options.select) {
+        return openCurrentWorktree(
+          repository.repoRoot,
+          options,
+          queryPullRequests,
+          promptForPullRequest,
+          openInBrowser
+        );
+      }
+      return openFromWorktreeSelector(
+        repository.repoRoot,
+        repository.repoName,
+        options,
+        promptForWorktree2,
+        promptForPullRequest,
+        queryPullRequests,
+        queryRepositoryPullRequests,
+        openInBrowser
+      );
+    }
+    const number = parsePrNumberTarget(options.target);
+    if (number !== null) {
+      return openByNumber(
+        repository.repoRoot,
+        number,
+        options,
+        findOpenPullRequest2,
+        openInBrowser
+      );
+    }
+    const worktrees = await listWorktrees(options.cwd).catch((error) => {
+      options.stderr(
+        `gji pr open: unable to list worktrees: ${formatError(error)}
+`
+      );
+      return null;
+    });
+    if (worktrees === null) return 1;
+    const match = resolveWorktreeQuery(
+      worktrees.map((worktree) => ({
+        repoRoot: repository.repoRoot,
+        repoName: repository.repoName,
+        worktree
+      })),
+      options.target
+    );
+    if (match === null) {
+      options.stderr(
+        `gji pr open: no worktree found matching: ${options.target}
+`
+      );
+      return 1;
+    }
+    return openForBranch(
+      repository.repoRoot,
+      match.worktree.branch,
+      options,
+      queryPullRequests,
+      promptForPullRequest,
+      openInBrowser
+    );
+  };
+}
+var runPrOpenCommand = createPrOpenCommand();
+async function openCurrentWorktree(repoRoot, options, queryPullRequests, promptForPullRequest, openInBrowser) {
+  const worktrees = await listWorktrees(options.cwd).catch((error) => {
+    options.stderr(
+      `gji pr open: unable to list worktrees: ${formatError(error)}
+`
+    );
+    return null;
+  });
+  if (worktrees === null) return 1;
+  const currentWorktree = worktrees.find((worktree) => worktree.isCurrent);
+  if (currentWorktree === void 0) {
+    options.stderr("gji pr open: unable to identify the current worktree\n");
+    return 1;
+  }
+  if (currentWorktree.branch === null) {
+    options.stderr(
+      "gji pr open: current worktree is detached and has no PR branch\n"
+    );
+    return 1;
+  }
+  let pullRequests;
+  try {
+    pullRequests = await queryPullRequests(repoRoot, currentWorktree.branch);
+  } catch (error) {
+    options.stderr(
+      `gji pr open: failed to look up PRs for current branch ${currentWorktree.branch}: ${formatError(error)}
+`
+    );
+    return 1;
+  }
+  if (pullRequests.length === 0) {
+    options.stderr(
+      isHeadless() ? "gji pr open: no open PR found for the current worktree; pass an explicit branch or PR number (for example, gji pr open '#123')\n" : "gji pr open: no open PR found for the current worktree; use gji pr open --select to choose another\n"
+    );
+    return 1;
+  }
+  return openPullRequests(
+    pullRequests,
+    options,
+    promptForPullRequest,
+    openInBrowser
+  );
+}
+async function openFromWorktreeSelector(repoRoot, repoName, options, promptForWorktree2, promptForPullRequest, queryPullRequests, queryRepositoryPullRequests, openInBrowser) {
+  const worktrees = await listWorktrees(options.cwd).catch((error) => {
+    options.stderr(
+      `gji pr open: unable to list worktrees: ${formatError(error)}
+`
+    );
+    return null;
+  });
+  if (worktrees === null) return 1;
+  let lookupError = null;
+  const queryForSelector = async (root, branch) => {
+    try {
+      return await queryPullRequests(root, branch);
+    } catch (error) {
+      lookupError ??= error;
+      throw error;
+    }
+  };
+  const queryRepositoryForSelector = queryRepositoryPullRequests === void 0 ? void 0 : async (root) => {
+    try {
+      return await queryRepositoryPullRequests(root);
+    } catch (error) {
+      lookupError ??= error;
+      throw error;
+    }
+  };
+  let connectedWorktrees;
+  try {
+    connectedWorktrees = await readConnectedWorktreeSources(
+      repoRoot,
+      repoName,
+      worktrees,
+      queryForSelector,
+      queryRepositoryForSelector
+    );
+  } catch {
+    connectedWorktrees = { pullRequestsByBranch: /* @__PURE__ */ new Map(), sources: [] };
+  }
+  const { pullRequestsByBranch, sources } = connectedWorktrees;
+  const entries = await buildWorktreePromptEntries(sources, {
+    queryPullRequests: async (_root, branch) => pullRequestsByBranch.get(branch) ?? []
+  });
+  const connectedEntries = entries.filter(
+    (entry) => (entry.pullRequestNumbers?.length ?? 0) > 0
+  );
+  if (connectedEntries.length === 0) {
+    if (lookupError !== null) {
+      options.stderr(
+        `gji pr open: failed to look up open PRs: ${formatError(lookupError)}
+`
+      );
+      return 1;
+    }
+    options.stderr("gji pr open: no open PR worktrees found\n");
+    return 1;
+  }
+  const selectedPath = await promptForWorktree2(connectedEntries);
+  if (selectedPath === null) {
+    options.stderr("Aborted\n");
+    return 1;
+  }
+  const selectedEntry = connectedEntries.find(
+    (entry) => entry.path === selectedPath
+  );
+  if (selectedEntry === void 0) {
+    options.stderr("gji pr open: selected worktree is no longer available\n");
+    return 1;
+  }
+  return openSelectedEntry(
+    selectedEntry,
+    options,
+    promptForPullRequest,
+    openInBrowser
+  );
+}
+async function readConnectedWorktreeSources(repoRoot, repoName, worktrees, queryPullRequests, queryRepositoryPullRequests) {
+  const pullRequestsByBranch = /* @__PURE__ */ new Map();
+  if (queryRepositoryPullRequests !== void 0) {
+    const pullRequests = await queryRepositoryPullRequests(repoRoot);
+    for (const worktree of worktrees) {
+      if (worktree.branch === null) continue;
+      const branchPullRequests = pullRequests.filter(
+        (pullRequest) => pullRequest.sourceBranch === worktree.branch
+      );
+      if (branchPullRequests.length > 0) {
+        pullRequestsByBranch.set(worktree.branch, branchPullRequests);
+      }
+    }
+  } else {
+    const branchResults = await Promise.all(
+      worktrees.map(async (worktree) => {
+        if (worktree.branch === null) {
+          return { pullRequests: [], worktree };
+        }
+        try {
+          return {
+            pullRequests: await queryPullRequests(repoRoot, worktree.branch),
+            worktree
+          };
+        } catch {
+          return { pullRequests: [], worktree };
+        }
+      })
+    );
+    for (const { pullRequests, worktree } of branchResults) {
+      if (worktree.branch !== null && pullRequests.length > 0) {
+        pullRequestsByBranch.set(worktree.branch, pullRequests);
+      }
+    }
+  }
+  const sources = worktrees.flatMap((worktree) => {
+    if (worktree.branch === null || !pullRequestsByBranch.has(worktree.branch)) {
+      return [];
+    }
+    return [{ repoRoot, repoName, worktree }];
+  });
+  return { pullRequestsByBranch, sources };
+}
+async function openByNumber(repoRoot, number, options, findOpenPullRequest2, openInBrowser) {
+  let pullRequest;
+  try {
+    pullRequest = await findOpenPullRequest2(repoRoot, number);
+  } catch (error) {
+    options.stderr(
+      `gji pr open: failed to look up PR #${number}: ${formatError(error)}
+`
+    );
+    return 1;
+  }
+  if (pullRequest === null) {
+    options.stderr(`gji pr open: no open PR found for #${number}
+`);
+    return 1;
+  }
+  return launchBrowser(pullRequest, options, openInBrowser);
+}
+async function openForBranch(repoRoot, branch, options, queryPullRequests, promptForPullRequest, openInBrowser) {
+  if (branch === null) {
+    options.stderr("gji pr open: detached worktrees have no PR branch\n");
+    return 1;
+  }
+  let pullRequests;
+  try {
+    pullRequests = await queryPullRequests(repoRoot, branch);
+  } catch (error) {
+    options.stderr(
+      `gji pr open: failed to look up PRs for branch ${branch}: ${formatError(error)}
+`
+    );
+    return 1;
+  }
+  return openPullRequests(
+    pullRequests,
+    options,
+    promptForPullRequest,
+    openInBrowser
+  );
+}
+async function openSelectedEntry(entry, options, promptForPullRequest, openInBrowser) {
+  const numbers = entry.pullRequestNumbers ?? [];
+  const urls = entry.pullRequestUrls ?? [];
+  const pullRequests = numbers.map((number, index) => ({
+    number,
+    sourceBranch: entry.branch ?? "",
+    url: urls[index] ?? ""
+  })).filter((pullRequest) => pullRequest.url.length > 0);
+  return openPullRequests(
+    pullRequests,
+    options,
+    promptForPullRequest,
+    openInBrowser
+  );
+}
+async function openPullRequests(pullRequests, options, promptForPullRequest, openInBrowser) {
+  if (pullRequests.length === 0) {
+    options.stderr("gji pr open: no open PR found for the selected branch\n");
+    return 1;
+  }
+  if (pullRequests.length > 1 && isHeadless()) {
+    options.stderr(
+      "gji pr open: multiple open PRs found; pass an explicit PR number in non-interactive mode (GJI_NO_TUI=1)\n"
+    );
+    return 1;
+  }
+  const selected = pullRequests.length === 1 ? pullRequests[0] : await promptForPullRequest(pullRequests);
+  if (selected === null || selected === void 0) {
+    options.stderr("Aborted\n");
+    return 1;
+  }
+  return launchBrowser(selected, options, openInBrowser);
+}
+async function launchBrowser(pullRequest, options, openInBrowser) {
+  try {
+    await openInBrowser(pullRequest.url);
+  } catch (error) {
+    options.stderr(
+      `gji pr open: failed to open PR #${pullRequest.number} in the browser: ${formatError(error)}
+`
+    );
+    return 1;
+  }
+  options.stdout(`Opened PR #${pullRequest.number}: ${pullRequest.url}
+`);
+  return 0;
+}
+function parsePrNumberTarget(target) {
+  const match = target.match(/^#?(\d+)$/);
+  return match === null ? null : Number(match[1]);
+}
+async function defaultPromptForWorktree2(worktrees) {
+  return promptForSingleWorktree(
+    "Choose a worktree with an open PR",
+    worktrees
+  );
+}
+async function defaultPromptForPullRequest(pullRequests) {
+  const choice = await ve({
+    message: "Choose a pull request",
+    options: pullRequests.map((pullRequest) => ({
+      value: pullRequest.number,
+      label: `#${pullRequest.number}`,
+      hint: pullRequest.url
+    }))
+  });
+  if (pD(choice)) return null;
+  return pullRequests.find((pullRequest) => pullRequest.number === choice) ?? null;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/remove.ts
-import { basename as basename8 } from "node:path";
+import { basename as basename9 } from "node:path";
 var REMOVE_OUTPUT_FILE_ENV = "GJI_REMOVE_OUTPUT_FILE";
 function createRemoveCommand(dependencies = {}) {
-  const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree2;
+  const promptForWorktree2 = dependencies.promptForWorktree ?? defaultPromptForWorktree3;
   const confirmRemoval = dependencies.confirmRemoval ?? defaultConfirmRemoval2;
   const confirmForceRemoveWorktree = dependencies.confirmForceRemoveWorktree ?? defaultConfirmForceRemoveWorktree;
   const confirmForceDeleteBranch = dependencies.confirmForceDeleteBranch ?? defaultConfirmForceDeleteBranch;
@@ -17944,7 +20001,7 @@ function createRemoveCommand(dependencies = {}) {
       {
         branch: worktree.branch ?? void 0,
         path: worktree.path,
-        repo: basename8(repository.repoRoot)
+        repo: basename9(repository.repoRoot)
       },
       options.stderr
     );
@@ -18004,7 +20061,7 @@ function createRemoveCommand(dependencies = {}) {
   };
 }
 var runRemoveCommand = createRemoveCommand();
-async function defaultPromptForWorktree2(worktrees) {
+async function defaultPromptForWorktree3(worktrees) {
   return promptForSingleWorktree("Choose a worktree to finish", worktrees);
 }
 async function defaultConfirmRemoval2(worktree) {
@@ -18329,11 +20386,11 @@ function resolveConfiguredString2(value) {
 }
 
 // src/sync-files-command.ts
-import { homedir as homedir6 } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { join as join10 } from "node:path";
 async function runSyncFilesCommand(options) {
   const repository = await detectRepository(options.cwd);
-  const home = options.home ?? homedir6();
+  const home = options.home ?? homedir7();
   const loaded = await loadGlobalConfig(home);
   const repoEntry = findRepoConfigEntry(
     loaded.config,
@@ -18379,7 +20436,7 @@ 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)) {
+    if (expandTilde3(key, home) === repoRoot && isPlainObject3(value)) {
       return { config: value, key };
     }
   }
@@ -18463,9 +20520,9 @@ function writeError(options, message) {
   options.stderr(`gji sync-files: ${message}
 `);
 }
-function expandTilde2(value, home) {
+function expandTilde3(value, home) {
   if (value === "~") return home;
-  if (value.startsWith("~/")) return join9(home, value.slice(2));
+  if (value.startsWith("~/")) return join10(home, value.slice(2));
   return value;
 }
 
@@ -18487,7 +20544,9 @@ function readPackageMetadata() {
 }
 async function runCli(argv, options = {}) {
   await maybeNotifyForUpdates(argv);
-  maybeRegisterCurrentRepo(options.cwd ?? process.cwd());
+  if (argv[0] !== "doctor") {
+    maybeRegisterCurrentRepo(options.cwd ?? process.cwd());
+  }
   const program2 = createProgram();
   const cwd = options.cwd ?? process.cwd();
   const stdout2 = options.stdout ?? (() => void 0);
@@ -18502,7 +20561,12 @@ async function runCli(argv, options = {}) {
     return { exitCode: 0 };
   }
   try {
-    attachCommandActions(program2, { cwd, stderr, stdout: stdout2 });
+    attachCommandActions(program2, {
+      cwd,
+      prOpenDependencies: options.prOpenDependencies,
+      stderr,
+      stdout: stdout2
+    });
     await program2.parseAsync(["node", "gji", ...argv], { from: "node" });
     return { exitCode: 0 };
   } catch (error) {
@@ -18548,9 +20612,12 @@ function registerCommands(program2) {
     "--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("init [shell]").description(
+    "set up shell integration interactively or print a shell wrapper"
+  ).option("--write", "write the integration to the shell config file").option("--json", "emit a JSON error in non-interactive mode").action(notImplemented("init"));
+  program2.command("doctor").description("check gji installation and configuration health").option("--fix", "apply safe automatic fixes after showing the plan").option("--yes", "apply --fix without prompting").option("--json", "emit diagnostic checks as JSON").action(notImplemented("doctor"));
   program2.command("completion [shell]").description("print shell completion definitions").action(notImplemented("completion"));
-  program2.command("pr <ref>").description(
+  const prCommand = program2.command("pr <ref>").usage("[options] <ref>").description(
     "fetch a pull request by number, #number, or URL into a linked worktree"
   ).option(
     "--dry-run",
@@ -18559,6 +20626,7 @@ function registerCommands(program2) {
     "--json",
     "emit JSON on success or error instead of human-readable output"
   ).action(notImplemented("pr"));
+  prCommand.command("open [target]").description("open an existing pull request in the default browser").option("--select", "choose a pull request from any linked worktree").action(notImplemented("pr open"));
   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"));
@@ -18616,16 +20684,16 @@ function registerCommands(program2) {
 }
 function attachCommandActions(program2, options) {
   program2.commands.find((command) => command.name() === "new")?.action(
-    async (branch, commandOptions) => {
+    async (branch, commandOptions2) => {
       const exitCode = await runNewCommand({
         ...options,
         branch,
-        detached: commandOptions.detached,
-        dryRun: commandOptions.dryRun,
-        editor: commandOptions.editor,
-        force: commandOptions.force,
-        json: commandOptions.json,
-        open: commandOptions.open
+        detached: commandOptions2.detached,
+        dryRun: commandOptions2.dryRun,
+        editor: commandOptions2.editor,
+        force: commandOptions2.force,
+        json: commandOptions2.json,
+        open: commandOptions2.open
       });
       if (exitCode !== 0) {
         throw commanderExit(exitCode);
@@ -18633,13 +20701,29 @@ function attachCommandActions(program2, options) {
     }
   );
   program2.commands.find((command) => command.name() === "init")?.action(
-    async (shell, commandOptions) => {
+    async (shell, commandOptions2) => {
       const exitCode = await runInitCommand({
         cwd: options.cwd,
+        json: commandOptions2.json,
         shell,
         stderr: options.stderr,
         stdout: options.stdout,
-        write: commandOptions.write
+        write: commandOptions2.write
+      });
+      if (exitCode !== 0) {
+        throw commanderExit(exitCode);
+      }
+    }
+  );
+  program2.commands.find((command) => command.name() === "doctor")?.action(
+    async (commandOptions2) => {
+      const exitCode = await runDoctorCommand({
+        cwd: options.cwd,
+        fix: commandOptions2.fix,
+        json: commandOptions2.json,
+        stderr: options.stderr,
+        stdout: options.stdout,
+        yes: commandOptions2.yes
       });
       if (exitCode !== 0) {
         throw commanderExit(exitCode);
@@ -18657,11 +20741,11 @@ function attachCommandActions(program2, options) {
     }
   });
   program2.commands.find((command) => command.name() === "pr")?.action(
-    async (number, commandOptions) => {
+    async (number, commandOptions2) => {
       const exitCode = await runPrCommand({
         cwd: options.cwd,
-        dryRun: commandOptions.dryRun,
-        json: commandOptions.json,
+        dryRun: commandOptions2.dryRun,
+        json: commandOptions2.json,
         number,
         stderr: options.stderr,
         stdout: options.stdout
@@ -18671,8 +20755,24 @@ function attachCommandActions(program2, options) {
       }
     }
   );
+  const prOpenCommand = program2.commands.find((command) => command.name() === "pr")?.commands.find((command) => command.name() === "open");
+  const runPrOpenCommand2 = createPrOpenCommand(options.prOpenDependencies);
+  prOpenCommand?.action(
+    async (target, commandOptions2) => {
+      const exitCode = await runPrOpenCommand2({
+        cwd: options.cwd,
+        stderr: options.stderr,
+        stdout: options.stdout,
+        select: commandOptions2.select,
+        target
+      });
+      if (exitCode !== 0) {
+        throw commanderExit(exitCode);
+      }
+    }
+  );
   program2.commands.find((command) => command.name() === "back")?.action(
-    async (n, commandOptions) => {
+    async (n, commandOptions2) => {
       if (n !== void 0 && !/^\d+$/.test(n)) {
         options.stderr(`gji back: invalid step count: ${n}
 `);
@@ -18682,7 +20782,7 @@ function attachCommandActions(program2, options) {
       const exitCode = await runBackCommand({
         cwd: options.cwd,
         n: steps,
-        print: commandOptions.print,
+        print: commandOptions2.print,
         stderr: options.stderr,
         stdout: options.stdout
       });
@@ -18691,10 +20791,10 @@ function attachCommandActions(program2, options) {
       }
     }
   );
-  program2.commands.find((command) => command.name() === "history")?.action(async (commandOptions) => {
+  program2.commands.find((command) => command.name() === "history")?.action(async (commandOptions2) => {
     const exitCode = await runHistoryCommand({
       cwd: options.cwd,
-      json: commandOptions.json,
+      json: commandOptions2.json,
       stdout: options.stdout
     });
     if (exitCode !== 0) {
@@ -18702,15 +20802,15 @@ function attachCommandActions(program2, options) {
     }
   });
   program2.commands.find((command) => command.name() === "open")?.action(
-    async (branch, commandOptions) => {
+    async (branch, commandOptions2) => {
       const exitCode = await runOpenCommand({
         branch,
         cwd: options.cwd,
-        editor: commandOptions.editor,
-        save: commandOptions.save,
+        editor: commandOptions2.editor,
+        save: commandOptions2.save,
         stderr: options.stderr,
         stdout: options.stdout,
-        workspace: commandOptions.workspace
+        workspace: commandOptions2.workspace
       });
       if (exitCode !== 0) {
         throw commanderExit(exitCode);
@@ -18718,11 +20818,11 @@ function attachCommandActions(program2, options) {
     }
   );
   program2.commands.find((command) => command.name() === "go")?.action(
-    async (branch, commandOptions) => {
+    async (branch, commandOptions2) => {
       const exitCode = await runGoCommand({
         branch,
         cwd: options.cwd,
-        print: commandOptions.print,
+        print: commandOptions2.print,
         stderr: options.stderr,
         stdout: options.stdout
       });
@@ -18731,31 +20831,31 @@ function attachCommandActions(program2, options) {
       }
     }
   );
-  program2.commands.find((command) => command.name() === "root")?.action(async (commandOptions) => {
+  program2.commands.find((command) => command.name() === "root")?.action(async (commandOptions2) => {
     const exitCode = await runRootCommand({
       cwd: options.cwd,
-      print: commandOptions.print,
+      print: commandOptions2.print,
       stdout: options.stdout
     });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "status")?.action(async (commandOptions) => {
+  program2.commands.find((command) => command.name() === "status")?.action(async (commandOptions2) => {
     const exitCode = await runStatusCommand({
       cwd: options.cwd,
-      json: commandOptions.json,
+      json: commandOptions2.json,
       stdout: options.stdout
     });
     if (exitCode !== 0) {
       throw commanderExit(exitCode);
     }
   });
-  program2.commands.find((command) => command.name() === "sync")?.action(async (commandOptions) => {
+  program2.commands.find((command) => command.name() === "sync")?.action(async (commandOptions2) => {
     const exitCode = await runSyncCommand({
-      all: commandOptions.all,
+      all: commandOptions2.all,
       cwd: options.cwd,
-      json: commandOptions.json,
+      json: commandOptions2.json,
       stderr: options.stderr,
       stdout: options.stdout
     });
@@ -18766,11 +20866,11 @@ function attachCommandActions(program2, options) {
   const syncFilesCommand = program2.commands.find(
     (command) => command.name() === "sync-files"
   );
-  syncFilesCommand?.action(async (commandOptions) => {
+  syncFilesCommand?.action(async (commandOptions2) => {
     const exitCode = await runSyncFilesCommand({
       action: "list",
       cwd: options.cwd,
-      json: commandOptions.json,
+      json: commandOptions2.json,
       stderr: options.stderr,
       stdout: options.stdout
     });
@@ -18778,11 +20878,11 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
-  syncFilesCommand?.commands.find((command) => command.name() === "list")?.action(async (commandOptions) => {
+  syncFilesCommand?.commands.find((command) => command.name() === "list")?.action(async (commandOptions2) => {
     const exitCode = await runSyncFilesCommand({
       action: "list",
       cwd: options.cwd,
-      json: commandOptions.json || syncFilesCommand?.opts().json,
+      json: commandOptions2.json || syncFilesCommand?.opts().json,
       stderr: options.stderr,
       stdout: options.stdout
     });
@@ -18790,11 +20890,11 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
-  syncFilesCommand?.commands.find((command) => command.name() === "add")?.action(async (paths, commandOptions) => {
+  syncFilesCommand?.commands.find((command) => command.name() === "add")?.action(async (paths, commandOptions2) => {
     const exitCode = await runSyncFilesCommand({
       action: "add",
       cwd: options.cwd,
-      json: commandOptions.json || syncFilesCommand?.opts().json,
+      json: commandOptions2.json || syncFilesCommand?.opts().json,
       paths,
       stderr: options.stderr,
       stdout: options.stdout
@@ -18803,11 +20903,11 @@ function attachCommandActions(program2, options) {
       throw commanderExit(exitCode);
     }
   });
-  const runSyncFilesRemoveCommand = async (paths, commandOptions) => {
+  const runSyncFilesRemoveCommand = async (paths, commandOptions2) => {
     const exitCode = await runSyncFilesCommand({
       action: "remove",
       cwd: options.cwd,
-      json: commandOptions.json || syncFilesCommand?.opts().json,
+      json: commandOptions2.json || syncFilesCommand?.opts().json,
       paths,
       stderr: options.stderr,
       stdout: options.stdout
@@ -18817,11 +20917,11 @@ function attachCommandActions(program2, options) {
     }
   };
   syncFilesCommand?.commands.find((command) => command.name() === "remove")?.action(runSyncFilesRemoveCommand);
-  program2.commands.find((command) => command.name() === "ls")?.action(async (commandOptions) => {
+  program2.commands.find((command) => command.name() === "ls")?.action(async (commandOptions2) => {
     const exitCode = await runLsCommand({
-      compact: commandOptions.compact,
+      compact: commandOptions2.compact,
       cwd: options.cwd,
-      json: commandOptions.json,
+      json: commandOptions2.json,
       stdout: options.stdout
     });
     if (exitCode !== 0) {
@@ -18829,13 +20929,13 @@ function attachCommandActions(program2, options) {
     }
   });
   program2.commands.find((command) => command.name() === "clean")?.action(
-    async (commandOptions) => {
+    async (commandOptions2) => {
       const exitCode = await runCleanCommand({
         cwd: options.cwd,
-        dryRun: commandOptions.dryRun,
-        force: commandOptions.force,
-        json: commandOptions.json,
-        stale: commandOptions.stale,
+        dryRun: commandOptions2.dryRun,
+        force: commandOptions2.force,
+        json: commandOptions2.json,
+        stale: commandOptions2.stale,
         stderr: options.stderr,
         stdout: options.stdout
       });
@@ -18844,13 +20944,13 @@ function attachCommandActions(program2, options) {
       }
     }
   );
-  const runRemovalCommand = async (branch, commandOptions = {}) => {
+  const runRemovalCommand = async (branch, commandOptions2 = {}) => {
     const exitCode = await runRemoveCommand({
       branch,
       cwd: options.cwd,
-      dryRun: commandOptions.dryRun,
-      force: commandOptions.force,
-      json: commandOptions.json,
+      dryRun: commandOptions2.dryRun,
+      force: commandOptions2.force,
+      json: commandOptions2.json,
       stderr: options.stderr,
       stdout: options.stdout
     });
@@ -18870,14 +20970,14 @@ function attachCommandActions(program2, options) {
     }
   });
   program2.commands.find((command) => command.name() === "warp")?.action(
-    async (branch, commandOptions) => {
-      const newFlag = commandOptions.new;
+    async (branch, commandOptions2) => {
+      const newFlag = commandOptions2.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,
+        json: commandOptions2.json,
         newWorktree,
         stderr: options.stderr,
         stdout: options.stdout
@@ -18971,18 +21071,21 @@ async function main() {
 }
 async function warnIfMissingShellIntegration() {
   try {
-    const { config } = await loadGlobalConfig(homedir7());
+    const { config } = await loadGlobalConfig(homedir8());
     if (!config.shellIntegration) {
-      const shellBin = (process.env.SHELL ?? "").split("/").at(-1);
-      const shellArg = shellBin && ["bash", "zsh", "fish"].includes(shellBin) ? ` ${shellBin}` : "";
+      const setupCommand = isHeadless() ? legacyShellSetupCommand() : "gji init";
       process.stderr.write(
-        `gji: shell integration not set up \u2014 run \`gji init${shellArg} --write\` to enable automatic cd.
+        `gji: shell integration not set up \u2014 run \`${setupCommand}\` to enable automatic cd.
 `
       );
     }
   } catch {
   }
 }
+function legacyShellSetupCommand() {
+  const shell = (process.env.SHELL ?? "").split("/").at(-1);
+  return shell && ["bash", "fish", "zsh"].includes(shell) ? `gji init ${shell} --write` : "gji init <shell> --write";
+}
 void main();
 /*! Bundled license information: