@difflab/pi 0.2.0 → 0.3.0

package/dist/index.js

@@ -94,76 +94,14 @@ ${document}
 function normalizeModelReference(value) {
   return value.toLowerCase().replace(/^~/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-// src/mcp.ts
-import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname, join as join2 } from "node:path";
-var mcp = {
-  globalConfigPath(homeDir = homedir2()) {
-    return join2(homeDir, ".config", "mcp", "mcp.json");
-  },
-  async serversEnsure(servers, options = {}) {
-    const path = options.path ?? mcp.globalConfigPath();
-    const currentText = await getOptionalFile(path);
-    const current = getParsedConfig(currentText, path);
-    const nextServers = { ...current.mcpServers };
-    for (const [name, entry] of Object.entries(servers)) {
-      nextServers[name] = mergeEntry(nextServers[name], entry);
-    }
-    const next = { ...current, mcpServers: nextServers };
-    const changed = JSON.stringify(current) !== JSON.stringify(next);
-    if (changed && !options.dryRun) {
-      await mkdir(dirname(path), { recursive: true });
-      await writeFile(path, `${JSON.stringify(next, null, 2)}
-`, "utf8");
-    }
-    return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
-  }
-};
-function mergeEntry(current, required) {
-  const merged = { ...current, ...required };
-  if (current?.env || required.env)
-    merged.env = { ...current?.env, ...required.env };
-  return merged;
-}
-function getParsedConfig(content, path) {
-  if (!content?.trim())
-    return { mcpServers: {} };
-  try {
-    const value = JSON.parse(content);
-    if (!isRecord(value))
-      throw new Error("not an object");
-    const servers = value.mcpServers;
-    if (servers !== undefined && !isRecord(servers))
-      throw new Error("mcpServers is not an object");
-    return { ...value, mcpServers: servers ?? {} };
-  } catch {
-    throw new Error(`Expected a valid pi-mcp-adapter configuration in ${path}.`);
-  }
-}
-async function getOptionalFile(path) {
-  try {
-    return await readFile2(path, "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return;
-    throw error;
-  }
-}
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-// src/mise.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { basename, dirname as dirname2, join as join4 } from "node:path";
+// src/environment.ts
+import { basename } from "node:path";
 
-// src/process.ts
+// src/extensions/processx.ts
+import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
-import { delimiter, join as join3 } from "node:path";
-import { spawn } from "node:child_process";
-var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
+import { delimiter, join as join2 } from "node:path";
 async function findExecutable(name) {
   if (name.includes("/")) {
     try {
@@ -176,7 +114,7 @@ async function findExecutable(name) {
   for (const directory of (process.env.PATH ?? "").split(delimiter)) {
     if (!directory)
       continue;
-    const candidate = join3(directory, name);
+    const candidate = join2(directory, name);
     try {
       await access(candidate, constants.X_OK);
       return candidate;
@@ -189,18 +127,35 @@ function run(command, args, options = {}) {
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: options.env ?? process.env,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
     });
     let stdout = "";
     let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout = appendBounded(stdout, chunk.toString());
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const unbounded = options.capture === "unbounded";
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (unbounded)
+        stdoutChunks.push(text);
+      else
+        stdout = appendBounded(stdout, text);
     });
-    child.stderr.on("data", (chunk) => {
-      stderr = appendBounded(stderr, chunk.toString());
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (unbounded)
+        stderrChunks.push(text);
+      else
+        stderr = appendBounded(stderr, text);
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    child.on("close", (code) => resolve({
+      code: code ?? 1,
+      stdout: unbounded ? stdoutChunks.join("") : stdout,
+      stderr: unbounded ? stderrChunks.join("") : stderr
+    }));
+    if (options.input !== undefined && child.stdin)
+      child.stdin.end(options.input);
   });
 }
 async function runChecked(command, args, options = {}) {
@@ -210,24 +165,555 @@ async function runChecked(command, args, options = {}) {
   const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
   throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
 }
+var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
 function appendBounded(current, next) {
   const combined = current + next;
   return combined.length <= MAX_CAPTURED_OUTPUT_LENGTH ? combined : combined.slice(-MAX_CAPTURED_OUTPUT_LENGTH);
 }
 
-// src/mise.ts
+// src/extensions/zedx.ts
+import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join3 } from "node:path";
+var ZED_LOCAL_REVIEW_TASK_NAME = "diffpi: tuicr local review";
+var ZED_REVIEW_TASK_NAME = ZED_LOCAL_REVIEW_TASK_NAME;
+var ZED_PR_REVIEW_TASK_NAME = "diffpi: tuicr PR review";
+var LEGACY_ZED_REVIEW_TASK_NAME = "diffpi: tuicr review";
+var REVIEW_KEYBINDING = "cmd-alt-r";
+function zedTasksPath(homeDir = homedir2()) {
+  return join3(homeDir, ".config", "zed", "tasks.json");
+}
+function zedKeymapPath(homeDir = homedir2()) {
+  return join3(homeDir, ".config", "zed", "keymap.json");
+}
+async function ensureZedReviewTask(homeDir = homedir2(), _command = ["tuicr", "-w", "-r", "main..HEAD"]) {
+  const path = zedTasksPath(homeDir);
+  const currentText = await readOptional(path);
+  const tasks = parseJsonArray(currentText, path);
+  const migrated = tasks.filter((task) => task.label !== LEGACY_ZED_REVIEW_TASK_NAME);
+  const next = [...migrated];
+  for (const task of [localReviewTask(), prReviewTask()]) {
+    const index = next.findIndex((existing) => existing.label === task.label);
+    if (index >= 0)
+      next[index] = { ...next[index], ...task };
+    else
+      next.push(task);
+  }
+  const changed = JSON.stringify(tasks) !== JSON.stringify(next);
+  if (changed)
+    await writeJson(path, next);
+  return { path, changed, existed: currentText !== undefined };
+}
+async function ensureZedReviewKeybinding(homeDir = homedir2()) {
+  const path = zedKeymapPath(homeDir);
+  const currentText = await readOptional(path);
+  const entries = parseJsonArray(currentText, path);
+  const migrated = entries.map(migrateReviewKeymapEntry);
+  const alreadyBound = migrated.some((entry) => Object.values(entry.bindings ?? {}).some((action) => Array.isArray(action) && action[0] === "task::Spawn" && bindsReviewTask(action[1])));
+  const next = alreadyBound ? migrated : [
+    ...migrated,
+    {
+      context: "Workspace",
+      bindings: { [REVIEW_KEYBINDING]: ["task::Spawn", { task_name: ZED_LOCAL_REVIEW_TASK_NAME }] }
+    }
+  ];
+  const changed = JSON.stringify(entries) !== JSON.stringify(next);
+  if (changed)
+    await writeJson(path, next);
+  return { path, changed, existed: currentText !== undefined };
+}
+function zedReviewTaskName(command) {
+  return command[0] === "tuicr" && command[1] === "pr" ? ZED_PR_REVIEW_TASK_NAME : ZED_LOCAL_REVIEW_TASK_NAME;
+}
+var LOCAL_REVIEW_SCRIPT = `set -eu
+remote=$(git remote get-url origin 2>/dev/null || true)
+branch=$(git branch --show-current)
+base=
+case "$remote" in
+  *github.com*)
+    base=$(gh pr list --head "$branch" --state open --limit 100 --json baseRefName,createdAt --jq 'sort_by(.createdAt) | reverse | .[0].baseRefName // empty' 2>/dev/null || true)
+    [ -n "$base" ] || base=$(gh repo view --json defaultBranchRef --jq .defaultBranchRef.name 2>/dev/null || true)
+    ;;
+  *gitlab*)
+    mr=$(glab mr list --source-branch "$branch" --order created_at --sort desc --per-page 100 --output json 2>/dev/null || true)
+    base=$(printf '%s' "$mr" | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{let a=JSON.parse(s);process.stdout.write(a[0]?.target_branch||"")}catch{}})')
+    [ -n "$base" ] || base=$(glab repo view --output json 2>/dev/null | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).default_branch||"")}catch{}})' || true)
+    ;;
+esac
+[ -n "$base" ] || { echo 'diffpi: could not resolve a GitHub/GitLab review base' >&2; exit 1; }
+exec tuicr -w -r "$base..HEAD"`;
+var PR_REVIEW_SCRIPT = `set -eu
+remote=$(git remote get-url origin 2>/dev/null || true)
+branch=$(git branch --show-current)
+case "$remote" in
+  *github.com*) number=$(gh pr list --head "$branch" --state open --limit 100 --json number,createdAt --jq 'sort_by(.createdAt) | reverse | .[0].number // empty' 2>/dev/null || true) ;;
+  *gitlab*) number=$(glab mr list --source-branch "$branch" --order created_at --sort desc --per-page 100 --output json 2>/dev/null | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{let a=JSON.parse(s);process.stdout.write(String(a[0]?.iid||a[0]?.number||""))}catch{}})' || true) ;;
+  *) number= ;;
+esac
+[ -n "$number" ] || { echo 'diffpi: could not resolve the current GitHub PR or GitLab MR' >&2; exit 1; }
+exec tuicr pr "$number"`;
+function staticReviewTask(label, script) {
+  return {
+    label,
+    command: "sh",
+    args: ["-lc", script],
+    cwd: "$ZED_WORKTREE_ROOT",
+    use_new_terminal: true,
+    reveal: "always",
+    reveal_target: "center"
+  };
+}
+function localReviewTask() {
+  return staticReviewTask(ZED_LOCAL_REVIEW_TASK_NAME, LOCAL_REVIEW_SCRIPT);
+}
+function prReviewTask() {
+  return staticReviewTask(ZED_PR_REVIEW_TASK_NAME, PR_REVIEW_SCRIPT);
+}
+function bindsReviewTask(payload) {
+  return typeof payload === "object" && payload !== null && payload.task_name === ZED_LOCAL_REVIEW_TASK_NAME;
+}
+function migrateReviewKeymapEntry(entry) {
+  const bindings = Object.fromEntries(Object.entries(entry.bindings ?? {}).map(([key, action]) => {
+    if (Array.isArray(action) && action[0] === "task::Spawn" && typeof action[1] === "object" && action[1] !== null && action[1].task_name === LEGACY_ZED_REVIEW_TASK_NAME) {
+      return [key, ["task::Spawn", { ...action[1], task_name: ZED_LOCAL_REVIEW_TASK_NAME }]];
+    }
+    return [key, action];
+  }));
+  return entry.bindings ? { ...entry, bindings } : entry;
+}
+async function readOptional(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function parseJsonArray(content, path) {
+  if (!content?.trim())
+    return [];
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch {
+    throw new Error(`Cannot safely edit ${path}: not strict JSON (it may contain JSONC comments).`);
+  }
+  if (!Array.isArray(value))
+    throw new Error(`Expected a JSON array in ${path}.`);
+  return value;
+}
+async function writeJson(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+
+// src/environment.ts
+function detectIde(env = process.env) {
+  const program = (env.TERM_PROGRAM ?? "").toLowerCase();
+  if (env.ZED_TERM === "true" || program === "zed")
+    return "zed";
+  if (env.CURSOR_TRACE_ID || program === "cursor")
+    return "cursor";
+  if (env.WINDSURF_ENV || program === "windsurf")
+    return "windsurf";
+  if (env.TERMINAL_EMULATOR?.toLowerCase().includes("jetbrains"))
+    return "jetbrains";
+  if (env.VSCODE_PID || env.VSCODE_GIT_IPC_HANDLE || program === "vscode")
+    return "vscode";
+  return "unknown";
+}
+function detectMux(env = process.env) {
+  if (env.ZELLIJ || env.ZELLIJ_SESSION_NAME)
+    return "zellij";
+  if (env.TMUX)
+    return "tmux";
+  if (env.STY)
+    return "screen";
+  return "none";
+}
+function detectShell(env = process.env) {
+  return env.SHELL ? basename(env.SHELL) : "unknown";
+}
+async function detectVcs(cwd) {
+  const root = (await run("git", ["-C", cwd, "rev-parse", "--show-toplevel"])).stdout.trim() || cwd;
+  const branch = (await run("git", ["-C", root, "rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
+  const remote = (await run("git", ["-C", root, "remote", "get-url", "origin"])).stdout.trim();
+  return { ...parseRemote(remote), branch, root };
+}
+function parseRemote(remote) {
+  const empty = { provider: "none", host: "", owner: "", repo: "" };
+  if (!remote)
+    return empty;
+  const scp = remote.match(/^[^@]+@([^:]+):(.+?)(?:\.git)?$/);
+  const url = remote.match(/^[a-z]+:\/\/(?:[^@]+@)?([^/]+)\/(.+?)(?:\.git)?$/i);
+  const match = scp ?? url;
+  if (!match)
+    return empty;
+  const host = match[1];
+  const segments = match[2].split("/").filter(Boolean);
+  if (segments.length < 2)
+    return { ...empty, host };
+  const repo = segments.at(-1) ?? "";
+  const owner = segments.slice(0, -1).join("/");
+  const provider = /github/i.test(host) ? "github" : /gitlab/i.test(host) ? "gitlab" : "none";
+  return { provider, host, owner, repo };
+}
+async function openInNewTab(command, opts) {
+  const env = opts.env ?? process.env;
+  const name = opts.name ?? "review";
+  const printable = command.join(" ");
+  const mux = detectMux(env);
+  if (mux !== "none") {
+    const opened = await openMuxTab(mux, command, opts.cwd, name, printable);
+    if (opened)
+      return opened;
+  }
+  if (detectIde(env) === "zed") {
+    try {
+      const taskName = zedReviewTaskName(command);
+      await ensureZedReviewTask(opts.homeDir, command);
+      return {
+        launched: false,
+        configured: true,
+        via: "zed-task",
+        command: printable,
+        taskName,
+        instruction: `Run the Zed task "${taskName}".`
+      };
+    } catch {}
+  }
+  return { launched: false, via: "print", command: printable };
+}
+function screenWindowArgs(command, cwd, name) {
+  return ["-X", "screen", "-t", name, "sh", "-lc", 'cd -- "$1" && shift && exec "$@"', "sh", cwd, ...command];
+}
+async function openMuxTab(mux, command, cwd, name, printable) {
+  if (mux === "zellij" && await findExecutable("zellij")) {
+    const result = await run("zellij", ["action", "new-tab", "--cwd", cwd, "--name", name, "--", ...command]);
+    if (result.code === 0)
+      return { launched: true, via: "zellij", command: printable };
+    const fallback = await run("zellij", ["run", "--cwd", cwd, "--name", name, "--", ...command]);
+    if (fallback.code === 0)
+      return { launched: true, via: "zellij-run", command: printable };
+  }
+  if (mux === "tmux" && await findExecutable("tmux")) {
+    const result = await run("tmux", ["new-window", "-c", cwd, "-n", name, printable]);
+    if (result.code === 0)
+      return { launched: true, via: "tmux", command: printable };
+  }
+  if (mux === "screen" && await findExecutable("screen")) {
+    const result = await run("screen", screenWindowArgs(command, cwd, name));
+    if (result.code === 0)
+      return { launched: true, via: "screen", command: printable };
+  }
+  return;
+}
+// src/extensions/gitx.ts
+import { realpath } from "node:fs/promises";
+import { basename as basename2, isAbsolute, join as join4, resolve } from "node:path";
+async function gitToplevel(cwd) {
+  const result = await run("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
+  const top = result.stdout.trim();
+  return result.code === 0 && top ? top : resolve(cwd);
+}
+async function inspectGitRepository(cwd) {
+  const root = await gitToplevel(cwd);
+  const remoteResult = await run("git", ["-C", root, "remote", "get-url", "origin"]);
+  const remote = remoteResult.code === 0 ? remoteResult.stdout.trim() : "";
+  const commonResult = await run("git", ["-C", root, "rev-parse", "--git-common-dir"]);
+  const common = commonResult.stdout.trim();
+  const commonPath = commonResult.code === 0 && common ? resolve(isAbsolute(common) ? common : join4(root, common)) : root;
+  const commonDir = await canonicalPath(commonPath);
+  return {
+    root,
+    commonDir,
+    ...remote ? { remote } : {},
+    name: remote ? repositoryName(remote) : basename2(resolve(commonDir, "..")) || basename2(root),
+    identity: remote ? `remote:${normalizeRemote(remote)}` : `git-common-dir:${commonDir}`
+  };
+}
+function normalizeRemote(remote) {
+  return remote.trim().replace(/\.git\/?$/i, "").replace(/\/+$/, "").toLowerCase();
+}
+function repositoryName(remote) {
+  const normalized = remote.trim().replace(/\.git\/?$/i, "").replace(/\/+$/, "");
+  return normalized.split(/[/\\:]/).filter(Boolean).at(-1) ?? "";
+}
+async function canonicalPath(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return resolve(path);
+  }
+}
+// src/extensions/ghx.ts
+function gh(args, options) {
+  return run("gh", args, options);
+}
+function ghChecked(args, options) {
+  return runChecked("gh", args, options);
+}
+
+// src/vcs/helpers.ts
+function isConfirmedMissingChange(provider, output) {
+  const message = output.toLowerCase();
+  return provider === "github" ? message.includes("no pull requests found for branch") || message.includes("could not find pull request") || message.includes("could not resolve to a pullrequest") : provider === "gitlab" ? message.includes("no open merge request") || /failed to get open merge request/.test(message) && /404(?: not found)?/.test(message) : false;
+}
+function parseJson(value, name) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`Cannot parse the ${name} response as JSON.`);
+  }
+}
+function commandFailure(command, args, result) {
+  return new Error(`${command} ${args.join(" ")} failed: ${result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`}`);
+}
+function requireBranchName(output, provider) {
+  const branch = output.trim();
+  if (!branch || branch === "null")
+    throw new Error(`${provider} did not return a default branch.`);
+  return branch;
+}
+
+// src/vcs/github.ts
+function GitHubVcsBackend(vcs) {
+  const repo = ["--repo", `${vcs.owner}/${vcs.repo}`];
+  const viewPr = async (idOrBranch) => {
+    const args = [
+      "pr",
+      "view",
+      idOrBranch,
+      ...repo,
+      "--json",
+      "number,title,url,isDraft,baseRefName,headRefName,headRefOid"
+    ];
+    const result = await gh(args);
+    if (result.code !== 0) {
+      if (isConfirmedMissingChange("github", result.stderr || result.stdout))
+        return;
+      throw commandFailure("gh", args, result);
+    }
+    if (!result.stdout.trim())
+      throw new Error("GitHub returned an empty pull request response.");
+    const data = parseJson(result.stdout, "GitHub pull request");
+    if (typeof data.number !== "number" || typeof data.title !== "string" || typeof data.url !== "string" || typeof data.isDraft !== "boolean" || typeof data.baseRefName !== "string" || typeof data.headRefName !== "string")
+      throw new Error("GitHub returned an invalid pull request response.");
+    return {
+      number: data.number,
+      title: data.title,
+      url: data.url,
+      isDraft: data.isDraft,
+      baseRef: data.baseRefName,
+      headRef: data.headRefName,
+      headSha: data.headRefOid
+    };
+  };
+  return {
+    provider: "github",
+    async createDraftPr(options) {
+      const args = [
+        "pr",
+        "create",
+        ...repo,
+        "--title",
+        options.title,
+        "--body",
+        options.body,
+        "--base",
+        options.base,
+        "--head",
+        options.head
+      ];
+      if (options.draft !== false)
+        args.push("--draft");
+      await ghChecked(args);
+      const ref = await viewPr(options.head);
+      if (!ref)
+        throw new Error("Draft PR created but could not be resolved.");
+      return ref;
+    },
+    viewPr,
+    async defaultBranch() {
+      return requireBranchName((await ghChecked([
+        "repo",
+        "view",
+        `${vcs.owner}/${vcs.repo}`,
+        "--json",
+        "defaultBranchRef",
+        "--jq",
+        ".defaultBranchRef.name"
+      ])).stdout, "GitHub");
+    },
+    async prDiff(id) {
+      return (await ghChecked(["pr", "diff", String(id), ...repo], { capture: "unbounded" })).stdout;
+    },
+    async prChecks(id) {
+      return (await gh(["pr", "checks", String(id), ...repo])).stdout;
+    },
+    async markReady(id) {
+      await ghChecked(["pr", "ready", String(id), ...repo]);
+    },
+    async closePr(id, comment) {
+      const args = ["pr", "close", String(id), ...repo];
+      if (comment)
+        args.push("--comment", comment);
+      await ghChecked(args);
+    },
+    async mergePr(id, subject) {
+      const readiness = await ghChecked([
+        "pr",
+        "view",
+        String(id),
+        ...repo,
+        "--json",
+        "isDraft,state,reviewDecision,mergeStateStatus,statusCheckRollup"
+      ]);
+      assertGitHubMergeReady(readiness.stdout);
+      await ghChecked(["pr", "merge", String(id), ...repo, "--squash", "--subject", subject]);
+    }
+  };
+}
+function assertGitHubMergeReady(input) {
+  const data = parseJson(input, "GitHub readiness");
+  const blockers = [];
+  if (data.state !== "OPEN")
+    blockers.push(`pull request state is ${data.state ?? "unknown"}`);
+  if (data.isDraft)
+    blockers.push("pull request is still a draft");
+  if (data.reviewDecision !== "APPROVED")
+    blockers.push(`review decision is ${data.reviewDecision || "not approved"}`);
+  if (data.mergeStateStatus !== "CLEAN")
+    blockers.push(`merge state is ${data.mergeStateStatus ?? "unknown"}`);
+  for (const check of data.statusCheckRollup ?? []) {
+    const name = check.name ?? check.context ?? "unnamed check";
+    if (check.__typename === "CheckRun") {
+      if (check.status !== "COMPLETED")
+        blockers.push(`${name} is ${check.status?.toLowerCase() ?? "pending"}`);
+      else if (!["SUCCESS", "SKIPPED", "NEUTRAL"].includes(check.conclusion ?? ""))
+        blockers.push(`${name} concluded ${(check.conclusion ?? "unknown").toLowerCase()}`);
+    } else if (check.state !== "SUCCESS")
+      blockers.push(`${name} is ${(check.state ?? "pending").toLowerCase()}`);
+  }
+  if (blockers.length > 0)
+    throw new Error(`Merge blocked: ${blockers.join("; ")}.`);
+}
+
+// src/extensions/glabx.ts
+function glab(args, options) {
+  return run("glab", args, options);
+}
+function glabChecked(args, options) {
+  return runChecked("glab", args, options);
+}
+
+// src/vcs/gitlab.ts
+function GitLabVcsBackend(vcs) {
+  const project = `${vcs.owner}/${vcs.repo}`;
+  const viewPr = async (idOrBranch) => {
+    const args = ["mr", "view", idOrBranch, "--repo", project, "--output", "json"];
+    const result = await glab(args);
+    if (result.code !== 0) {
+      if (isConfirmedMissingChange("gitlab", result.stderr || result.stdout))
+        return;
+      throw commandFailure("glab", args, result);
+    }
+    if (!result.stdout.trim())
+      throw new Error("GitLab returned an empty merge request response.");
+    const data = parseJson(result.stdout, "GitLab merge request");
+    if (typeof data.iid !== "number" || typeof data.title !== "string" || typeof data.web_url !== "string" || typeof data.target_branch !== "string" || typeof data.source_branch !== "string")
+      throw new Error("GitLab returned an invalid merge request response.");
+    return {
+      number: data.iid,
+      title: data.title,
+      url: data.web_url,
+      isDraft: Boolean(data.draft ?? data.work_in_progress),
+      baseRef: data.target_branch,
+      headRef: data.source_branch,
+      headSha: data.sha
+    };
+  };
+  return {
+    provider: "gitlab",
+    async createDraftPr(options) {
+      await glabChecked([
+        "mr",
+        "create",
+        "--repo",
+        project,
+        "--title",
+        `Draft: ${options.title}`,
+        "--description",
+        options.body,
+        "--target-branch",
+        options.base,
+        "--source-branch",
+        options.head,
+        "--yes"
+      ]);
+      const ref = await viewPr(options.head);
+      if (!ref)
+        throw new Error("Draft MR created but could not be resolved.");
+      return ref;
+    },
+    viewPr,
+    async defaultBranch() {
+      return requireBranchName((await glabChecked(["api", `projects/${encodeURIComponent(project)}`, "--jq", ".default_branch"])).stdout, "GitLab");
+    },
+    async prDiff(id) {
+      return (await glabChecked(["mr", "diff", String(id), "--repo", project], { capture: "unbounded" })).stdout;
+    },
+    async prChecks(id) {
+      return (await glabChecked([
+        "api",
+        `projects/${encodeURIComponent(project)}/merge_requests/${id}/pipelines?per_page=100`
+      ])).stdout;
+    },
+    async markReady(id) {
+      await glabChecked(["mr", "update", String(id), "--repo", project, "--ready"]);
+    },
+    async closePr(id, comment) {
+      if (comment)
+        await glabChecked(["mr", "note", String(id), "--repo", project, "--message", comment]);
+      await glabChecked(["mr", "close", String(id), "--repo", project]);
+    },
+    async mergePr() {
+      throw new Error("Merge is not supported by the GitLab forge adapter.");
+    }
+  };
+}
+
+// src/vcs/forge-backend.ts
+function createForgeBackend(vcs) {
+  if (vcs.provider === "github")
+    return GitHubVcsBackend(vcs);
+  if (vcs.provider === "gitlab")
+    return GitLabVcsBackend(vcs);
+  throw new Error("No supported forge detected from the git remote. Use --local for an offline review.");
+}
+var createVcsBackend = createForgeBackend;
+var createForge = createForgeBackend;
+// src/extensions/misex.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename3, dirname as dirname2, join as join5 } from "node:path";
 var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
 var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
 var mise = {
   async executableCheck(name = "mise") {
     return findExecutable(name);
   },
+  async run(args, options = {}) {
+    return run("mise", args, options);
+  },
   async install(options = {}) {
     const homeDir = options.homeDir ?? homedir3();
     const platform = options.platform ?? process.platform;
     if (platform === "win32")
       throw new Error("Automatic mise installation supports macOS and Linux only.");
-    const installedPath = join4(homeDir, ".local", "bin", "mise");
+    const installedPath = join5(homeDir, ".local", "bin", "mise");
     if (options.dryRun)
       return installedPath;
     await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
@@ -238,8 +724,8 @@ var mise = {
   },
   async hookEnsure(executable, options = {}) {
     const homeDir = options.homeDir ?? homedir3();
-    const hook = getShellHook(basename(options.shell ?? process.env.SHELL ?? ""), executable, homeDir);
-    const current = await getOptionalFile2(hook.path);
+    const hook = getShellHook(basename3(options.shell ?? process.env.SHELL ?? ""), executable, homeDir);
+    const current = await getOptionalFile(hook.path);
     if (current.includes(MISE_HOOK_START))
       return { path: hook.path, changed: false, planned: false };
     if (options.dryRun)
@@ -274,7 +760,7 @@ function getShellHook(shell, executable, homeDir) {
   switch (shell.toLowerCase()) {
     case "zsh":
       return {
-        path: join4(homeDir, ".zshrc"),
+        path: join5(homeDir, ".zshrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate zsh)"
 ${MISE_HOOK_END}
@@ -282,7 +768,7 @@ ${MISE_HOOK_END}
       };
     case "fish":
       return {
-        path: join4(homeDir, ".config", "fish", "config.fish"),
+        path: join5(homeDir, ".config", "fish", "config.fish"),
         content: `${MISE_HOOK_START}
 ${command} activate fish | source
 ${MISE_HOOK_END}
@@ -291,7 +777,7 @@ ${MISE_HOOK_END}
     case "nu":
     case "nushell":
       return {
-        path: join4(homeDir, ".config", "nushell", "config.nu"),
+        path: join5(homeDir, ".config", "nushell", "config.nu"),
         content: `${MISE_HOOK_START}
 let mise_bin = ${command}
 let mise_path = $nu.default-config-dir | path join mise.nu
@@ -302,7 +788,7 @@ ${MISE_HOOK_END}
       };
     case "xonsh":
       return {
-        path: join4(homeDir, ".xonshrc"),
+        path: join5(homeDir, ".xonshrc"),
         content: `${MISE_HOOK_START}
 execx($(${command} activate xonsh))
 ${MISE_HOOK_END}
@@ -310,7 +796,7 @@ ${MISE_HOOK_END}
       };
     case "elvish":
       return {
-        path: join4(homeDir, ".config", "elvish", "rc.elv"),
+        path: join5(homeDir, ".config", "elvish", "rc.elv"),
         content: `${MISE_HOOK_START}
 var mise: = (ns [&])
 eval (${command} activate elvish | slurp) &ns=$mise: &on-end={|ns| set mise: = $ns }
@@ -321,7 +807,7 @@ ${MISE_HOOK_END}
     case "pwsh":
     case "powershell":
       return {
-        path: join4(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        path: join5(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
         content: `${MISE_HOOK_START}
 (& ${command} activate pwsh) | Out-String | Invoke-Expression
 ${MISE_HOOK_END}
@@ -330,7 +816,7 @@ ${MISE_HOOK_END}
     case "bash":
     default:
       return {
-        path: join4(homeDir, ".bashrc"),
+        path: join5(homeDir, ".bashrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate bash)"
 ${MISE_HOOK_END}
@@ -367,7 +853,7 @@ function isVersionAtLeast(version, minimumVersion) {
   }
   return true;
 }
-async function getOptionalFile2(path) {
+async function getOptionalFile(path) {
   try {
     return await readFile3(path, "utf8");
   } catch (error) {
@@ -379,48 +865,1055 @@ async function getOptionalFile2(path) {
 function getShellQuoted(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
+
+// src/gates.ts
+var CONVENTIONAL_COMMIT = /^(feat|fix|perf|refactor|docs|chore|test|build|ci|style|revert)(\([^)]+\))?!?: .+/;
+var MISE_GATES = ["format:check", "lint", "test"];
+function checkConventionalSubject(subject) {
+  const trimmed = subject.trim();
+  const ok = CONVENTIONAL_COMMIT.test(trimmed);
+  return {
+    name: "conventional-subject",
+    status: ok ? "pass" : "warn",
+    detail: ok ? trimmed : `not a conventional-commit subject: "${trimmed}"`
+  };
+}
+async function runMiseGates(cwd) {
+  const tasks = await discoverMiseTasks(cwd);
+  const results = [];
+  for (const gate of MISE_GATES) {
+    const targets = tasks.get(gate) ?? [];
+    if (targets.length === 0) {
+      results.push({ name: gate, status: "skip", detail: "no mise recipe" });
+      continue;
+    }
+    const invocations = targets.flatMap((target, index) => index === 0 ? [target] : [":::", target]);
+    const result = await mise.run(["run", ...invocations], { cwd });
+    results.push({
+      name: gate,
+      status: result.code === 0 ? "pass" : "fail",
+      detail: result.code === 0 ? "clean" : (result.stderr.trim() || result.stdout.trim()).slice(-400)
+    });
+  }
+  return results;
+}
+function ciGate(checksOutput) {
+  const text = checksOutput.toLowerCase();
+  if (!text.trim())
+    return { name: "ci", status: "skip", detail: "no CI output" };
+  if (/\bfail|error\b/.test(text))
+    return { name: "ci", status: "warn", detail: "CI failing" };
+  if (/\bpending|in progress|queued\b/.test(text))
+    return { name: "ci", status: "warn", detail: "CI pending" };
+  return { name: "ci", status: "pass", detail: "CI green" };
+}
+function parseMiseTasks(input) {
+  let tasks;
+  try {
+    tasks = JSON.parse(input);
+  } catch {
+    return new Map;
+  }
+  if (!Array.isArray(tasks))
+    return new Map;
+  const found = new Map;
+  for (const gate of MISE_GATES) {
+    const targets = tasks.flatMap((task) => {
+      if (typeof task.name !== "string")
+        return [];
+      return task.name === gate || task.name.endsWith(`:${gate}`) || task.aliases?.includes(gate) ? [task.name] : [];
+    });
+    if (targets.length > 0)
+      found.set(gate, [...new Set(targets)]);
+  }
+  return found;
+}
+async function discoverMiseTasks(cwd) {
+  const result = await mise.run(["tasks", "--json", "--all"], { cwd });
+  if (result.code !== 0)
+    return new Map;
+  return parseMiseTasks(result.stdout);
+}
+// src/review/types.ts
+import { z as z2 } from "zod";
+var severitySchema = z2.enum(["BLOCKING", "CONSIDER", "NOTE"]);
+var findingSchema = z2.object({
+  file: z2.string().min(1),
+  line: z2.number().int().nonnegative(),
+  severity: severitySchema,
+  body: z2.string().min(1),
+  reference: z2.string().optional().default("")
+});
+var findingsSchema = z2.array(findingSchema);
+function reviewSlug(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+function yymmdd(date = new Date) {
+  const yy = String(date.getFullYear() % 100).padStart(2, "0");
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  return `${yy}${mm}${dd}`;
+}
+function reviewRecordName(target, date = new Date) {
+  return `${yymmdd(date)}-${reviewSlug(target) || "uncommitted"}`;
+}
+function isLocalResponse(body) {
+  return /^<!-- diffpi(?:-local-response:[A-Za-z0-9_-]+)? -->\n/m.test(body);
+}
+function dedupeFindings(findings) {
+  const rank = { BLOCKING: 3, CONSIDER: 2, NOTE: 1 };
+  const byKey = new Map;
+  for (const finding of findings) {
+    const key = `${finding.file}:${finding.line}`;
+    const existing = byKey.get(key);
+    if (!existing || rank[finding.severity] > rank[existing.severity])
+      byKey.set(key, finding);
+  }
+  return [...byKey.values()].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || rank[b.severity] - rank[a.severity]);
+}
+function toReviewComments(findings, model) {
+  const comments = [];
+  for (const finding of findings) {
+    if (finding.line <= 0)
+      continue;
+    const body = renderCommentBody(finding);
+    comments.push({
+      file: finding.file,
+      line: finding.line,
+      side: "RIGHT",
+      body: model ? withRemoteProvenance(body, model) : body
+    });
+  }
+  return comments;
+}
+function withRemoteProvenance(body, model) {
+  const normalized = body.trimEnd();
+  if (/Generated review by Diffpi using `[^`]+`\.$/.test(normalized))
+    return body;
+  return `${normalized}
+
+Generated review by Diffpi using \`${model}\`.`;
+}
+function localReviewAuthor(model) {
+  return `Agent: ${model}`;
+}
+function renderCommentBody(finding) {
+  const prefix = finding.severity === "BLOCKING" ? "**BLOCKING** " : "";
+  const reference = finding.reference ? `
+
+> **Reference:** ${finding.reference}` : "";
+  return `${prefix}${finding.body}${reference}`;
+}
+// src/review/review-markdown.ts
+import { z as z3 } from "zod";
+var reviewThreadRecordSchema = z3.object({
+  id: z3.string().min(1),
+  file: z3.string().optional(),
+  line: z3.number().int().positive().optional(),
+  body: z3.string(),
+  author: z3.string().optional(),
+  resolved: z3.boolean(),
+  addressed: z3.boolean().optional(),
+  question: z3.boolean(),
+  replies: z3.array(z3.string()).optional()
+});
+function renderReviewDoc(input) {
+  const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
+  const lines = [`# Review: ${input.title}`, "", "## Metadata"];
+  if (input.number !== undefined)
+    lines.push(`- **PR/MR**: #${input.number}${input.url ? ` — ${input.url}` : ""}`);
+  if (input.author)
+    lines.push(`- **Author**: ${input.author}`);
+  if (input.model)
+    lines.push(`- **Review agent**: ${input.model}`);
+  if (input.headRef && input.baseRef)
+    lines.push(`- **Branch**: ${input.headRef} → ${input.baseRef}`);
+  if (input.additions !== undefined)
+    lines.push(`- **Stats**: +${input.additions} -${input.deletions ?? 0} across ${input.changedFiles ?? 0} files`);
+  lines.push(`- **Reviewed**: ${input.timestamp ?? new Date().toISOString()}`, "");
+  if (input.overallIssues.length > 0) {
+    lines.push("## Overall issues", "");
+    for (const issue of input.overallIssues)
+      lines.push(`- ${issue}`);
+    lines.push("");
+  }
+  lines.push("## Verification", "");
+  for (const gate of input.gates)
+    lines.push(`- ${gate.name}: ${gate.status} — ${gate.detail}`);
+  lines.push("");
+  if (input.notVerified.length > 0) {
+    lines.push("## What was NOT verified", "");
+    for (const item of input.notVerified)
+      lines.push(`- ${item}`);
+    lines.push("");
+  }
+  lines.push("## Inline Comments", "");
+  for (const finding of anchored) {
+    lines.push(`### ${finding.file}:${finding.line} — ${finding.severity}`, "", finding.body, "");
+    if (finding.reference)
+      lines.push(`> **Reference:** ${finding.reference}`, "");
+    lines.push("---", "");
+  }
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+function renderThreadArtifact(title, target, threads, options = {}) {
+  const records = threads.map((thread) => ({
+    id: thread.id,
+    file: thread.file,
+    line: thread.line,
+    body: thread.body,
+    author: thread.author,
+    resolved: thread.resolved,
+    addressed: thread.addressed,
+    question: thread.question,
+    replies: thread.replies
+  }));
+  const payload = Buffer.from(JSON.stringify(records), "utf8").toString("base64url");
+  const lines = [
+    `<!-- diffpi-threads:${payload} -->`,
+    `# Review threads: ${title}`,
+    "",
+    "## Metadata",
+    "",
+    `- Target: ${target}`,
+    `- Pulled: ${options.timestamp ?? new Date().toISOString()}`
+  ];
+  if (options.number !== undefined)
+    lines.push(`- PR/MR: #${options.number}${options.url ? ` — ${options.url}` : ""}`);
+  lines.push("", "## Replies", "");
+  for (const thread of threads) {
+    const id = Buffer.from(thread.id, "utf8").toString("base64url");
+    lines.push(`### ${thread.file ?? "review"}:${thread.line ?? "n/a"} (${thread.id})`, "", `<!-- diffpi-reply-start:${id} -->`, thread.reply ?? "", `<!-- diffpi-reply-end:${id} -->`, "");
+  }
+  lines.push("## Source comments", "");
+  for (const thread of threads) {
+    lines.push(`### ${thread.file ?? "review"}:${thread.line ?? "n/a"} — ${thread.author ?? "unknown"}`, "", `Thread: ${thread.id}`, `Status: ${thread.resolved ? "resolved" : thread.addressed ? "addressed" : "open"}`, "", thread.body, "", "---", "");
+  }
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+function parseThreadArtifact(content) {
+  const payload = content.match(/^<!-- diffpi-threads:([A-Za-z0-9_-]+) -->$/m)?.[1];
+  if (!payload)
+    throw new Error("This file is not a Diffpi thread artifact.");
+  let threads;
+  try {
+    const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    threads = z3.array(reviewThreadRecordSchema).parse(decoded);
+  } catch {
+    throw new Error("Cannot parse the Diffpi thread artifact payload.");
+  }
+  const replies = content.split(/^## Source comments$/m, 1)[0] ?? "";
+  return threads.map((thread) => {
+    const id = Buffer.from(thread.id, "utf8").toString("base64url");
+    const startMarker = `<!-- diffpi-reply-start:${id} -->
+`;
+    const endMarker = `
+<!-- diffpi-reply-end:${id} -->`;
+    const start = replies.indexOf(startMarker);
+    const end = start < 0 ? -1 : replies.indexOf(endMarker, start + startMarker.length);
+    const reply = start >= 0 && end >= 0 ? replies.slice(start + startMarker.length, end).trim() : "";
+    return reply ? { ...thread, reply } : thread;
+  });
+}
+function upsertThreadReply(content, threadId, body, question, resolved) {
+  const threads = parseThreadArtifact(content);
+  const thread = threads.find((candidate) => candidate.id === threadId);
+  if (!thread)
+    throw new Error(`Review thread ${threadId} was not found in the local artifact.`);
+  thread.reply = body;
+  thread.addressed = true;
+  if (question !== undefined)
+    thread.question = question;
+  if (resolved !== undefined)
+    thread.resolved = resolved;
+  const title = content.match(/^# Review threads: (.+)$/m)?.[1] ?? "review";
+  const target = content.match(/^- Target: (.+)$/m)?.[1] ?? "local";
+  const timestamp = content.match(/^- Pulled: (.+)$/m)?.[1];
+  const pr = content.match(/^- PR\/MR: #(\d+)(?: — (.+))?$/m);
+  return renderThreadArtifact(title, target, threads, {
+    timestamp,
+    number: pr ? Number.parseInt(pr[1], 10) : undefined,
+    url: pr?.[2]
+  });
+}
+// src/review/github-review-backend.ts
+function GitHubReviewBackend(vcs, number) {
+  const pendingReview = async () => {
+    const result = await ghChecked([
+      "api",
+      `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews`,
+      "--jq",
+      '[.[] | select(.state=="PENDING")] | last | {id: (.id | tostring), nodeId: .node_id}'
+    ]);
+    if (!result.stdout.trim())
+      return;
+    let pending;
+    try {
+      pending = JSON.parse(result.stdout);
+    } catch {
+      throw new Error("Cannot parse the pending GitHub review identifier as JSON.");
+    }
+    if (!pending.id || !pending.nodeId)
+      return;
+    return { id: pending.id, nodeId: pending.nodeId };
+  };
+  const listThreads = async () => {
+    const threads = [];
+    let cursor;
+    do {
+      const args = [
+        "api",
+        "graphql",
+        "-f",
+        `query=${GITHUB_THREADS_QUERY}`,
+        "-f",
+        `owner=${vcs.owner}`,
+        "-f",
+        `repo=${vcs.repo}`,
+        "-F",
+        `number=${number}`
+      ];
+      if (cursor)
+        args.push("-f", `after=${cursor}`);
+      const result = await ghChecked(args);
+      let data;
+      try {
+        data = JSON.parse(result.stdout);
+      } catch {
+        throw new Error("Cannot parse GitHub review threads as JSON.");
+      }
+      const connection = data.data?.repository?.pullRequest?.reviewThreads;
+      threads.push(...connection?.nodes ?? []);
+      cursor = connection?.pageInfo?.hasNextPage ? connection.pageInfo.endCursor : undefined;
+      if (connection?.pageInfo?.hasNextPage && !cursor) {
+        throw new Error("GitHub review thread pagination did not return an end cursor.");
+      }
+    } while (cursor);
+    return threads.map((thread) => {
+      const nodes = thread.comments?.nodes ?? [];
+      const comment = nodes[0];
+      const body = comment?.body ?? "";
+      return {
+        id: thread.id,
+        file: thread.path,
+        line: thread.line,
+        body,
+        author: comment?.author?.login,
+        resolved: thread.isResolved,
+        question: /\?\s*$/.test(body.trim()),
+        replies: nodes.slice(1).map((node) => node.body)
+      };
+    });
+  };
+  return {
+    kind: "remote",
+    async stage(draft) {
+      const pending = await pendingReview();
+      if (!pending) {
+        const payload = {
+          body: draft.body,
+          comments: draft.comments.map((comment) => ({
+            path: comment.file,
+            line: comment.line,
+            side: comment.side ?? "RIGHT",
+            body: comment.body
+          }))
+        };
+        await ghChecked(["api", "--method", "POST", `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews`, "--input", "-"], { input: JSON.stringify(payload) });
+        return;
+      }
+      if (draft.body.trim()) {
+        await ghChecked([
+          "api",
+          "--method",
+          "PUT",
+          `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}`,
+          "-f",
+          `body=${draft.body}`
+        ]);
+      }
+      for (const comment of draft.comments) {
+        await ghChecked([
+          "api",
+          "graphql",
+          "-f",
+          `query=${GITHUB_ADD_THREAD_MUTATION}`,
+          "-f",
+          `reviewId=${pending.nodeId}`,
+          "-f",
+          `body=${comment.body}`,
+          "-f",
+          `path=${comment.file}`,
+          "-F",
+          `line=${comment.line}`,
+          "-f",
+          `side=${comment.side ?? "RIGHT"}`
+        ]);
+      }
+    },
+    async readDraft() {
+      const pending = await pendingReview();
+      if (!pending)
+        return { comments: [], body: "" };
+      const review = await ghChecked(["api", `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}`]);
+      const comments = await ghChecked([
+        "api",
+        `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}/comments`
+      ]);
+      let reviewData;
+      let commentData;
+      try {
+        reviewData = JSON.parse(review.stdout);
+        commentData = JSON.parse(comments.stdout);
+      } catch {
+        throw new Error("Cannot parse the pending GitHub review as JSON.");
+      }
+      return {
+        body: reviewData.body ?? "",
+        comments: commentData.map((comment) => ({
+          file: comment.path,
+          line: comment.line ?? comment.original_line ?? 1,
+          side: comment.side,
+          body: comment.body
+        }))
+      };
+    },
+    listThreads,
+    async reply(input) {
+      const threads = await listThreads();
+      const existing = threads.find((thread) => thread.id === input.threadId);
+      if (!existing?.replies?.includes(input.body)) {
+        await ghChecked([
+          "api",
+          "graphql",
+          "-f",
+          `query=${GITHUB_REPLY_MUTATION}`,
+          "-f",
+          `threadId=${input.threadId}`,
+          "-f",
+          `body=${input.body}`
+        ]);
+      }
+      if (input.resolve) {
+        await ghChecked([
+          "api",
+          "graphql",
+          "-f",
+          `query=${GITHUB_RESOLVE_MUTATION}`,
+          "-f",
+          `threadId=${input.threadId}`
+        ]);
+      }
+    },
+    async publish(event) {
+      const pending = await pendingReview();
+      if (!pending && event === "COMMENT")
+        return;
+      if (!pending && event === "REQUEST_CHANGES") {
+        throw new Error("GitHub requires pending comments before publishing a request-changes review without a body.");
+      }
+      const endpoint = githubReviewSubmissionEndpoint(vcs.owner, vcs.repo, number, pending?.id ?? "");
+      await ghChecked(["api", "--method", "POST", endpoint, "-f", `event=${event}`]);
+    }
+  };
+}
+function githubReviewSubmissionEndpoint(owner, repo, id, pendingReviewId) {
+  return pendingReviewId ? `/repos/${owner}/${repo}/pulls/${id}/reviews/${pendingReviewId}/events` : `/repos/${owner}/${repo}/pulls/${id}/reviews`;
+}
+var GITHUB_THREADS_QUERY = `query($owner:String!,$repo:String!,$number:Int!,$after:String){repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewThreads(first:100,after:$after){nodes{id,isResolved,path,line,comments(first:100){nodes{body,author{login}}}}pageInfo{hasNextPage,endCursor}}}}}`;
+var GITHUB_ADD_THREAD_MUTATION = `mutation($reviewId:ID!,$body:String!,$path:String!,$line:Int!,$side:DiffSide!){addPullRequestReviewThread(input:{pullRequestReviewId:$reviewId,body:$body,path:$path,line:$line,side:$side}){thread{id}}}`;
+var GITHUB_REPLY_MUTATION = `mutation($threadId:ID!,$body:String!){addPullRequestReviewThreadReply(input:{pullRequestReviewThreadId:$threadId,body:$body}){comment{id}}}`;
+var GITHUB_RESOLVE_MUTATION = `mutation($threadId:ID!){resolveReviewThread(input:{threadId:$threadId}){thread{isResolved}}}`;
+
+// src/review/gitlab-review-backend.ts
+function GitLabReviewBackend(vcs, number) {
+  const project = () => `${vcs.owner}/${vcs.repo}`;
+  const mergeRequestEndpoint = () => `projects/${encodeURIComponent(project())}/merge_requests/${number}`;
+  const listThreads = async () => {
+    const discussions = [];
+    for (let page = 1;; page += 1) {
+      const result = await glabChecked(["api", `${mergeRequestEndpoint()}/discussions?per_page=100&page=${page}`]);
+      let batch;
+      try {
+        batch = JSON.parse(result.stdout);
+      } catch {
+        throw new Error("Cannot parse GitLab review discussions as JSON.");
+      }
+      discussions.push(...batch);
+      if (batch.length < 100)
+        break;
+    }
+    return discussions.map((discussion) => {
+      const notes = discussion.notes ?? [];
+      const note = notes[0];
+      const body = note?.body ?? "";
+      return {
+        id: discussion.id,
+        file: note?.position?.new_path ?? note?.position?.old_path,
+        line: note?.position?.new_line ?? note?.position?.old_line,
+        body,
+        author: note?.author?.username,
+        resolved: Boolean(discussion.resolved),
+        question: /\?\s*$/.test(body.trim()),
+        replies: notes.slice(1).map((reply) => reply.body)
+      };
+    });
+  };
+  return {
+    kind: "remote",
+    async stage(draft) {
+      const endpoint = `${mergeRequestEndpoint()}/draft_notes`;
+      if (draft.body.trim()) {
+        await glabChecked(["api", "--method", "POST", endpoint, "--input", "-"], {
+          input: JSON.stringify({ note: draft.body })
+        });
+      }
+      if (draft.comments.length === 0)
+        return;
+      const response = await glabChecked(["api", mergeRequestEndpoint()]);
+      const diffRefs = parseGitlabDiffRefs(response.stdout);
+      for (const comment of draft.comments) {
+        const payload = {
+          note: comment.body,
+          position: {
+            ...diffRefs,
+            position_type: "text",
+            new_path: comment.file,
+            old_path: comment.file,
+            new_line: comment.side === "LEFT" ? undefined : comment.line,
+            old_line: comment.side === "LEFT" ? comment.line : undefined
+          }
+        };
+        await glabChecked(["api", "--method", "POST", endpoint, "--input", "-"], {
+          input: JSON.stringify(payload)
+        });
+      }
+    },
+    async readDraft() {
+      const result = await glabChecked(["api", `${mergeRequestEndpoint()}/draft_notes`]);
+      let notes;
+      try {
+        notes = JSON.parse(result.stdout);
+      } catch {
+        throw new Error("Cannot parse GitLab draft notes as JSON.");
+      }
+      const comments = [];
+      const body = [];
+      for (const note of notes) {
+        if (!note.note)
+          continue;
+        const file = note.position?.new_path ?? note.position?.old_path;
+        const line = note.position?.new_line ?? note.position?.old_line;
+        if (file && line) {
+          comments.push({
+            file,
+            line,
+            side: note.position?.new_line ? "RIGHT" : "LEFT",
+            body: note.note
+          });
+        } else {
+          body.push(note.note);
+        }
+      }
+      return { comments, body: body.join(`
+
+`) };
+    },
+    listThreads,
+    async reply(input) {
+      const endpoint = `${mergeRequestEndpoint()}/discussions/${encodeURIComponent(input.threadId)}`;
+      const threads = await listThreads();
+      const existing = threads.find((thread) => thread.id === input.threadId);
+      if (!existing?.replies?.includes(input.body)) {
+        await glabChecked(["api", "--method", "POST", `${endpoint}/notes`, "--input", "-"], {
+          input: JSON.stringify({ body: input.body })
+        });
+      }
+      if (input.resolve)
+        await glabChecked(["api", "--method", "PUT", `${endpoint}?resolved=true`]);
+    },
+    async publish(event) {
+      assertReviewEventSupported(vcs.provider, event);
+      const drafts = await glabChecked(["api", `${mergeRequestEndpoint()}/draft_notes`]);
+      if (hasGitlabDraftNotes(drafts.stdout)) {
+        await glabChecked(["api", "--method", "POST", `${mergeRequestEndpoint()}/draft_notes/bulk_publish`]);
+      }
+      if (event === "APPROVE")
+        await glabChecked(["mr", "approve", String(number), "--repo", project()]);
+    }
+  };
+}
+function assertReviewEventSupported(provider, event) {
+  if (provider === "gitlab" && event === "REQUEST_CHANGES") {
+    throw new Error("GitLab does not support REQUEST_CHANGES reviews; post a comment or reject the merge request manually.");
+  }
+}
+function parseGitlabDiffRefs(input) {
+  let data;
+  try {
+    data = JSON.parse(input);
+  } catch {
+    throw new Error("Cannot create positioned GitLab draft notes: the merge request response was not valid JSON.");
+  }
+  const { base_sha, start_sha, head_sha } = data.diff_refs ?? {};
+  if (!base_sha || !start_sha || !head_sha) {
+    throw new Error("Cannot create positioned GitLab draft notes: merge request diff refs are unavailable.");
+  }
+  return { base_sha, start_sha, head_sha };
+}
+function hasGitlabDraftNotes(input) {
+  try {
+    const data = JSON.parse(input);
+    return Array.isArray(data) && data.length > 0;
+  } catch {
+    throw new Error("Cannot publish the GitLab review: the draft notes response was not valid JSON.");
+  }
+}
+
+// src/review/local-review-backend.ts
+import { readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+
+// src/extensions/tuicrx.ts
+import { readFile as readFile4, realpath as realpath2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+async function tuicrAvailable() {
+  return Boolean(await findExecutable("tuicr"));
+}
+async function listSessions(repo = ".") {
+  await requireTuicr();
+  const result = await run("tuicr", ["review", "list", "--repo", repo]);
+  if (result.code !== 0 || !result.stdout.trim())
+    return [];
+  try {
+    const raw = JSON.parse(result.stdout);
+    return raw.map((entry) => ({
+      slug: entry.slug,
+      kind: entry.kind,
+      path: entry.path,
+      updatedAt: entry.updated_at,
+      commentCount: entry.comment_count,
+      anchor: entry.anchor,
+      active: entry.active
+    }));
+  } catch {
+    throw new Error("Cannot parse tuicr review list output.");
+  }
+}
+async function addComment(session, body, opts = {}) {
+  await requireTuicr();
+  const args = ["review", "add", "--session", session, body];
+  if (opts.targetFile)
+    args.push("--target-file", opts.targetFile);
+  if (opts.line !== undefined)
+    args.push("--line", String(opts.line));
+  if (opts.side)
+    args.push("--side", opts.side);
+  if (opts.username)
+    args.push("--username", opts.username);
+  await runChecked("tuicr", args);
+}
+async function launch(cwd, pr, localBase) {
+  let command;
+  if (pr !== undefined)
+    command = ["tuicr", "pr", String(pr)];
+  else if (localBase)
+    command = ["tuicr", "-w", "-r", `${localBase}..HEAD`];
+  else
+    throw new Error("Cannot launch a local tuicr review: no base branch could be determined.");
+  if (!await tuicrAvailable()) {
+    return {
+      launched: false,
+      via: "print",
+      command: command.join(" "),
+      reason: "tuicr is not installed or is not available on PATH.",
+      instruction: `Install tuicr, then run: ${command.join(" ")}`
+    };
+  }
+  return openInNewTab(command, { cwd, name: "tuicr" });
+}
+async function resolveSession(cwd, branch) {
+  const sessions = await listSessions(cwd);
+  return findMatchingSession(sessions, cwd, branch);
+}
+async function resolveReviewSession(cwd, target) {
+  if (!target.workingTree && target.owner && target.repo && target.number !== undefined) {
+    return resolvePrSession(cwd, target.owner, target.repo, target.number);
+  }
+  return resolveSession(cwd, target.branch);
+}
+async function resolvePrSession(cwd, owner, repo, number) {
+  const coordinate = `${owner}/${repo}`.toLowerCase();
+  const sessions = await listSessions(cwd);
+  return sessions.find((session) => {
+    const slug = session.slug.toLowerCase();
+    return session.kind === "pr" && slug.includes(coordinate) && (slug.endsWith(`/pr/${number}`) || slug.endsWith(`/mr/${number}`));
+  });
+}
+async function findMatchingSession(sessions, cwd, branch) {
+  const repository = await canonicalPath2(await gitToplevel(cwd));
+  for (const session of sessions) {
+    if (session.kind !== "local")
+      continue;
+    try {
+      const data = await readSession(session.path);
+      if (data.branch_name !== branch || !data.repo_path)
+        continue;
+      if (await canonicalPath2(data.repo_path) === repository)
+        return session;
+    } catch {}
+  }
+  return;
+}
+async function readSession(path) {
+  const content = await readFile4(path, "utf8");
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Cannot parse tuicr session JSON: ${path}`);
+  }
+}
+function toFindings(session, options = {}) {
+  const comments = [];
+  const include = (comment) => (!options.agentOnly || commentAuthor(comment)?.startsWith("Agent: ")) && (!options.excludeLocalResponses || !isLocalResponse(comment.content));
+  const bodyParts = (session.review_comments ?? []).flatMap((comment) => include(comment) ? [comment.content] : []);
+  for (const [file, entry] of Object.entries(session.files ?? {})) {
+    const fileComments = (entry.file_comments ?? []).flatMap((comment) => include(comment) ? [comment.content] : []);
+    if (fileComments.length > 0)
+      bodyParts.push(`File: ${file}
+
+${fileComments.join(`
+
+`)}`);
+    for (const [lineKey, lineComments] of Object.entries(entry.line_comments ?? {})) {
+      const line = Number.parseInt(lineKey, 10);
+      if (!Number.isFinite(line))
+        continue;
+      for (const lineComment of lineComments) {
+        if (!include(lineComment))
+          continue;
+        const comment = {
+          file,
+          line,
+          side: lineComment.side === "old" ? "LEFT" : "RIGHT",
+          body: lineComment.content
+        };
+        const author = commentAuthor(lineComment);
+        if (author)
+          comment.author = author;
+        comments.push(comment);
+      }
+    }
+  }
+  return { comments, body: bodyParts.join(`
+
+`) };
+}
+async function requireTuicr() {
+  if (!await tuicrAvailable())
+    throw new Error("tuicr is not installed or is not available on PATH.");
+}
+function commentAuthor(comment) {
+  return comment.username ?? comment.author;
+}
+async function canonicalPath2(path) {
+  try {
+    return await realpath2(path);
+  } catch {
+    return resolve2(path);
+  }
+}
+
+// src/review/local-review-backend.ts
+function LocalReviewBackend(options) {
+  return {
+    kind: "local",
+    async stage(draft) {
+      for (const comment of draft.comments) {
+        await addComment(options.session, comment.body, {
+          targetFile: comment.file,
+          line: comment.line,
+          side: comment.side === "LEFT" ? "old" : "new",
+          username: options.author
+        });
+      }
+      if (draft.body.trim())
+        await addComment(options.session, draft.body, { username: options.author });
+    },
+    async readDraft() {
+      return toFindings(await readSession(options.session), { agentOnly: true, excludeLocalResponses: true });
+    },
+    async listThreads() {
+      try {
+        return parseThreadArtifact(await readFile5(options.artifactPath, "utf8"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          return [];
+        throw error;
+      }
+    },
+    async reply(input) {
+      const content = await readFile5(options.artifactPath, "utf8");
+      await writeFile3(options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question, input.resolve), "utf8");
+    },
+    async publish() {
+      throw new Error("Promote a local draft through a remote review backend before publishing it.");
+    }
+  };
+}
+
+// src/review/review-backend.ts
+function createRemoteReviewBackend(vcs, number) {
+  if (vcs.provider === "github")
+    return GitHubReviewBackend(vcs, number);
+  if (vcs.provider === "gitlab")
+    return GitLabReviewBackend(vcs, number);
+  throw new Error("A remote review backend requires a GitHub or GitLab repository.");
+}
+function createLocalReviewBackend(options) {
+  return LocalReviewBackend(options);
+}
+// src/review/review-state.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile6, rename, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { z as z4 } from "zod";
+
+// src/store.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir as mkdir3, readlink, realpath as realpath3, symlink, unlink } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join6, resolve as resolve3 } from "node:path";
+var STORE_LINK = ".diffpi";
+var LEGACY_STORE_LINK = join6(".pi", "diffpi");
+async function computeProjectSlug(cwd) {
+  return projectSlug(await inspectGitRepository(cwd));
+}
+function storeGlobalRoot(homeDir = homedir4()) {
+  return join6(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir4()) {
+  const repository = await inspectGitRepository(cwd);
+  const root = repository.root;
+  const slug = projectSlug(repository);
+  const dest = join6(storeGlobalRoot(homeDir), slug);
+  const link = join6(root, STORE_LINK);
+  await mkdir3(dest, { recursive: true });
+  try {
+    await assertStoreLink(link, dest);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    await symlink(dest, link);
+  }
+  await removeLegacyStoreLink(join6(root, LEGACY_STORE_LINK), dest);
+  return { slug, root, dest, link, linked: true };
+}
+async function storeDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  return store.dest;
+}
+async function reviewsDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join6(store.link, "review");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join6(store.link, "sessions");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function assertStoreLink(path, dest) {
+  const entry = await lstat(path);
+  if (!entry.isSymbolicLink())
+    throw new Error(`${path} exists and is not a symlink.`);
+  const target = await symlinkTarget(path);
+  if (target !== await canonicalPath3(dest))
+    throw new Error(`${path} points to ${target}, not ${dest}.`);
+}
+async function removeLegacyStoreLink(path, dest) {
+  try {
+    const entry = await lstat(path);
+    if (!entry.isSymbolicLink())
+      return;
+    const target = await symlinkTarget(path);
+    if (target === await canonicalPath3(dest))
+      await unlink(path);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+}
+async function symlinkTarget(path) {
+  const target = await readlink(path);
+  return canonicalPath3(isAbsolute2(target) ? target : resolve3(dirname3(path), target));
+}
+async function canonicalPath3(path) {
+  try {
+    return await realpath3(path);
+  } catch {
+    return resolve3(path);
+  }
+}
+function projectSlug(repository) {
+  const readable = repository.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed";
+  const digest = createHash("sha256").update(repository.identity).digest("hex").slice(0, 12);
+  return `${readable}-${digest}`;
+}
+
+// src/review/review-state.ts
+var reviewPublicationStateSchema = z4.object({
+  target: z4.string().optional(),
+  bodies: z4.array(z4.string()).default([]),
+  comments: z4.array(z4.string()).default([]),
+  replies: z4.array(z4.string()).default([]),
+  overlayPath: z4.string().optional()
+});
+function reviewBodyFingerprint(body) {
+  return digest(body);
+}
+function reviewCommentFingerprint(comment) {
+  return digest([comment.file, String(comment.line), comment.side ?? "RIGHT", comment.body].join("\x00"));
+}
+function reviewReplyFingerprint(threadId, body) {
+  return digest(`${threadId}\x00${body}`);
+}
+function unpublishedReviewComments(comments, knownFingerprints) {
+  return comments.filter((comment) => !knownFingerprints.has(reviewCommentFingerprint(comment)));
+}
+async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
+  const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
+  const path = join7(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  try {
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile6(path, "utf8")));
+    return { path, state: { ...parsed, target } };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { path, state: { target, bodies: [], comments: [], replies: [] } };
+    }
+    if (error instanceof SyntaxError || error instanceof z4.ZodError) {
+      throw new Error(`Cannot parse review publication state: ${path}`);
+    }
+    throw error;
+  }
+}
+async function saveReviewPublicationState(path, state) {
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile4(temp, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  await rename(temp, path);
+}
+function digest(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+// src/mcp.ts
+import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname4, join as join8 } from "node:path";
+var mcp = {
+  globalConfigPath(homeDir = homedir5()) {
+    return join8(homeDir, ".config", "mcp", "mcp.json");
+  },
+  async serversEnsure(servers, options = {}) {
+    const path = options.path ?? mcp.globalConfigPath();
+    const currentText = await getOptionalFile2(path);
+    const current = getParsedConfig(currentText, path);
+    const nextServers = { ...current.mcpServers };
+    for (const [name, entry] of Object.entries(servers)) {
+      nextServers[name] = mergeEntry(nextServers[name], entry);
+    }
+    const next = { ...current, mcpServers: nextServers };
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (changed && !options.dryRun) {
+      await mkdir4(dirname4(path), { recursive: true });
+      await writeFile5(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    }
+    return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
+  }
+};
+function mergeEntry(current, required) {
+  const merged = { ...current, ...required };
+  if (current?.env || required.env)
+    merged.env = { ...current?.env, ...required.env };
+  return merged;
+}
+function getParsedConfig(content, path) {
+  if (!content?.trim())
+    return { mcpServers: {} };
+  try {
+    const value = JSON.parse(content);
+    if (!isRecord(value))
+      throw new Error("not an object");
+    const servers = value.mcpServers;
+    if (servers !== undefined && !isRecord(servers))
+      throw new Error("mcpServers is not an object");
+    return { ...value, mcpServers: servers ?? {} };
+  } catch {
+    throw new Error(`Expected a valid pi-mcp-adapter configuration in ${path}.`);
+  }
+}
+async function getOptionalFile2(path) {
+  try {
+    return await readFile7(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 // src/modes.ts
 import {
   getAgentDir,
   parseFrontmatter as parseFrontmatter2
 } from "@earendil-works/pi-coding-agent";
-import { readFile as readFile4 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { basename as basename2, extname, join as join6 } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { basename as basename4, extname, join as join10 } from "node:path";
 
 // src/assets.ts
 import { existsSync } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
+import { dirname as dirname5, join as join9 } from "node:path";
 import { fileURLToPath } from "node:url";
-function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
-  const moduleDir = dirname3(fileURLToPath(moduleUrl));
-  const candidates = [
-    join5(moduleDir, "agents"),
-    join5(moduleDir, "..", "agents"),
-    join5(moduleDir, "..", "..", "agents")
-  ];
+function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
+  const moduleDir = dirname5(fileURLToPath(moduleUrl));
+  const candidates = [join9(moduleDir, name), join9(moduleDir, "..", name), join9(moduleDir, "..", "..", name)];
   return candidates.find((path) => existsSync(path)) ?? candidates[1];
 }
+function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("agents", moduleUrl);
+}
+function resolveBundledTemplatesDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("templates", moduleUrl);
+}
 
 // src/modes.ts
 async function discoverAgentModes(options) {
   const agentDir = options.agentDir ?? getAgentDir();
-  const homeDir = options.homeDir ?? homedir4();
+  const homeDir = options.homeDir ?? homedir6();
   const modes = new Map;
   const diagnostics = [];
   await loadAgentModes(options.bundledAgentsDir ?? BUNDLED_AGENTS_DIR, "diffpi agent", modes, diagnostics);
-  await loadAgentModes(join6(agentDir, "agents"), "user agent", modes, diagnostics);
+  await loadAgentModes(join10(agentDir, "agents"), "user agent", modes, diagnostics);
   if (options.includeSkills) {
-    await loadSkillModes(join6(homeDir, ".agents", "skills"), "user skill", modes, diagnostics);
-    await loadSkillModes(join6(agentDir, "skills"), "pi user skill", modes, diagnostics);
+    await loadSkillModes(join10(homeDir, ".agents", "skills"), "user skill", modes, diagnostics);
+    await loadSkillModes(join10(agentDir, "skills"), "pi user skill", modes, diagnostics);
   }
   if (options.projectTrusted === true) {
     if (options.includeSkills) {
-      await loadSkillModes(join6(options.cwd, ".agents", "skills"), "project skill", modes, diagnostics);
-      await loadSkillModes(join6(options.cwd, ".pi", "skills"), "pi project skill", modes, diagnostics);
+      await loadSkillModes(join10(options.cwd, ".agents", "skills"), "project skill", modes, diagnostics);
+      await loadSkillModes(join10(options.cwd, ".pi", "skills"), "pi project skill", modes, diagnostics);
     }
-    await loadAgentModes(join6(options.cwd, ".agents", "agents"), "project agent", modes, diagnostics);
-    await loadAgentModes(join6(options.cwd, ".pi", "agents"), "pi project agent", modes, diagnostics);
+    await loadAgentModes(join10(options.cwd, ".agents", "agents"), "project agent", modes, diagnostics);
+    await loadAgentModes(join10(options.cwd, ".pi", "agents"), "pi project agent", modes, diagnostics);
   }
   const userConfig = await loadDiffpiConfig({ homeDir });
   const configuredModes = [...modes.values()].map((mode) => ({
@@ -457,7 +1950,11 @@ function createModeController(pi, options = {}) {
   let active;
   let baseline;
   const updateStatus = (ctx) => {
-    ctx.ui.setStatus(MODE_STATUS_KEY, active ? `mode: ${active.id}` : undefined);
+    const model = ctx.model ? ` · ${ctx.model.provider}/${ctx.model.id}` : "";
+    const label = active?.label.toUpperCase() ?? "DEFAULT";
+    const badge = `AGENT ${label}${model}`;
+    ctx.ui.setStatus(MODE_STATUS_KEY, undefined);
+    ctx.ui.setWidget?.(MODE_WIDGET_KEY, [badge], { placement: "belowEditor" });
   };
   const list = (ctx, listOptions = {}) => discoverAgentModes({
     cwd: ctx.cwd,
@@ -512,6 +2009,9 @@ function createModeController(pi, options = {}) {
       }
       updateStatus(ctx);
     },
+    refresh(ctx) {
+      updateStatus(ctx);
+    },
     apply(systemPrompt) {
       if (!active)
         return systemPrompt;
@@ -530,6 +2030,7 @@ ${active.systemPrompt}`;
 }
 var MODE_STATE_ENTRY = "diffpi-mode-state";
 var MODE_STATUS_KEY = "diffpi-mode";
+var MODE_WIDGET_KEY = "diffpi-mode-badge";
 var MODE_CONTROL_TOOLS = ["ask_user_question", "diffpi_modes_list", "diffpi_modes_set", "diffpi_modes_unset"];
 var BUNDLED_AGENTS_DIR = resolveBundledAgentsDir();
 var THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
@@ -583,19 +2084,19 @@ function captureRuntime(pi, ctx) {
 async function loadSkillModes(skillsDir, source, modes, diagnostics) {
   const entries = await readDirectoryIfExists(skillsDir);
   for (const entry of entries.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-    await loadAgentModes(join6(skillsDir, entry.name, "agents"), `${source} ${entry.name}`, modes, diagnostics, entry.name);
+    await loadAgentModes(join10(skillsDir, entry.name, "agents"), `${source} ${entry.name}`, modes, diagnostics, entry.name);
   }
 }
 async function loadAgentModes(directory, source, modes, diagnostics, skillName) {
   const entries = await readDirectoryIfExists(directory);
   for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name))) {
-    const path = join6(directory, entry.name);
+    const path = join10(directory, entry.name);
     try {
-      const content = await readFile4(path, "utf8");
+      const content = await readFile8(path, "utf8");
       const { frontmatter, body } = parseFrontmatter2(content.startsWith("\uFEFF") ? content.slice(1) : content);
       if (frontmatter.enabled === false || frontmatter.inline === false)
         continue;
-      const name = getFrontmatterText(frontmatter.name) ?? basename2(path, extname(path));
+      const name = getFrontmatterText(frontmatter.name) ?? basename4(path, extname(path));
       const systemPrompt = body.trim();
       if (!name || name.includes(":") || !systemPrompt) {
         diagnostics.push(`Skipped ${path}: agent name must not contain ":" and prompt body is required.`);
@@ -605,7 +2106,7 @@ async function loadAgentModes(directory, source, modes, diagnostics, skillName)
       modes.set(id, {
         id,
         label: getFrontmatterText(frontmatter.display_name) ?? name,
-        description: getFrontmatterText(frontmatter.description) ?? `Inline agent from ${basename2(path)}`,
+        description: getFrontmatterText(frontmatter.description) ?? `Inline agent from ${basename4(path)}`,
         systemPrompt,
         promptStrategy: frontmatter.prompt_mode === "append" ? "append" : "replace",
         modelPreferences: [
@@ -647,9 +2148,9 @@ function isModeBaseline(value) {
   return (model === undefined || typeof model.provider === "string" && typeof model.id === "string") && candidate.thinkingLevel !== undefined && THINKING_LEVELS.has(candidate.thinkingLevel) && Array.isArray(candidate.tools) && candidate.tools.every((tool) => typeof tool === "string");
 }
 // src/pi.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname6, join as join11 } from "node:path";
 var pi = {
   executableCheck: findPiExecutable,
   packageList: listPiPackages,
@@ -662,19 +2163,19 @@ var pi = {
   configEnsure: ensurePiConfig
 };
 async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
-  const path = join7(agentDir, "agents", filename);
+  const path = join11(agentDir, "agents", filename);
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
-    await mkdir3(dirname4(path), { recursive: true });
-    await writeFile3(path, content, "utf8");
+    await mkdir5(dirname6(path), { recursive: true });
+    await writeFile6(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
-async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join7(homedir5(), ".agents", "skills")) {
-  const roots = [join7(agentDir, "skills"), sharedSkillsDir];
+async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join11(homedir7(), ".agents", "skills")) {
+  const roots = [join11(agentDir, "skills"), sharedSkillsDir];
   for (const root of roots) {
-    if (await readTextIfExists(join7(root, name, "SKILL.md")) !== undefined)
+    if (await readTextIfExists(join11(root, name, "SKILL.md")) !== undefined)
       return true;
   }
   return false;
@@ -703,8 +2204,8 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const next = update(current);
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
-    await mkdir3(dirname4(path), { recursive: true });
-    await writeFile3(path, `${JSON.stringify(next, null, 2)}
+    await mkdir5(dirname6(path), { recursive: true });
+    await writeFile6(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -723,8 +2224,8 @@ function hasPiPackage(listOutput, source) {
 async function installPiPackage(executable, source) {
   await runChecked(executable, ["install", source]);
 }
-function resolvePiAgentDir(homeDir = homedir5()) {
-  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join7(process.env.XDG_CONFIG_HOME, "pi") : join7(homeDir, ".pi", "agent"));
+function resolvePiAgentDir(homeDir = homedir7()) {
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join11(process.env.XDG_CONFIG_HOME, "pi") : join11(homeDir, ".pi", "agent"));
 }
 function parseJsonObject(content, path) {
   if (!content?.trim())
@@ -738,9 +2239,9 @@ function parseJsonObject(content, path) {
 }
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter3 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir2, readFile as readFile5 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename3, join as join8 } from "node:path";
+import { readdir as readdir2, readFile as readFile9 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { basename as basename5, join as join12 } from "node:path";
 var MISE_DEPENDENCIES = [
   { name: "node", tool: "node", spec: "node@22", minimumVersion: "22.19.0" },
   { name: "zellij", tool: "zellij", spec: "zellij@latest", minimumVersion: undefined },
@@ -768,13 +2269,18 @@ var PI_PACKAGES = [
 ];
 var PI_SKILL_SOURCES = [
   { repository: "arabold/docs-mcp-server", skills: ["docs-manage", "docs-search", "fetch-url"] },
-  { repository: "AminBlg/SimpleEnglish", skills: ["simple-english"] }
+  { repository: "AminBlg/SimpleEnglish", skills: ["simple-english"] },
+  { repository: "cloudvoyant/codevoyant", skills: ["git"] }
 ];
 var MCP_ADAPTER_PACKAGE = "npm:pi-mcp-adapter";
 var BUNDLED_AGENTS_DIR2 = resolveBundledAgentsDir();
+var FORGE_DEPENDENCIES = {
+  github: { name: "gh", tool: "gh", spec: "gh@latest", minimumVersion: undefined },
+  gitlab: { name: "glab", tool: "glab", spec: "glab@latest", minimumVersion: undefined }
+};
 async function ensureMise(options = {}) {
-  const homeDir = options.homeDir ?? homedir6();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join8(homeDir, ".local", "bin", "mise"));
+  const homeDir = options.homeDir ?? homedir8();
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join12(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -803,7 +2309,11 @@ async function ensureMiseHooks(miseExecutable, options = {}) {
 async function ensureMiseDeps(miseExecutable, options = {}) {
   const canRunMise = Boolean(await mise.executableCheck(miseExecutable));
   const actions = [];
-  for (const dependency of MISE_DEPENDENCIES) {
+  const dependencies = [
+    ...MISE_DEPENDENCIES,
+    ...configuredForges(options).map((forge) => FORGE_DEPENDENCIES[forge])
+  ];
+  for (const dependency of dependencies) {
     const installed = canRunMise && await mise.toolCheckGlobal(miseExecutable, dependency.tool, dependency.minimumVersion);
     if (installed) {
       actions.push(createSetupAction(dependency.name, "ready", dependency.spec));
@@ -819,9 +2329,9 @@ async function ensureMiseDeps(miseExecutable, options = {}) {
 async function ensurePiPlugins(options = {}) {
   const actions = await ensurePiPackages(PI_PACKAGES, options);
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const webSearch = await pi.configEnsure(join8(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  const webSearch = await pi.configEnsure(join12(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
   actions.push(getConfigSetupAction("web search settings", webSearch));
-  const lsp = await pi.configEnsure(join8(agentDir, "pi-lsp.json"), (config) => ({
+  const lsp = await pi.configEnsure(join12(agentDir, "pi-lsp.json"), (config) => ({
     ...config,
     progressive: { ...getRecord(config.progressive), enabled: true, inject: "none" }
   }), options.dryRun);
@@ -835,8 +2345,8 @@ async function ensurePiAgents(options = {}) {
   const entries = (await readdir2(bundledAgentsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
   const actions = [];
   for (const entry of entries) {
-    const id = basename3(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile5(join8(bundledAgentsDir, entry.name), "utf8");
+    const id = basename5(entry.name, ".md").replace(/^diffpi-/, "");
+    const source = await readFile9(join12(bundledAgentsDir, entry.name), "utf8");
     const content = materializeAgentModels(source, id, userConfig.config, options.availableModels);
     const result = await pi.agentEnsure(entry.name, content, agentDir, options.dryRun);
     actions.push(getConfigSetupAction(`pi agent ${id}`, result));
@@ -845,7 +2355,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join8(options.homeDir ?? homedir6(), ".agents", "skills");
+  const sharedSkillsDir = join12(options.homeDir ?? homedir8(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -889,6 +2399,14 @@ async function ensureMcpAdapters(miseExecutable, options = {}) {
   } else if (options.issueTracker === "jira") {
     servers.atlassian = { url: "https://mcp.atlassian.com/v1/mcp", auth: "oauth", protocolVersion: "auto" };
   }
+  for (const forge of configuredForges(options)) {
+    if (forge === "github") {
+      servers.github = { url: "https://api.githubcopilot.com/mcp/", auth: "oauth", protocolVersion: "auto" };
+      continue;
+    }
+    const host = await gitlabMcpHost(projectDir);
+    servers.gitlab = { url: `https://${host}/api/v4/mcp`, auth: "oauth", protocolVersion: "auto" };
+  }
   const result = await mcp.serversEnsure(servers, {
     dryRun: options.dryRun,
     path: mcp.globalConfigPath(options.homeDir)
@@ -905,6 +2423,8 @@ async function setupPi(options = {}) {
   actions.push(...await ensurePiAgents(options));
   actions.push(...await ensurePiSkills(miseResult.executable, options));
   actions.push(...await ensureMcpAdapters(miseResult.executable, options));
+  if (options.bindZedKey)
+    actions.push(...await ensureZedIntegration(options));
   return {
     actions,
     restartPi: setupRequiresRestart(actions)
@@ -913,6 +2433,40 @@ async function setupPi(options = {}) {
 function setupRequiresRestart(actions) {
   return actions.some((item) => (item.status === "installed" || item.status === "updated") && (item.name.startsWith("pi package ") || item.name.startsWith("pi agent ") || item.name.startsWith("pi skill ") || item.name === "MCP configuration" || item.name === "web search settings" || item.name === "pi-lsp settings"));
 }
+async function ensureZedIntegration(options = {}) {
+  if (options.dryRun) {
+    const actions = [
+      createSetupAction("Zed review tasks", "planned", "global static runtime-resolver tasks in tasks.json")
+    ];
+    if (options.bindZedKey)
+      actions.push(createSetupAction("Zed review keybinding", "planned", "keymap.json"));
+    return actions;
+  }
+  const actions = [];
+  try {
+    const tasks = await ensureZedReviewTask(options.homeDir);
+    actions.push(createSetupAction("Zed review tasks", tasks.changed ? "installed" : "ready", tasks.path));
+  } catch (error) {
+    actions.push(createSetupAction("Zed review tasks", "skipped", error instanceof Error ? error.message : String(error)));
+  }
+  if (options.bindZedKey) {
+    try {
+      const key = await ensureZedReviewKeybinding(options.homeDir);
+      actions.push(createSetupAction("Zed review keybinding", key.changed ? "installed" : "ready", key.path));
+    } catch (error) {
+      actions.push(createSetupAction("Zed review keybinding", "skipped", error instanceof Error ? error.message : String(error)));
+    }
+  }
+  return actions;
+}
+async function gitlabMcpHost(projectDir) {
+  try {
+    const vcs = await detectVcs(projectDir);
+    return vcs.provider === "gitlab" && vcs.host ? vcs.host : "gitlab.com";
+  } catch {
+    return "gitlab.com";
+  }
+}
 function materializeAgentModels(content, agentId, config, availableModels) {
   const { frontmatter } = parseFrontmatter3(content.startsWith("\uFEFF") ? content.slice(1) : content);
   const profilePreferences = [...getTextList(frontmatter.model), ...getTextList(frontmatter.model_fallbacks)];
@@ -972,6 +2526,10 @@ ${source}`;
   }
   return actions;
 }
+function configuredForges(options) {
+  const selected = options.forges ?? (options.forge && options.forge !== "none" ? [options.forge] : []);
+  return [...new Set(selected)];
+}
 function getTextList(value) {
   const values = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
   return values.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
@@ -992,8 +2550,65 @@ function reportProgress(options, message) {
 function getRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+// src/templates.ts
+import { readFile as readFile10 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { join as join13, normalize } from "node:path";
+async function loadTemplate(name, options = {}) {
+  const relative = templateRelativePath(name);
+  const userPath = join13(options.homeDir ?? homedir9(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join13(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
+  const user = await readOptionalFile(userPath);
+  if (user !== undefined)
+    return { name, path: userPath, source: "user", content: user };
+  const bundled = await readOptionalFile(bundledPath);
+  if (bundled !== undefined)
+    return { name, path: bundledPath, source: "bundled", content: bundled };
+  throw new Error(`Template "${name}" was not found at ${userPath} or ${bundledPath}.`);
+}
+function renderTemplate(content, variables) {
+  return content.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => variables[key] ?? match);
+}
+function templateRelativePath(name) {
+  const normalized = normalize(name.replaceAll("\\", "/")).replace(/^\.\//, "");
+  if (!normalized || normalized.startsWith("../") || normalized.includes("/../") || normalized.startsWith("/")) {
+    throw new Error(`Invalid template name: ${name}`);
+  }
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile10(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
 export {
+  CONVENTIONAL_COMMIT,
+  GitHubVcsBackend,
+  GitLabVcsBackend,
+  ZED_LOCAL_REVIEW_TASK_NAME,
+  ZED_PR_REVIEW_TASK_NAME,
+  ZED_REVIEW_TASK_NAME,
+  addComment,
+  assertGitHubMergeReady,
+  assertReviewEventSupported,
+  checkConventionalSubject,
+  ciGate,
+  computeProjectSlug,
+  createForge,
+  createForgeBackend,
+  createLocalReviewBackend,
   createModeController,
+  createRemoteReviewBackend,
+  createVcsBackend,
+  dedupeFindings,
+  detectIde,
+  detectMux,
+  detectShell,
+  detectVcs,
   diffpiConfigPaths,
   discoverAgentModes,
   ensureMcpAdapters,
@@ -1003,12 +2618,59 @@ export {
   ensurePiAgents,
   ensurePiPlugins,
   ensurePiSkills,
+  ensureStore,
+  ensureZedReviewKeybinding,
+  ensureZedReviewTask,
   findPreferredModel,
+  findingSchema,
+  findingsSchema,
+  gitToplevel,
+  githubReviewSubmissionEndpoint,
+  hasGitlabDraftNotes,
+  launch,
+  listSessions,
   loadDiffpiConfig,
+  loadReviewPublicationState,
+  loadTemplate,
+  localReviewAuthor,
   mcp,
   mise,
+  openInNewTab,
+  parseGitlabDiffRefs,
+  parseRemote,
+  parseThreadArtifact,
   pi,
+  readSession,
+  renderReviewDoc,
+  renderTemplate,
+  renderThreadArtifact,
   resolveAgentMode,
   resolveAgentModelPreferences,
-  setupPi
+  resolvePrSession,
+  resolveReviewSession,
+  resolveSession,
+  reviewBodyFingerprint,
+  reviewCommentFingerprint,
+  reviewRecordName,
+  reviewReplyFingerprint,
+  reviewSlug,
+  reviewsDir,
+  runMiseGates,
+  saveReviewPublicationState,
+  sessionsDir,
+  setupPi,
+  severitySchema,
+  storeDir,
+  storeGlobalRoot,
+  templateRelativePath,
+  toFindings,
+  toReviewComments,
+  tuicrAvailable,
+  unpublishedReviewComments,
+  upsertThreadReply,
+  withRemoteProvenance,
+  yymmdd,
+  zedKeymapPath,
+  zedReviewTaskName,
+  zedTasksPath
 };