@plannotator/opencode 0.19.10 → 0.19.11

package/dist/index.js

@@ -42405,9 +42405,9 @@ var Thread = class {
         stderrChunks.push(data);
       });
     }
-    const exitPromise = new Promise((resolve5) => {
+    const exitPromise = new Promise((resolve6) => {
       child.once("exit", (code, signal) => {
-        resolve5({ code, signal });
+        resolve6({ code, signal });
       });
     });
     const rl2 = readline.createInterface({
@@ -42910,8 +42910,8 @@ class PiProcess {
   }
   sendAndWait(command) {
     const id = `req_${++this.nextId}`;
-    return new Promise((resolve5, reject) => {
-      this.pendingRequests.set(id, { resolve: resolve5, reject });
+    return new Promise((resolve6, reject) => {
+      this.pendingRequests.set(id, { resolve: resolve6, reject });
       this.send({ ...command, id });
     });
   }
@@ -43052,15 +43052,15 @@ var init_pi_sdk = __esm(() => {
         }
         const effectivePrompt = buildEffectivePrompt(prompt, this.config.systemPrompt, this._firstQuerySent);
         const queue = [];
-        let resolve5 = null;
+        let resolve6 = null;
         let done = false;
         const push = (msg) => {
           queue.push(msg);
-          resolve5?.();
+          resolve6?.();
         };
         const finish = () => {
           done = true;
-          resolve5?.();
+          resolve6?.();
         };
         const unsubscribe = this.process.onEvent((event) => {
           const mapped = mapPiEvent(event, this.id);
@@ -43092,9 +43092,9 @@ var init_pi_sdk = __esm(() => {
               yield queue.shift();
             } else {
               await new Promise((r9) => {
-                resolve5 = r9;
+                resolve6 = r9;
               });
-              resolve5 = null;
+              resolve6 = null;
             }
           }
         } finally {
@@ -43130,7 +43130,7 @@ var init_types_gen = () => {};
 // ../../node_modules/.bun/@opencode-ai+sdk@1.3.5/node_modules/@opencode-ai/sdk/dist/gen/core/serverSentEvents.gen.js
 var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
   let lastEventId;
-  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve5) => setTimeout(resolve5, ms)));
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve6) => setTimeout(resolve6, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3000;
     let attempt = 0;
@@ -44531,7 +44531,7 @@ async function createOpencodeServer(options) {
       OPENCODE_CONFIG_CONTENT: JSON.stringify(options.config ?? {})
     }
   });
-  const url = await new Promise((resolve5, reject) => {
+  const url = await new Promise((resolve6, reject) => {
     const id = setTimeout(() => {
       reject(new Error(`Timeout waiting for server to start after ${options.timeout}ms`));
     }, options.timeout);
@@ -44547,7 +44547,7 @@ async function createOpencodeServer(options) {
             throw new Error(`Failed to parse server url from output: ${line}`);
           }
           clearTimeout(id);
-          resolve5(match[1]);
+          resolve6(match[1]);
           return;
         }
       }
@@ -61846,6 +61846,33 @@ async function startPlannotatorServer(options) {
 
 // ../../packages/shared/review-core.ts
 import { resolve as resolvePath } from "path";
+var JJ_TRUNK_REVSET = "trunk()";
+function parseRemoteBookmark(target) {
+  const at = target.lastIndexOf("@");
+  if (at <= 0 || at === target.length - 1)
+    return null;
+  return { name: target.slice(0, at), remote: target.slice(at + 1) };
+}
+function jjCompareTargetRevset(target) {
+  const remoteBookmark = parseRemoteBookmark(target);
+  if (remoteBookmark) {
+    return `remote_bookmarks(exact:${quoteJjString(remoteBookmark.name)}, exact:${quoteJjString(remoteBookmark.remote)})`;
+  }
+  const localBookmark = parseJjBookmarkName(target);
+  return localBookmark ? `bookmarks(exact:${quoteJjString(localBookmark)})` : target;
+}
+function jjLineBaseRevset(target) {
+  const compareTarget = jjCompareTargetRevset(target);
+  return `heads(::@ & ::(${compareTarget}))`;
+}
+function parseJjBookmarkName(target) {
+  if (!target || target.startsWith("@") || /[()\s]/.test(target))
+    return null;
+  return target;
+}
+function quoteJjString(value) {
+  return JSON.stringify(value);
+}
 async function getCurrentBranch2(runtime, cwd) {
   const result = await runtime.runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd });
   return result.exitCode === 0 ? result.stdout.trim() || "HEAD" : "HEAD";
@@ -61972,7 +61999,21 @@ async function getGitContext(runtime, cwd) {
     diffOptions,
     worktrees: worktrees.filter((wt) => wt.path !== currentTreePath),
     availableBranches,
-    cwd
+    compareTarget: {
+      diffTypes: ["branch", "merge-base"],
+      fallback: "main",
+      picker: {
+        rowLabel: "compare against",
+        triggerLabel: "base",
+        triggerTitlePrefix: "Review base",
+        searchPlaceholder: "Search branches\u2026",
+        emptyText: "No branches match.",
+        localGroupLabel: "Local",
+        remoteGroupLabel: "Remote"
+      }
+    },
+    cwd,
+    vcsType: "git"
   };
 }
 async function getUntrackedFileDiffs(runtime, srcPrefix = "a/", dstPrefix = "b/", cwd, options) {
@@ -62171,9 +62212,6 @@ async function runGitDiff(runtime, diffType, defaultBranch = "main", externalCwd
   }
   return { patch, label };
 }
-async function runGitDiffWithContext(runtime, diffType, gitContext, options) {
-  return runGitDiff(runtime, diffType, gitContext.defaultBranch, gitContext.cwd, options);
-}
 async function getFileContentsForDiff(runtime, diffType, defaultBranch, filePath, oldPath, cwd) {
   const oldFilePath = oldPath || filePath;
   let effectiveDiffType = diffType;
@@ -62263,53 +62301,507 @@ function parseP4DiffType(diffType) {
   return null;
 }
 
-// ../../packages/server/git.ts
-async function runGit(args, options) {
-  const proc = Bun.spawn(["git", "-c", "core.quotePath=false", ...args], {
-    cwd: options?.cwd,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  let timer;
-  if (options?.timeoutMs) {
-    timer = setTimeout(() => proc.kill(), options.timeoutMs);
+// ../../packages/shared/vcs-core.ts
+import { isAbsolute as isAbsolute2, relative, resolve as resolve5 } from "path";
+
+// ../../packages/shared/jj-core.ts
+import { basename as basename2 } from "path";
+async function detectJjWorkspace(runtime, cwd) {
+  const result = await runtime.runJj(["workspace", "root"], { cwd });
+  return result.exitCode === 0 ? result.stdout.trim() || null : null;
+}
+async function getJjContext(runtime, cwd) {
+  const root3 = await detectJjWorkspace(runtime, cwd);
+  const targets = await listJjCompareTargets(runtime, root3 ?? cwd);
+  const defaultTarget = selectDefaultJjCompareTarget(targets);
+  const contextCwd = root3 ?? cwd;
+  return {
+    currentBranch: "",
+    defaultBranch: defaultTarget,
+    diffOptions: [
+      { id: "jj-current", label: "Current change" },
+      { id: "jj-last", label: "Last change" },
+      { id: "jj-line", label: "Line of work" },
+      { id: "jj-all", label: "All files" }
+    ],
+    worktrees: [],
+    availableBranches: targets,
+    compareTarget: {
+      diffTypes: ["jj-line"],
+      fallback: defaultTarget,
+      picker: {
+        rowLabel: "from revision",
+        triggerLabel: "revision",
+        triggerTitlePrefix: "Compare against",
+        searchPlaceholder: "Search bookmarks...",
+        emptyText: "No bookmarks match.",
+        localGroupLabel: "Bookmarks",
+        remoteGroupLabel: "Remote bookmarks"
+      }
+    },
+    repository: contextCwd ? { displayFallback: basename2(contextCwd) } : undefined,
+    cwd: contextCwd,
+    vcsType: "jj"
+  };
+}
+async function runJjDiff(runtime, diffType, defaultBranch, cwd, options) {
+  const compareTarget = defaultBranch.length > 0 ? defaultBranch : JJ_TRUNK_REVSET;
+  const args = getJjDiffArgs(diffType, compareTarget, options);
+  if (!args)
+    return { patch: "", label: "Unknown diff type" };
+  const result = await runtime.runJj(args.args, { cwd });
+  if (result.exitCode !== 0) {
+    return { patch: "", label: args.label, error: firstErrorLine(result.stderr) };
   }
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  if (timer)
-    clearTimeout(timer);
-  return { stdout, stderr, exitCode };
+  const patch = options?.hideWhitespace ? dropHunklessGitDiffChunks(result.stdout) : result.stdout;
+  return { patch, label: args.label };
 }
-var runtime = {
-  runGit,
-  async readTextFile(path2) {
-    try {
-      return await Bun.file(path2).text();
-    } catch {
-      return null;
+function dropHunklessGitDiffChunks(patch) {
+  if (!patch.includes("diff --git "))
+    return patch;
+  const chunks = patch.split(/^diff --git /m);
+  const prefix = chunks.shift() ?? "";
+  const filtered = chunks.filter(hasReviewableGitDiffChunk).map((chunk) => `diff --git ${chunk}`).join("");
+  return `${prefix}${filtered}`;
+}
+function hasReviewableGitDiffChunk(chunk) {
+  if (/^@@@? /m.test(chunk))
+    return true;
+  return /^(new file mode|deleted file mode|old mode|new mode|rename from|rename to|copy from|copy to|GIT binary patch|Binary files |similarity index|dissimilarity index)/m.test(chunk);
+}
+async function getJjFileContentsForDiff(runtime, diffType, defaultBranch, filePath, oldPath, cwd) {
+  validateFilePath(filePath);
+  if (oldPath)
+    validateFilePath(oldPath);
+  const oldFilePath = oldPath === undefined || oldPath.length === 0 ? filePath : oldPath;
+  const root3 = await detectJjWorkspace(runtime, cwd);
+  const fileCwd = root3 ?? cwd;
+  switch (diffType) {
+    case "jj-current":
+      return {
+        oldContent: await jjFileContent(runtime, "@-", oldFilePath, fileCwd),
+        newContent: await jjFileContent(runtime, "@", filePath, fileCwd)
+      };
+    case "jj-last": {
+      const parentRev = await resolveJjParent(runtime, "@-", fileCwd);
+      return {
+        oldContent: parentRev ? await jjFileContent(runtime, parentRev, oldFilePath, fileCwd) : null,
+        newContent: await jjFileContent(runtime, "@-", filePath, fileCwd)
+      };
+    }
+    case "jj-line": {
+      const compareTarget = defaultBranch.length > 0 ? defaultBranch : JJ_TRUNK_REVSET;
+      return {
+        oldContent: await jjFileContent(runtime, jjLineBaseRevset(compareTarget), oldFilePath, fileCwd),
+        newContent: await jjFileContent(runtime, "@", filePath, fileCwd)
+      };
     }
+    case "jj-all":
+      return {
+        oldContent: null,
+        newContent: await jjFileContent(runtime, "@", filePath, fileCwd)
+      };
+    default:
+      return { oldContent: null, newContent: null };
   }
-};
-function getGitContext2(cwd) {
-  return getGitContext(runtime, cwd);
 }
-function runGitDiff2(diffType, defaultBranch = "main", cwd, options) {
-  return runGitDiff(runtime, diffType, defaultBranch, cwd, options);
+function getJjDiffArgs(diffType, compareTarget, options) {
+  const whitespaceArgs = options?.hideWhitespace ? ["-w"] : [];
+  switch (diffType) {
+    case "jj-current":
+      return { args: ["diff", "--git", ...whitespaceArgs, "-r", "@"], label: "Current change" };
+    case "jj-last":
+      return { args: ["diff", "--git", ...whitespaceArgs, "-r", "@-"], label: "Last change" };
+    case "jj-line":
+      return {
+        args: ["diff", "--git", ...whitespaceArgs, "--from", jjLineBaseRevset(compareTarget), "--to", "@"],
+        label: `Line of work vs ${compareTarget}`
+      };
+    case "jj-all":
+      return { args: ["diff", "--git", ...whitespaceArgs, "--from", "root()", "--to", "@"], label: "All files" };
+    default:
+      return null;
+  }
+}
+function selectDefaultJjCompareTarget(targets) {
+  const preferredNames = ["main", "develop", "master", "trunk"];
+  for (const name of preferredNames) {
+    const preferredRemote = [
+      `${name}@origin`,
+      `${name}@upstream`,
+      `${name}@git`,
+      ...targets.remote.filter((target) => target.startsWith(`${name}@`)).sort()
+    ].find((target) => targets.remote.includes(target));
+    if (preferredRemote)
+      return preferredRemote;
+    if (targets.local.includes(name))
+      return name;
+  }
+  return JJ_TRUNK_REVSET;
+}
+async function listJjCompareTargets(runtime, cwd) {
+  const [localResult, remoteResult] = await Promise.all([
+    runtime.runJj([
+      "bookmark",
+      "list",
+      "--sort",
+      "committer-date-",
+      "--sort",
+      "name",
+      "-T",
+      "if(remote, '', if(present, json(name) ++ '\\n', ''))"
+    ], { cwd }),
+    runtime.runJj([
+      "bookmark",
+      "list",
+      "--all-remotes",
+      "--sort",
+      "committer-date-",
+      "--sort",
+      "name",
+      "-T",
+      "if(remote, if(present, json(name) ++ '\\t' ++ json(remote) ++ '\\n', ''), '')"
+    ], { cwd })
+  ]);
+  const local = localResult.exitCode === 0 ? parseJjBookmarkList(localResult.stdout) : [];
+  const remote = remoteResult.exitCode === 0 ? parseJjRemoteBookmarkList(remoteResult.stdout) : [];
+  return {
+    local,
+    remote
+  };
+}
+function parseJjBookmarkList(stdout) {
+  const seen = new Set;
+  const bookmarks = [];
+  for (const rawLine of splitJjTemplateRecords(stdout)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    const bookmark = parseSerializedJjString(line);
+    if (!bookmark || seen.has(bookmark))
+      continue;
+    seen.add(bookmark);
+    bookmarks.push(bookmark);
+  }
+  return bookmarks;
+}
+function parseJjRemoteBookmarkList(stdout) {
+  const seen = new Set;
+  const bookmarks = [];
+  for (const rawLine of splitJjTemplateRecords(stdout)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    const fields = splitJjTemplateFields(line);
+    if (!fields)
+      continue;
+    const [nameField, remoteField] = fields;
+    const name = parseSerializedJjString(nameField);
+    const remote = parseSerializedJjString(remoteField);
+    if (!name || !remote)
+      continue;
+    const bookmark = `${name}@${remote}`;
+    if (seen.has(bookmark))
+      continue;
+    seen.add(bookmark);
+    bookmarks.push(bookmark);
+  }
+  return bookmarks;
+}
+function splitJjTemplateRecords(stdout) {
+  return stdout.split(/\n|\\n/g);
+}
+function splitJjTemplateFields(line) {
+  const literalTab = line.indexOf("\t");
+  if (literalTab !== -1)
+    return [line.slice(0, literalTab), line.slice(literalTab + 1)];
+  const escapedTab = line.indexOf("\\t");
+  if (escapedTab !== -1)
+    return [line.slice(0, escapedTab), line.slice(escapedTab + 2)];
+  return null;
+}
+function parseSerializedJjString(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function jjFileContent(runtime, rev, filePath, cwd) {
+  const result = await runtime.runJj(["file", "show", "-r", rev, "--", filePath], { cwd });
+  return result.exitCode === 0 ? result.stdout : null;
+}
+async function resolveJjParent(runtime, rev, cwd) {
+  const result = await runtime.runJj(["log", "-r", rev, "--no-graph", "-T", "parents.map(|p| p.change_id()).join(' ')", "--limit", "1"], { cwd });
+  const parent = result.stdout.trim().split(/\s+/).find(Boolean);
+  return result.exitCode === 0 && parent ? parent : null;
+}
+function firstErrorLine(stderr) {
+  const line = stderr.split(`
+`).find((value) => value.trim().length > 0)?.trim();
+  if (!line)
+    return;
+  return line.length > 200 ? line.slice(0, 200) + "..." : line;
+}
+
+// ../../packages/shared/vcs-core.ts
+var GIT_DIFF_TYPES = new Set(["uncommitted", "staged", "unstaged", "last-commit", "branch", "merge-base", "all"]);
+var JJ_DIFF_TYPES = new Set(["jj-current", "jj-last", "jj-line", "jj-all"]);
+function selectNearestProvider(candidates, cwd) {
+  if (candidates.length === 0)
+    return null;
+  const effectiveCwd = resolve5(cwd ?? process.cwd());
+  const ranked = candidates.map((candidate) => ({
+    ...candidate,
+    rootDepth: candidate.root ? vcsRootDepth(candidate.root) : -1,
+    containsCwd: candidate.root ? isSameOrAncestor(candidate.root, effectiveCwd) : false
+  })).sort((a2, b3) => {
+    if (a2.containsCwd !== b3.containsCwd)
+      return a2.containsCwd ? -1 : 1;
+    if (a2.rootDepth !== b3.rootDepth)
+      return b3.rootDepth - a2.rootDepth;
+    return a2.order - b3.order;
+  });
+  return ranked[0]?.provider ?? null;
+}
+function isSameOrAncestor(root3, child) {
+  const relativePath = relative(resolve5(root3), child);
+  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute2(relativePath);
 }
-function runGitDiffWithContext2(diffType, gitContext, options) {
-  return runGitDiffWithContext(runtime, diffType, gitContext, options);
+function vcsRootDepth(root3) {
+  return resolve5(root3).split(/[\\/]+/).filter(Boolean).length;
 }
-function getFileContentsForDiff2(diffType, defaultBranch, filePath, oldPath, cwd) {
-  return getFileContentsForDiff(runtime, diffType, defaultBranch, filePath, oldPath, cwd);
+function createGitProvider(runtime) {
+  return {
+    id: "git",
+    async detect(cwd) {
+      try {
+        const result = await runtime.runGit(["rev-parse", "--is-inside-work-tree"], { cwd });
+        return result.exitCode === 0;
+      } catch {
+        return false;
+      }
+    },
+    async getRoot(cwd) {
+      const result = await runtime.runGit(["rev-parse", "--show-toplevel"], { cwd });
+      return result.exitCode === 0 ? result.stdout.trim() || null : null;
+    },
+    ownsDiffType(diffType) {
+      return GIT_DIFF_TYPES.has(diffType) || diffType.startsWith("worktree:");
+    },
+    canStageFiles(diffType) {
+      const effectiveDiffType = parseWorktreeDiffType(diffType)?.subType ?? diffType;
+      return effectiveDiffType === "uncommitted" || effectiveDiffType === "unstaged";
+    },
+    getContext(cwd) {
+      return getGitContext(runtime, cwd);
+    },
+    runDiff(diffType, defaultBranch, cwd, options) {
+      return runGitDiff(runtime, diffType, defaultBranch, cwd, options);
+    },
+    getFileContents(diffType, defaultBranch, filePath, oldPath, cwd) {
+      return getFileContentsForDiff(runtime, diffType, defaultBranch, filePath, oldPath, cwd);
+    },
+    stageFile(filePath, cwd) {
+      return gitAddFile(runtime, filePath, cwd);
+    },
+    unstageFile(filePath, cwd) {
+      return gitResetFile(runtime, filePath, cwd);
+    },
+    detectRemoteDefaultCompareTarget(cwd) {
+      return detectRemoteDefaultBranch(runtime, cwd);
+    },
+    resolveCwd(diffType, fallbackCwd) {
+      const parsed = parseWorktreeDiffType(diffType);
+      return parsed?.path ?? fallbackCwd;
+    }
+  };
 }
-function gitAddFile2(filePath, cwd) {
-  return gitAddFile(runtime, filePath, cwd);
+function createJjProvider(runtime) {
+  return {
+    id: "jj",
+    async detect(cwd) {
+      return await detectJjWorkspace(runtime, cwd) !== null;
+    },
+    getRoot(cwd) {
+      return detectJjWorkspace(runtime, cwd);
+    },
+    ownsDiffType(diffType) {
+      return JJ_DIFF_TYPES.has(diffType);
+    },
+    getContext(cwd) {
+      return getJjContext(runtime, cwd);
+    },
+    runDiff(diffType, defaultBranch, cwd, options) {
+      return runJjDiff(runtime, diffType, defaultBranch, cwd, options);
+    },
+    getFileContents(diffType, defaultBranch, filePath, oldPath, cwd) {
+      return getJjFileContentsForDiff(runtime, diffType, defaultBranch, filePath, oldPath, cwd);
+    }
+  };
 }
-function gitResetFile2(filePath, cwd) {
-  return gitResetFile(runtime, filePath, cwd);
+function createVcsApi(providers) {
+  const providerList = [...providers];
+  const defaultProvider = providerList.find((provider) => provider.id === "git") ?? providerList[0];
+  const vcsCache = new Map;
+  if (!defaultProvider) {
+    throw new Error("createVcsApi requires at least one provider");
+  }
+  async function detectVcs(cwd) {
+    const key2 = cwd ?? process.cwd();
+    const cached = vcsCache.get(key2);
+    if (cached)
+      return cached;
+    const candidates = [];
+    for (const provider of providerList) {
+      let root3 = null;
+      let detected2 = false;
+      try {
+        if (provider.getRoot) {
+          root3 = await provider.getRoot(cwd);
+          detected2 = root3 !== null;
+        } else {
+          detected2 = await provider.detect(cwd);
+        }
+      } catch {
+        continue;
+      }
+      if (detected2) {
+        candidates.push({ provider, root: root3, order: candidates.length });
+      }
+    }
+    const detected = selectNearestProvider(candidates, cwd) ?? defaultProvider;
+    vcsCache.set(key2, detected);
+    return detected;
+  }
+  function getProviderForDiffType(diffType) {
+    for (const provider of providerList) {
+      if (provider.ownsDiffType(diffType)) {
+        return provider;
+      }
+    }
+    return null;
+  }
+  function getProviderById(id) {
+    return providerList.find((provider) => provider.id === id) ?? null;
+  }
+  function formatVcsName(id) {
+    switch (id) {
+      case "git":
+        return "Git";
+      case "jj":
+        return "JJ";
+      case "p4":
+        return "P4";
+    }
+  }
+  async function getProviderForSelection(vcsType, cwd) {
+    if (!vcsType || vcsType === "auto") {
+      return detectVcs(cwd);
+    }
+    const provider = getProviderById(vcsType);
+    const vcsName = formatVcsName(vcsType);
+    if (!provider) {
+      throw new Error(`${vcsName} support is not available in this runtime.`);
+    }
+    if (!await provider.detect(cwd)) {
+      throw new Error(`${vcsName} workspace not found.`);
+    }
+    return provider;
+  }
+  async function getProviderForOperation(diffType, cwd) {
+    return getProviderForDiffType(diffType) ?? detectVcs(cwd);
+  }
+  async function getContextWithProvider(cwd, vcsType) {
+    const provider = await getProviderForSelection(vcsType, cwd);
+    return { provider, gitContext: await provider.getContext(cwd) };
+  }
+  function resolveRequestedDiffType(provider, gitContext, requestedDiffType, configuredDiffType) {
+    if (requestedDiffType && provider.ownsDiffType(requestedDiffType)) {
+      return requestedDiffType;
+    }
+    return resolveInitialDiffType(gitContext, configuredDiffType);
+  }
+  function resolveInitialBase(gitContext, diffType, requestedBase, ownsRequestedDiffType) {
+    if (gitContext.vcsType === "jj") {
+      if (diffType === "jj-line" && ownsRequestedDiffType && requestedBase) {
+        return requestedBase;
+      }
+      return gitContext.defaultBranch;
+    }
+    return requestedBase ?? gitContext.defaultBranch;
+  }
+  return {
+    detectVcs,
+    async getVcsContext(cwd, vcsType) {
+      return (await getContextWithProvider(cwd, vcsType)).gitContext;
+    },
+    async detectRemoteDefaultCompareTarget(cwd, vcsType) {
+      const provider = await getProviderForSelection(vcsType, cwd);
+      return provider.detectRemoteDefaultCompareTarget?.(cwd) ?? null;
+    },
+    async prepareLocalReviewDiff(options) {
+      const { provider, gitContext } = await getContextWithProvider(options.cwd, options.vcsType);
+      const ownsRequestedDiffType = options.requestedDiffType !== undefined && provider.ownsDiffType(options.requestedDiffType);
+      const diffType = resolveRequestedDiffType(provider, gitContext, options.requestedDiffType, options.configuredDiffType);
+      const base = resolveInitialBase(gitContext, diffType, options.requestedBase, ownsRequestedDiffType);
+      const result = await provider.runDiff(diffType, base, gitContext.cwd ?? options.cwd, {
+        hideWhitespace: options.hideWhitespace
+      });
+      return {
+        gitContext,
+        diffType,
+        base,
+        rawPatch: result.patch,
+        gitRef: result.label,
+        error: result.error
+      };
+    },
+    async runVcsDiff(diffType, defaultBranch = "main", cwd, options) {
+      const provider = await getProviderForOperation(diffType, cwd);
+      return provider.runDiff(diffType, defaultBranch, cwd, options);
+    },
+    async getVcsFileContentsForDiff(diffType, defaultBranch, filePath, oldPath, cwd) {
+      const provider = await getProviderForOperation(diffType, cwd);
+      return provider.getFileContents(diffType, defaultBranch, filePath, oldPath, cwd);
+    },
+    async canStageFiles(diffType, cwd) {
+      const provider = await getProviderForOperation(diffType, cwd);
+      return provider.stageFile !== undefined && (provider.canStageFiles?.(diffType) ?? false);
+    },
+    async stageFile(diffType, filePath, cwd) {
+      const provider = await getProviderForOperation(diffType, cwd);
+      if (!provider.stageFile || !(provider.canStageFiles?.(diffType) ?? false)) {
+        throw new Error(`Staging not available for ${provider.id}`);
+      }
+      return provider.stageFile(filePath, cwd);
+    },
+    async unstageFile(diffType, filePath, cwd) {
+      const provider = await getProviderForOperation(diffType, cwd);
+      if (!provider.unstageFile || !(provider.canStageFiles?.(diffType) ?? false)) {
+        throw new Error(`Unstaging not available for ${provider.id}`);
+      }
+      return provider.unstageFile(filePath, cwd);
+    },
+    resolveVcsCwd(diffType, fallbackCwd) {
+      const provider = getProviderForDiffType(diffType);
+      return provider?.resolveCwd?.(diffType, fallbackCwd) ?? fallbackCwd;
+    }
+  };
+}
+function resolveInitialDiffType(gitContext, configuredDiffType) {
+  if (gitContext.vcsType === "p4") {
+    return "p4-default";
+  }
+  if (gitContext.vcsType === "jj") {
+    return "jj-current";
+  }
+  if (gitContext.diffOptions.some((option2) => option2.id === configuredDiffType)) {
+    return configuredDiffType;
+  }
+  const fallback = gitContext.diffOptions[0]?.id;
+  return fallback ? fallback : configuredDiffType;
 }
 
 // ../../packages/server/p4.ts
@@ -62605,43 +63097,66 @@ async function getP4FileContentsForDiff(diffType, filePath, cwd) {
   };
 }
 
-// ../../packages/server/vcs.ts
-var GIT_DIFF_TYPES = new Set(["uncommitted", "staged", "unstaged", "last-commit", "branch", "merge-base", "all"]);
-var gitProvider = {
-  id: "git",
-  async detect(cwd) {
+// ../../packages/server/git.ts
+async function runGit(args, options) {
+  const proc = Bun.spawn(["git", "-c", "core.quotePath=false", ...args], {
+    cwd: options?.cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  let timer;
+  if (options?.timeoutMs) {
+    timer = setTimeout(() => proc.kill(), options.timeoutMs);
+  }
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  if (timer)
+    clearTimeout(timer);
+  return { stdout, stderr, exitCode };
+}
+var runtime = {
+  runGit,
+  async readTextFile(path2) {
     try {
-      const proc = Bun.spawn(["git", "rev-parse", "--is-inside-work-tree"], {
-        cwd: cwd ?? undefined,
-        stdout: "ignore",
-        stderr: "ignore"
-      });
-      return await proc.exited === 0;
+      return await Bun.file(path2).text();
     } catch {
-      return false;
+      return null;
     }
-  },
-  ownsDiffType(diffType) {
-    return GIT_DIFF_TYPES.has(diffType) || diffType.startsWith("worktree:");
-  },
-  getContext: getGitContext2,
-  runDiff(diffType, defaultBranch, cwd, options) {
-    return runGitDiff2(diffType, defaultBranch, cwd, options);
-  },
-  getFileContents(diffType, defaultBranch, filePath, oldPath, cwd) {
-    return getFileContentsForDiff2(diffType, defaultBranch, filePath, oldPath, cwd);
-  },
-  stageFile: gitAddFile2,
-  unstageFile: gitResetFile2,
-  resolveCwd(diffType, fallbackCwd) {
-    if (diffType.startsWith("worktree:")) {
-      const parsed = parseWorktreeDiffType(diffType);
-      if (parsed)
-        return parsed.path;
+  }
+};
+
+// ../../packages/server/jj.ts
+async function runJj(args, options) {
+  try {
+    const proc = Bun.spawn(["jj", ...args], {
+      cwd: options?.cwd,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    let timer;
+    if (options?.timeoutMs) {
+      timer = setTimeout(() => proc.kill(), options.timeoutMs);
     }
-    return fallbackCwd;
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (timer)
+      clearTimeout(timer);
+    return { stdout, stderr, exitCode };
+  } catch {
+    return { stdout: "", stderr: "jj not found", exitCode: 1 };
   }
+}
+var runtime2 = {
+  runJj
 };
+
+// ../../packages/server/vcs.ts
 var p4Provider = {
   id: "p4",
   async detect(cwd) {
@@ -62658,63 +63173,23 @@ var p4Provider = {
     return getP4FileContentsForDiff(diffType, filePath, cwd);
   }
 };
-var providers = [gitProvider, p4Provider];
-var vcsCache = new Map;
-async function detectVcs(cwd) {
-  const key2 = cwd ?? process.cwd();
-  const cached = vcsCache.get(key2);
-  if (cached)
-    return cached;
-  for (const provider of providers) {
-    if (await provider.detect(cwd)) {
-      vcsCache.set(key2, provider);
-      return provider;
-    }
-  }
-  vcsCache.set(key2, gitProvider);
-  return gitProvider;
-}
-function getProviderForDiffType(diffType) {
-  for (const provider of providers) {
-    if (provider.ownsDiffType(diffType))
-      return provider;
-  }
-  return gitProvider;
-}
-async function getVcsContext(cwd) {
-  const provider = await detectVcs(cwd);
-  return provider.getContext(cwd);
-}
-async function runVcsDiff(diffType, defaultBranch = "main", cwd, options) {
-  const provider = getProviderForDiffType(diffType);
-  return provider.runDiff(diffType, defaultBranch, cwd, options);
-}
-async function getVcsFileContentsForDiff(diffType, defaultBranch, filePath, oldPath, cwd) {
-  const provider = getProviderForDiffType(diffType);
-  return provider.getFileContents(diffType, defaultBranch, filePath, oldPath, cwd);
-}
-function canStageFiles(diffType) {
-  const provider = getProviderForDiffType(diffType);
-  return provider.stageFile !== undefined;
-}
-async function stageFile(diffType, filePath, cwd) {
-  const provider = getProviderForDiffType(diffType);
-  if (!provider.stageFile) {
-    throw new Error(`Staging not available for ${provider.id}`);
-  }
-  return provider.stageFile(filePath, cwd);
-}
-async function unstageFile(diffType, filePath, cwd) {
-  const provider = getProviderForDiffType(diffType);
-  if (!provider.unstageFile) {
-    throw new Error(`Unstaging not available for ${provider.id}`);
-  }
-  return provider.unstageFile(filePath, cwd);
-}
-function resolveVcsCwd(diffType, fallbackCwd) {
-  const provider = getProviderForDiffType(diffType);
-  return provider.resolveCwd?.(diffType, fallbackCwd) ?? fallbackCwd;
-}
+var api = createVcsApi([
+  createJjProvider(runtime2),
+  createGitProvider(runtime),
+  p4Provider
+]);
+var {
+  detectVcs,
+  getVcsContext,
+  detectRemoteDefaultCompareTarget,
+  prepareLocalReviewDiff,
+  runVcsDiff,
+  getVcsFileContentsForDiff,
+  canStageFiles,
+  stageFile,
+  unstageFile,
+  resolveVcsCwd
+} = api;
 
 // ../../packages/shared/pr-stack.ts
 function branchNameIsSafe(branch) {
@@ -62763,17 +63238,17 @@ function getPRDiffScopeOptions(metadata, hasLocalCheckout) {
     }
   ];
 }
-async function resolvePRFullStackBaseRef(runtime2, defaultBranch, cwd) {
+async function resolvePRFullStackBaseRef(runtime3, defaultBranch, cwd) {
   const remoteRef = `origin/${defaultBranch}`;
-  const remote = await runtime2.runGit(["show-ref", "--verify", "--quiet", `refs/remotes/${remoteRef}`], { cwd });
+  const remote = await runtime3.runGit(["show-ref", "--verify", "--quiet", `refs/remotes/${remoteRef}`], { cwd });
   if (remote.exitCode === 0)
     return remoteRef;
-  const local = await runtime2.runGit(["show-ref", "--verify", "--quiet", `refs/heads/${defaultBranch}`], { cwd });
+  const local = await runtime3.runGit(["show-ref", "--verify", "--quiet", `refs/heads/${defaultBranch}`], { cwd });
   if (local.exitCode === 0)
     return defaultBranch;
   return null;
 }
-async function runPRFullStackDiff(runtime2, metadata, cwd) {
+async function runPRFullStackDiff(runtime3, metadata, cwd) {
   const defaultBranch = metadata.defaultBranch;
   if (!defaultBranch || !branchNameIsSafe(defaultBranch)) {
     return {
@@ -62782,7 +63257,7 @@ async function runPRFullStackDiff(runtime2, metadata, cwd) {
       error: "Could not determine a safe default branch for this review."
     };
   }
-  const baseRef = await resolvePRFullStackBaseRef(runtime2, defaultBranch, cwd);
+  const baseRef = await resolvePRFullStackBaseRef(runtime3, defaultBranch, cwd);
   if (!baseRef) {
     return {
       patch: "",
@@ -62798,7 +63273,7 @@ async function runPRFullStackDiff(runtime2, metadata, cwd) {
     "--end-of-options",
     `${baseRef}...HEAD`
   ];
-  const diff = await runtime2.runGit(diffArgs, { cwd });
+  const diff = await runtime3.runGit(diffArgs, { cwd });
   if (diff.exitCode !== 0) {
     const message = diff.stderr.trim() || `git ${diffArgs.join(" ")} failed`;
     return {
@@ -62813,21 +63288,21 @@ async function runPRFullStackDiff(runtime2, metadata, cwd) {
     label: `Full stack diff vs ${baseRef}`
   };
 }
-async function checkoutPRHead(runtime2, metadata, cwd) {
+async function checkoutPRHead(runtime3, metadata, cwd) {
   const refSpec = metadata.platform === "github" ? `refs/pull/${metadata.number}/head` : `refs/merge-requests/${metadata.iid}/head`;
-  const fetch2 = await runtime2.runGit(["fetch", "origin", refSpec], { cwd });
+  const fetch2 = await runtime3.runGit(["fetch", "origin", refSpec], { cwd });
   if (fetch2.exitCode !== 0)
     return false;
-  const checkout = await runtime2.runGit(["checkout", "FETCH_HEAD"], { cwd });
+  const checkout = await runtime3.runGit(["checkout", "FETCH_HEAD"], { cwd });
   return checkout.exitCode === 0;
 }
 
 // ../../packages/server/path-utils.ts
-import { relative } from "path";
+import { relative as relative2 } from "path";
 function toRelativePath2(absolutePath, cwd) {
   if (!cwd)
     return absolutePath;
-  const rel = relative(cwd, absolutePath);
+  const rel = relative2(cwd, absolutePath);
   if (rel.startsWith(".."))
     return absolutePath;
   return rel.replace(/\\/g, "/");
@@ -62877,7 +63352,7 @@ project guidance files explicitly expand your scope.
 ## Pipeline
 
 Step 1: Gather context
-  - Retrieve the PR diff (gh pr diff or git diff)
+  - Retrieve the PR diff or local diff (gh pr diff, git diff, or jj diff)
   - Read CLAUDE.md and REVIEW.md at the repo root and in every directory
     containing modified files
   - Build a map of which rules apply to which file paths
@@ -62995,6 +63470,13 @@ function buildClaudeCommand(prompt, model = "claude-opus-4-7", effort) {
     "Bash(git remote:*)",
     "Bash(git rev-parse:*)",
     "Bash(git show-ref:*)",
+    "Bash(jj status:*)",
+    "Bash(jj diff:*)",
+    "Bash(jj log:*)",
+    "Bash(jj show:*)",
+    "Bash(jj file show:*)",
+    "Bash(jj cat:*)",
+    "Bash(jj bookmark list:*)",
     "Bash(wc:*)"
   ].join(",");
   const disallowedTools = [
@@ -63610,64 +64092,6 @@ Ignore non-blocking issues such as style, formatting, typos, documentation, and
 
 FORMATTING GUIDELINES:
 The finding description should be one paragraph.`;
-function buildCodexReviewUserMessage(patch, diffType, options, prMetadata) {
-  if (prMetadata) {
-    if (options?.prDiffScope === "full-stack") {
-      return [
-        `Full-stack review of ${prMetadata.url}`,
-        "",
-        "This is a stacked PR. The diff below shows ALL accumulated changes from the repository default branch through this PR's head (not just this PR's own layer).",
-        "Review the complete diff for issues that span the stack.",
-        "",
-        "```diff",
-        patch,
-        "```"
-      ].join(`
-`);
-    }
-    if (options?.hasLocalAccess) {
-      return [
-        prMetadata.url,
-        "",
-        "You are in a local worktree checked out at the PR head. The code is available locally.",
-        `To see the PR changes, diff against the remote base branch: git diff origin/${prMetadata.baseBranch}...HEAD`,
-        "Do NOT diff against the local `main` branch \u2014 it may be stale. Always use origin/."
-      ].join(`
-`);
-    }
-    return prMetadata.url;
-  }
-  const effectiveDiffType = diffType.startsWith("worktree:") ? diffType.split(":").pop() || "uncommitted" : diffType;
-  switch (effectiveDiffType) {
-    case "uncommitted":
-      return "Review the current code changes (staged, unstaged, and untracked files) and provide prioritized findings.";
-    case "staged":
-      return "Review the currently staged code changes (`git diff --staged`) and provide prioritized findings.";
-    case "unstaged":
-      return "Review the unstaged code changes (tracked modifications and untracked files) and provide prioritized findings.";
-    case "last-commit":
-      return "Review the code changes introduced in the last commit (`git diff HEAD~1..HEAD`) and provide prioritized findings.";
-    case "branch": {
-      const base = options?.defaultBranch || "main";
-      return `Review the code changes against the base branch '${base}'. Run \`git diff ${base}..HEAD\` to inspect the changes. Provide prioritized, actionable findings.`;
-    }
-    case "merge-base": {
-      const base = options?.defaultBranch || "main";
-      return `Review the PR-style diff against base '${base}'. First find the common ancestor with \`git merge-base ${base} HEAD\`, then run \`git diff <merge-base>..HEAD\` using that commit to inspect only the changes introduced on this branch (matches GitHub's PR view). Provide prioritized, actionable findings.`;
-    }
-    case "all":
-      return "Review every file in the repository (all files shown as additions, diffed against an empty tree). Provide prioritized, actionable findings.";
-    default:
-      return [
-        "Review the following code changes and provide prioritized findings.",
-        "",
-        "```diff",
-        patch,
-        "```"
-      ].join(`
-`);
-  }
-}
 async function buildCodexCommand(options) {
   const { cwd, outputPath, prompt, model, reasoningEffort, fastMode } = options;
   const schemaPath = await ensureSchemaFile();
@@ -63760,6 +64184,124 @@ ${f3.body}`.trim(),
   return annotations;
 }
 
+// ../../packages/server/agent-review-message.ts
+function buildAgentReviewUserMessage(patch, diffType, options, prMetadata) {
+  if (prMetadata) {
+    if (options?.prDiffScope === "full-stack") {
+      return [
+        `Full-stack review of ${prMetadata.url}`,
+        "",
+        "This is a stacked PR. The diff below shows ALL accumulated changes from the repository default branch through this PR's head (not just this PR's own layer).",
+        "Review the complete diff for issues that span the stack.",
+        "",
+        "```diff",
+        patch,
+        "```"
+      ].join(`
+`);
+    }
+    if (options?.hasLocalAccess) {
+      return [
+        prMetadata.url,
+        "",
+        "You are in a local worktree checked out at the PR head. The code is available locally.",
+        `To see the PR changes, diff against the remote base branch: git diff origin/${prMetadata.baseBranch}...HEAD`,
+        "Do NOT diff against the local `main` branch; it may be stale. Always use origin/."
+      ].join(`
+`);
+    }
+    return prMetadata.url;
+  }
+  const instruction = getLocalDiffInstruction(diffType, options?.defaultBranch);
+  if (instruction) {
+    return `Review ${instruction.target}. ${instruction.inspect} Provide prioritized, actionable findings.`;
+  }
+  return [
+    "Review the following code changes and provide prioritized findings.",
+    "",
+    "```diff",
+    patch,
+    "```"
+  ].join(`
+`);
+}
+function getLocalDiffInstruction(diffType, defaultBranch) {
+  const effectiveDiffType = normalizeLocalDiffType(diffType);
+  switch (effectiveDiffType) {
+    case "uncommitted":
+      return {
+        target: "the current code changes (staged, unstaged, and untracked files)",
+        inspect: "Inspect the working tree changes locally."
+      };
+    case "staged":
+      return {
+        target: "the currently staged code changes",
+        inspect: "Run `git diff --staged` to inspect the changes."
+      };
+    case "unstaged":
+      return {
+        target: "the unstaged code changes (tracked modifications and untracked files)",
+        inspect: "Inspect the unstaged working tree changes locally."
+      };
+    case "last-commit":
+      return {
+        target: "the code changes introduced in the last commit",
+        inspect: "Run `git diff HEAD~1..HEAD` to inspect the changes."
+      };
+    case "branch": {
+      const base = defaultBranch || "main";
+      return {
+        target: `the code changes against the base branch '${base}'`,
+        inspect: `Run \`git diff ${base}..HEAD\` to inspect the changes.`
+      };
+    }
+    case "merge-base": {
+      const base = defaultBranch || "main";
+      return {
+        target: `the PR-style diff against base '${base}'`,
+        inspect: `First find the common ancestor with \`git merge-base ${base} HEAD\`, then run \`git diff <merge-base>..HEAD\` using that commit to inspect only the changes introduced on this branch (matches GitHub's PR view).`
+      };
+    }
+    case "all":
+      return {
+        target: "every file in the repository",
+        inspect: "All files are shown as additions, diffed against an empty tree."
+      };
+    case "jj-current":
+      return {
+        target: "the current JJ change",
+        inspect: "Run `jj diff --git -r @` to inspect the changes."
+      };
+    case "jj-last":
+      return {
+        target: "the previous JJ change",
+        inspect: "Run `jj diff --git -r @-` to inspect the changes."
+      };
+    case "jj-line": {
+      const base = defaultBranch || JJ_TRUNK_REVSET;
+      const baseRevset = jjLineBaseRevset(base);
+      return {
+        target: `the JJ line of work against \`${base}\``,
+        inspect: `Run \`jj diff --git --from ${shellQuote(baseRevset)} --to @\` to inspect the changes.`
+      };
+    }
+    case "jj-all":
+      return {
+        target: "all files in the JJ workspace",
+        inspect: "Run `jj diff --git --from 'root()' --to @` to inspect the changes."
+      };
+    default:
+      return null;
+  }
+}
+function normalizeLocalDiffType(diffType) {
+  const worktree = parseWorktreeDiffType(diffType);
+  return worktree?.subType ?? diffType;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
 // ../../packages/server/tour/tour-review.ts
 import { join as join10 } from "path";
 import { homedir as homedir6, tmpdir as tmpdir3 } from "os";
@@ -63992,7 +64534,7 @@ should reference at least one stop.
 
 ## Pipeline
 
-1. Read the full diff (git diff or inlined patch).
+1. Read the full diff (git diff, jj diff, or inlined patch).
 2. Read CLAUDE.md and README.md for project context.
 3. Read commit messages (git log --oneline) and PR title/body if available.
 4. Identify logical groupings of change (cross-file when appropriate). These
@@ -64062,36 +64604,18 @@ function buildTourUserMessage(patch, diffType, options, prMetadata) {
     return [prMetadata.url, "", "Walk the reviewer through this PR as a guided tour."].join(`
 `);
   }
-  const effectiveDiffType = diffType.startsWith("worktree:") ? diffType.split(":").pop() || "uncommitted" : diffType;
-  switch (effectiveDiffType) {
-    case "uncommitted":
-      return "Walk the reviewer through the current code changes (staged, unstaged, and untracked files) as a guided tour.";
-    case "staged":
-      return "Walk the reviewer through the currently staged code changes (`git diff --staged`) as a guided tour.";
-    case "unstaged":
-      return "Walk the reviewer through the unstaged code changes (tracked modifications and untracked files) as a guided tour.";
-    case "last-commit":
-      return "Walk the reviewer through the code changes introduced in the last commit (`git diff HEAD~1..HEAD`) as a guided tour.";
-    case "branch": {
-      const base = options?.defaultBranch || "main";
-      return `Walk the reviewer through the code changes against the base branch '${base}' as a guided tour. Run \`git diff ${base}..HEAD\` to inspect the changes.`;
-    }
-    case "merge-base": {
-      const base = options?.defaultBranch || "main";
-      return `Walk the reviewer through the PR-style diff against base '${base}' as a guided tour. First find the common ancestor with \`git merge-base ${base} HEAD\`, then run \`git diff <merge-base>..HEAD\` using that commit to inspect only the changes introduced on this branch (matches GitHub's PR view).`;
-    }
-    case "all":
-      return "Walk the reviewer through every file in the repository as a guided tour. All files are shown as additions (diffed against an empty tree).";
-    default:
-      return [
-        "Walk the reviewer through the following code changes as a guided tour.",
-        "",
-        "```diff",
-        patch,
-        "```"
-      ].join(`
-`);
+  const instruction = getLocalDiffInstruction(diffType, options?.defaultBranch);
+  if (instruction) {
+    return `Walk the reviewer through ${instruction.target} as a guided tour. ${instruction.inspect}`;
   }
+  return [
+    "Walk the reviewer through the following code changes as a guided tour.",
+    "",
+    "```diff",
+    patch,
+    "```"
+  ].join(`
+`);
 }
 function buildTourClaudeCommand(prompt, model = "sonnet", effort) {
   const allowedTools = [
@@ -64112,6 +64636,13 @@ function buildTourClaudeCommand(prompt, model = "sonnet", effort) {
     "Bash(git remote:*)",
     "Bash(git rev-parse:*)",
     "Bash(git show-ref:*)",
+    "Bash(jj status:*)",
+    "Bash(jj diff:*)",
+    "Bash(jj log:*)",
+    "Bash(jj show:*)",
+    "Bash(jj file show:*)",
+    "Bash(jj cat:*)",
+    "Bash(jj bookmark list:*)",
     "Bash(gh pr view:*)",
     "Bash(gh pr diff:*)",
     "Bash(gh pr list:*)",
@@ -64315,8 +64846,8 @@ function hostnameArgs(host, args) {
   }
   return args;
 }
-async function checkGhAuth(runtime2, host) {
-  const result = await runtime2.runCommand("gh", hostnameArgs(host, ["auth", "status"]));
+async function checkGhAuth(runtime3, host) {
+  const result = await runtime3.runCommand("gh", hostnameArgs(host, ["auth", "status"]));
   if (result.exitCode !== 0) {
     const stderr = result.stderr.trim();
     const hostHint = host !== "github.com" ? ` --hostname ${host}` : "";
@@ -64324,9 +64855,9 @@ async function checkGhAuth(runtime2, host) {
 ${stderr}`);
   }
 }
-async function getGhUser(runtime2, host) {
+async function getGhUser(runtime3, host) {
   try {
-    const result = await runtime2.runCommand("gh", hostnameArgs(host, ["api", "user", "--jq", ".login"]));
+    const result = await runtime3.runCommand("gh", hostnameArgs(host, ["api", "user", "--jq", ".login"]));
     if (result.exitCode === 0 && result.stdout.trim()) {
       return result.stdout.trim();
     }
@@ -64335,17 +64866,17 @@ async function getGhUser(runtime2, host) {
     return null;
   }
 }
-async function fetchGhPR(runtime2, ref) {
+async function fetchGhPR(runtime3, ref) {
   const repo = repoFlag(ref);
   const [diffResult, viewResult, repoResult] = await Promise.all([
-    runtime2.runCommand("gh", [
+    runtime3.runCommand("gh", [
       "pr",
       "diff",
       String(ref.number),
       "--repo",
       repo
     ]),
-    runtime2.runCommand("gh", [
+    runtime3.runCommand("gh", [
       "pr",
       "view",
       String(ref.number),
@@ -64354,7 +64885,7 @@ async function fetchGhPR(runtime2, ref) {
       "--json",
       "id,title,author,baseRefName,headRefName,baseRefOid,headRefOid,url"
     ]),
-    runtime2.runCommand("gh", [
+    runtime3.runCommand("gh", [
       "repo",
       "view",
       repo,
@@ -64373,7 +64904,7 @@ async function fetchGhPR(runtime2, ref) {
   const raw2 = JSON.parse(viewResult.stdout);
   let mergeBaseSha;
   try {
-    const compareResult = await runtime2.runCommand("gh", hostnameArgs(ref.host, [
+    const compareResult = await runtime3.runCommand("gh", hostnameArgs(ref.host, [
       "api",
       `repos/${ref.owner}/${ref.repo}/compare/${raw2.baseRefOid}...${raw2.headRefOid}`,
       "--jq",
@@ -64460,9 +64991,9 @@ function parseGhPRContext(raw2) {
     }))
   };
 }
-async function fetchGhPRContext(runtime2, ref) {
+async function fetchGhPRContext(runtime3, ref) {
   const repo = repoFlag(ref);
-  const result = await runtime2.runCommand("gh", [
+  const result = await runtime3.runCommand("gh", [
     "pr",
     "view",
     String(ref.number),
@@ -64477,7 +65008,7 @@ async function fetchGhPRContext(runtime2, ref) {
   const raw2 = JSON.parse(result.stdout);
   const context = parseGhPRContext(raw2);
   try {
-    context.reviewThreads = await fetchGhReviewThreads(runtime2, ref);
+    context.reviewThreads = await fetchGhReviewThreads(runtime3, ref);
   } catch {
     context.reviewThreads = [];
   }
@@ -64511,8 +65042,8 @@ query($owner: String!, $repo: String!, $number: Int!) {
     }
   }
 }`;
-async function fetchGhReviewThreads(runtime2, ref) {
-  const result = await runtime2.runCommand("gh", hostnameArgs(ref.host, [
+async function fetchGhReviewThreads(runtime3, ref) {
+  const result = await runtime3.runCommand("gh", hostnameArgs(ref.host, [
     "api",
     "graphql",
     "-f",
@@ -64548,8 +65079,8 @@ async function fetchGhReviewThreads(runtime2, ref) {
     })) : []
   }));
 }
-async function fetchGhPRFileContent(runtime2, ref, sha, filePath) {
-  const result = await runtime2.runCommand("gh", hostnameArgs(ref.host, [
+async function fetchGhPRFileContent(runtime3, ref, sha, filePath) {
+  const result = await runtime3.runCommand("gh", hostnameArgs(ref.host, [
     "api",
     `repos/${ref.owner}/${ref.repo}/contents/${encodeApiFilePath(filePath)}?ref=${sha}`,
     "--jq",
@@ -64567,7 +65098,7 @@ async function fetchGhPRFileContent(runtime2, ref, sha, filePath) {
     return null;
   }
 }
-async function fetchGhPRViewedFiles(runtime2, ref) {
+async function fetchGhPRViewedFiles(runtime3, ref) {
   const query = `
     query($owner: String!, $repo: String!, $number: Int!, $cursor: String) {
       repository(owner: $owner, name: $repo) {
@@ -64604,7 +65135,7 @@ async function fetchGhPRViewedFiles(runtime2, ref) {
     if (cursor) {
       args.push("-F", `cursor=${cursor}`);
     }
-    const res = await runtime2.runCommand("gh", args);
+    const res = await runtime3.runCommand("gh", args);
     if (res.exitCode !== 0) {
       throw new Error(`Failed to fetch PR viewed files: ${res.stderr.trim() || `exit code ${res.exitCode}`}`);
     }
@@ -64622,7 +65153,7 @@ async function fetchGhPRViewedFiles(runtime2, ref) {
   } while (cursor !== null);
   return result;
 }
-async function markGhFilesViewed(runtime2, ref, prNodeId, filePaths, viewed) {
+async function markGhFilesViewed(runtime3, ref, prNodeId, filePaths, viewed) {
   if (filePaths.length === 0)
     return;
   const mutationName = viewed ? "markFileAsViewed" : "unmarkFileAsViewed";
@@ -64633,7 +65164,7 @@ async function markGhFilesViewed(runtime2, ref, prNodeId, filePaths, viewed) {
       }
     }
   `;
-  const results = await Promise.allSettled(filePaths.map((path2) => runtime2.runCommandWithInput ? runtime2.runCommand("gh", hostnameArgs(ref.host, [
+  const results = await Promise.allSettled(filePaths.map((path2) => runtime3.runCommandWithInput ? runtime3.runCommand("gh", hostnameArgs(ref.host, [
     "api",
     "graphql",
     "-f",
@@ -64648,7 +65179,7 @@ async function markGhFilesViewed(runtime2, ref, prNodeId, filePaths, viewed) {
     throw new Error(`Failed to ${mutationName} all files: ${failures[0].reason}`);
   }
 }
-async function submitGhPRReview(runtime2, ref, headSha, action, body3, fileComments) {
+async function submitGhPRReview(runtime3, ref, headSha, action, body3, fileComments) {
   const payload = JSON.stringify({
     commit_id: headSha,
     body: body3,
@@ -64657,8 +65188,8 @@ async function submitGhPRReview(runtime2, ref, headSha, action, body3, fileComme
   });
   const endpoint = `repos/${ref.owner}/${ref.repo}/pulls/${ref.number}/reviews`;
   let result;
-  if (runtime2.runCommandWithInput) {
-    result = await runtime2.runCommandWithInput("gh", hostnameArgs(ref.host, ["api", endpoint, "--method", "POST", "--input", "-"]), payload);
+  if (runtime3.runCommandWithInput) {
+    result = await runtime3.runCommandWithInput("gh", hostnameArgs(ref.host, ["api", endpoint, "--method", "POST", "--input", "-"]), payload);
   } else {
     throw new Error("Runtime does not support stdin input; cannot submit PR review");
   }
@@ -64679,9 +65210,9 @@ query($owner: String!, $repo: String!, $${varName}: String!) {
   }
 }`;
 }
-async function queryPRsByRef(runtime2, ref, kind, refName) {
+async function queryPRsByRef(runtime3, ref, kind, refName) {
   const varName = kind === "head" ? "headRefName" : "baseRefName";
-  const result = await runtime2.runCommand("gh", hostnameArgs(ref.host, [
+  const result = await runtime3.runCommand("gh", hostnameArgs(ref.host, [
     "api",
     "graphql",
     "-f",
@@ -64699,7 +65230,7 @@ async function queryPRsByRef(runtime2, ref, kind, refName) {
   const prs = data?.data?.repository?.pullRequests?.nodes;
   return Array.isArray(prs) ? prs : [];
 }
-async function fetchGhPRStack(runtime2, ref, metadata) {
+async function fetchGhPRStack(runtime3, ref, metadata) {
   if (metadata.platform !== "github")
     return null;
   const defaultBranch = metadata.defaultBranch;
@@ -64719,7 +65250,7 @@ async function fetchGhPRStack(runtime2, ref, metadata) {
   for (let i3 = 0;i3 < maxDepth; i3++) {
     if (nextHead === defaultBranch)
       break;
-    const prs = await queryPRsByRef(runtime2, ref, "head", nextHead);
+    const prs = await queryPRsByRef(runtime3, ref, "head", nextHead);
     if (prs.length === 0) {
       ancestors.push({ branch: nextHead, isCurrent: false, isDefaultBranch: false });
       break;
@@ -64739,7 +65270,7 @@ async function fetchGhPRStack(runtime2, ref, metadata) {
   const descendants = [];
   let nextBase = metadata.headBranch;
   for (let i3 = 0;i3 < maxDepth; i3++) {
-    const prs = await queryPRsByRef(runtime2, ref, "base", nextBase);
+    const prs = await queryPRsByRef(runtime3, ref, "base", nextBase);
     if (prs.length === 0)
       break;
     const pr = prs[0];
@@ -64762,8 +65293,8 @@ async function fetchGhPRStack(runtime2, ref, metadata) {
   ];
   return { nodes };
 }
-async function fetchGhPRList(runtime2, ref) {
-  const result = await runtime2.runCommand("gh", [
+async function fetchGhPRList(runtime3, ref) {
+  const result = await runtime3.runCommand("gh", [
     "pr",
     "list",
     "--repo",
@@ -64831,12 +65362,12 @@ ${d2.diff}`);
   }
   return parts.join("");
 }
-async function checkGlAuth(runtime2, host) {
+async function checkGlAuth(runtime3, host) {
   const args = ["auth", "status"];
   if (host !== "gitlab.com") {
     args.push("--hostname", host);
   }
-  const result = await runtime2.runCommand("glab", args);
+  const result = await runtime3.runCommand("glab", args);
   if (result.exitCode !== 0) {
     const stderr = result.stderr.trim();
     const hostHint = host !== "gitlab.com" ? ` --hostname ${host}` : "";
@@ -64844,9 +65375,9 @@ async function checkGlAuth(runtime2, host) {
 ${stderr}`);
   }
 }
-async function getGlUser(runtime2, host) {
+async function getGlUser(runtime3, host) {
   try {
-    const result = await runtime2.runCommand("glab", apiArgs(host, "/user"));
+    const result = await runtime3.runCommand("glab", apiArgs(host, "/user"));
     if (result.exitCode === 0 && result.stdout.trim()) {
       const user = JSON.parse(result.stdout);
       return user.username ?? null;
@@ -64856,11 +65387,11 @@ async function getGlUser(runtime2, host) {
     return null;
   }
 }
-async function fetchGlMR(runtime2, ref) {
+async function fetchGlMR(runtime3, ref) {
   const encoded = encodeProject(ref.projectPath);
   const [diffResult, viewResult] = await Promise.all([
-    runtime2.runCommand("glab", apiArgs(ref.host, `projects/${encoded}/merge_requests/${ref.iid}/diffs?per_page=100`, ["--paginate"])),
-    runtime2.runCommand("glab", apiArgs(ref.host, `projects/${encoded}/merge_requests/${ref.iid}`))
+    runtime3.runCommand("glab", apiArgs(ref.host, `projects/${encoded}/merge_requests/${ref.iid}/diffs?per_page=100`, ["--paginate"])),
+    runtime3.runCommand("glab", apiArgs(ref.host, `projects/${encoded}/merge_requests/${ref.iid}`))
   ]);
   if (diffResult.exitCode !== 0) {
     throw new Error(`Failed to fetch MR diff: ${diffResult.stderr.trim() || `exit code ${diffResult.exitCode}`}`);
@@ -64877,7 +65408,7 @@ async function fetchGlMR(runtime2, ref) {
   let defaultBranch;
   const projectEndpoint = typeof raw2.target_project_id === "number" ? `projects/${raw2.target_project_id}` : `projects/${encoded}`;
   try {
-    const projectResult = await runtime2.runCommand("glab", apiArgs(ref.host, projectEndpoint));
+    const projectResult = await runtime3.runCommand("glab", apiArgs(ref.host, projectEndpoint));
     if (projectResult.exitCode === 0 && projectResult.stdout.trim()) {
       const project = JSON.parse(projectResult.stdout);
       defaultBranch = project.default_branch;
@@ -64899,15 +65430,15 @@ async function fetchGlMR(runtime2, ref) {
   };
   return { metadata, rawPatch };
 }
-async function fetchGlMRContext(runtime2, ref) {
+async function fetchGlMRContext(runtime3, ref) {
   const encoded = encodeProject(ref.projectPath);
   const mrEndpoint = `projects/${encoded}/merge_requests/${ref.iid}`;
   const [mrResult, notesResult, approvalsResult, pipelinesResult, issuesResult] = await Promise.all([
-    runtime2.runCommand("glab", apiArgs(ref.host, mrEndpoint)),
-    runtime2.runCommand("glab", apiArgs(ref.host, `${mrEndpoint}/notes?sort=asc&per_page=100`)),
-    runtime2.runCommand("glab", apiArgs(ref.host, `${mrEndpoint}/approvals`)),
-    runtime2.runCommand("glab", apiArgs(ref.host, `${mrEndpoint}/pipelines?per_page=5`)),
-    runtime2.runCommand("glab", apiArgs(ref.host, `${mrEndpoint}/closes_issues`))
+    runtime3.runCommand("glab", apiArgs(ref.host, mrEndpoint)),
+    runtime3.runCommand("glab", apiArgs(ref.host, `${mrEndpoint}/notes?sort=asc&per_page=100`)),
+    runtime3.runCommand("glab", apiArgs(ref.host, `${mrEndpoint}/approvals`)),
+    runtime3.runCommand("glab", apiArgs(ref.host, `${mrEndpoint}/pipelines?per_page=5`)),
+    runtime3.runCommand("glab", apiArgs(ref.host, `${mrEndpoint}/closes_issues`))
   ]);
   const str = (v2) => typeof v2 === "string" ? v2 : "";
   const arr = (v2) => Array.isArray(v2) ? v2 : [];
@@ -64990,7 +65521,7 @@ async function fetchGlMRContext(runtime2, ref) {
       const pipelines = JSON.parse(pipelinesResult.stdout);
       if (pipelines.length > 0) {
         const latest = pipelines[0];
-        const jobsResult = await runtime2.runCommand("glab", apiArgs(ref.host, `projects/${encoded}/pipelines/${latest.id}/jobs?per_page=100`));
+        const jobsResult = await runtime3.runCommand("glab", apiArgs(ref.host, `projects/${encoded}/pipelines/${latest.id}/jobs?per_page=100`));
         if (jobsResult.exitCode === 0) {
           try {
             const jobs = JSON.parse(jobsResult.stdout);
@@ -65044,30 +65575,30 @@ async function fetchGlMRContext(runtime2, ref) {
     linkedIssues
   };
 }
-async function fetchGlFileContent(runtime2, ref, sha, filePath) {
+async function fetchGlFileContent(runtime3, ref, sha, filePath) {
   const encoded = encodeProject(ref.projectPath);
   const encodedPath = encodeApiFilePath(filePath);
-  const result = await runtime2.runCommand("glab", apiArgs(ref.host, `projects/${encoded}/repository/files/${encodedPath}/raw?ref=${sha}`));
+  const result = await runtime3.runCommand("glab", apiArgs(ref.host, `projects/${encoded}/repository/files/${encodedPath}/raw?ref=${sha}`));
   if (result.exitCode !== 0)
     return null;
   return result.stdout;
 }
-async function submitGlMRReview(runtime2, ref, headSha, action, body3, fileComments) {
-  if (!runtime2.runCommandWithInput) {
+async function submitGlMRReview(runtime3, ref, headSha, action, body3, fileComments) {
+  if (!runtime3.runCommandWithInput) {
     throw new Error("Runtime does not support stdin input; cannot submit MR review");
   }
   const encoded = encodeProject(ref.projectPath);
   const mrEndpoint = `projects/${encoded}/merge_requests/${ref.iid}`;
   if (body3 && body3.trim()) {
     const notePayload = JSON.stringify({ body: body3.trim() });
-    const noteResult = await runtime2.runCommandWithInput("glab", apiArgs(ref.host, `${mrEndpoint}/notes`, ["--method", "POST", "--input", "-", "-H", "Content-Type:application/json"]), notePayload);
+    const noteResult = await runtime3.runCommandWithInput("glab", apiArgs(ref.host, `${mrEndpoint}/notes`, ["--method", "POST", "--input", "-", "-H", "Content-Type:application/json"]), notePayload);
     if (noteResult.exitCode !== 0) {
       const msg = noteResult.stderr.trim() || noteResult.stdout.trim() || `exit code ${noteResult.exitCode}`;
       throw new Error(`Failed to post MR note: ${msg}`);
     }
   }
   if (fileComments.length > 0) {
-    const mrResult = await runtime2.runCommand("glab", apiArgs(ref.host, mrEndpoint));
+    const mrResult = await runtime3.runCommand("glab", apiArgs(ref.host, mrEndpoint));
     let baseSha = headSha;
     let startSha = headSha;
     if (mrResult.exitCode === 0 && mrResult.stdout.trim()) {
@@ -65110,7 +65641,7 @@ async function submitGlMRReview(runtime2, ref, headSha, action, body3, fileComme
         position.line_range = { start: startEntry, end: endEntry };
       }
       const payload = JSON.stringify({ body: comment2.body, position });
-      const res = await runtime2.runCommandWithInput("glab", apiArgs(ref.host, `${mrEndpoint}/discussions`, ["--method", "POST", "--input", "-", "-H", "Content-Type:application/json"]), payload);
+      const res = await runtime3.runCommandWithInput("glab", apiArgs(ref.host, `${mrEndpoint}/discussions`, ["--method", "POST", "--input", "-", "-H", "Content-Type:application/json"]), payload);
       if (res.exitCode !== 0) {
         const msg = res.stderr.trim() || res.stdout.trim() || `exit code ${res.exitCode}`;
         throw new Error(`${comment2.path}:${comment2.line}: ${msg}`);
@@ -65133,7 +65664,7 @@ ${errors.join(`
     }
   }
   if (action === "approve") {
-    const approveResult = await runtime2.runCommandWithInput("glab", apiArgs(ref.host, `${mrEndpoint}/approve`, ["--method", "POST", "--input", "-", "-H", "Content-Type:application/json"]), "{}");
+    const approveResult = await runtime3.runCommandWithInput("glab", apiArgs(ref.host, `${mrEndpoint}/approve`, ["--method", "POST", "--input", "-", "-H", "Content-Type:application/json"]), "{}");
     if (approveResult.exitCode !== 0) {
       const msg = approveResult.stderr.trim() || approveResult.stdout.trim() || `exit code ${approveResult.exitCode}`;
       throw new Error(`Failed to approve MR: ${msg}`);
@@ -65202,58 +65733,58 @@ function parsePRUrl(url) {
   }
   return null;
 }
-async function checkAuth(runtime2, ref) {
+async function checkAuth(runtime3, ref) {
   if (ref.platform === "github")
-    return checkGhAuth(runtime2, ref.host);
-  return checkGlAuth(runtime2, ref.host);
+    return checkGhAuth(runtime3, ref.host);
+  return checkGlAuth(runtime3, ref.host);
 }
-async function getUser(runtime2, ref) {
+async function getUser(runtime3, ref) {
   if (ref.platform === "github")
-    return getGhUser(runtime2, ref.host);
-  return getGlUser(runtime2, ref.host);
+    return getGhUser(runtime3, ref.host);
+  return getGlUser(runtime3, ref.host);
 }
-async function fetchPR(runtime2, ref) {
+async function fetchPR(runtime3, ref) {
   if (ref.platform === "github")
-    return fetchGhPR(runtime2, ref);
-  return fetchGlMR(runtime2, ref);
+    return fetchGhPR(runtime3, ref);
+  return fetchGlMR(runtime3, ref);
 }
-async function fetchPRContext(runtime2, ref) {
+async function fetchPRContext(runtime3, ref) {
   if (ref.platform === "github")
-    return fetchGhPRContext(runtime2, ref);
-  return fetchGlMRContext(runtime2, ref);
+    return fetchGhPRContext(runtime3, ref);
+  return fetchGlMRContext(runtime3, ref);
 }
-async function fetchPRFileContent(runtime2, ref, sha, filePath) {
+async function fetchPRFileContent(runtime3, ref, sha, filePath) {
   if (ref.platform === "github")
-    return fetchGhPRFileContent(runtime2, ref, sha, filePath);
-  return fetchGlFileContent(runtime2, ref, sha, filePath);
+    return fetchGhPRFileContent(runtime3, ref, sha, filePath);
+  return fetchGlFileContent(runtime3, ref, sha, filePath);
 }
-async function submitPRReview(runtime2, ref, headSha, action, body3, fileComments) {
+async function submitPRReview(runtime3, ref, headSha, action, body3, fileComments) {
   if (ref.platform === "github")
-    return submitGhPRReview(runtime2, ref, headSha, action, body3, fileComments);
-  return submitGlMRReview(runtime2, ref, headSha, action, body3, fileComments);
+    return submitGhPRReview(runtime3, ref, headSha, action, body3, fileComments);
+  return submitGlMRReview(runtime3, ref, headSha, action, body3, fileComments);
 }
-async function fetchPRViewedFiles(runtime2, ref) {
+async function fetchPRViewedFiles(runtime3, ref) {
   if (ref.platform === "github")
-    return fetchGhPRViewedFiles(runtime2, ref);
+    return fetchGhPRViewedFiles(runtime3, ref);
   return {};
 }
-async function markPRFilesViewed(runtime2, ref, prNodeId, filePaths, viewed) {
+async function markPRFilesViewed(runtime3, ref, prNodeId, filePaths, viewed) {
   if (ref.platform === "github")
-    return markGhFilesViewed(runtime2, ref, prNodeId, filePaths, viewed);
+    return markGhFilesViewed(runtime3, ref, prNodeId, filePaths, viewed);
 }
-async function fetchPRStack(runtime2, ref, metadata) {
+async function fetchPRStack(runtime3, ref, metadata) {
   if (ref.platform === "github")
-    return fetchGhPRStack(runtime2, ref, metadata);
+    return fetchGhPRStack(runtime3, ref, metadata);
   return null;
 }
-async function fetchPRList(runtime2, ref) {
+async function fetchPRList(runtime3, ref) {
   if (ref.platform === "github")
-    return fetchGhPRList(runtime2, ref);
+    return fetchGhPRList(runtime3, ref);
   return [];
 }
 
 // ../../packages/server/pr.ts
-var runtime2 = {
+var runtime3 = {
   async runCommand(cmd, args) {
     const proc = Bun.spawn([cmd, ...args], {
       stdout: "pipe",
@@ -65284,34 +65815,34 @@ var runtime2 = {
 };
 var parsePRUrl2 = parsePRUrl;
 function checkPRAuth(ref) {
-  return checkAuth(runtime2, ref);
+  return checkAuth(runtime3, ref);
 }
 function getPRUser(ref) {
-  return getUser(runtime2, ref);
+  return getUser(runtime3, ref);
 }
 function fetchPR2(ref) {
-  return fetchPR(runtime2, ref);
+  return fetchPR(runtime3, ref);
 }
 function fetchPRContext2(ref) {
-  return fetchPRContext(runtime2, ref);
+  return fetchPRContext(runtime3, ref);
 }
 function fetchPRFileContent2(ref, sha, filePath) {
-  return fetchPRFileContent(runtime2, ref, sha, filePath);
+  return fetchPRFileContent(runtime3, ref, sha, filePath);
 }
 function submitPRReview2(ref, headSha, action, body3, fileComments) {
-  return submitPRReview(runtime2, ref, headSha, action, body3, fileComments);
+  return submitPRReview(runtime3, ref, headSha, action, body3, fileComments);
 }
 function fetchPRViewedFiles2(ref) {
-  return fetchPRViewedFiles(runtime2, ref);
+  return fetchPRViewedFiles(runtime3, ref);
 }
 function markPRFilesViewed2(ref, prNodeId, filePaths, viewed) {
-  return markPRFilesViewed(runtime2, ref, prNodeId, filePaths, viewed);
+  return markPRFilesViewed(runtime3, ref, prNodeId, filePaths, viewed);
 }
 function fetchPRStack2(ref, metadata) {
-  return fetchPRStack(runtime2, ref, metadata);
+  return fetchPRStack(runtime3, ref, metadata);
 }
 function fetchPRList2(ref) {
-  return fetchPRList(runtime2, ref);
+  return fetchPRList(runtime3, ref);
 }
 
 // ../../packages/ai/index.ts
@@ -65569,6 +66100,7 @@ async function startReviewServer(options) {
   let prMetadata = options.prMetadata;
   const isPRMode = !!prMetadata;
   const hasLocalAccess = !!gitContext;
+  const sessionVcsType = gitContext?.vcsType;
   let draftKey = contentHash(options.rawPatch);
   const editorAnnotations = createEditorAnnotationHandler();
   const externalAnnotations = createExternalAnnotationHandler("review");
@@ -65588,10 +66120,14 @@ async function startReviewServer(options) {
   if (isPRMode && prMetadata)
     prSwitchCache.set(prMetadata.url, { metadata: prMetadata, rawPatch: options.rawPatch });
   const prStackTreeCache = new Map;
-  let currentBase = options.initialBase || gitContext?.defaultBranch || "main";
+  const detectedCompareTarget = () => gitContext?.defaultBranch || gitContext?.compareTarget?.fallback || "main";
+  let currentBase = options.initialBase || detectedCompareTarget();
   let baseEverSwitched = false;
+  const resolveReviewBase = (requestedBase) => {
+    return resolveBaseBranch(requestedBase, detectedCompareTarget());
+  };
   if (gitContext && !options.initialBase && !isPRMode) {
-    detectRemoteDefaultBranch(runtime, gitContext.cwd).then((remote) => {
+    detectRemoteDefaultCompareTarget(gitContext.cwd, sessionVcsType).then((remote) => {
       if (remote && !baseEverSwitched)
         currentBase = remote;
     });
@@ -65632,7 +66168,7 @@ async function startReviewServer(options) {
         });
         return built ? { ...built, prUrl: launchPrUrl, diffScope: launchDiffScope, diffContext } : built;
       }
-      const userMessage = buildCodexReviewUserMessage(currentPatch, currentDiffType, userMessageOptions, prMetadata);
+      const userMessage = buildAgentReviewUserMessage(currentPatch, currentDiffType, userMessageOptions, prMetadata);
       if (provider === "codex") {
         const model = typeof config?.model === "string" && config.model ? config.model : undefined;
         const reasoningEffort = typeof config?.reasoningEffort === "string" && config.reasoningEffort ? config.reasoningEffort : undefined;
@@ -65785,6 +66321,12 @@ async function startReviewServer(options) {
   const wslFlag = await isWSL();
   const gitUser = detectGitUser();
   let repoInfo = isPRMode && prMetadata ? { display: getDisplayRepo(prMetadata), branch: `${getMRLabel(prMetadata)} ${getMRNumberLabel(prMetadata)}` } : await getRepoInfo();
+  if (gitContext?.repository?.displayFallback) {
+    repoInfo = {
+      ...repoInfo,
+      display: repoInfo?.display || gitContext.repository.displayFallback
+    };
+  }
   let prRef = isPRMode && prMetadata ? prRefFromMetadata(prMetadata) : null;
   const platformUser = prRef ? await getPRUser(prRef) : null;
   let prStackInfo = prMetadata ? getPRStackInfo(prMetadata) : null;
@@ -65809,8 +66351,8 @@ async function startReviewServer(options) {
     } catch {}
   }
   let resolveDecision;
-  const decisionPromise = new Promise((resolve5) => {
-    resolveDecision = resolve5;
+  const decisionPromise = new Promise((resolve6) => {
+    resolveDecision = resolve6;
   });
   let server2 = null;
   for (let attempt = 1;attempt <= MAX_RETRIES2; attempt++) {
@@ -65879,9 +66421,8 @@ async function startReviewServer(options) {
               if (typeof body3.hideWhitespace === "boolean") {
                 currentHideWhitespace = body3.hideWhitespace;
               }
-              const detectedBase = gitContext?.defaultBranch || "main";
               const requestedBase = typeof body3.base === "string" ? body3.base : undefined;
-              const base = resolveBaseBranch(requestedBase, detectedBase);
+              const base = resolveReviewBase(requestedBase);
               const defaultCwd = gitContext?.cwd;
               const result = await runVcsDiff(newDiffType, base, defaultCwd, {
                 hideWhitespace: currentHideWhitespace
@@ -65896,7 +66437,7 @@ async function startReviewServer(options) {
               if (gitContext) {
                 try {
                   const effectiveCwd = resolveVcsCwd(newDiffType, gitContext.cwd);
-                  updatedContext = await getVcsContext(effectiveCwd);
+                  updatedContext = await getVcsContext(effectiveCwd, sessionVcsType);
                 } catch {}
               }
               return Response.json({
@@ -66094,8 +66635,8 @@ async function startReviewServer(options) {
               return Response.json(result);
             }
             if (hasLocalAccess) {
-              const detectedBase = gitContext?.defaultBranch || "main";
-              const base = resolveBaseBranch(url.searchParams.get("base") ?? undefined, detectedBase);
+              const requestedBase = url.searchParams.get("base") ?? undefined;
+              const base = resolveReviewBase(requestedBase);
               const defaultCwd = gitContext?.cwd;
               const result = await getVcsFileContentsForDiff(currentDiffType, base, filePath, oldPath, defaultCwd);
               return Response.json(result);
@@ -66111,7 +66652,8 @@ async function startReviewServer(options) {
             return Response.json({ error: "No file access available" }, { status: 400 });
           }
           if (url.pathname === "/api/git-add" && req.method === "POST") {
-            if (isPRMode || !canStageFiles(currentDiffType)) {
+            const stageCwd = resolveVcsCwd(currentDiffType, gitContext?.cwd);
+            if (isPRMode || !await canStageFiles(currentDiffType, stageCwd)) {
               return Response.json({ error: "Staging not available" }, { status: 400 });
             }
             try {
@@ -66119,11 +66661,10 @@ async function startReviewServer(options) {
               if (!body3.filePath) {
                 return Response.json({ error: "Missing filePath" }, { status: 400 });
               }
-              const cwd = resolveVcsCwd(currentDiffType, gitContext?.cwd);
               if (body3.undo) {
-                await unstageFile(currentDiffType, body3.filePath, cwd);
+                await unstageFile(currentDiffType, body3.filePath, stageCwd);
               } else {
-                await stageFile(currentDiffType, body3.filePath, cwd);
+                await stageFile(currentDiffType, body3.filePath, stageCwd);
               }
               return Response.json({ ok: true });
             } catch (err) {
@@ -66344,8 +66885,8 @@ async function startAnnotateServer(options) {
   const externalAnnotations = createExternalAnnotationHandler("plan");
   const repoInfo = await getRepoInfo();
   let resolveDecision;
-  const decisionPromise = new Promise((resolve5) => {
-    resolveDecision = resolve5;
+  const decisionPromise = new Promise((resolve6) => {
+    resolveDecision = resolve6;
   });
   let server2 = null;
   for (let attempt = 1;attempt <= MAX_RETRIES3; attempt++) {
@@ -66514,8 +67055,8 @@ var PLAN_TOOL_NAMES = {
   codex: "ExitPlanMode",
   "gemini-cli": "exit_plan_mode"
 };
-function getPlanToolName(runtime3) {
-  return runtime3 && PLAN_TOOL_NAMES[runtime3] || "ExitPlanMode";
+function getPlanToolName(runtime4) {
+  return runtime4 && PLAN_TOOL_NAMES[runtime4] || "ExitPlanMode";
 }
 function buildPlanFileRule(toolName, planFilePath) {
   if (!planFilePath)
@@ -66573,11 +67114,11 @@ function getConfiguredPrompt(options) {
   const runtimeFallback = options.runtime ? options.runtimeFallbacks?.[options.runtime] : undefined;
   return runtimePrompt ?? genericPrompt ?? runtimeFallback ?? options.fallback;
 }
-function getReviewApprovedPrompt(runtime3, config) {
+function getReviewApprovedPrompt(runtime4, config) {
   return getConfiguredPrompt({
     section: "review",
     key: "approved",
-    runtime: runtime3,
+    runtime: runtime4,
     config,
     fallback: DEFAULT_REVIEW_APPROVED_PROMPT
   });
@@ -66590,21 +67131,21 @@ Please address this feedback.`,
 
 Please address this feedback.`
 };
-function getReviewDeniedSuffix(runtime3, config) {
+function getReviewDeniedSuffix(runtime4, config) {
   return getConfiguredPrompt({
     section: "review",
     key: "denied",
-    runtime: runtime3,
+    runtime: runtime4,
     config,
     fallback: DEFAULT_REVIEW_DENIED_SUFFIX,
     runtimeFallbacks: REVIEW_DENIED_RUNTIME_DEFAULTS
   });
 }
-function getPlanDeniedPrompt(runtime3, config, vars) {
+function getPlanDeniedPrompt(runtime4, config, vars) {
   const template = getConfiguredPrompt({
     section: "plan",
     key: "denied",
-    runtime: runtime3,
+    runtime: runtime4,
     config,
     fallback: DEFAULT_PLAN_DENIED_PROMPT
   });
@@ -66613,11 +67154,11 @@ function getPlanDeniedPrompt(runtime3, config, vars) {
 var PLAN_APPROVED_RUNTIME_DEFAULTS = {
   opencode: "Plan approved!{{doneMsg}}"
 };
-function getPlanApprovedPrompt(runtime3, config, vars) {
+function getPlanApprovedPrompt(runtime4, config, vars) {
   const template = getConfiguredPrompt({
     section: "plan",
     key: "approved",
-    runtime: runtime3,
+    runtime: runtime4,
     config,
     fallback: DEFAULT_PLAN_APPROVED_PROMPT,
     runtimeFallbacks: PLAN_APPROVED_RUNTIME_DEFAULTS
@@ -66634,32 +67175,32 @@ The user approved your plan but added the following notes to consider during imp
 
 {{feedback}}{{proceedSuffix}}`
 };
-function getPlanApprovedWithNotesPrompt(runtime3, config, vars) {
+function getPlanApprovedWithNotesPrompt(runtime4, config, vars) {
   const template = getConfiguredPrompt({
     section: "plan",
     key: "approvedWithNotes",
-    runtime: runtime3,
+    runtime: runtime4,
     config,
     fallback: DEFAULT_PLAN_APPROVED_WITH_NOTES_PROMPT,
     runtimeFallbacks: PLAN_APPROVED_WITH_NOTES_RUNTIME_DEFAULTS
   });
   return resolveTemplate(template, { proceedSuffix: "", ...vars });
 }
-function getAnnotateFileFeedbackPrompt(runtime3, config, vars) {
+function getAnnotateFileFeedbackPrompt(runtime4, config, vars) {
   const template = getConfiguredPrompt({
     section: "annotate",
     key: "fileFeedback",
-    runtime: runtime3,
+    runtime: runtime4,
     config,
     fallback: DEFAULT_ANNOTATE_FILE_FEEDBACK_PROMPT
   });
   return resolveTemplate(template, vars ?? {});
 }
-function getAnnotateMessageFeedbackPrompt(runtime3, config, vars) {
+function getAnnotateMessageFeedbackPrompt(runtime4, config, vars) {
   const template = getConfiguredPrompt({
     section: "annotate",
     key: "messageFeedback",
-    runtime: runtime3,
+    runtime: runtime4,
     config,
     fallback: DEFAULT_ANNOTATE_MESSAGE_FEEDBACK_PROMPT
   });
@@ -66711,6 +67252,73 @@ function parseAnnotateArgs(raw2) {
   return { filePath: stripAtPrefix(rawFilePath), rawFilePath, ...flags };
 }
 
+// ../../packages/shared/review-args.ts
+function parseReviewArgs(input) {
+  const tokens = Array.isArray(input) ? input.map((token2) => stripWrappingQuotes(token2.trim())).filter(Boolean) : tokenizeReviewArgs(input ?? "");
+  let vcsType;
+  let useLocal = true;
+  const positional = [];
+  for (const token2 of tokens) {
+    switch (token2) {
+      case "--git":
+        vcsType = "git";
+        break;
+      case "--local":
+        useLocal = true;
+        break;
+      case "--no-local":
+        useLocal = false;
+        break;
+      default:
+        positional.push(token2);
+        break;
+    }
+  }
+  const target = positional[0];
+  return {
+    prUrl: target && isReviewUrl(target) ? target : undefined,
+    vcsType,
+    useLocal
+  };
+}
+function isReviewUrl(value) {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+function tokenizeReviewArgs(input) {
+  const raw2 = input.trim();
+  if (!raw2)
+    return [];
+  const tokens = [];
+  let current = "";
+  let quote;
+  for (let i4 = 0;i4 < raw2.length; i4++) {
+    const char = raw2[i4];
+    if (quote) {
+      if (char === quote) {
+        quote = undefined;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current)
+    tokens.push(current);
+  return tokens.map((token2) => stripWrappingQuotes(token2.trim())).filter(Boolean);
+}
+
 // ../../packages/shared/url-to-markdown.ts
 var isConvertedSource = (source) => source === "jina" || source === "fetch+turndown";
 var FETCH_TIMEOUT_MS = 30000;
@@ -66950,8 +67558,9 @@ import { statSync as statSync5 } from "fs";
 import path3 from "path";
 async function handleReviewCommand(event, deps) {
   const { client: client3, reviewHtmlContent, getSharingEnabled, getShareBaseUrl, directory } = deps;
-  const urlArg = event.properties?.arguments || "";
-  const isPRMode = urlArg?.startsWith("http://") || urlArg?.startsWith("https://");
+  const reviewArgs = parseReviewArgs(event.properties?.arguments || "");
+  const urlArg = reviewArgs.prUrl;
+  const isPRMode = urlArg !== undefined;
   let rawPatch;
   let gitRef;
   let diffError;
@@ -66983,14 +67592,17 @@ async function handleReviewCommand(event, deps) {
     }
   } else {
     client3.app.log({ level: "info", message: "Opening code review UI..." });
-    gitContext = await getGitContext2(directory);
     const config = loadConfig();
-    userDiffType = resolveDefaultDiffType(config);
-    const diffResult = await runGitDiffWithContext2(userDiffType, gitContext, {
+    const diffResult = await prepareLocalReviewDiff({
+      cwd: directory,
+      vcsType: reviewArgs.vcsType,
+      configuredDiffType: resolveDefaultDiffType(config),
       hideWhitespace: config.diffOptions?.hideWhitespace ?? false
     });
-    rawPatch = diffResult.patch;
-    gitRef = diffResult.label;
+    gitContext = diffResult.gitContext;
+    userDiffType = diffResult.diffType;
+    rawPatch = diffResult.rawPatch;
+    gitRef = diffResult.gitRef;
     diffError = diffResult.error;
   }
   const server2 = await startReviewServer({
@@ -67716,14 +68328,14 @@ Use /plannotator-last or /plannotator-annotate for manual review, or set workflo
           });
           const timeoutSeconds = getPlanTimeoutSeconds();
           const timeoutMs = timeoutSeconds === null ? null : timeoutSeconds * 1000;
-          const result = timeoutMs === null ? await server2.waitForDecision() : await new Promise((resolve5) => {
-            const timeoutId = setTimeout(() => resolve5({
+          const result = timeoutMs === null ? await server2.waitForDecision() : await new Promise((resolve6) => {
+            const timeoutId = setTimeout(() => resolve6({
               approved: false,
               feedback: `[Plannotator] No response within ${timeoutSeconds} seconds. Port released automatically. Please call submit_plan again.`
             }), timeoutMs);
             server2.waitForDecision().then((r9) => {
               clearTimeout(timeoutId);
-              resolve5(r9);
+              resolve6(r9);
             });
           });
           await Bun.sleep(1500);