@difflab/pi 0.2.0 → 0.3.0

package/dist/tools/index.js

@@ -124,41 +124,2589 @@ function sanitize(value) {
   return value.replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").trim();
 }
 
+// src/tools/review.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir4, readdir, readFile as readFile7, rename as rename2, stat, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+import { defineTool as defineTool3 } from "@earendil-works/pi-coding-agent";
+import { z as z6 } from "zod";
+
+// src/environment.ts
+import { basename } from "node:path";
+
+// src/extensions/processx.ts
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+async function findExecutable(name) {
+  if (name.includes("/")) {
+    try {
+      await access(name, constants.X_OK);
+      return name;
+    } catch {
+      return;
+    }
+  }
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!directory)
+      continue;
+    const candidate = join(directory, name);
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {}
+  }
+  return;
+}
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env ?? process.env,
+      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    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) => {
+      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: 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 = {}) {
+  const result = await run(command, args, options);
+  if (result.code === 0)
+    return result;
+  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/extensions/zedx.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join as join2 } from "node:path";
+var ZED_LOCAL_REVIEW_TASK_NAME = "diffpi: tuicr local review";
+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 = homedir()) {
+  return join2(homeDir, ".config", "zed", "tasks.json");
+}
+function zedKeymapPath(homeDir = homedir()) {
+  return join2(homeDir, ".config", "zed", "keymap.json");
+}
+async function ensureZedReviewTask(homeDir = homedir(), _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 = homedir()) {
+  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 readFile(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/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;
+// src/extensions/misex.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename2, dirname as dirname2, join as join3 } 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 ?? homedir2();
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32")
+      throw new Error("Automatic mise installation supports macOS and Linux only.");
+    const installedPath = join3(homeDir, ".local", "bin", "mise");
+    if (options.dryRun)
+      return installedPath;
+    await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
+    const executable = await findExecutable(installedPath) ?? await findExecutable("mise");
+    if (!executable)
+      throw new Error(`mise installation completed, but ${installedPath} was not found.`);
+    return executable;
+  },
+  async hookEnsure(executable, options = {}) {
+    const homeDir = options.homeDir ?? homedir2();
+    const hook = getShellHook(basename2(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)
+      return { path: hook.path, changed: true, planned: true };
+    const separator = current.length === 0 || current.endsWith(`
+`) ? "" : `
+`;
+    await mkdir2(dirname2(hook.path), { recursive: true });
+    await writeFile2(hook.path, `${current}${separator}${hook.content}`, "utf8");
+    return { path: hook.path, changed: true, planned: false };
+  },
+  async toolCheckGlobal(executable, tool, minimumVersion) {
+    const result = await run(executable, ["ls", "--global", "--installed", tool, "--json"]);
+    return result.code === 0 && isToolInstalled(result.stdout, minimumVersion);
+  },
+  async toolInstallGlobal(executable, specification) {
+    await runChecked(executable, ["use", "--global", specification]);
+  },
+  async toolCheckLocal(executable, tool, cwd = process.cwd()) {
+    const result = await run(executable, ["ls", "--local", "--installed", tool, "--json"], { cwd });
+    return result.code === 0 && isToolInstalled(result.stdout);
+  },
+  async toolInstallLocal(executable, specification, cwd = process.cwd()) {
+    await runChecked(executable, ["use", "--path", cwd, specification], { cwd });
+  },
+  async toolUpdateAllGlobal(executable, homeDir = homedir2()) {
+    await runChecked(executable, ["upgrade"], { cwd: homeDir });
+  }
+};
+function getShellHook(shell, executable, homeDir) {
+  const command = getShellQuoted(executable);
+  switch (shell.toLowerCase()) {
+    case "zsh":
+      return {
+        path: join3(homeDir, ".zshrc"),
+        content: `${MISE_HOOK_START}
+eval "$(${command} activate zsh)"
+${MISE_HOOK_END}
+`
+      };
+    case "fish":
+      return {
+        path: join3(homeDir, ".config", "fish", "config.fish"),
+        content: `${MISE_HOOK_START}
+${command} activate fish | source
+${MISE_HOOK_END}
+`
+      };
+    case "nu":
+    case "nushell":
+      return {
+        path: join3(homeDir, ".config", "nushell", "config.nu"),
+        content: `${MISE_HOOK_START}
+let mise_bin = ${command}
+let mise_path = $nu.default-config-dir | path join mise.nu
+^$mise_bin activate nu | save $mise_path --force
+use ($nu.default-config-dir | path join mise.nu)
+${MISE_HOOK_END}
+`
+      };
+    case "xonsh":
+      return {
+        path: join3(homeDir, ".xonshrc"),
+        content: `${MISE_HOOK_START}
+execx($(${command} activate xonsh))
+${MISE_HOOK_END}
+`
+      };
+    case "elvish":
+      return {
+        path: join3(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 }
+mise:activate
+${MISE_HOOK_END}
+`
+      };
+    case "pwsh":
+    case "powershell":
+      return {
+        path: join3(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        content: `${MISE_HOOK_START}
+(& ${command} activate pwsh) | Out-String | Invoke-Expression
+${MISE_HOOK_END}
+`
+      };
+    case "bash":
+    default:
+      return {
+        path: join3(homeDir, ".bashrc"),
+        content: `${MISE_HOOK_START}
+eval "$(${command} activate bash)"
+${MISE_HOOK_END}
+`
+      };
+  }
+}
+function isToolInstalled(output, minimumVersion) {
+  try {
+    const value = JSON.parse(output);
+    if (!Array.isArray(value))
+      return false;
+    return value.some((entry) => {
+      if (!entry || typeof entry !== "object" || !("installed" in entry) || entry.installed !== true)
+        return false;
+      if (!minimumVersion)
+        return true;
+      if (!("version" in entry) || typeof entry.version !== "string")
+        return false;
+      return isVersionAtLeast(entry.version, minimumVersion);
+    });
+  } catch {
+    return false;
+  }
+}
+function isVersionAtLeast(version, minimumVersion) {
+  const current = version.match(/^v?(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
+  const minimum = minimumVersion.match(/^v?(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
+  if (!current || !minimum)
+    return false;
+  for (let index = 0;index < minimum.length; index += 1) {
+    if (current[index] !== minimum[index])
+      return current[index] > minimum[index];
+  }
+  return true;
+}
+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 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 z3 } from "zod";
+var severitySchema = z3.enum(["BLOCKING", "CONSIDER", "NOTE"]);
+var findingSchema = z3.object({
+  file: z3.string().min(1),
+  line: z3.number().int().nonnegative(),
+  severity: severitySchema,
+  body: z3.string().min(1),
+  reference: z3.string().optional().default("")
+});
+var findingsSchema = z3.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 localResponseMarker(threadId) {
+  return `<!-- diffpi -->`;
+}
+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 z4 } from "zod";
+var reviewThreadRecordSchema = z4.object({
+  id: z4.string().min(1),
+  file: z4.string().optional(),
+  line: z4.number().int().positive().optional(),
+  body: z4.string(),
+  author: z4.string().optional(),
+  resolved: z4.boolean(),
+  addressed: z4.boolean().optional(),
+  question: z4.boolean(),
+  replies: z4.array(z4.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 = z4.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 readFile4, writeFile as writeFile3 } from "node:fs/promises";
+
+// src/extensions/tuicrx.ts
+import { readFile as readFile3, realpath as realpath2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+
+// src/extensions/gitx.ts
+import { realpath } from "node:fs/promises";
+import { basename as basename3, 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) : basename3(resolve(commonDir, "..")) || basename3(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/tuicrx.ts
+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 readFile3(path, "utf8");
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Cannot parse tuicr session JSON: ${path}`);
+  }
+}
+function toLocalReviewThreads(session) {
+  const threads = [];
+  const add = (comment, location = {}) => {
+    if (isLocalResponse(comment.content))
+      return;
+    const author = commentAuthor(comment);
+    threads.push({
+      id: comment.id ?? `local-${threads.length + 1}`,
+      ...location,
+      body: comment.content,
+      ...author ? { author } : {},
+      resolved: false,
+      question: /\?\s*$/.test(comment.content.trim())
+    });
+  };
+  for (const comment of session.review_comments ?? [])
+    add(comment);
+  for (const [file, entry] of Object.entries(session.files ?? {})) {
+    for (const comment of entry.file_comments ?? [])
+      add(comment, { file });
+    for (const [lineKey, lineComments] of Object.entries(entry.line_comments ?? {})) {
+      const line = Number.parseInt(lineKey, 10);
+      if (!Number.isFinite(line))
+        continue;
+      for (const comment of lineComments)
+        add(comment, { file, line });
+    }
+  }
+  return threads;
+}
+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 readFile4(options.artifactPath, "utf8"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          return [];
+        throw error;
+      }
+    },
+    async reply(input) {
+      const content = await readFile4(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 readFile5, rename, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+import { z as z5 } 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 homedir3 } from "node:os";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join5, resolve as resolve3 } from "node:path";
+var STORE_LINK = ".diffpi";
+var LEGACY_STORE_LINK = join5(".pi", "diffpi");
+function storeGlobalRoot(homeDir = homedir3()) {
+  return join5(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir3()) {
+  const repository = await inspectGitRepository(cwd);
+  const root = repository.root;
+  const slug = projectSlug(repository);
+  const dest = join5(storeGlobalRoot(homeDir), slug);
+  const link = join5(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(join5(root, LEGACY_STORE_LINK), dest);
+  return { slug, root, dest, link, linked: true };
+}
+async function reviewsDir(cwd, homeDir = homedir3()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join5(store.link, "review");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function completedReviewsDir(cwd, homeDir = homedir3()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join5(store.link, "reviews");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir3()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join5(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 = z5.object({
+  target: z5.string().optional(),
+  bodies: z5.array(z5.string()).default([]),
+  comments: z5.array(z5.string()).default([]),
+  replies: z5.array(z5.string()).default([]),
+  overlayPath: z5.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 = join6(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  try {
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile5(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 z5.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/templates.ts
+import { readFile as readFile6 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join8, normalize } from "node:path";
+
+// src/assets.ts
+import { existsSync } from "node:fs";
+import { dirname as dirname4, join as join7 } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
+  const moduleDir = dirname4(fileURLToPath(moduleUrl));
+  const candidates = [join7(moduleDir, name), join7(moduleDir, "..", name), join7(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/templates.ts
+async function loadTemplate(name, options = {}) {
+  const relative = templateRelativePath(name);
+  const userPath = join8(options.homeDir ?? homedir4(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join8(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 readFile6(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+
+// src/tools/review.ts
+var contextSchema = z6.object({
+  cwd: z6.string().optional(),
+  target: z6.string().optional(),
+  workingTree: z6.boolean().optional()
+});
+var localSchema = contextSchema.extend({ local: z6.boolean().optional() });
+var openSchema = localSchema.extend({
+  title: z6.string().optional(),
+  intent: z6.string().optional(),
+  issueUrl: z6.string().url().optional(),
+  base: z6.string().optional()
+});
+var submitSchema = localSchema.extend({
+  findings: findingsSchema,
+  overallIssues: z6.array(z6.string()).optional(),
+  notVerified: z6.array(z6.string()).optional(),
+  title: z6.string().optional()
+});
+var addCommentSchema = localSchema.extend({
+  body: z6.string().min(1),
+  file: z6.string().min(1),
+  line: z6.number().int().positive(),
+  side: z6.enum(["LEFT", "RIGHT"]).optional()
+});
+var respondSchema = localSchema.extend({
+  threadId: z6.string().min(1),
+  body: z6.string().min(1),
+  question: z6.boolean().optional(),
+  resolve: z6.boolean().optional()
+});
+var publishSchema = localSchema.extend({
+  status: z6.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
+});
+var completeSchema = localSchema.extend({
+  action: z6.enum(["approve", "reject", "abandon"]).optional()
+});
+function hasReviewDraft(comments, body) {
+  return comments.length > 0 || body.trim().length > 0;
+}
+async function workingTreeDiff(cwd) {
+  const tracked = await run("git", ["-C", cwd, "diff", "HEAD"], { capture: "unbounded" });
+  if (tracked.code !== 0)
+    throw new Error(tracked.stderr || "Cannot read tracked working-tree changes.");
+  const untracked = await runChecked("git", ["-C", cwd, "ls-files", "--others", "--exclude-standard", "-z"]);
+  const patches = [tracked.stdout];
+  for (const file of untracked.stdout.split("\x00").filter(Boolean)) {
+    const patch = await run("git", ["-C", cwd, "diff", "--no-index", "--", "/dev/null", file], {
+      capture: "unbounded"
+    });
+    if (patch.code > 1)
+      throw new Error(patch.stderr || `Cannot read untracked file diff: ${file}`);
+    patches.push(patch.stdout);
+  }
+  return patches.filter(Boolean).join(`
+`);
+}
+function createReviewTools() {
+  return [
+    defineTool3({
+      name: "review_context",
+      label: "review context",
+      description: "Orient to the target, backend, forge, environment, shared store, PR/MR, and tuicr session.",
+      promptSnippet: "Call review_context first",
+      promptGuidelines: ["Call this before every review workflow."],
+      parameters: parameters(localSchema),
+      executionMode: "parallel",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const store = await ensureStore(review.cwd);
+        const env = { ide: detectIde(), mux: detectMux(), shell: detectShell() };
+        const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
+        const baseRef = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "local");
+        const backend = params.local || params.workingTree ? "tuicr" : review.forge?.provider ?? "unsupported";
+        return result([
+          `Backend: ${backend}`,
+          `Forge: ${review.vcs.provider}${review.vcs.provider === "none" ? "" : ` (${review.vcs.owner}/${review.vcs.repo})`}`,
+          `Branch: ${review.vcs.branch} → ${baseRef}`,
+          `Env: ide=${env.ide} mux=${env.mux} shell=${env.shell}`,
+          `Store: ${store.link} → ${store.dest}`,
+          review.pr ? `PR/MR: #${review.pr.number} ${review.pr.url}` : "PR/MR: none",
+          session ? `tuicr: ${session.slug} (${session.commentCount} comments)` : "tuicr: none"
+        ].join(`
+`), { ...review, env, store, session, baseRef, backend });
+      }
+    }),
+    defineTool3({
+      name: "review_new",
+      label: "review new",
+      description: "Create a new local tuicr review or a remote draft PR/MR and open it in tuicr.",
+      promptSnippet: "Call review_new to start",
+      promptGuidelines: ["Use local to select tuicr as the review backend."],
+      parameters: parameters(openSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = openSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        await ensureStore(review.cwd);
+        if (params.local || params.workingTree)
+          return launchLocalReview(review, true, params.base);
+        if (!review.forge)
+          return result(unsupportedForgeMessage());
+        if (review.pr)
+          return result(`A remote review already exists for this branch: ${review.pr.url}. Use review_edit to open it.`);
+        await assertRemoteBranchReady(review.cwd);
+        const base = params.base ?? await review.forge.defaultBranch();
+        const template = await loadTemplate("review/draft-pr");
+        const body = renderTemplate(template.content, {
+          intent: params.intent ?? "<!-- Describe why this change is needed. -->",
+          issue_url: params.issueUrl ?? "<!-- Add issue tracker URL. -->",
+          head: review.vcs.branch,
+          base
+        });
+        const pr = await review.forge.createDraftPr({
+          title: params.title ?? deriveTitle(review.vcs.branch),
+          body,
+          base,
+          head: review.vcs.branch
+        });
+        const launched = await launch(review.cwd, pr.number);
+        const openMessage = launched.launched ? `Opened PR/MR #${pr.number} in tuicr (${launched.via}).` : launched.instruction ?? `Run: ${launched.command}`;
+        return result(`Draft PR/MR created from ${template.source} template: ${pr.url}
+${openMessage}`, {
+          pr,
+          template,
+          launched
+        });
+      }
+    }),
+    defineTool3({
+      name: "review_edit",
+      label: "review edit",
+      description: "Open an existing local tuicr session or remote PR/MR in tuicr without generating findings.",
+      promptSnippet: "Call review_edit to continue an existing review",
+      promptGuidelines: ["This tool never creates review findings or a PR/MR."],
+      parameters: parameters(localSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        await ensureStore(review.cwd);
+        if (params.local || params.workingTree) {
+          if (!await resolveTuicrSession(review, true))
+            return result("No local tuicr review exists. Use review_new with local=true to create one.");
+          return launchLocalReview(review, true);
+        }
+        if (!review.forge)
+          return result(unsupportedForgeMessage());
+        if (!review.pr)
+          return result("No remote PR/MR exists. Use review_new to create a draft review first.");
+        return launchLocalReview(review, false);
+      }
+    }),
+    defineTool3({
+      name: "review_diff",
+      label: "review diff",
+      description: "Fetch the target PR/MR diff or auto-detected local working-tree diff.",
+      promptSnippet: "Call review_diff for the code under review",
+      promptGuidelines: ["Ground findings in this diff."],
+      parameters: parameters(localSchema),
+      executionMode: "parallel",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        if (params.local || params.workingTree) {
+          const diff = await workingTreeDiff(review.cwd);
+          return result(diff || "No working-tree changes.", { diff, target: "local" });
+        }
+        if (!review.forge)
+          return result(unsupportedForgeMessage());
+        if (!review.pr)
+          return result("No PR/MR matches this remote review target.");
+        const diff = await review.forge.prDiff(review.pr.number);
+        return result(diff || "Empty diff.", { diff, pr: review.pr });
+      }
+    }),
+    defineTool3({
+      name: "review_gates",
+      label: "review gates",
+      description: "Run format, lint, test, conventional-subject, and available CI checks.",
+      promptSnippet: "Call review_gates before submitting findings",
+      promptGuidelines: ["Report skipped gates as skipped."],
+      parameters: parameters(localSchema),
+      executionMode: "parallel",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const gates = await runMiseGates(review.cwd);
+        const commit = await run("git", ["-C", review.cwd, "log", "-1", "--format=%s"]);
+        const subject = commit.stdout.trim();
+        if (subject)
+          gates.push(checkConventionalSubject(subject));
+        if (!params.local && review.pr && review.forge)
+          gates.push(ciGate(await review.forge.prChecks(review.pr.number)));
+        return result(gates.map((gate) => `- ${gate.name}: ${gate.status} — ${gate.detail}`).join(`
+`), {
+          results: gates
+        });
+      }
+    }),
+    defineTool3({
+      name: "review_submit",
+      label: "review submit",
+      description: "Write the review artifact and stage comments in the selected local or remote backend.",
+      promptSnippet: "Call review_submit with the findings JSON",
+      promptGuidelines: ["Remote comments remain pending until review_publish."],
+      parameters: parameters(submitSchema),
+      executionMode: "sequential",
+      async execute(_id, input, _signal, _onUpdate, ctx) {
+        const params = submitSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const model = modelRoute(ctx);
+        const useLocalBackend = Boolean(params.local || params.workingTree);
+        if (!useLocalBackend && !review.forge)
+          return result(unsupportedForgeMessage());
+        const findings = dedupeFindings(params.findings);
+        const gates = await runMiseGates(review.cwd);
+        const baseRef = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "local");
+        const artifact = await newReviewArtifactPath(review.cwd, params.local || params.workingTree || !review.pr ? "uncommitted" : await reviewTargetId(review));
+        await writeFile5(artifact, renderReviewDoc({
+          title: params.title ?? review.pr?.title ?? review.vcs.branch,
+          number: useLocalBackend ? undefined : review.pr?.number,
+          url: useLocalBackend ? undefined : review.pr?.url,
+          model,
+          headRef: review.vcs.branch,
+          baseRef,
+          findings,
+          overallIssues: params.overallIssues ?? [],
+          gates,
+          notVerified: params.notVerified ?? []
+        }), "utf8");
+        const comments = toReviewComments(findings, useLocalBackend ? undefined : model);
+        const body = (params.overallIssues ?? []).join(`
+`);
+        if (useLocalBackend) {
+          const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
+          if (!session) {
+            return result(`Review written: ${artifact}. Open tuicr, then call review_submit again to seed comments.`, {
+              artifact,
+              count: findings.length
+            });
+          }
+          const backend = createLocalReviewBackend({
+            session: session.path,
+            artifactPath: artifact,
+            author: localReviewAuthor(model)
+          });
+          await backend.stage({ comments, body });
+          return result(`Local review staged in tuicr: ${artifact}`, { artifact, count: findings.length, session });
+        }
+        if (!review.pr)
+          return result(`Review written: ${artifact}. No PR/MR matches this remote target.`, { artifact });
+        const hasDraft = hasReviewDraft(comments, body);
+        if (hasDraft) {
+          await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments, body });
+        }
+        return result(`${hasDraft ? "Pending review staged" : "Clean review recorded"} on #${review.pr.number}. Artifact: ${artifact}`, {
+          artifact,
+          pr: review.pr,
+          count: findings.length
+        });
+      }
+    }),
+    defineTool3({
+      name: "review_add_comment",
+      label: "review add comment",
+      description: "Add one provenance-marked comment through tuicr or the remote pending-review backend.",
+      promptSnippet: "Call review_add_comment for incremental comments",
+      promptGuidelines: ["Pass local=true when tuicr owns the draft."],
+      parameters: parameters(addCommentSchema),
+      executionMode: "sequential",
+      async execute(_id, input, _signal, _onUpdate, ctx) {
+        const params = addCommentSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const model = modelRoute(ctx);
+        const useLocalBackend = Boolean(params.local || params.workingTree);
+        if (!useLocalBackend && !review.forge)
+          return result(unsupportedForgeMessage());
+        const comment = {
+          file: params.file,
+          line: params.line,
+          side: params.side ?? "RIGHT",
+          body: useLocalBackend ? params.body : withRemoteProvenance(params.body, model)
+        };
+        if (useLocalBackend) {
+          const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
+          if (!session)
+            return result("No matching tuicr session. Open review_new or review_launch_ui first.");
+          const backend = createLocalReviewBackend({
+            session: session.path,
+            artifactPath: "",
+            author: localReviewAuthor(model)
+          });
+          await backend.stage({ comments: [comment], body: "" });
+          return result(`Comment added to tuicr session ${session.slug}.`, { session, comment });
+        }
+        if (!review.pr)
+          return result("No PR/MR matches this remote review target.");
+        await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments: [comment], body: "" });
+        return result(`Draft comment added to #${review.pr.number}.`, { pr: review.pr, comment });
+      }
+    }),
+    defineTool3({
+      name: "review_comments",
+      label: "review comments",
+      description: "Pull review threads or local tuicr comments and write a target-named artifact.",
+      promptSnippet: "Call review_comments before addressing findings",
+      promptGuidelines: ["Pass local=true to prepare the local reply overlay."],
+      parameters: parameters(localSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        let threads;
+        let artifact;
+        if (params.local || params.workingTree) {
+          const session = await resolveTuicrSession(review, true);
+          if (!session)
+            return result("No matching tuicr session found.");
+          artifact = await localThreadArtifactPath(review.cwd, session.slug);
+          threads = await syncLocalThreadArtifact(artifact, review.pr?.title ?? review.vcs.branch, session.slug, toLocalReviewThreads(await readSession(session.path)));
+        } else if (review.pr && review.forge) {
+          threads = await createRemoteReviewBackend(review.vcs, review.pr.number).listThreads();
+          const target = await reviewTargetId(review);
+          artifact = await newReviewArtifactPath(review.cwd, target);
+          await writeFile5(artifact, renderThreadArtifact(review.pr.title, target, threads, { number: review.pr.number, url: review.pr.url }), "utf8");
+        } else {
+          return result(review.forge ? "No PR/MR matches this remote review target." : unsupportedForgeMessage());
+        }
+        return result(threads.map((thread) => `${thread.id} ${thread.file ?? "review"}:${thread.line ?? "-"} — ${thread.body}`).join(`
+`) || "No comments.", { artifact, threads });
+      }
+    }),
+    defineTool3({
+      name: "review_respond",
+      label: "review respond",
+      description: "Post local question replies to tuicr and record their publish overlay, or reply to remote threads.",
+      promptSnippet: "Call review_respond after addressing a comment",
+      promptGuidelines: ["Question replies remain unresolved."],
+      parameters: parameters(respondSchema),
+      executionMode: "sequential",
+      async execute(_id, input, _signal, _onUpdate, ctx) {
+        const params = respondSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const model = modelRoute(ctx);
+        if (params.local) {
+          const tuicrSession = await resolveTuicrSession(review, true);
+          if (!tuicrSession)
+            return result("No matching tuicr session. Open review_new or review_launch_ui first.");
+          const artifact = await localThreadArtifactPath(review.cwd, tuicrSession.slug);
+          if (!existsSync2(artifact))
+            return result("No local review artifact. Run review_comments with local=true first.");
+          const threads = await readThreadArtifact(artifact);
+          const known = threads.find((thread) => thread.id === params.threadId);
+          const question = known?.question === true || params.question === true || !known && params.question === undefined;
+          const awaitUserDeletion = !question && params.resolve === true;
+          await addComment(tuicrSession.path, `${localResponseMarker(params.threadId)}
+${params.body}`, {
+            targetFile: known?.file,
+            line: known?.line,
+            side: "new",
+            username: localReviewAuthor(model)
+          });
+          await createLocalReviewBackend({
+            session: tuicrSession.path,
+            artifactPath: artifact,
+            author: localReviewAuthor(model)
+          }).reply({
+            threadId: params.threadId,
+            body: params.body,
+            resolve: false,
+            question
+          });
+          return result(`Local ${question ? "answer" : "response"} posted to tuicr and recorded in ${artifact}${awaitUserDeletion ? "; delete the source comment in tuicr to resolve it" : ""}.`, { artifact, question, awaitUserDeletion, session: tuicrSession });
+        }
+        if (!review.pr || !review.forge)
+          return result("No remote PR/MR for this reply.");
+        const remote = createRemoteReviewBackend(review.vcs, review.pr.number);
+        const remoteThreads = await remote.listThreads();
+        const known = remoteThreads.find((thread) => thread.id === params.threadId);
+        const question = known?.question === true || params.question === true || !known && params.question === undefined;
+        const resolve = question ? false : params.resolve ?? true;
+        await remote.reply({
+          threadId: params.threadId,
+          body: withRemoteProvenance(params.body, model),
+          resolve,
+          question
+        });
+        return result(`Replied to ${params.threadId}${resolve ? " and resolved it" : " and left it open"}.`, {
+          pr: review.pr,
+          resolve
+        });
+      }
+    }),
+    defineTool3({
+      name: "review_publish",
+      label: "review publish",
+      description: "Publish pending remote draft PR/MR review comments and status, or promote a local tuicr draft before publishing.",
+      promptSnippet: "Call review_publish to make remote review work public",
+      promptGuidelines: ["Statuses are COMMENT, APPROVE, REQUEST_CHANGES, or CLOSE."],
+      parameters: parameters(publishSchema),
+      executionMode: "sequential",
+      async execute(_id, input, _signal, _onUpdate, ctx) {
+        const params = publishSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        if (!review.pr || !review.forge)
+          return result("No remote PR/MR to publish.");
+        return publishResolvedReview(review, params, modelRoute(ctx));
+      }
+    }),
+    defineTool3({
+      name: "review_complete",
+      label: "review complete",
+      description: "Approve, reject, or abandon a remote review, or archive a local review artifact.",
+      promptSnippet: "Call review_complete to finish a review without merging it.",
+      promptGuidelines: ["A local completion archives the Diffpi artifact and deletes the matching tuicr session."],
+      parameters: parameters(completeSchema),
+      executionMode: "sequential",
+      async execute(_id, input, _signal, _onUpdate, ctx) {
+        const params = completeSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        if (params.local) {
+          const session = await resolveTuicrSession(review, true);
+          if (!session)
+            return result("No matching local tuicr session to close.");
+          const artifact = await localThreadArtifactPath(review.cwd, session.slug);
+          if (!existsSync2(artifact))
+            return result("No local review artifact. Run review_comments with local=true first.");
+          const archived = await uniqueRecordPath(await completedReviewsDir(review.cwd), reviewSlug(session.slug));
+          await rename2(artifact, archived);
+          await unlink2(session.path);
+          return result(`Archived ${archived} and deleted the tuicr session ${session.slug}.`, {
+            artifact: archived,
+            session
+          });
+        }
+        if (!review.pr || !review.forge)
+          return result("No remote PR/MR to complete.");
+        if (!params.action)
+          return result("Choose a complete action: approve, reject, or abandon.");
+        const status = { approve: "APPROVE", reject: "REQUEST_CHANGES", abandon: "CLOSE" }[params.action];
+        return publishResolvedReview(review, { ...params, status }, modelRoute(ctx));
+      }
+    }),
+    defineTool3({
+      name: "review_merge",
+      label: "review merge",
+      description: "Squash-merge an approved GitHub PR after checking its conventional subject.",
+      promptSnippet: "Call review_merge only after review_publish APPROVE",
+      promptGuidelines: ["This is intentionally GitHub-only until GitLab merge support is added."],
+      parameters: parameters(contextSchema.extend({ subject: z6.string().optional() })),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = contextSchema.extend({ subject: z6.string().optional() }).parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        if (review.vcs.provider !== "github" || !review.forge)
+          return result("review_merge currently supports GitHub only.");
+        if (!review.pr)
+          return result("No open PR/MR for this branch.");
+        const subject = params.subject ?? review.pr.title;
+        const guard = checkConventionalSubject(subject);
+        if (guard.status !== "pass")
+          return result(`Merge blocked: ${guard.detail}`, { pr: review.pr, guard });
+        await review.forge.mergePr(review.pr.number, subject);
+        return result(`Merged #${review.pr.number} with subject: ${subject}.`, { pr: review.pr, guard });
+      }
+    }),
+    defineTool3({
+      name: "review_launch_ui",
+      label: "review launch UI",
+      description: "Open a tuicr UI in a mux tab, configure Zed, or return the command to run.",
+      promptSnippet: "Call review_launch_ui for the interactive tuicr TUI",
+      promptGuidelines: ["Show the returned command when launch cannot open a tab."],
+      parameters: parameters(localSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const workingTree = Boolean(params.local || params.workingTree);
+        if (!workingTree && !review.forge)
+          return result(unsupportedForgeMessage());
+        return launchLocalReview(review, workingTree);
+      }
+    })
+  ];
+}
+async function syncLocalThreadArtifact(path, title, sessionSlug, threads) {
+  let previous = [];
+  try {
+    previous = parseThreadArtifact(await readFile7(path, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const previousById = new Map(previous.map((thread) => [thread.id, thread]));
+  const currentIds = new Set(threads.map((thread) => thread.id));
+  const current = threads.map((thread) => {
+    const existing = previousById.get(thread.id);
+    return {
+      ...thread,
+      resolved: false,
+      addressed: existing?.addressed ?? Boolean(existing?.reply),
+      reply: existing?.reply
+    };
+  });
+  const removed = previous.filter((thread) => !currentIds.has(thread.id)).map((thread) => ({ ...thread, resolved: true }));
+  const merged = [...current, ...removed];
+  await writeFile5(path, renderThreadArtifact(title, sessionSlug, merged), "utf8");
+  return merged;
+}
+function parameters(schema) {
+  return z6.toJSONSchema(schema, { io: "input" });
+}
+function resolveWorkingDirectory(params) {
+  return params.cwd ?? process.cwd();
+}
+function result(text, details = {}) {
+  return { content: [{ type: "text", text }], details };
+}
+function unsupportedForgeMessage() {
+  return "No supported GitHub or GitLab remote was detected. Use local=true for an offline tuicr review.";
+}
+function modelRoute(ctx) {
+  if (!ctx.model)
+    throw new Error("Cannot record review provenance because Pi did not provide an active model route.");
+  return `${ctx.model.provider}/${ctx.model.id}`;
+}
+async function publishResolvedReview(review, params, model) {
+  const status = params.status ?? "COMMENT";
+  const event = status === "CLOSE" ? "COMMENT" : status;
+  assertReviewEventSupported(review.vcs.provider, event);
+  const remote = createRemoteReviewBackend(review.vcs, review.pr.number);
+  const promotion = params.local ? await promoteLocalReview(review, remote, model, true) : undefined;
+  if (status !== "CLOSE" && review.pr.isDraft)
+    await review.forge.markReady(review.pr.number);
+  await remote.publish(event);
+  if (promotion) {
+    promotion.publication.state.bodies = [
+      ...new Set([...promotion.publication.state.bodies, ...promotion.bodyFingerprints])
+    ];
+    promotion.publication.state.comments = [
+      ...new Set([...promotion.publication.state.comments, ...promotion.commentFingerprints])
+    ];
+    await saveReviewPublicationState(promotion.publication.path, promotion.publication.state);
+  }
+  if (status === "CLOSE")
+    await review.forge.closePr(review.pr.number);
+  const finalPr = await review.forge.viewPr(String(review.pr.number));
+  const promotedBodies = promotion?.promotedBodies ?? 0;
+  const promotedComments = promotion?.promotedComments ?? 0;
+  const promotedReplies = promotion?.promotedReplies ?? 0;
+  return result(`Published #${review.pr.number} (${status}); promoted ${promotedBodies} review bodies, ${promotedComments} comments, and ${promotedReplies} replies.`, { pr: finalPr ?? review.pr, status, promotedBodies, promotedComments, promotedReplies });
+}
+async function promoteLocalReview(review, remote, model, workingTree) {
+  const publication = await loadReviewPublicationState(review.cwd, review.vcs, review.pr.number);
+  const session = await resolveTuicrSession(review, workingTree);
+  if (!session)
+    throw new Error("No matching tuicr session to publish.");
+  const local = createLocalReviewBackend({
+    session: session.path,
+    artifactPath: "",
+    author: localReviewAuthor(model)
+  });
+  const draft = await local.readDraft();
+  const comments = draft.comments.map((comment) => ({
+    ...comment,
+    body: withRemoteProvenance(comment.body, comment.author?.replace(/^Agent:\s*/, "") || model)
+  }));
+  const body = draft.body.trim() ? withRemoteProvenance(draft.body, model) : "";
+  const bodyFingerprints = body ? [reviewBodyFingerprint(body)] : [];
+  const commentFingerprints = comments.map(reviewCommentFingerprint);
+  const remoteDraft = await remote.readDraft();
+  const knownBodies = new Set(publication.state.bodies);
+  if (remoteDraft.body.trim())
+    knownBodies.add(reviewBodyFingerprint(remoteDraft.body));
+  const unpublishedBody = body && !knownBodies.has(reviewBodyFingerprint(body)) ? body : "";
+  const known = new Set([...publication.state.comments, ...remoteDraft.comments.map(reviewCommentFingerprint)]);
+  const unpublished = unpublishedReviewComments(comments, known);
+  if (unpublished.length > 0 || unpublishedBody)
+    await remote.stage({ comments: unpublished, body: unpublishedBody });
+  const promotedReplies = await promoteLocalReplies(review, remote, publication, model, workingTree);
+  return {
+    publication,
+    bodyFingerprints,
+    commentFingerprints,
+    promotedBodies: unpublishedBody ? 1 : 0,
+    promotedComments: unpublished.length,
+    promotedReplies
+  };
+}
+async function promoteLocalReplies(review, remote, publication, model, workingTree) {
+  const target = workingTree ? "uncommitted" : await reviewTargetId(review);
+  const artifact = workingTree ? await latestThreadArtifact(review.cwd, review, target) : publication.state.overlayPath ?? await latestThreadArtifact(review.cwd, review, target);
+  if (!artifact)
+    return 0;
+  if (!workingTree)
+    publication.state.overlayPath = artifact;
+  let count = 0;
+  for (const thread of await readThreadArtifact(artifact)) {
+    if (!thread.reply)
+      continue;
+    const body = withRemoteProvenance(thread.reply, model);
+    const fingerprint = reviewReplyFingerprint(thread.id, body);
+    if (publication.state.replies.includes(fingerprint))
+      continue;
+    await remote.reply({
+      threadId: thread.id,
+      body,
+      resolve: !thread.question,
+      question: thread.question
+    });
+    publication.state.replies.push(fingerprint);
+    await saveReviewPublicationState(publication.path, publication.state);
+    count += 1;
+  }
+  return count;
+}
+async function resolveReviewContext(cwd, target) {
+  const vcs = await detectVcs(cwd);
+  const forge = vcs.provider === "none" ? undefined : createVcsBackend(vcs);
+  const requested = target ? normalizeTarget(target) : vcs.branch;
+  const pr = forge ? await forge.viewPr(requested) : undefined;
+  return { cwd, vcs, forge, pr };
+}
+function normalizeTarget(target) {
+  return target.match(/\/(?:pull|merge_requests)\/(\d+)(?:\/|$)/)?.[1] ?? target;
+}
+function resolveTuicrSession(review, workingTree = false) {
+  return resolveReviewSession(review.cwd, {
+    branch: review.vcs.branch,
+    workingTree,
+    owner: review.vcs.provider === "none" ? undefined : review.vcs.owner,
+    repo: review.vcs.provider === "none" ? undefined : review.vcs.repo,
+    number: review.pr?.number
+  });
+}
+async function launchLocalReview(review, workingTree, requestedBase) {
+  const base = workingTree ? requestedBase ?? review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : undefined) : undefined;
+  const launched = await launch(review.cwd, workingTree ? undefined : review.pr?.number, base);
+  const commandTarget = workingTree || !review.pr ? "full branch" : `PR/MR #${review.pr.number}`;
+  return result(launched.launched ? `Opened ${commandTarget} in tuicr (${launched.via}).` : launched.instruction ?? `Run: ${launched.command}`, { launched, pr: review.pr, target: commandTarget });
+}
+async function assertRemoteBranchReady(cwd) {
+  const dirty = await runChecked("git", ["-C", cwd, "status", "--porcelain"]);
+  if (dirty.stdout.trim())
+    throw new Error("Commit and push all changes before opening a remote review.");
+  const upstream = await run("git", ["-C", cwd, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]);
+  if (upstream.code !== 0 || !upstream.stdout.trim())
+    throw new Error("Push the current branch and set its upstream before opening a remote review.");
+  const [head, pushed] = await Promise.all([
+    runChecked("git", ["-C", cwd, "rev-parse", "HEAD"]),
+    runChecked("git", ["-C", cwd, "rev-parse", "@{upstream}"])
+  ]);
+  if (head.stdout.trim() !== pushed.stdout.trim())
+    throw new Error("Push the current branch before opening a remote review.");
+}
+async function reviewTargetId(review) {
+  if (!review.pr)
+    return "uncommitted";
+  if (review.pr.headSha)
+    return review.pr.headSha.slice(0, 12);
+  if (review.pr.headRef === review.vcs.branch)
+    return headSha(review.cwd);
+  const remote = await run("git", ["-C", review.cwd, "ls-remote", "origin", `refs/heads/${review.pr.headRef}`]);
+  return remote.stdout.trim().split(/\s+/)[0]?.slice(0, 12) || headSha(review.cwd);
+}
+async function headSha(cwd) {
+  const result = await runChecked("git", ["-C", cwd, "rev-parse", "--short=12", "HEAD"]);
+  return result.stdout.trim();
+}
+async function newReviewArtifactPath(cwd, target) {
+  const dir = await reviewsDir(cwd);
+  await mkdir4(dir, { recursive: true });
+  return uniqueRecordPath(dir, reviewRecordName(target));
+}
+async function localThreadArtifactPath(cwd, sessionSlug) {
+  const dir = await reviewsDir(cwd);
+  return join9(dir, `${reviewSlug(sessionSlug) || "local-review"}.md`);
+}
+async function readThreadArtifact(path) {
+  try {
+    return parseThreadArtifact(await readFile7(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Expected local reply overlay is missing: ${path}`);
+    }
+    throw error;
+  }
+}
+async function latestThreadArtifact(cwd, review, target) {
+  try {
+    return await findLatestThreadArtifact(cwd, review, target);
+  } catch (error) {
+    throw new Error(`Cannot locate the latest review thread artifact for ${target}.`, { cause: error });
+  }
+}
+async function findLatestThreadArtifact(cwd, review, target) {
+  const dir = await reviewsDir(cwd);
+  const suffix = reviewSlug(target) || "uncommitted";
+  const names = await listReviewArtifactNames(dir);
+  const candidates = await Promise.all(names.flatMap((name) => {
+    if (!name.endsWith(".md"))
+      return [];
+    return [
+      (async () => {
+        const path = join9(dir, name);
+        const info = await stat(path);
+        return { path, name, content: await readFile7(path, "utf8"), modified: info.mtimeMs };
+      })()
+    ];
+  }));
+  return candidates.filter(({ name, content }) => {
+    if (!content.startsWith("<!-- diffpi-threads:"))
+      return false;
+    if (review.pr && target !== "local" && target !== "uncommitted")
+      return content.includes(`- PR/MR: #${review.pr.number}`);
+    return artifactNameMatches(name, suffix);
+  }).sort((a, b) => b.modified - a.modified)[0]?.path;
+}
+async function listReviewArtifactNames(dir) {
+  try {
+    return await readdir(dir);
+  } catch (error) {
+    throw new Error(`Cannot read review artifacts in ${dir}.`, { cause: error });
+  }
+}
+function deriveTitle(branch) {
+  return branch.replace(/^(feature|feat|fix|bug|chore)\//, "").replace(/^eng-\d+-/i, "").replace(/[-_]+/g, " ").replace(/^\w/, (char) => char.toUpperCase());
+}
+function uniqueRecordPath(dir, base) {
+  let path = join9(dir, `${base}.md`);
+  let count = 2;
+  while (existsSync2(path))
+    path = join9(dir, `${base}-${count++}.md`);
+  return path;
+}
+function artifactNameMatches(name, suffix) {
+  if (!name.endsWith(".md"))
+    return false;
+  const stem = name.slice(0, -3);
+  const marker = `-${suffix}`;
+  const markerIndex = stem.lastIndexOf(marker);
+  if (markerIndex < 0)
+    return false;
+  const tail = stem.slice(markerIndex + marker.length);
+  return tail === "" || /^-\d+$/.test(tail);
+}
+
 // src/tools/setup.ts
-import { defineTool as defineTool3 } from "@earendil-works/pi-coding-agent";
-import { z as z4 } from "zod";
+import { defineTool as defineTool4 } from "@earendil-works/pi-coding-agent";
+import { z as z8 } from "zod";
 
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter2 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir2, readFile as readFile4 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { basename as basename2, join as join7 } from "node:path";
-
-// src/assets.ts
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
-  const moduleDir = dirname(fileURLToPath(moduleUrl));
-  const candidates = [
-    join(moduleDir, "agents"),
-    join(moduleDir, "..", "agents"),
-    join(moduleDir, "..", "..", "agents")
-  ];
-  return candidates.find((path) => existsSync(path)) ?? candidates[1];
-}
+import { readdir as readdir3, readFile as readFile10 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { basename as basename4, join as join13 } from "node:path";
 
 // src/config.ts
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { z as z3 } from "zod";
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { z as z7 } from "zod";
+import { homedir as homedir5 } from "node:os";
+import { join as join10 } from "node:path";
 
 // src/fsx.ts
-import { readdir, readFile } from "node:fs/promises";
+import { readdir as readdir2, readFile as readFile8 } from "node:fs/promises";
 async function readTextIfExists(path) {
   try {
-    return await readFile(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch (error) {
     if (isMissingPath(error))
       return;
@@ -170,18 +2718,18 @@ function isMissingPath(error) {
 }
 
 // src/config.ts
-var modelReferenceSchema = z3.string().trim().min(1);
-var agentConfigSchema = z3.object({
-  models: z3.array(modelReferenceSchema).optional()
+var modelReferenceSchema = z7.string().trim().min(1);
+var agentConfigSchema = z7.object({
+  models: z7.array(modelReferenceSchema).optional()
 }).strict();
-var diffpiConfigSchema = z3.object({
-  agents: z3.record(z3.string(), agentConfigSchema).optional()
+var diffpiConfigSchema = z7.object({
+  agents: z7.record(z7.string(), agentConfigSchema).optional()
 }).strict();
-function diffpiConfigPaths(homeDir = homedir()) {
-  const directory = join2(homeDir, ".difflab", "diffpi");
+function diffpiConfigPaths(homeDir = homedir5()) {
+  const directory = join10(homeDir, ".difflab", "diffpi");
   return {
-    yaml: join2(directory, "config.yaml"),
-    json: join2(directory, "config.json")
+    yaml: join10(directory, "config.yaml"),
+    json: join10(directory, "config.json")
   };
 }
 async function loadDiffpiConfig(options = {}) {
@@ -237,16 +2785,16 @@ function normalizeModelReference(value) {
 }
 
 // src/mcp.ts
-import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname5, join as join11 } from "node:path";
 var mcp = {
-  globalConfigPath(homeDir = homedir2()) {
-    return join3(homeDir, ".config", "mcp", "mcp.json");
+  globalConfigPath(homeDir = homedir6()) {
+    return join11(homeDir, ".config", "mcp", "mcp.json");
   },
   async serversEnsure(servers, options = {}) {
     const path = options.path ?? mcp.globalConfigPath();
-    const currentText = await getOptionalFile(path);
+    const currentText = await getOptionalFile2(path);
     const current = getParsedConfig(currentText, path);
     const nextServers = { ...current.mcpServers };
     for (const [name, entry] of Object.entries(servers)) {
@@ -255,8 +2803,8 @@ var mcp = {
     const next = { ...current, mcpServers: nextServers };
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
-      await mkdir(dirname2(path), { recursive: true });
-      await writeFile(path, `${JSON.stringify(next, null, 2)}
+      await mkdir5(dirname5(path), { recursive: true });
+      await writeFile6(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -283,9 +2831,9 @@ function getParsedConfig(content, path) {
     throw new Error(`Expected a valid pi-mcp-adapter configuration in ${path}.`);
   }
 }
-async function getOptionalFile(path) {
+async function getOptionalFile2(path) {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile9(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -296,237 +2844,10 @@ 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 dirname3, join as join5 } from "node:path";
-
-// src/process.ts
-import { constants } from "node:fs";
-import { access } from "node:fs/promises";
-import { delimiter, join as join4 } from "node:path";
-import { spawn } from "node:child_process";
-var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
-async function findExecutable(name) {
-  if (name.includes("/")) {
-    try {
-      await access(name, constants.X_OK);
-      return name;
-    } catch {
-      return;
-    }
-  }
-  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
-    if (!directory)
-      continue;
-    const candidate = join4(directory, name);
-    try {
-      await access(candidate, constants.X_OK);
-      return candidate;
-    } catch {}
-  }
-  return;
-}
-function run(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      env: options.env ?? process.env,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout = appendBounded(stdout, chunk.toString());
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr = appendBounded(stderr, chunk.toString());
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
-  });
-}
-async function runChecked(command, args, options = {}) {
-  const result = await run(command, args, options);
-  if (result.code === 0)
-    return result;
-  const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
-  throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
-}
-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
-var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
-var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
-var mise = {
-  async executableCheck(name = "mise") {
-    return findExecutable(name);
-  },
-  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 = join5(homeDir, ".local", "bin", "mise");
-    if (options.dryRun)
-      return installedPath;
-    await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
-    const executable = await findExecutable(installedPath) ?? await findExecutable("mise");
-    if (!executable)
-      throw new Error(`mise installation completed, but ${installedPath} was not found.`);
-    return executable;
-  },
-  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);
-    if (current.includes(MISE_HOOK_START))
-      return { path: hook.path, changed: false, planned: false };
-    if (options.dryRun)
-      return { path: hook.path, changed: true, planned: true };
-    const separator = current.length === 0 || current.endsWith(`
-`) ? "" : `
-`;
-    await mkdir2(dirname3(hook.path), { recursive: true });
-    await writeFile2(hook.path, `${current}${separator}${hook.content}`, "utf8");
-    return { path: hook.path, changed: true, planned: false };
-  },
-  async toolCheckGlobal(executable, tool, minimumVersion) {
-    const result = await run(executable, ["ls", "--global", "--installed", tool, "--json"]);
-    return result.code === 0 && isToolInstalled(result.stdout, minimumVersion);
-  },
-  async toolInstallGlobal(executable, specification) {
-    await runChecked(executable, ["use", "--global", specification]);
-  },
-  async toolCheckLocal(executable, tool, cwd = process.cwd()) {
-    const result = await run(executable, ["ls", "--local", "--installed", tool, "--json"], { cwd });
-    return result.code === 0 && isToolInstalled(result.stdout);
-  },
-  async toolInstallLocal(executable, specification, cwd = process.cwd()) {
-    await runChecked(executable, ["use", "--path", cwd, specification], { cwd });
-  },
-  async toolUpdateAllGlobal(executable, homeDir = homedir3()) {
-    await runChecked(executable, ["upgrade"], { cwd: homeDir });
-  }
-};
-function getShellHook(shell, executable, homeDir) {
-  const command = getShellQuoted(executable);
-  switch (shell.toLowerCase()) {
-    case "zsh":
-      return {
-        path: join5(homeDir, ".zshrc"),
-        content: `${MISE_HOOK_START}
-eval "$(${command} activate zsh)"
-${MISE_HOOK_END}
-`
-      };
-    case "fish":
-      return {
-        path: join5(homeDir, ".config", "fish", "config.fish"),
-        content: `${MISE_HOOK_START}
-${command} activate fish | source
-${MISE_HOOK_END}
-`
-      };
-    case "nu":
-    case "nushell":
-      return {
-        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
-^$mise_bin activate nu | save $mise_path --force
-use ($nu.default-config-dir | path join mise.nu)
-${MISE_HOOK_END}
-`
-      };
-    case "xonsh":
-      return {
-        path: join5(homeDir, ".xonshrc"),
-        content: `${MISE_HOOK_START}
-execx($(${command} activate xonsh))
-${MISE_HOOK_END}
-`
-      };
-    case "elvish":
-      return {
-        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 }
-mise:activate
-${MISE_HOOK_END}
-`
-      };
-    case "pwsh":
-    case "powershell":
-      return {
-        path: join5(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
-        content: `${MISE_HOOK_START}
-(& ${command} activate pwsh) | Out-String | Invoke-Expression
-${MISE_HOOK_END}
-`
-      };
-    case "bash":
-    default:
-      return {
-        path: join5(homeDir, ".bashrc"),
-        content: `${MISE_HOOK_START}
-eval "$(${command} activate bash)"
-${MISE_HOOK_END}
-`
-      };
-  }
-}
-function isToolInstalled(output, minimumVersion) {
-  try {
-    const value = JSON.parse(output);
-    if (!Array.isArray(value))
-      return false;
-    return value.some((entry) => {
-      if (!entry || typeof entry !== "object" || !("installed" in entry) || entry.installed !== true)
-        return false;
-      if (!minimumVersion)
-        return true;
-      if (!("version" in entry) || typeof entry.version !== "string")
-        return false;
-      return isVersionAtLeast(entry.version, minimumVersion);
-    });
-  } catch {
-    return false;
-  }
-}
-function isVersionAtLeast(version, minimumVersion) {
-  const current = version.match(/^v?(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
-  const minimum = minimumVersion.match(/^v?(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
-  if (!current || !minimum)
-    return false;
-  for (let index = 0;index < minimum.length; index += 1) {
-    if (current[index] !== minimum[index])
-      return current[index] > minimum[index];
-  }
-  return true;
-}
-async function getOptionalFile2(path) {
-  try {
-    return await readFile3(path, "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return "";
-    throw error;
-  }
-}
-function getShellQuoted(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`;
-}
-
 // src/pi.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, join as join6 } from "node:path";
+import { mkdir as mkdir6, writeFile as writeFile7 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname6, join as join12 } from "node:path";
 var pi = {
   executableCheck: findPiExecutable,
   packageList: listPiPackages,
@@ -539,19 +2860,19 @@ var pi = {
   configEnsure: ensurePiConfig
 };
 async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
-  const path = join6(agentDir, "agents", filename);
+  const path = join12(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 mkdir6(dirname6(path), { recursive: true });
+    await writeFile7(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
-async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join6(homedir4(), ".agents", "skills")) {
-  const roots = [join6(agentDir, "skills"), sharedSkillsDir];
+async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join12(homedir7(), ".agents", "skills")) {
+  const roots = [join12(agentDir, "skills"), sharedSkillsDir];
   for (const root of roots) {
-    if (await readTextIfExists(join6(root, name, "SKILL.md")) !== undefined)
+    if (await readTextIfExists(join12(root, name, "SKILL.md")) !== undefined)
       return true;
   }
   return false;
@@ -580,8 +2901,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 mkdir6(dirname6(path), { recursive: true });
+    await writeFile7(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -600,8 +2921,8 @@ function hasPiPackage(listOutput, source) {
 async function installPiPackage(executable, source) {
   await runChecked(executable, ["install", source]);
 }
-function resolvePiAgentDir(homeDir = homedir4()) {
-  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join6(process.env.XDG_CONFIG_HOME, "pi") : join6(homeDir, ".pi", "agent"));
+function resolvePiAgentDir(homeDir = homedir7()) {
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join12(process.env.XDG_CONFIG_HOME, "pi") : join12(homeDir, ".pi", "agent"));
 }
 function parseJsonObject(content, path) {
   if (!content?.trim())
@@ -642,13 +2963,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_DIR = 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 ?? homedir5();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join7(homeDir, ".local", "bin", "mise"));
+  const homeDir = options.homeDir ?? homedir8();
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join13(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -677,7 +3003,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));
@@ -693,9 +3023,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(join7(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  const webSearch = await pi.configEnsure(join13(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
   actions.push(getConfigSetupAction("web search settings", webSearch));
-  const lsp = await pi.configEnsure(join7(agentDir, "pi-lsp.json"), (config) => ({
+  const lsp = await pi.configEnsure(join13(agentDir, "pi-lsp.json"), (config) => ({
     ...config,
     progressive: { ...getRecord(config.progressive), enabled: true, inject: "none" }
   }), options.dryRun);
@@ -706,11 +3036,11 @@ async function ensurePiAgents(options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
   const bundledAgentsDir = options.bundledAgentsDir ?? BUNDLED_AGENTS_DIR;
   const userConfig = await loadDiffpiConfig({ homeDir: options.homeDir });
-  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 entries = (await readdir3(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 = basename2(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile4(join7(bundledAgentsDir, entry.name), "utf8");
+    const id = basename4(entry.name, ".md").replace(/^diffpi-/, "");
+    const source = await readFile10(join13(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));
@@ -719,7 +3049,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join7(options.homeDir ?? homedir5(), ".agents", "skills");
+  const sharedSkillsDir = join13(options.homeDir ?? homedir8(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -763,6 +3093,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)
@@ -779,6 +3117,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)
@@ -787,6 +3127,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 } = parseFrontmatter2(content.startsWith("\uFEFF") ? content.slice(1) : content);
   const profilePreferences = [...getTextList(frontmatter.model), ...getTextList(frontmatter.model_fallbacks)];
@@ -846,6 +3220,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);
@@ -868,11 +3246,14 @@ function getRecord(value) {
 }
 
 // src/tools/setup.ts
-var setupParametersSchema = z4.object({
-  issueTracker: z4.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira.")
+var setupParametersSchema = z8.object({
+  issueTracker: z8.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
+  forges: z8.array(z8.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
+  forge: z8.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
+  bindZedKey: z8.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
 });
-var setupParameters = z4.toJSONSchema(setupParametersSchema, { io: "input" });
-var diffpiSetupTool = defineTool3({
+var setupParameters = z8.toJSONSchema(setupParametersSchema, { io: "input" });
+var diffpiSetupTool = defineTool4({
   name: "diffpi_setup",
   label: "diffpi setup",
   description: "Install or repair the @difflab/pi environment. This mutates user-level tool installations and configuration files.",
@@ -889,6 +3270,9 @@ var diffpiSetupTool = defineTool3({
     const params = setupParametersSchema.parse(input);
     const result = await setupPi({
       issueTracker: params.issueTracker,
+      forges: params.forges,
+      forge: params.forge,
+      bindZedKey: params.bindZedKey,
       installMiseHook: true,
       availableModels: ctx.modelRegistry.getAvailable(),
       onProgress(message) {
@@ -898,7 +3282,7 @@ var diffpiSetupTool = defineTool3({
     return formatResult(result, "Setup complete.");
   }
 });
-var diffpiValidateTool = defineTool3({
+var diffpiValidateTool = defineTool4({
   name: "diffpi_validate",
   label: "diffpi validate",
   description: "Inspect the @difflab/pi environment without installing software or changing configuration files.",
@@ -914,6 +3298,9 @@ var diffpiValidateTool = defineTool3({
     const params = setupParametersSchema.parse(input);
     const result = await setupPi({
       issueTracker: params.issueTracker,
+      forges: params.forges,
+      forge: params.forge,
+      bindZedKey: params.bindZedKey,
       installMiseHook: true,
       dryRun: true,
       availableModels: ctx.modelRegistry.getAvailable()
@@ -936,14 +3323,50 @@ ${lines.join(`
   };
 }
 
+// src/tools/templates.ts
+import { defineTool as defineTool5 } from "@earendil-works/pi-coding-agent";
+import { z as z9 } from "zod";
+var templateSchema = z9.object({
+  name: z9.string().min(1),
+  variables: z9.record(z9.string(), z9.string()).optional(),
+  homeDir: z9.string().optional()
+});
+var diffpiTemplateTool = defineTool5({
+  name: "diffpi_template",
+  label: "diffpi template",
+  description: "Load a bundled Diffpi template or a user override and render named variables.",
+  promptSnippet: "Use diffpi_template for package workflow templates",
+  promptGuidelines: ["User overrides live under ~/.difflab/diffpi/templates."],
+  parameters: z9.toJSONSchema(templateSchema, { io: "input" }),
+  executionMode: "parallel",
+  async execute(_id, input) {
+    const params = templateSchema.parse(input);
+    const template = await loadTemplate(params.name, { homeDir: params.homeDir });
+    const content = renderTemplate(template.content, params.variables ?? {});
+    return {
+      content: [{ type: "text", text: content }],
+      details: { name: params.name, path: template.path, source: template.source }
+    };
+  }
+});
+
 // src/tools/index.ts
 function createPiTools(pi, modes) {
-  return [diffpiSetupTool, diffpiValidateTool, createDiffpiReloadTool(pi), ...createModeTools(modes)];
+  return [
+    diffpiSetupTool,
+    diffpiValidateTool,
+    createDiffpiReloadTool(pi),
+    diffpiTemplateTool,
+    ...createModeTools(modes),
+    ...createReviewTools()
+  ];
 }
 export {
   createDiffpiReloadTool,
   createModeTools,
   createPiTools,
+  createReviewTools,
   diffpiSetupTool,
+  diffpiTemplateTool,
   diffpiValidateTool
 };