@difflab/pi 0.1.0 → 0.2.0-rc.202609170958.44c1e9f

package/dist/tools/index.js

@@ -25,21 +25,2386 @@ function createDiffpiReloadTool(pi) {
   });
 }
 
+// src/tools/modes.ts
+import { defineTool as defineTool2 } from "@earendil-works/pi-coding-agent";
+import { z as z2 } from "zod";
+var emptyParametersSchema = z2.object({});
+var emptyParameters = z2.toJSONSchema(emptyParametersSchema, { io: "input" });
+var listParametersSchema = z2.object({
+  includeSkills: z2.boolean().optional().describe("Include skill-owned agents using skill:agent ids.")
+});
+var listParameters = z2.toJSONSchema(listParametersSchema, { io: "input" });
+var setParametersSchema = z2.object({
+  agent: z2.string().trim().min(1).describe("Inline agent id from diffpi_modes_list.")
+});
+var setParameters = z2.toJSONSchema(setParametersSchema, { io: "input" });
+function createModeTools(controller) {
+  return [
+    defineTool2({
+      name: "diffpi_modes_list",
+      label: "diffpi modes list",
+      description: "List inline agents shared with the subagent plugin, optionally including skill-owned agents.",
+      promptSnippet: "List inline agents before selecting one when the requested agent is unclear",
+      promptGuidelines: [
+        "Call diffpi_modes_list when the user asks which inline agents are available.",
+        "Set includeSkills to true only when the user asks for skill agents or runs /skill:mode --include-skills.",
+        "Inline mode applies the profile prompt, first available preferred model, thinking level, and available tools."
+      ],
+      parameters: listParameters,
+      executionMode: "parallel",
+      async execute(_toolCallId, input, _signal, _onUpdate, ctx) {
+        const params = listParametersSchema.parse(input);
+        const catalog = await controller.list(ctx, { includeSkills: params.includeSkills });
+        return {
+          content: [{ type: "text", text: formatCatalog(catalog, controller.getActive()?.id) }],
+          details: { active: controller.getActive()?.id, catalog }
+        };
+      }
+    }),
+    defineTool2({
+      name: "diffpi_modes_set",
+      label: "diffpi modes set",
+      description: "Set a validated available agent as the inline behavioral agent for subsequent chat turns.",
+      promptSnippet: "Set the inline behavioral agent only after the user chooses one",
+      promptGuidelines: [
+        "Call diffpi_modes_set only after the user explicitly selects an agent.",
+        "Use the exact skill:agent id for a skill-owned agent.",
+        "The selected prompt takes effect on the next model turn."
+      ],
+      parameters: setParameters,
+      executionMode: "sequential",
+      async execute(_toolCallId, input, _signal, _onUpdate, ctx) {
+        const params = setParametersSchema.parse(input);
+        const result = await controller.set(params.agent, ctx);
+        if (!result.ok)
+          throw new Error(result.message);
+        return {
+          content: [{ type: "text", text: `${result.message} The prompt takes effect on the next turn.` }],
+          details: { active: result.active }
+        };
+      }
+    }),
+    defineTool2({
+      name: "diffpi_modes_unset",
+      label: "diffpi modes unset",
+      description: "Clear the inline behavioral agent and restore default Pi prompting for subsequent turns.",
+      promptSnippet: "Clear the inline agent when the user asks for default behavior",
+      promptGuidelines: [
+        "Call diffpi_modes_unset only when the user explicitly asks to clear the active inline agent."
+      ],
+      parameters: emptyParameters,
+      executionMode: "sequential",
+      async execute(_toolCallId, input, _signal, _onUpdate, ctx) {
+        emptyParametersSchema.parse(input);
+        const result = await controller.unset(ctx);
+        return {
+          content: [{ type: "text", text: result.message }],
+          details: { active: controller.getActive()?.id }
+        };
+      }
+    })
+  ];
+}
+function formatCatalog(catalog, active) {
+  const lines = [`Active inline agent: ${active ?? "default"}.`, "", "Available inline agents:"];
+  for (const mode of catalog.modes) {
+    const runtime = [mode.modelPreferences[0], mode.thinkingLevel].filter(Boolean).join(", ");
+    lines.push(`- ${mode.id} [${mode.promptStrategy}${runtime ? `; ${runtime}` : ""}] — ${sanitize(mode.description)} (${mode.source})`);
+  }
+  if (catalog.diagnostics.length > 0) {
+    lines.push("", "Skipped agent files:");
+    for (const diagnostic of catalog.diagnostics)
+      lines.push(`- ${sanitize(diagnostic)}`);
+  }
+  lines.push("", "Inline mode applies the profile prompt, preferred available model, thinking level, and tool set.");
+  return lines.join(`
+`);
+}
+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 mkdir3, readdir, readFile as readFile6, stat, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+import { defineTool as defineTool3 } from "@earendil-works/pi-coding-agent";
+import { z as z5 } from "zod";
+
+// src/environment.ts
+import { basename } from "node:path";
+
+// src/process.ts
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { delimiter, join } 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 = 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}`);
+}
+function appendBounded(current, next) {
+  const combined = current + next;
+  return combined.length <= MAX_CAPTURED_OUTPUT_LENGTH ? combined : combined.slice(-MAX_CAPTURED_OUTPUT_LENGTH);
+}
+
+// src/zed.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join as join2 } from "node:path";
+var ZED_REVIEW_TASK_NAME = "diffpi: tuicr review";
+var REVIEW_KEYBINDING = "cmd-alt-r";
+var REVIEW_TASK = {
+  label: ZED_REVIEW_TASK_NAME,
+  command: "tuicr",
+  args: ["-w"],
+  cwd: "$ZED_WORKTREE_ROOT",
+  use_new_terminal: true,
+  reveal: "always"
+};
+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()) {
+  const path = zedTasksPath(homeDir);
+  const currentText = await readOptional(path);
+  const tasks = parseJsonArray(currentText, path);
+  const index = tasks.findIndex((task) => task.label === ZED_REVIEW_TASK_NAME);
+  const next = [...tasks];
+  if (index >= 0)
+    next[index] = { ...tasks[index], ...REVIEW_TASK };
+  else
+    next.push(REVIEW_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 alreadyBound = entries.some((entry) => Object.values(entry.bindings ?? {}).some((action) => Array.isArray(action) && action[0] === "task::Spawn" && bindsReviewTask(action[1])));
+  if (alreadyBound)
+    return { path, changed: false, existed: currentText !== undefined };
+  const next = [
+    ...entries,
+    { context: "Workspace", bindings: { [REVIEW_KEYBINDING]: ["task::Spawn", { task_name: ZED_REVIEW_TASK_NAME }] } }
+  ];
+  await writeJson(path, next);
+  return { path, changed: true, existed: currentText !== undefined };
+}
+function bindsReviewTask(payload) {
+  return typeof payload === "object" && payload !== null && payload.task_name === ZED_REVIEW_TASK_NAME;
+}
+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 {
+      await ensureZedReviewTask(opts.homeDir);
+      return {
+        launched: false,
+        configured: true,
+        via: "zed-task",
+        command: printable,
+        taskName: ZED_REVIEW_TASK_NAME,
+        instruction: `Run the Zed task "${ZED_REVIEW_TASK_NAME}".`
+      };
+    } catch {}
+  }
+  return { launched: false, via: "print", command: printable };
+}
+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;
+}
+function screenWindowArgs(command, cwd, name) {
+  return ["-X", "screen", "-t", name, "sh", "-lc", 'cd -- "$1" && shift && exec "$@"', "sh", cwd, ...command];
+}
+
+// src/forge.ts
+function createForge(vcs) {
+  if (vcs.provider === "github")
+    return new GithubForge(vcs);
+  if (vcs.provider === "gitlab")
+    return new GitlabForge(vcs);
+  throw new Error("No forge detected from the git remote. Use --local for an offline review.");
+}
+
+class GithubForge {
+  vcs;
+  provider = "github";
+  constructor(vcs) {
+    this.vcs = vcs;
+  }
+  repoFlag() {
+    return ["--repo", `${this.vcs.owner}/${this.vcs.repo}`];
+  }
+  async createDraftPr(options) {
+    const args = [
+      "pr",
+      "create",
+      ...this.repoFlag(),
+      "--title",
+      options.title,
+      "--body",
+      options.body,
+      "--base",
+      options.base,
+      "--head",
+      options.head
+    ];
+    if (options.draft !== false)
+      args.push("--draft");
+    await runChecked("gh", args);
+    const ref = await this.viewPr(options.head);
+    if (!ref)
+      throw new Error("Draft PR created but could not be resolved.");
+    return ref;
+  }
+  async viewPr(idOrBranch) {
+    const args = [
+      "pr",
+      "view",
+      idOrBranch,
+      ...this.repoFlag(),
+      "--json",
+      "number,title,url,isDraft,baseRefName,headRefName,headRefOid"
+    ];
+    const result = await run("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.");
+    let data;
+    try {
+      data = JSON.parse(result.stdout);
+    } catch {
+      throw new Error("Cannot parse the GitHub pull request response as JSON.");
+    }
+    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
+    };
+  }
+  async defaultBranch() {
+    const result = await runChecked("gh", [
+      "repo",
+      "view",
+      `${this.vcs.owner}/${this.vcs.repo}`,
+      "--json",
+      "defaultBranchRef",
+      "--jq",
+      ".defaultBranchRef.name"
+    ]);
+    return requireBranchName(result.stdout, "GitHub");
+  }
+  async prDiff(id) {
+    const result = await runChecked("gh", ["pr", "diff", String(id), ...this.repoFlag()], { capture: "unbounded" });
+    return result.stdout;
+  }
+  async prChecks(id) {
+    const result = await run("gh", ["pr", "checks", String(id), ...this.repoFlag()]);
+    return result.stdout;
+  }
+  async markReady(id) {
+    await runChecked("gh", ["pr", "ready", String(id), ...this.repoFlag()]);
+  }
+  async closePr(id, comment) {
+    const args = ["pr", "close", String(id), ...this.repoFlag()];
+    if (comment)
+      args.push("--comment", comment);
+    await runChecked("gh", args);
+  }
+  async mergePr(id, subject) {
+    const readiness = await runChecked("gh", [
+      "pr",
+      "view",
+      String(id),
+      ...this.repoFlag(),
+      "--json",
+      "isDraft,state,reviewDecision,mergeStateStatus,statusCheckRollup"
+    ]);
+    assertGitHubMergeReady(readiness.stdout);
+    await runChecked("gh", ["pr", "merge", String(id), ...this.repoFlag(), "--squash", "--subject", subject]);
+  }
+}
+
+class GitlabForge {
+  vcs;
+  provider = "gitlab";
+  constructor(vcs) {
+    this.vcs = vcs;
+  }
+  project() {
+    return `${this.vcs.owner}/${this.vcs.repo}`;
+  }
+  async createDraftPr(options) {
+    await runChecked("glab", [
+      "mr",
+      "create",
+      "--repo",
+      this.project(),
+      "--title",
+      `Draft: ${options.title}`,
+      "--description",
+      options.body,
+      "--target-branch",
+      options.base,
+      "--source-branch",
+      options.head,
+      "--yes"
+    ]);
+    const ref = await this.viewPr(options.head);
+    if (!ref)
+      throw new Error("Draft MR created but could not be resolved.");
+    return ref;
+  }
+  async viewPr(idOrBranch) {
+    const args = ["mr", "view", idOrBranch, "--repo", this.project(), "--output", "json"];
+    const result = await run("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.");
+    let data;
+    try {
+      data = JSON.parse(result.stdout);
+    } catch {
+      throw new Error("Cannot parse the GitLab merge request response as JSON.");
+    }
+    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
+    };
+  }
+  async defaultBranch() {
+    const result = await runChecked("glab", [
+      "api",
+      `projects/${encodeURIComponent(this.project())}`,
+      "--jq",
+      ".default_branch"
+    ]);
+    return requireBranchName(result.stdout, "GitLab");
+  }
+  async prDiff(id) {
+    return (await runChecked("glab", ["mr", "diff", String(id), "--repo", this.project()], { capture: "unbounded" })).stdout;
+  }
+  async prChecks(id) {
+    return (await runChecked("glab", [
+      "api",
+      `projects/${encodeURIComponent(this.project())}/merge_requests/${id}/pipelines?per_page=100`
+    ])).stdout;
+  }
+  async markReady(id) {
+    await runChecked("glab", ["mr", "update", String(id), "--repo", this.project(), "--ready"]);
+  }
+  async closePr(id, comment) {
+    if (comment)
+      await runChecked("glab", ["mr", "note", String(id), "--repo", this.project(), "--message", comment]);
+    await runChecked("glab", ["mr", "close", String(id), "--repo", this.project()]);
+  }
+  async mergePr() {
+    throw new Error("Merge is not supported by the GitLab forge adapter.");
+  }
+}
+function assertGitHubMergeReady(input) {
+  let data;
+  try {
+    data = JSON.parse(input);
+  } catch {
+    throw new Error("Merge blocked: GitHub readiness response was not valid JSON.");
+  }
+  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("; ")}.`);
+}
+function isConfirmedMissingChange(provider, output) {
+  const message = output.toLowerCase();
+  if (provider === "github") {
+    return message.includes("no pull requests found for branch") || message.includes("could not find pull request") || message.includes("could not resolve to a pullrequest");
+  }
+  if (provider === "gitlab") {
+    return message.includes("no open merge request") || /failed to get open merge request/.test(message) && /404(?: not found)?/.test(message);
+  }
+  return false;
+}
+function commandFailure(command, args, result) {
+  const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+  return new Error(`${command} ${args.join(" ")} failed: ${detail}`);
+}
+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/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 run("mise", ["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" };
+}
+async function discoverMiseTasks(cwd) {
+  const result = await run("mise", ["tasks", "--json", "--all"], { cwd });
+  if (result.code !== 0)
+    return new Map;
+  return parseMiseTasks(result.stdout);
+}
+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;
+}
+
+// src/review-backend.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+
+// src/review.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);
+var reviewThreadRecordSchema = z3.object({
+  id: z3.string().min(1),
+  file: z3.string().optional(),
+  line: z3.number().int().positive().optional(),
+  body: z3.string(),
+  author: z3.string().optional(),
+  resolved: z3.boolean(),
+  question: z3.boolean(),
+  replies: z3.array(z3.string()).optional()
+});
+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) || "local"}`;
+}
+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 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,
+    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}`, "", thread.body, "", "---", "");
+  }
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+function parseThreadArtifact(content) {
+  const payload = content.match(/^<!-- diffpi-threads:([A-Za-z0-9_-]+) -->$/m)?.[1];
+  if (!payload)
+    throw new Error("This file is not a Diffpi thread artifact.");
+  let threads;
+  try {
+    const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    threads = z3.array(reviewThreadRecordSchema).parse(decoded);
+  } catch {
+    throw new Error("Cannot parse the Diffpi thread artifact payload.");
+  }
+  const replies = content.split(/^## Source comments$/m, 1)[0] ?? "";
+  return threads.map((thread) => {
+    const id = Buffer.from(thread.id, "utf8").toString("base64url");
+    const startMarker = `<!-- diffpi-reply-start:${id} -->
+`;
+    const endMarker = `
+<!-- diffpi-reply-end:${id} -->`;
+    const start = replies.indexOf(startMarker);
+    const end = start < 0 ? -1 : replies.indexOf(endMarker, start + startMarker.length);
+    const reply = start >= 0 && end >= 0 ? replies.slice(start + startMarker.length, end).trim() : "";
+    return reply ? { ...thread, reply } : thread;
+  });
+}
+function upsertThreadReply(content, threadId, body, question) {
+  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;
+  if (question !== undefined)
+    thread.question = question;
+  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]
+  });
+}
+function renderCommentBody(finding) {
+  const prefix = finding.severity === "BLOCKING" ? "**BLOCKING** " : "";
+  const reference = finding.reference ? `
+
+> **Reference:** ${finding.reference}` : "";
+  return `${prefix}${finding.body}${reference}`;
+}
+
+// src/tuicr.ts
+import { readFile as readFile2, realpath as realpath2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+
+// src/store.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir as mkdir2, readlink, realpath, symlink, unlink } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, isAbsolute, join as join3, resolve } from "node:path";
+var STORE_LINK = ".diffpi";
+var LEGACY_STORE_LINK = join3(".pi", "diffpi");
+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 computeProjectSlug(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();
+  let commonPath = root;
+  if (commonResult.code === 0 && common) {
+    const resolvedCommon = isAbsolute(common) ? common : join3(root, common);
+    commonPath = resolve(resolvedCommon);
+  }
+  const canonicalCommon = await canonicalPath(commonPath);
+  const identity = remote ? `remote:${normalizeRemote(remote)}` : `git-common-dir:${canonicalCommon}`;
+  const name = remote ? repositoryName(remote) : basename2(resolve(canonicalCommon, "..")) || basename2(root);
+  const readable = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed";
+  const digest = createHash("sha256").update(identity).digest("hex").slice(0, 12);
+  return `${readable}-${digest}`;
+}
+function storeGlobalRoot(homeDir = homedir2()) {
+  return join3(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir2()) {
+  const root = await gitToplevel(cwd);
+  const slug = await computeProjectSlug(root);
+  const dest = join3(storeGlobalRoot(homeDir), slug);
+  const link = join3(root, STORE_LINK);
+  await mkdir2(dest, { recursive: true });
+  try {
+    await assertStoreLink(link, dest);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    await symlink(dest, link);
+  }
+  await removeLegacyStoreLink(join3(root, LEGACY_STORE_LINK), dest);
+  return { slug, root, dest, link, linked: true };
+}
+async function reviewsDir(cwd, homeDir = homedir2()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join3(store.link, "reviews");
+  await mkdir2(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir2()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join3(store.link, "sessions");
+  await mkdir2(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 canonicalPath(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 canonicalPath(dest))
+      await unlink(path);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+}
+async function symlinkTarget(path) {
+  const target = await readlink(path);
+  return canonicalPath(isAbsolute(target) ? target : resolve(dirname2(path), target));
+}
+async function canonicalPath(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return resolve(path);
+  }
+}
+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) ?? "";
+}
+function basename2(path) {
+  const parts = resolve(path).split(/[/\\]/).filter(Boolean);
+  return parts.at(-1) ?? "";
+}
+
+// src/tuicr.ts
+async function listSessions(repo = ".") {
+  const result = await run("tuicr", ["review", "list", "--repo", repo]);
+  if (result.code !== 0 || !result.stdout.trim())
+    return [];
+  let raw;
+  try {
+    raw = JSON.parse(result.stdout);
+  } catch {
+    return [];
+  }
+  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
+  }));
+}
+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 readFile2(path, "utf8");
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Cannot parse tuicr session JSON: ${path}`);
+  }
+}
+async function addComment(session, body, opts = {}) {
+  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) {
+  const command = pr === undefined ? ["tuicr", "-w"] : ["tuicr", "pr", String(pr)];
+  return openInNewTab(command, { cwd, name: "tuicr" });
+}
+function toFindings(session, options = {}) {
+  const comments = [];
+  const include = (comment) => !options.agentOnly || commentAuthor(comment)?.startsWith("Agent: ");
+  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(`
+
+`)
+  };
+}
+function commentAuthor(comment) {
+  return comment.username ?? comment.author;
+}
+async function canonicalPath2(path) {
+  try {
+    return await realpath2(path);
+  } catch {
+    return resolve2(path);
+  }
+}
+
+// src/review-backend.ts
+function createRemoteReviewBackend(vcs, number) {
+  if (vcs.provider === "github")
+    return new GithubReviewBackend(vcs, number);
+  if (vcs.provider === "gitlab")
+    return new GitlabReviewBackend(vcs, number);
+  throw new Error("A remote review backend requires a GitHub or GitLab repository.");
+}
+function createLocalReviewBackend(options) {
+  return new LocalReviewBackend(options);
+}
+
+class LocalReviewBackend {
+  options;
+  kind = "local";
+  constructor(options) {
+    this.options = options;
+  }
+  async stage(draft) {
+    for (const comment of draft.comments) {
+      await addComment(this.options.session, comment.body, {
+        targetFile: comment.file,
+        line: comment.line,
+        side: comment.side === "LEFT" ? "old" : "new",
+        username: this.options.author
+      });
+    }
+    if (draft.body.trim()) {
+      await addComment(this.options.session, draft.body, { username: this.options.author });
+    }
+  }
+  async readDraft() {
+    return toFindings(await readSession(this.options.session), { agentOnly: true });
+  }
+  async listThreads() {
+    try {
+      return parseThreadArtifact(await readFile3(this.options.artifactPath, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return [];
+      throw error;
+    }
+  }
+  async reply(input) {
+    const content = await readFile3(this.options.artifactPath, "utf8");
+    await writeFile2(this.options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question), "utf8");
+  }
+  async publish() {
+    throw new Error("Promote a local draft through a remote review backend before publishing it.");
+  }
+}
+
+class GithubReviewBackend {
+  vcs;
+  number;
+  kind = "remote";
+  constructor(vcs, number) {
+    this.vcs = vcs;
+    this.number = number;
+  }
+  async stage(draft) {
+    const pending = await this.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 runChecked("gh", [
+        "api",
+        "--method",
+        "POST",
+        `/repos/${this.vcs.owner}/${this.vcs.repo}/pulls/${this.number}/reviews`,
+        "--input",
+        "-"
+      ], { input: JSON.stringify(payload) });
+      return;
+    }
+    if (draft.body.trim()) {
+      await runChecked("gh", [
+        "api",
+        "--method",
+        "PUT",
+        `/repos/${this.vcs.owner}/${this.vcs.repo}/pulls/${this.number}/reviews/${pending.id}`,
+        "-f",
+        `body=${draft.body}`
+      ]);
+    }
+    for (const comment of draft.comments) {
+      await runChecked("gh", [
+        "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 this.pendingReview();
+    if (!pending)
+      return { comments: [], body: "" };
+    const review = await runChecked("gh", [
+      "api",
+      `/repos/${this.vcs.owner}/${this.vcs.repo}/pulls/${this.number}/reviews/${pending.id}`
+    ]);
+    const comments = await runChecked("gh", [
+      "api",
+      `/repos/${this.vcs.owner}/${this.vcs.repo}/pulls/${this.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
+      }))
+    };
+  }
+  async listThreads() {
+    const threads = [];
+    let cursor;
+    do {
+      const args = [
+        "api",
+        "graphql",
+        "-f",
+        `query=${GITHUB_THREADS_QUERY}`,
+        "-f",
+        `owner=${this.vcs.owner}`,
+        "-f",
+        `repo=${this.vcs.repo}`,
+        "-F",
+        `number=${this.number}`
+      ];
+      if (cursor)
+        args.push("-f", `after=${cursor}`);
+      const result = await runChecked("gh", 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)
+      };
+    });
+  }
+  async reply(input) {
+    const threads = await this.listThreads();
+    const existing = threads.find((thread) => thread.id === input.threadId);
+    if (!existing?.replies?.includes(input.body)) {
+      await runChecked("gh", [
+        "api",
+        "graphql",
+        "-f",
+        `query=${GITHUB_REPLY_MUTATION}`,
+        "-f",
+        `threadId=${input.threadId}`,
+        "-f",
+        `body=${input.body}`
+      ]);
+    }
+    if (input.resolve) {
+      await runChecked("gh", [
+        "api",
+        "graphql",
+        "-f",
+        `query=${GITHUB_RESOLVE_MUTATION}`,
+        "-f",
+        `threadId=${input.threadId}`
+      ]);
+    }
+  }
+  async publish(event) {
+    const pending = await this.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(this.vcs.owner, this.vcs.repo, this.number, pending?.id ?? "");
+    await runChecked("gh", ["api", "--method", "POST", endpoint, "-f", `event=${event}`]);
+  }
+  async pendingReview() {
+    const result = await runChecked("gh", [
+      "api",
+      `/repos/${this.vcs.owner}/${this.vcs.repo}/pulls/${this.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 };
+  }
+}
+
+class GitlabReviewBackend {
+  vcs;
+  number;
+  kind = "remote";
+  constructor(vcs, number) {
+    this.vcs = vcs;
+    this.number = number;
+  }
+  async stage(draft) {
+    const endpoint = `${this.mergeRequestEndpoint()}/draft_notes`;
+    if (draft.body.trim()) {
+      await runChecked("glab", ["api", "--method", "POST", endpoint, "--input", "-"], {
+        input: JSON.stringify({ note: draft.body })
+      });
+    }
+    if (draft.comments.length === 0)
+      return;
+    const response = await runChecked("glab", ["api", this.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 runChecked("glab", ["api", "--method", "POST", endpoint, "--input", "-"], {
+        input: JSON.stringify(payload)
+      });
+    }
+  }
+  async readDraft() {
+    const result = await runChecked("glab", ["api", `${this.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(`
+
+`) };
+  }
+  async listThreads() {
+    const discussions = [];
+    for (let page = 1;; page += 1) {
+      const result = await runChecked("glab", [
+        "api",
+        `${this.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)
+      };
+    });
+  }
+  async reply(input) {
+    const endpoint = `${this.mergeRequestEndpoint()}/discussions/${encodeURIComponent(input.threadId)}`;
+    const threads = await this.listThreads();
+    const existing = threads.find((thread) => thread.id === input.threadId);
+    if (!existing?.replies?.includes(input.body)) {
+      await runChecked("glab", ["api", "--method", "POST", `${endpoint}/notes`, "--input", "-"], {
+        input: JSON.stringify({ body: input.body })
+      });
+    }
+    if (input.resolve)
+      await runChecked("glab", ["api", "--method", "PUT", `${endpoint}?resolved=true`]);
+  }
+  async publish(event) {
+    assertReviewEventSupported(this.vcs.provider, event);
+    const drafts = await runChecked("glab", ["api", `${this.mergeRequestEndpoint()}/draft_notes`]);
+    if (hasGitlabDraftNotes(drafts.stdout)) {
+      await runChecked("glab", ["api", "--method", "POST", `${this.mergeRequestEndpoint()}/draft_notes/bulk_publish`]);
+    }
+    if (event === "APPROVE") {
+      await runChecked("glab", ["mr", "approve", String(this.number), "--repo", this.project()]);
+    }
+  }
+  project() {
+    return `${this.vcs.owner}/${this.vcs.repo}`;
+  }
+  mergeRequestEndpoint() {
+    return `projects/${encodeURIComponent(this.project())}/merge_requests/${this.number}`;
+  }
+}
+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 githubReviewSubmissionEndpoint(owner, repo, id, pendingReviewId) {
+  return pendingReviewId ? `/repos/${owner}/${repo}/pulls/${id}/reviews/${pendingReviewId}/events` : `/repos/${owner}/${repo}/pulls/${id}/reviews`;
+}
+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.");
+  }
+}
+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-publication.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile4, rename, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { z as z4 } from "zod";
+var reviewPublicationStateSchema = z4.object({
+  target: z4.string().optional(),
+  comments: z4.array(z4.string()).default([]),
+  replies: z4.array(z4.string()).default([]),
+  overlayPath: z4.string().optional()
+});
+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 = join4(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  try {
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile4(path, "utf8")));
+    return { path, state: { ...parsed, target } };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { path, state: { target, comments: [], replies: [] } };
+    }
+    if (error instanceof SyntaxError || error instanceof z4.ZodError) {
+      throw new Error(`Cannot parse review publication state: ${path}`);
+    }
+    throw error;
+  }
+}
+async function saveReviewPublicationState(path, state) {
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile3(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 readFile5 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join6, normalize } from "node:path";
+
+// src/assets.ts
+import { existsSync } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
+  const moduleDir = dirname3(fileURLToPath(moduleUrl));
+  const candidates = [join5(moduleDir, name), join5(moduleDir, "..", name), join5(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 = join6(options.homeDir ?? homedir3(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join6(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 readFile5(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+
+// src/tools/review.ts
+var contextSchema = z5.object({
+  cwd: z5.string().optional(),
+  target: z5.string().optional(),
+  workingTree: z5.boolean().optional()
+});
+var localSchema = contextSchema.extend({ local: z5.boolean().optional() });
+var openSchema = localSchema.extend({
+  title: z5.string().optional(),
+  intent: z5.string().optional(),
+  base: z5.string().optional()
+});
+var submitSchema = localSchema.extend({
+  findings: findingsSchema,
+  overallIssues: z5.array(z5.string()).optional(),
+  notVerified: z5.array(z5.string()).optional(),
+  title: z5.string().optional()
+});
+var addCommentSchema = localSchema.extend({
+  body: z5.string().min(1),
+  file: z5.string().min(1),
+  line: z5.number().int().positive(),
+  side: z5.enum(["LEFT", "RIGHT"]).optional()
+});
+var respondSchema = localSchema.extend({
+  threadId: z5.string().min(1),
+  body: z5.string().min(1),
+  question: z5.boolean().optional(),
+  resolve: z5.boolean().optional()
+});
+var publishSchema = localSchema.extend({
+  status: z5.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
+});
+function parameters(schema) {
+  return z5.toJSONSchema(schema, { io: "input" });
+}
+function cwdOf(params) {
+  return params.cwd ?? process.cwd();
+}
+function result(text, details = {}) {
+  return { content: [{ type: "text", text }], details };
+}
+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}`;
+}
+function conventionalMergeGuard(subject) {
+  return checkConventionalSubject(subject);
+}
+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(cwdOf(params), params.target);
+        const store = await ensureStore(review.cwd);
+        const env = { ide: detectIde(), mux: detectMux(), shell: detectShell() };
+        const session = await resolveTuicrSession(review, params.workingTree);
+        const baseRef = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "local");
+        const backend = params.local ? "tuicr" : review.forge ? review.vcs.provider : "tuicr";
+        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_open",
+      label: "review open",
+      description: "Create a draft PR/MR from the template registry, or launch a local tuicr target.",
+      promptSnippet: "Call review_open 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(cwdOf(params), params.target);
+        await ensureStore(review.cwd);
+        if (params.local || !review.forge)
+          return launchLocalReview(review, params.workingTree);
+        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. -->",
+          head: review.vcs.branch,
+          base
+        });
+        const pr = await review.forge.createDraftPr({
+          title: params.title ?? deriveTitle(review.vcs.branch),
+          body,
+          base,
+          head: review.vcs.branch
+        });
+        return result(`Draft PR/MR created from ${template.source} template: ${pr.url}`, { pr, template });
+      }
+    }),
+    defineTool3({
+      name: "review_edit",
+      label: "review edit",
+      description: "Switch to the requested PR branch when necessary and open its existing tuicr session without generating comments.",
+      promptSnippet: "Call review_edit for the local-only edit workflow",
+      promptGuidelines: ["This tool never generates review findings."],
+      parameters: parameters(contextSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = contextSchema.parse(input);
+        let review = await resolveReviewContext(cwdOf(params), params.target);
+        if (review.pr && review.pr.headRef !== review.vcs.branch) {
+          await switchBranch(review.cwd, review.pr.headRef);
+          review = await resolveReviewContext(review.cwd, params.target);
+        }
+        await ensureStore(review.cwd);
+        return launchLocalReview(review, params.workingTree);
+      }
+    }),
+    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(cwdOf(params), params.target);
+        if (params.workingTree || !review.pr && (params.local || !review.forge)) {
+          const diff = await workingTreeDiff(review.cwd);
+          return result(diff || "No working-tree changes.", { diff, target: "local" });
+        }
+        if (!review.pr || !review.forge)
+          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(cwdOf(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(cwdOf(params), params.target);
+        const model = modelRoute(ctx);
+        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.workingTree || !review.pr ? "local" : await reviewTargetId(review));
+        await writeFile4(artifact, renderReviewDoc({
+          title: params.title ?? review.pr?.title ?? review.vcs.branch,
+          number: review.pr?.number,
+          url: review.pr?.url,
+          model,
+          headRef: review.vcs.branch,
+          baseRef,
+          findings,
+          overallIssues: params.overallIssues ?? [],
+          gates,
+          notVerified: params.notVerified ?? []
+        }), "utf8");
+        const useLocalBackend = Boolean(params.local || !review.forge);
+        const comments = toReviewComments(findings, useLocalBackend ? undefined : model);
+        if (useLocalBackend) {
+          const session = await resolveTuicrSession(review, 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: (params.overallIssues ?? []).join(`
+`) });
+          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 });
+        if (comments.length > 0) {
+          await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments, body: "" });
+        }
+        return result(`${comments.length > 0 ? "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(cwdOf(params), params.target);
+        const model = modelRoute(ctx);
+        const useLocalBackend = Boolean(params.local || !review.forge);
+        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, params.workingTree);
+          if (!session)
+            return result("No matching tuicr session. Open review_edit or review_launch 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(cwdOf(params), params.target);
+        let threads;
+        if (!params.workingTree && review.pr && review.forge) {
+          threads = await createRemoteReviewBackend(review.vcs, review.pr.number).listThreads();
+        } else if (params.local || !review.forge) {
+          const session = await resolveTuicrSession(review, params.workingTree);
+          if (!session)
+            return result("No matching tuicr session found.");
+          const draft = toFindings(await readSession(session.path));
+          threads = draft.comments.map((comment, index) => ({
+            id: `local-${index + 1}`,
+            file: comment.file,
+            line: comment.line,
+            body: comment.body,
+            resolved: false,
+            question: /\?\s*$/.test(comment.body.trim())
+          }));
+        } else {
+          return result("No PR/MR matches this remote review target.");
+        }
+        const target = params.workingTree ? "local" : await reviewTargetId(review);
+        const artifact = await newReviewArtifactPath(review.cwd, target);
+        await writeFile4(artifact, renderThreadArtifact(review.pr?.title ?? review.vcs.branch, target, threads, {
+          number: params.workingTree ? undefined : review.pr?.number,
+          url: params.workingTree ? undefined : review.pr?.url
+        }), "utf8");
+        if (params.local && !params.workingTree && review.pr && review.forge) {
+          const publication = await loadReviewPublicationState(review.cwd, review.vcs, review.pr.number);
+          publication.state.overlayPath = artifact;
+          await saveReviewPublicationState(publication.path, publication.state);
+        }
+        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: "Record a local overlay reply or post a provenance-marked remote thread reply.",
+      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(cwdOf(params), params.target);
+        const model = modelRoute(ctx);
+        if (params.local) {
+          const target = params.workingTree ? "local" : await reviewTargetId(review);
+          const publication = !params.workingTree && review.pr && review.forge ? await loadReviewPublicationState(review.cwd, review.vcs, review.pr.number) : undefined;
+          const artifact = publication?.state.overlayPath ?? await latestThreadArtifact(review.cwd, review, target);
+          if (!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 tuicrSession = await resolveTuicrSession(review, params.workingTree);
+          const session = tuicrSession?.path ?? "";
+          await createLocalReviewBackend({ session, artifactPath: artifact, author: localReviewAuthor(model) }).reply({
+            threadId: params.threadId,
+            body: withRemoteProvenance(params.body, model),
+            resolve: false,
+            question
+          });
+          return result(`Local reply recorded in ${artifact}.`, { artifact, question });
+        }
+        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: "Promote local drafts when needed, publish pending review work, and apply the selected public status.",
+      promptSnippet: "Call review_publish to make 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(cwdOf(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_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: z5.string().optional() })),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = contextSchema.extend({ subject: z5.string().optional() }).parse(input);
+        const review = await resolveReviewContext(cwdOf(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 = conventionalMergeGuard(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",
+      label: "review launch",
+      description: "Open the auto-detected tuicr target in a mux tab, configure Zed, or print the command.",
+      promptSnippet: "Call review_launch for the interactive tuicr TUI",
+      promptGuidelines: ["Show the returned command when launch cannot open a tab."],
+      parameters: parameters(contextSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = contextSchema.parse(input);
+        const review = await resolveReviewContext(cwdOf(params), params.target);
+        return launchLocalReview(review, params.workingTree);
+      }
+    })
+  ];
+}
+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, Boolean(params.workingTree)) : undefined;
+  if (status !== "CLOSE" && review.pr.isDraft)
+    await review.forge.markReady(review.pr.number);
+  await remote.publish(event);
+  if (promotion) {
+    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 promotedComments = promotion?.promotedComments ?? 0;
+  const promotedReplies = promotion?.promotedReplies ?? 0;
+  return result(`Published #${review.pr.number} (${status}); promoted ${promotedComments} comments and ${promotedReplies} replies.`, { pr: finalPr ?? review.pr, status, 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 commentFingerprints = comments.map(reviewCommentFingerprint);
+  const remoteDraft = await remote.readDraft();
+  const known = new Set([...publication.state.comments, ...remoteDraft.comments.map(reviewCommentFingerprint)]);
+  const unpublished = unpublishedReviewComments(comments, known);
+  if (unpublished.length > 0)
+    await remote.stage({ comments: unpublished, body: "" });
+  const promotedReplies = await promoteLocalReplies(review, remote, publication, model, workingTree);
+  return {
+    publication,
+    commentFingerprints,
+    promotedComments: unpublished.length,
+    promotedReplies
+  };
+}
+async function promoteLocalReplies(review, remote, publication, model, workingTree) {
+  const target = workingTree ? "local" : 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 : createForge(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) {
+  const launched = await launch(review.cwd, workingTree ? undefined : review.pr?.number);
+  const commandTarget = workingTree || !review.pr ? "working tree" : `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 switchBranch(cwd, branch) {
+  const dirty = await runChecked("git", ["-C", cwd, "status", "--porcelain"]);
+  if (dirty.stdout.trim())
+    throw new Error(`Cannot switch to ${branch}: the current worktree has uncommitted changes.`);
+  await runChecked("git", ["-C", cwd, "fetch", "origin", branch]);
+  const local = await run("git", ["-C", cwd, "show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+  if (local.code === 0)
+    await runChecked("git", ["-C", cwd, "switch", branch]);
+  else
+    await runChecked("git", ["-C", cwd, "switch", "--track", "-c", branch, `origin/${branch}`]);
+}
+async function reviewTargetId(review) {
+  if (!review.pr)
+    return "local";
+  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 mkdir3(dir, { recursive: true });
+  return uniqueRecordPath(dir, reviewRecordName(target));
+}
+async function readThreadArtifact(path) {
+  try {
+    return parseThreadArtifact(await readFile6(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) || "local";
+  const names = await listReviewArtifactNames(dir);
+  const candidates = await Promise.all(names.flatMap((name) => {
+    if (!name.endsWith(".md"))
+      return [];
+    return [
+      (async () => {
+        const path = join7(dir, name);
+        const info = await stat(path);
+        return { path, name, content: await readFile6(path, "utf8"), modified: info.mtimeMs };
+      })()
+    ];
+  }));
+  return candidates.filter(({ name, content }) => {
+    if (!content.startsWith("<!-- diffpi-threads:"))
+      return false;
+    if (review.pr && target !== "local")
+      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 = join7(dir, `${base}.md`);
+  let count = 2;
+  while (existsSync2(path))
+    path = join7(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 defineTool2 } from "@earendil-works/pi-coding-agent";
-import { z as z2 } from "zod";
+import { defineTool as defineTool4 } from "@earendil-works/pi-coding-agent";
+import { z as z7 } from "zod";
 
 // src/setup.ts
+import { parseFrontmatter as parseFrontmatter2 } from "@earendil-works/pi-coding-agent";
+import { readdir as readdir3, readFile as readFile10 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { basename as basename4, join as join12 } from "node:path";
+
+// src/config.ts
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { z as z6 } from "zod";
 import { homedir as homedir4 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join8 } from "node:path";
+
+// src/fsx.ts
+import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
+async function readTextIfExists(path) {
+  try {
+    return await readFile7(path, "utf8");
+  } catch (error) {
+    if (isMissingPath(error))
+      return;
+    throw error;
+  }
+}
+function isMissingPath(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/config.ts
+var modelReferenceSchema = z6.string().trim().min(1);
+var agentConfigSchema = z6.object({
+  models: z6.array(modelReferenceSchema).optional()
+}).strict();
+var diffpiConfigSchema = z6.object({
+  agents: z6.record(z6.string(), agentConfigSchema).optional()
+}).strict();
+function diffpiConfigPaths(homeDir = homedir4()) {
+  const directory = join8(homeDir, ".difflab", "diffpi");
+  return {
+    yaml: join8(directory, "config.yaml"),
+    json: join8(directory, "config.json")
+  };
+}
+async function loadDiffpiConfig(options = {}) {
+  const paths = diffpiConfigPaths(options.homeDir);
+  for (const [format, path] of [
+    ["yaml", paths.yaml],
+    ["json", paths.json]
+  ]) {
+    const content = await readTextIfExists(path);
+    if (content === undefined)
+      continue;
+    try {
+      const value = format === "yaml" ? parseYamlConfig(content) : JSON.parse(content);
+      return { config: diffpiConfigSchema.parse(value ?? {}), path };
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(`Invalid Diffpi config at ${path}: ${reason}`, { cause: error });
+    }
+  }
+  return { config: {} };
+}
+function resolveAgentModelPreferences(agentId, profilePreferences, config) {
+  const override = config.agents?.[agentId];
+  if (override && Object.hasOwn(override, "models"))
+    return [...override.models ?? []];
+  return [...profilePreferences];
+}
+function findPreferredModel(models, preference) {
+  const normalizedPreference = normalizeModelReference(preference);
+  const exactReference = models.find((model) => normalizeModelReference(`${model.provider}/${model.id}`) === normalizedPreference);
+  if (exactReference)
+    return exactReference;
+  const idPreference = preference.includes("/") ? preference.slice(preference.indexOf("/") + 1) : preference;
+  const normalizedIdPreference = normalizeModelReference(idPreference);
+  const exactId = models.find((model) => normalizeModelReference(model.id) === normalizedIdPreference);
+  if (exactId)
+    return exactId;
+  const preferenceTokens = normalizedIdPreference.split("-").filter(Boolean);
+  return models.find((model) => {
+    const modelTokens = new Set(normalizeModelReference(model.id).split("-").filter(Boolean));
+    return preferenceTokens.every((token) => modelTokens.has(token));
+  });
+}
+function parseYamlConfig(content) {
+  const document = content.replace(/^\uFEFF/, "").replace(/^---[^\S\r\n]*(?:#.*)?(?:\r?\n|$)/, "");
+  return parseFrontmatter(`---
+${document}
+---
+`).frontmatter;
+}
+function normalizeModelReference(value) {
+  return value.toLowerCase().replace(/^~/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
 
 // src/mcp.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { mkdir as mkdir4, readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname4, join as join9 } from "node:path";
 var mcp = {
-  globalConfigPath(homeDir = homedir()) {
-    return join(homeDir, ".config", "mcp", "mcp.json");
+  globalConfigPath(homeDir = homedir5()) {
+    return join9(homeDir, ".config", "mcp", "mcp.json");
   },
   async serversEnsure(servers, options = {}) {
     const path = options.path ?? mcp.globalConfigPath();
@@ -52,8 +2417,8 @@ var mcp = {
     const next = { ...current, mcpServers: nextServers };
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
-      await mkdir(dirname(path), { recursive: true });
-      await writeFile(path, `${JSON.stringify(next, null, 2)}
+      await mkdir4(dirname4(path), { recursive: true });
+      await writeFile5(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -82,7 +2447,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile(path) {
   try {
-    return await readFile(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -94,68 +2459,9 @@ function isRecord(value) {
 }
 
 // src/mise.ts
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { basename, dirname as dirname2, join as join3 } from "node:path";
-
-// src/process.ts
-import { constants } from "node:fs";
-import { access } from "node:fs/promises";
-import { delimiter, join as join2 } 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 = join2(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
+import { mkdir as mkdir5, readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { basename as basename3, dirname as dirname5, join as join10 } from "node:path";
 var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
 var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
 var mise = {
@@ -163,11 +2469,11 @@ var mise = {
     return findExecutable(name);
   },
   async install(options = {}) {
-    const homeDir = options.homeDir ?? homedir2();
+    const homeDir = options.homeDir ?? homedir6();
     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");
+    const installedPath = join10(homeDir, ".local", "bin", "mise");
     if (options.dryRun)
       return installedPath;
     await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
@@ -177,8 +2483,8 @@ var mise = {
     return executable;
   },
   async hookEnsure(executable, options = {}) {
-    const homeDir = options.homeDir ?? homedir2();
-    const hook = getShellHook(basename(options.shell ?? process.env.SHELL ?? ""), executable, homeDir);
+    const homeDir = options.homeDir ?? homedir6();
+    const hook = getShellHook(basename3(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 };
@@ -187,8 +2493,8 @@ var mise = {
     const separator = current.length === 0 || current.endsWith(`
 `) ? "" : `
 `;
-    await mkdir2(dirname2(hook.path), { recursive: true });
-    await writeFile2(hook.path, `${current}${separator}${hook.content}`, "utf8");
+    await mkdir5(dirname5(hook.path), { recursive: true });
+    await writeFile6(hook.path, `${current}${separator}${hook.content}`, "utf8");
     return { path: hook.path, changed: true, planned: false };
   },
   async toolCheckGlobal(executable, tool, minimumVersion) {
@@ -205,7 +2511,7 @@ var mise = {
   async toolInstallLocal(executable, specification, cwd = process.cwd()) {
     await runChecked(executable, ["use", "--path", cwd, specification], { cwd });
   },
-  async toolUpdateAllGlobal(executable, homeDir = homedir2()) {
+  async toolUpdateAllGlobal(executable, homeDir = homedir6()) {
     await runChecked(executable, ["upgrade"], { cwd: homeDir });
   }
 };
@@ -214,7 +2520,7 @@ function getShellHook(shell, executable, homeDir) {
   switch (shell.toLowerCase()) {
     case "zsh":
       return {
-        path: join3(homeDir, ".zshrc"),
+        path: join10(homeDir, ".zshrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate zsh)"
 ${MISE_HOOK_END}
@@ -222,7 +2528,7 @@ ${MISE_HOOK_END}
       };
     case "fish":
       return {
-        path: join3(homeDir, ".config", "fish", "config.fish"),
+        path: join10(homeDir, ".config", "fish", "config.fish"),
         content: `${MISE_HOOK_START}
 ${command} activate fish | source
 ${MISE_HOOK_END}
@@ -231,7 +2537,7 @@ ${MISE_HOOK_END}
     case "nu":
     case "nushell":
       return {
-        path: join3(homeDir, ".config", "nushell", "config.nu"),
+        path: join10(homeDir, ".config", "nushell", "config.nu"),
         content: `${MISE_HOOK_START}
 let mise_bin = ${command}
 let mise_path = $nu.default-config-dir | path join mise.nu
@@ -242,7 +2548,7 @@ ${MISE_HOOK_END}
       };
     case "xonsh":
       return {
-        path: join3(homeDir, ".xonshrc"),
+        path: join10(homeDir, ".xonshrc"),
         content: `${MISE_HOOK_START}
 execx($(${command} activate xonsh))
 ${MISE_HOOK_END}
@@ -250,7 +2556,7 @@ ${MISE_HOOK_END}
       };
     case "elvish":
       return {
-        path: join3(homeDir, ".config", "elvish", "rc.elv"),
+        path: join10(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 }
@@ -261,7 +2567,7 @@ ${MISE_HOOK_END}
     case "pwsh":
     case "powershell":
       return {
-        path: join3(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        path: join10(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
         content: `${MISE_HOOK_START}
 (& ${command} activate pwsh) | Out-String | Invoke-Expression
 ${MISE_HOOK_END}
@@ -270,7 +2576,7 @@ ${MISE_HOOK_END}
     case "bash":
     default:
       return {
-        path: join3(homeDir, ".bashrc"),
+        path: join10(homeDir, ".bashrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate bash)"
 ${MISE_HOOK_END}
@@ -309,7 +2615,7 @@ function isVersionAtLeast(version, minimumVersion) {
 }
 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 "";
@@ -321,79 +2627,86 @@ function getShellQuoted(value) {
 }
 
 // src/pi.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname3, join as join4 } 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 join11 } from "node:path";
 var pi = {
-  async executableCheck() {
-    return findExecutable("pi");
-  },
-  async packageList(executable) {
-    return (await runChecked(executable, ["list"])).stdout;
-  },
-  packageCheck(listOutput, source) {
-    if (listOutput.includes(source))
+  executableCheck: findPiExecutable,
+  packageList: listPiPackages,
+  packageCheck: hasPiPackage,
+  packageInstall: installPiPackage,
+  agentDir: resolvePiAgentDir,
+  agentEnsure: ensurePiAgent,
+  skillCheckGlobal: checkGlobalPiSkill,
+  skillInstallGlobal: installGlobalPiSkills,
+  configEnsure: ensurePiConfig
+};
+async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
+  const path = join11(agentDir, "agents", filename);
+  const currentText = await readTextIfExists(path);
+  const changed = currentText !== content;
+  if (changed && !dryRun) {
+    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 = join11(homedir7(), ".agents", "skills")) {
+  const roots = [join11(agentDir, "skills"), sharedSkillsDir];
+  for (const root of roots) {
+    if (await readTextIfExists(join11(root, name, "SKILL.md")) !== undefined)
       return true;
-    return source.startsWith("https://") && listOutput.includes(source.slice("https://".length));
-  },
-  async packageInstall(executable, source) {
-    await runChecked(executable, ["install", source]);
-  },
-  agentDir(homeDir = homedir3()) {
-    return getAgentDir(homeDir);
-  },
-  async skillCheckGlobal(name, agentDir = getAgentDir(), sharedSkillsDir = join4(homedir3(), ".agents", "skills")) {
-    const roots = [join4(agentDir, "skills"), sharedSkillsDir];
-    for (const root of roots) {
-      if (await getOptionalFile3(join4(root, name, "SKILL.md")) !== undefined)
-        return true;
-    }
-    return false;
-  },
-  async skillInstallGlobal(miseExecutable, source, names) {
-    const selection = names.flatMap((name) => ["--skill", name]);
-    await runChecked(miseExecutable, [
-      "x",
-      "node@22",
-      "--",
-      "npx",
-      "-y",
-      "skills",
-      "add",
-      source,
-      ...selection,
-      "--global",
-      "--agent",
-      "pi",
-      "--yes"
-    ]);
-  },
-  async configEnsure(path, update, dryRun = false) {
-    const currentText = await getOptionalFile3(path);
-    const current = getParsedObject(currentText, path);
-    const next = update(current);
-    const changed = JSON.stringify(current) !== JSON.stringify(next);
-    if (changed && !dryRun) {
-      await mkdir3(dirname3(path), { recursive: true });
-      await writeFile3(path, `${JSON.stringify(next, null, 2)}
-`, "utf8");
-    }
-    return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
   }
-};
-function getAgentDir(homeDir = homedir3()) {
-  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join4(process.env.XDG_CONFIG_HOME, "pi") : join4(homeDir, ".pi", "agent"));
+  return false;
 }
-async function getOptionalFile3(path) {
-  try {
-    return await readFile3(path, "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return;
-    throw error;
+async function installGlobalPiSkills(miseExecutable, source, names) {
+  const selection = names.flatMap((name) => ["--skill", name]);
+  await runChecked(miseExecutable, [
+    "x",
+    "node@22",
+    "--",
+    "npx",
+    "-y",
+    "skills",
+    "add",
+    source,
+    ...selection,
+    "--global",
+    "--agent",
+    "pi",
+    "--yes"
+  ]);
+}
+async function ensurePiConfig(path, update, dryRun = false) {
+  const currentText = await readTextIfExists(path);
+  const current = parseJsonObject(currentText, path);
+  const next = update(current);
+  const changed = JSON.stringify(current) !== JSON.stringify(next);
+  if (changed && !dryRun) {
+    await mkdir6(dirname6(path), { recursive: true });
+    await writeFile7(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
   }
+  return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
+}
+async function findPiExecutable() {
+  return findExecutable("pi");
 }
-function getParsedObject(content, path) {
+async function listPiPackages(executable) {
+  return (await runChecked(executable, ["list"])).stdout;
+}
+function hasPiPackage(listOutput, source) {
+  if (listOutput.includes(source))
+    return true;
+  return source.startsWith("https://") && listOutput.includes(source.slice("https://".length));
+}
+async function installPiPackage(executable, source) {
+  await runChecked(executable, ["install", source]);
+}
+function resolvePiAgentDir(homeDir = homedir7()) {
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join11(process.env.XDG_CONFIG_HOME, "pi") : join11(homeDir, ".pi", "agent"));
+}
+function parseJsonObject(content, path) {
   if (!content?.trim())
     return {};
   try {
@@ -435,9 +2748,14 @@ var PI_SKILL_SOURCES = [
   { repository: "AminBlg/SimpleEnglish", skills: ["simple-english"] }
 ];
 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 ?? homedir4();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join5(homeDir, ".local", "bin", "mise"));
+  const homeDir = options.homeDir ?? homedir8();
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join12(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -466,7 +2784,10 @@ 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];
+  if (options.forge && options.forge !== "none")
+    dependencies.push(FORGE_DEPENDENCIES[options.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));
@@ -482,18 +2803,33 @@ 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(join5(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  const webSearch = await pi.configEnsure(join12(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
   actions.push(getConfigSetupAction("web search settings", webSearch));
-  const lsp = await pi.configEnsure(join5(agentDir, "pi-lsp.json"), (config) => ({
+  const lsp = await pi.configEnsure(join12(agentDir, "pi-lsp.json"), (config) => ({
     ...config,
     progressive: { ...getRecord(config.progressive), enabled: true, inject: "none" }
   }), options.dryRun);
   actions.push(getConfigSetupAction("pi-lsp settings", lsp));
   return actions;
 }
+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 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 = basename4(entry.name, ".md").replace(/^diffpi-/, "");
+    const source = await readFile10(join12(bundledAgentsDir, entry.name), "utf8");
+    const content = materializeAgentModels(source, id, userConfig.config, options.availableModels);
+    const result = await pi.agentEnsure(entry.name, content, agentDir, options.dryRun);
+    actions.push(getConfigSetupAction(`pi agent ${id}`, result));
+  }
+  return actions;
+}
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join5(options.homeDir ?? homedir4(), ".agents", "skills");
+  const sharedSkillsDir = join12(options.homeDir ?? homedir8(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -537,6 +2873,12 @@ async function ensureMcpAdapters(miseExecutable, options = {}) {
   } else if (options.issueTracker === "jira") {
     servers.atlassian = { url: "https://mcp.atlassian.com/v1/mcp", auth: "oauth", protocolVersion: "auto" };
   }
+  if (options.forge === "github") {
+    servers.github = { url: "https://api.githubcopilot.com/mcp/", auth: "oauth", protocolVersion: "auto" };
+  } else if (options.forge === "gitlab") {
+    const host = (await detectVcs(projectDir)).host || "gitlab.com";
+    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)
@@ -550,13 +2892,81 @@ async function setupPi(options = {}) {
   actions.push(await ensureMiseHooks(miseResult.executable, options));
   actions.push(...await ensureMiseDeps(miseResult.executable, options));
   actions.push(...await ensurePiPlugins(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: actions.some((item) => (item.status === "installed" || item.status === "updated") && (item.name.startsWith("pi package ") || item.name.startsWith("pi skill ") || item.name === "MCP configuration" || item.name === "web search settings" || item.name === "pi-lsp settings"))
+    restartPi: setupRequiresRestart(actions)
   };
 }
+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"));
+}
+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)];
+  const preferences = resolveAgentModelPreferences(agentId, profilePreferences, config);
+  let selectedIndex = availableModels === undefined && preferences.length > 0 ? 0 : -1;
+  let selectedModel = selectedIndex === 0 ? preferences[0] : undefined;
+  if (availableModels) {
+    for (const [index, preference] of preferences.entries()) {
+      const match = findPreferredModel(availableModels, preference);
+      if (!match)
+        continue;
+      selectedIndex = index;
+      selectedModel = `${match.provider}/${match.id}`;
+      break;
+    }
+  }
+  const fallbacks = preferences.filter((_preference, index) => index !== selectedIndex);
+  return replaceAgentModelFields(content, selectedModel, fallbacks);
+}
+function replaceAgentModelFields(content, model, fallbacks) {
+  const newline = content.includes(`\r
+`) ? `\r
+` : `
+`;
+  const lines = content.replaceAll(`\r
+`, `
+`).split(`
+`);
+  const closingDelimiter = lines.indexOf("---", 1);
+  if (lines[0] !== "---" || closingDelimiter < 0)
+    return content;
+  const frontmatter = lines.slice(1, closingDelimiter).filter((line) => !/^model(?:_fallbacks)?:/.test(line));
+  if (model)
+    frontmatter.push(`model: ${model}`);
+  if (fallbacks.length > 0)
+    frontmatter.push(`model_fallbacks: ${fallbacks.join(", ")}`);
+  return ["---", ...frontmatter, "---", ...lines.slice(closingDelimiter + 1)].join(newline);
+}
+async function ensureZedIntegration(options = {}) {
+  if (options.dryRun) {
+    const actions = [createSetupAction("Zed review task", "planned", "tasks.json")];
+    if (options.bindZedKey)
+      actions.push(createSetupAction("Zed review keybinding", "planned", "keymap.json"));
+    return actions;
+  }
+  const actions = [];
+  try {
+    const task = await ensureZedReviewTask(options.homeDir);
+    actions.push(createSetupAction("Zed review task", task.changed ? "installed" : "ready", task.path));
+  } catch (error) {
+    actions.push(createSetupAction("Zed review task", "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 ensurePiPackages(packages, options) {
   const executable = await pi.executableCheck();
   if (!executable && !options.dryRun)
@@ -578,6 +2988,10 @@ ${source}`;
   }
   return actions;
 }
+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);
+}
 function getConfigSetupAction(name, result) {
   if (!result.changed)
     return createSetupAction(name, "ready", result.path);
@@ -596,11 +3010,13 @@ function getRecord(value) {
 }
 
 // src/tools/setup.ts
-var setupParametersSchema = z2.object({
-  issueTracker: z2.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 = z7.object({
+  issueTracker: z7.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
+  forge: z7.enum(["none", "github", "gitlab"]).default("none").describe("Forge to configure for /review. Installs gh or glab and registers its MCP server."),
+  bindZedKey: z7.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
 });
-var setupParameters = z2.toJSONSchema(setupParametersSchema, { io: "input" });
-var diffpiSetupTool = defineTool2({
+var setupParameters = z7.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.",
@@ -613,11 +3029,14 @@ var diffpiSetupTool = defineTool2({
   ],
   parameters: setupParameters,
   executionMode: "sequential",
-  async execute(_toolCallId, input, _signal, onUpdate) {
+  async execute(_toolCallId, input, _signal, onUpdate, ctx) {
     const params = setupParametersSchema.parse(input);
     const result = await setupPi({
       issueTracker: params.issueTracker,
+      forge: params.forge,
+      bindZedKey: params.bindZedKey,
       installMiseHook: true,
+      availableModels: ctx.modelRegistry.getAvailable(),
       onProgress(message) {
         onUpdate?.({ content: [{ type: "text", text: message }], details: {} });
       }
@@ -625,7 +3044,7 @@ var diffpiSetupTool = defineTool2({
     return formatResult(result, "Setup complete.");
   }
 });
-var diffpiValidateTool = defineTool2({
+var diffpiValidateTool = defineTool4({
   name: "diffpi_validate",
   label: "diffpi validate",
   description: "Inspect the @difflab/pi environment without installing software or changing configuration files.",
@@ -637,12 +3056,15 @@ var diffpiValidateTool = defineTool2({
   ],
   parameters: setupParameters,
   executionMode: "sequential",
-  async execute(_toolCallId, input) {
+  async execute(_toolCallId, input, _signal, _onUpdate, ctx) {
     const params = setupParametersSchema.parse(input);
     const result = await setupPi({
       issueTracker: params.issueTracker,
+      forge: params.forge,
+      bindZedKey: params.bindZedKey,
       installMiseHook: true,
-      dryRun: true
+      dryRun: true,
+      availableModels: ctx.modelRegistry.getAvailable()
     });
     const incomplete = result.actions.some((item) => item.status === "planned");
     return formatResult(result, incomplete ? "Setup is incomplete." : "Setup is ready.");
@@ -662,13 +3084,50 @@ ${lines.join(`
   };
 }
 
+// src/tools/templates.ts
+import { defineTool as defineTool5 } from "@earendil-works/pi-coding-agent";
+import { z as z8 } from "zod";
+var templateSchema = z8.object({
+  name: z8.string().min(1),
+  variables: z8.record(z8.string(), z8.string()).optional(),
+  homeDir: z8.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: z8.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) {
-  return [diffpiSetupTool, diffpiValidateTool, createDiffpiReloadTool(pi)];
+function createPiTools(pi, modes) {
+  return [
+    diffpiSetupTool,
+    diffpiValidateTool,
+    createDiffpiReloadTool(pi),
+    diffpiTemplateTool,
+    ...createModeTools(modes),
+    ...createReviewTools()
+  ];
 }
 export {
   createDiffpiReloadTool,
+  createModeTools,
   createPiTools,
+  createReviewTools,
   diffpiSetupTool,
+  diffpiTemplateTool,
   diffpiValidateTool
 };