@difflab/pi 0.1.0 → 0.2.0-rc.202609170717.9cb91d1

package/dist/tools/index.js

@@ -25,83 +25,119 @@ function createDiffpiReloadTool(pi) {
   });
 }
 
-// src/tools/setup.ts
+// src/tools/modes.ts
 import { defineTool as defineTool2 } from "@earendil-works/pi-coding-agent";
 import { z as z2 } from "zod";
-
-// src/setup.ts
-import { homedir as homedir4 } from "node:os";
-import { join as join5 } from "node:path";
-
-// src/mcp.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-var mcp = {
-  globalConfigPath(homeDir = homedir()) {
-    return join(homeDir, ".config", "mcp", "mcp.json");
-  },
-  async serversEnsure(servers, options = {}) {
-    const path = options.path ?? mcp.globalConfigPath();
-    const currentText = await getOptionalFile(path);
-    const current = getParsedConfig(currentText, path);
-    const nextServers = { ...current.mcpServers };
-    for (const [name, entry] of Object.entries(servers)) {
-      nextServers[name] = mergeEntry(nextServers[name], entry);
-    }
-    const next = { ...current, mcpServers: nextServers };
-    const changed = JSON.stringify(current) !== JSON.stringify(next);
-    if (changed && !options.dryRun) {
-      await mkdir(dirname(path), { recursive: true });
-      await writeFile(path, `${JSON.stringify(next, null, 2)}
-`, "utf8");
-    }
-    return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
-  }
-};
-function mergeEntry(current, required) {
-  const merged = { ...current, ...required };
-  if (current?.env || required.env)
-    merged.env = { ...current?.env, ...required.env };
-  return merged;
+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 getParsedConfig(content, path) {
-  if (!content?.trim())
-    return { mcpServers: {} };
-  try {
-    const value = JSON.parse(content);
-    if (!isRecord(value))
-      throw new Error("not an object");
-    const servers = value.mcpServers;
-    if (servers !== undefined && !isRecord(servers))
-      throw new Error("mcpServers is not an object");
-    return { ...value, mcpServers: servers ?? {} };
-  } catch {
-    throw new Error(`Expected a valid pi-mcp-adapter configuration in ${path}.`);
+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})`);
   }
-}
-async function getOptionalFile(path) {
-  try {
-    return await readFile(path, "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return;
-    throw error;
+  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 isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function sanitize(value) {
+  return value.replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").trim();
 }
 
-// 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/tools/review.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+import { defineTool as defineTool3 } from "@earendil-works/pi-coding-agent";
+import { z as z4 } 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 as join2 } from "node:path";
+import { delimiter, join } from "node:path";
 import { spawn } from "node:child_process";
 var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
 async function findExecutable(name) {
@@ -116,7 +152,7 @@ async function findExecutable(name) {
   for (const directory of (process.env.PATH ?? "").split(delimiter)) {
     if (!directory)
       continue;
-    const candidate = join2(directory, name);
+    const candidate = join(directory, name);
     try {
       await access(candidate, constants.X_OK);
       return candidate;
@@ -129,18 +165,35 @@ function run(command, args, options = {}) {
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: options.env ?? process.env,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
     });
     let stdout = "";
     let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout = appendBounded(stdout, chunk.toString());
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const unbounded = options.capture === "unbounded";
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (unbounded)
+        stdoutChunks.push(text);
+      else
+        stdout = appendBounded(stdout, text);
     });
-    child.stderr.on("data", (chunk) => {
-      stderr = appendBounded(stderr, chunk.toString());
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (unbounded)
+        stderrChunks.push(text);
+      else
+        stderr = appendBounded(stderr, text);
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    child.on("close", (code) => resolve({
+      code: code ?? 1,
+      stdout: unbounded ? stdoutChunks.join("") : stdout,
+      stderr: unbounded ? stderrChunks.join("") : stderr
+    }));
+    if (options.input !== undefined && child.stdin)
+      child.stdin.end(options.input);
   });
 }
 async function runChecked(command, args, options = {}) {
@@ -155,7 +208,1422 @@ function appendBounded(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"
+    ];
+    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
+    };
+  }
+  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) {
+    return (await runChecked("gh", ["pr", "diff", String(id), ...this.repoFlag()], { capture: "unbounded" })).stdout;
+  }
+  async prChecks(id) {
+    return (await run("gh", ["pr", "checks", String(id), ...this.repoFlag()])).stdout;
+  }
+  async createPendingReview(id, comments, body) {
+    const payload = {
+      body,
+      comments: 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/${id}/reviews`, "--input", "-"], { input: JSON.stringify(payload) });
+  }
+  async submitReview(id, event, body) {
+    const pending = await runChecked("gh", [
+      "api",
+      `/repos/${this.vcs.owner}/${this.vcs.repo}/pulls/${id}/reviews`,
+      "--jq",
+      '[.[] | select(.state=="PENDING")] | last | .id'
+    ]);
+    const reviewId = pending.stdout.trim();
+    const endpoint = githubReviewSubmissionEndpoint(this.vcs.owner, this.vcs.repo, id, reviewId);
+    const args = ["api", "--method", "POST", endpoint, "-f", `event=${event}`];
+    if (body.trim())
+      args.push("-f", `body=${body}`);
+    await runChecked("gh", args);
+  }
+  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);
+  }
+}
+
+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
+    };
+  }
+  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() {
+    return (await run("glab", ["ci", "status", "--repo", this.project()])).stdout;
+  }
+  async createPendingReview(id, comments, body) {
+    const endpoint = `projects/${encodeURIComponent(this.project())}/merge_requests/${id}/draft_notes`;
+    if (body.trim()) {
+      await runChecked("glab", ["api", "--method", "POST", endpoint, "--input", "-"], {
+        input: JSON.stringify({ note: body })
+      });
+    }
+    if (comments.length === 0)
+      return;
+    const response = await runChecked("glab", [
+      "api",
+      `projects/${encodeURIComponent(this.project())}/merge_requests/${id}`
+    ]);
+    const diffRefs = parseGitlabDiffRefs(response.stdout);
+    for (const comment of 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 submitReview(id, event, body) {
+    assertReviewEventSupported(this.provider, event);
+    const drafts = await runChecked("glab", [
+      "api",
+      `projects/${encodeURIComponent(this.project())}/merge_requests/${id}/draft_notes`
+    ]);
+    const hasDrafts = hasGitlabDraftNotes(drafts.stdout);
+    if (hasDrafts) {
+      await runChecked("glab", [
+        "api",
+        "--method",
+        "POST",
+        `projects/${encodeURIComponent(this.project())}/merge_requests/${id}/draft_notes/bulk_publish`
+      ]);
+    } else if (body.trim()) {
+      await runChecked("glab", ["mr", "note", String(id), "--repo", this.project(), "--message", body]);
+    }
+    if (event === "APPROVE")
+      await runChecked("glab", ["mr", "approve", String(id), "--repo", this.project()]);
+  }
+  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()]);
+  }
+}
+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 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;
+}
+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 complete GitLab review: the draft notes response was not valid JSON.");
+  }
+}
+
+// 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.ts
+import { join as join3 } from "node:path";
+import { z as z3 } from "zod";
+var severitySchema = z3.enum(["BLOCKING", "CONSIDER", "NOTE"]);
+var findingSchema = z3.object({
+  file: z3.string().min(1),
+  line: z3.number().int().nonnegative(),
+  severity: severitySchema,
+  body: z3.string().min(1),
+  reference: z3.string().optional().default("")
+});
+var findingsSchema = z3.array(findingSchema);
+function reviewSlug(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+function mmddyy(date = new Date) {
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  const yy = String(date.getFullYear() % 100).padStart(2, "0");
+  return `${mm}${dd}${yy}`;
+}
+function reviewRecordName(branch, date = new Date) {
+  return `${mmddyy(date)}-${reviewSlug(branch)}`;
+}
+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) {
+  return findings.filter((finding) => finding.line > 0).map((finding) => ({
+    file: finding.file,
+    line: finding.line,
+    side: "RIGHT",
+    body: renderCommentBody(finding)
+  }));
+}
+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.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 reviewWorkingDir(storeReviewsDir, slug) {
+  return join3(storeReviewsDir, slug);
+}
+function renderCommentBody(finding) {
+  const prefix = finding.severity === "BLOCKING" ? "**BLOCKING** " : "";
+  const reference = finding.reference ? `
+
+> **Reference:** ${finding.reference}` : "";
+  return `${prefix}${finding.body}${reference}`;
+}
+
+// src/store.ts
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { mkdir as mkdir2, realpath, symlink } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { isAbsolute, join as join4, resolve } from "node:path";
+var STORE_LINK = join4(".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 : join4(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 join4(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir2()) {
+  const root = await gitToplevel(cwd);
+  const slug = await computeProjectSlug(root);
+  const dest = join4(storeGlobalRoot(homeDir), slug);
+  const link = join4(root, STORE_LINK);
+  if (existsSync(link))
+    return { slug, root, dest, link, linked: true };
+  await mkdir2(dest, { recursive: true });
+  await mkdir2(join4(root, ".pi"), { recursive: true });
+  await symlink(dest, link);
+  return { slug, root, dest, link, linked: true };
+}
+async function storeDir(cwd, homeDir = homedir2()) {
+  return (await ensureStore(cwd, homeDir)).dest;
+}
+async function reviewsDir(cwd, homeDir = homedir2()) {
+  const dir = join4(await storeDir(cwd, homeDir), "reviews");
+  await mkdir2(dir, { recursive: true });
+  return dir;
+}
+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
+import { readFile as readFile2, realpath as realpath2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+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) {
+  return findMatchingSession(await listSessions(cwd), cwd, branch);
+}
+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 launch(cwd) {
+  return openInNewTab(["tuicr", "-w"], { cwd, name: "tuicr" });
+}
+function toFindings(session) {
+  const comments = [];
+  const bodyParts = (session.review_comments ?? []).map((comment) => comment.content);
+  for (const [file, entry] of Object.entries(session.files ?? {})) {
+    const fileComments = (entry.file_comments ?? []).map((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) {
+        comments.push({ file, line, side: lineComment.side === "old" ? "LEFT" : "RIGHT", body: lineComment.content });
+      }
+    }
+  }
+  return {
+    comments,
+    body: bodyParts.join(`
+
+`)
+  };
+}
+async function canonicalPath2(path) {
+  try {
+    return await realpath2(path);
+  } catch {
+    return resolve2(path);
+  }
+}
+
+// src/tools/review.ts
+var contextSchema = z4.object({ cwd: z4.string().optional() });
+var localSchema = contextSchema.extend({ local: z4.boolean().optional() });
+var openSchema = localSchema.extend({ title: z4.string().optional(), base: z4.string().optional() });
+var submitSchema = localSchema.extend({
+  findings: findingsSchema,
+  overallIssues: z4.array(z4.string()).optional(),
+  notVerified: z4.array(z4.string()).optional(),
+  title: z4.string().optional()
+});
+var completeSchema = contextSchema.extend({
+  action: z4.enum(["accept", "reject", "close", "local"]),
+  comment: z4.string().optional()
+});
+var eventSchema = localSchema.extend({ event: z4.enum(["APPROVE", "REQUEST_CHANGES", "COMMENT"]).optional() });
+var respondSchema = contextSchema.extend({
+  body: z4.string().min(1),
+  file: z4.string().optional(),
+  line: z4.number().int().positive().optional()
+});
+function parameters(schema) {
+  return z4.toJSONSchema(schema, { io: "input" });
+}
+function cwdOf(params) {
+  return params.cwd ?? process.cwd();
+}
+function result(text, details = {}) {
+  return { content: [{ type: "text", text }], details };
+}
+function conventionalMergeGuard(subject) {
+  return checkConventionalSubject(subject);
+}
+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 reviewSubmissionBody(body) {
+  return body.trim() || "Inline comments only.";
+}
+function createReviewTools() {
+  return [
+    defineTool3({
+      name: "review_context",
+      label: "review context",
+      description: "Read-only orientation for the current forge, environment, store, branch, PR, and tuicr session.",
+      promptSnippet: "Call review_context first",
+      promptGuidelines: ["Call this before every review workflow."],
+      parameters: parameters(contextSchema),
+      executionMode: "parallel",
+      async execute(_id, input) {
+        const params = contextSchema.parse(input);
+        const cwd = cwdOf(params);
+        const vcs = await detectVcs(cwd);
+        const store = await ensureStore(cwd);
+        const env = { ide: detectIde(), mux: detectMux(), shell: detectShell() };
+        const forge = vcs.provider === "none" ? undefined : createForge(vcs);
+        const pr = forge ? await forge.viewPr(vcs.branch) : undefined;
+        const baseRef = pr?.baseRef ?? (forge ? await forge.defaultBranch() : "local");
+        const session = await resolveSession(cwd, vcs.branch);
+        return result([
+          `Forge: ${vcs.provider}${vcs.provider === "none" ? "" : ` (${vcs.owner}/${vcs.repo})`}`,
+          `Branch: ${vcs.branch} → ${baseRef}`,
+          `Env: ide=${env.ide} mux=${env.mux} shell=${env.shell}`,
+          `Store: ${store.link} → ${store.dest}`,
+          pr ? `PR/MR: #${pr.number} ${pr.url}` : "PR/MR: none",
+          session ? `tuicr: ${session.slug} (${session.commentCount} comments)` : "tuicr: none"
+        ].join(`
+`), { vcs, env, store, pr, session, baseRef });
+      }
+    }),
+    defineTool3({
+      name: "review_open",
+      label: "review open",
+      description: "Create a draft PR/MR, or launch a local tuicr review.",
+      promptSnippet: "Call review_open to start",
+      promptGuidelines: ["Use local for the offline tuicr flow."],
+      parameters: parameters(openSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = openSchema.parse(input);
+        const cwd = cwdOf(params);
+        await ensureStore(cwd);
+        const vcs = await detectVcs(cwd);
+        if (params.local || vcs.provider === "none") {
+          const launched = await launch(cwd);
+          const record = join5(await reviewsDir(cwd), `${reviewRecordName(vcs.branch)}.md`);
+          if (!existsSync2(record))
+            await writeFile2(record, `# Local review: ${vcs.branch}
+`, "utf8");
+          return result(launched.launched ? `Opened tuicr (${launched.via}). Record: ${record}` : `${launched.instruction ?? `Run: ${launched.command}`}
+Record: ${record}`, { launched, record });
+        }
+        const forge = createForge(vcs);
+        const pr = await forge.createDraftPr({
+          title: params.title ?? deriveTitle(vcs.branch),
+          body: "<!-- fill in intent, changes, validation -->",
+          base: params.base ?? await forge.defaultBranch(),
+          head: vcs.branch
+        });
+        return result(`Draft PR/MR created: ${pr.url}`, { pr });
+      }
+    }),
+    defineTool3({
+      name: "review_diff",
+      label: "review diff",
+      description: "Fetch the forge diff or the 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 cwd = cwdOf(params);
+        const vcs = await detectVcs(cwd);
+        if (params.local || vcs.provider === "none") {
+          const diff = await run("git", ["-C", cwd, "diff", "HEAD"]);
+          return result(diff.stdout || "No working-tree changes.", { diff: diff.stdout });
+        }
+        const pr = await createForge(vcs).viewPr(vcs.branch);
+        if (!pr)
+          return result("No open PR/MR. Run review_open first.");
+        const diff = await createForge(vcs).prDiff(pr.number);
+        return result(diff || "Empty diff.", { diff, 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 cwd = cwdOf(params);
+        const vcs = await detectVcs(cwd);
+        const gates = await runMiseGates(cwd);
+        const subject = (await run("git", ["-C", cwd, "log", "-1", "--format=%s"])).stdout.trim();
+        if (subject)
+          gates.push(checkConventionalSubject(subject));
+        if (!params.local && vcs.provider !== "none") {
+          const forge = createForge(vcs);
+          const pr = await forge.viewPr(vcs.branch);
+          if (pr)
+            gates.push(ciGate(await forge.prChecks(pr.number)));
+        }
+        return result(gates.map((gate) => `- ${gate.name}: ${gate.status} — ${gate.detail}`).join(`
+`), {
+          results: gates
+        });
+      }
+    }),
+    defineTool3({
+      name: "review_submit",
+      label: "review submit",
+      description: "Render findings to the shared review store and create a pending forge review unless local.",
+      promptSnippet: "Call review_submit with the findings JSON",
+      promptGuidelines: ["Use concrete file and line values."],
+      parameters: parameters(submitSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = submitSchema.parse(input);
+        const cwd = cwdOf(params);
+        await ensureStore(cwd);
+        const vcs = await detectVcs(cwd);
+        const findings = dedupeFindings(params.findings);
+        const slug = reviewSlug(params.title ?? vcs.branch) || "review";
+        const dir = reviewWorkingDir(await reviewsDir(cwd), slug);
+        await mkdir3(dir, { recursive: true });
+        const gates = await runMiseGates(cwd);
+        const forge = !params.local && vcs.provider !== "none" ? createForge(vcs) : undefined;
+        const pr = forge ? await forge.viewPr(vcs.branch) : undefined;
+        const baseRef = pr?.baseRef ?? (forge ? await forge.defaultBranch() : "local");
+        const docPath = join5(dir, "new-review.md");
+        await writeFile2(docPath, renderReviewDoc({
+          title: params.title ?? vcs.branch,
+          headRef: vcs.branch,
+          baseRef,
+          findings,
+          overallIssues: params.overallIssues ?? [],
+          gates,
+          notVerified: params.notVerified ?? []
+        }), "utf8");
+        if (!forge)
+          return result(`Local review written: ${docPath}`, { docPath, count: findings.length });
+        if (!pr)
+          return result(`No open PR/MR. Review written: ${docPath}`, { docPath });
+        await forge.createPendingReview(pr.number, toReviewComments(findings), reviewSubmissionBody((params.overallIssues ?? []).join(`
+`)));
+        return result(`Pending review posted to #${pr.number}. Doc: ${docPath}`, {
+          docPath,
+          pr,
+          count: findings.length
+        });
+      }
+    }),
+    defineTool3({
+      name: "review_comments",
+      label: "review comments",
+      description: "Read unresolved local tuicr comments. Forge thread retrieval is delegated to the forge MCP when available.",
+      promptSnippet: "Call review_comments before addressing findings",
+      promptGuidelines: ["Use forge MCP thread tools when the review is remote."],
+      parameters: parameters(localSchema),
+      executionMode: "parallel",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const cwd = cwdOf(params);
+        const vcs = await detectVcs(cwd);
+        const session = await resolveSession(cwd, vcs.branch);
+        if (!session)
+          return result("No tuicr session found.");
+        const normalized = toFindings(await readSession(session.path));
+        return result(normalized.comments.map((comment) => `${comment.file}:${comment.line} — ${comment.body}`).join(`
+`) || "No comments.", { session, comments: normalized.comments });
+      }
+    }),
+    defineTool3({
+      name: "review_respond",
+      label: "review respond",
+      description: "Append a response to the local review record; remote responses should use the forge MCP thread tool.",
+      promptSnippet: "Call review_respond after addressing a local comment",
+      promptGuidelines: ["For remote reviews, prefer the forge MCP response and resolve tools."],
+      parameters: parameters(respondSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = respondSchema.parse(input);
+        const cwd = cwdOf(params);
+        const path = join5(await reviewsDir(cwd), `${reviewRecordName((await detectVcs(cwd)).branch)}.md`);
+        await mkdir3(join5(path, ".."), { recursive: true });
+        await writeFile2(path, `
+## Response${params.file ? ` — ${params.file}:${params.line ?? 1}` : ""}
+
+${params.body}
+`, { encoding: "utf8", flag: "a" });
+        return result(`Response recorded: ${path}`, { path });
+      }
+    }),
+    defineTool3({
+      name: "review_publish",
+      label: "review publish",
+      description: "Mark a draft ready and submit its pending forge review, optionally publishing a local tuicr session.",
+      promptSnippet: "Call review_publish to publish",
+      promptGuidelines: ["Pass local to publish a tuicr session first."],
+      parameters: parameters(eventSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = eventSchema.parse(input);
+        const cwd = cwdOf(params);
+        const vcs = await detectVcs(cwd);
+        if (vcs.provider === "none")
+          return result("No forge detected; local review remains in the shared store.");
+        const forge = createForge(vcs);
+        const pr = await forge.viewPr(vcs.branch);
+        if (!pr)
+          return result("No open PR/MR for this branch.");
+        const event = params.event ?? "COMMENT";
+        assertReviewEventSupported(forge.provider, event);
+        let body = "";
+        if (params.local) {
+          const session = await resolveSession(cwd, vcs.branch);
+          if (!session)
+            return result("No tuicr session to publish.");
+          const normalized = toFindings(await readSession(session.path));
+          body = reviewSubmissionBody(normalized.body);
+          await forge.createPendingReview(pr.number, normalized.comments, body);
+        }
+        if (pr.isDraft)
+          await forge.markReady(pr.number);
+        await forge.submitReview(pr.number, event, body);
+        return result(`Published #${pr.number} (${event}).`, { pr, event });
+      }
+    }),
+    defineTool3({
+      name: "review_complete",
+      label: "review complete",
+      description: "Approve, request changes, close, or archive a review. This never merges.",
+      promptSnippet: "Call review_complete to finish without merging",
+      promptGuidelines: ["Use review_merge separately for merging."],
+      parameters: parameters(completeSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = completeSchema.parse(input);
+        const cwd = cwdOf(params);
+        const vcs = await detectVcs(cwd);
+        if (params.action === "local") {
+          const source = await resolveSession(cwd, vcs.branch);
+          const dest = uniqueRecordPath(await reviewsDir(cwd), reviewRecordName(vcs.branch));
+          if (source) {
+            const normalized = toFindings(await readSession(source.path));
+            await writeFile2(dest, `# Completed review: ${vcs.branch}
+
+${normalized.body}
+
+${normalized.comments.map((comment) => `- ${comment.file}:${comment.line} — ${comment.body}`).join(`
+`)}
+`, "utf8");
+          } else
+            await writeFile2(dest, `# Completed review: ${vcs.branch}
+`, "utf8");
+          return result(`Local review archived: ${dest}`, { dest });
+        }
+        if (vcs.provider === "none")
+          return result("No forge detected. Use action=local for a local review.");
+        const forge = createForge(vcs);
+        const pr = await forge.viewPr(vcs.branch);
+        if (!pr)
+          return result("No open PR/MR for this branch.");
+        if (params.action === "accept") {
+          if (pr.isDraft)
+            await forge.markReady(pr.number);
+          await forge.submitReview(pr.number, "APPROVE", params.comment ?? "Approved.");
+          return result(`Approved #${pr.number}. Merge separately with review_merge.`, { pr });
+        }
+        if (params.action === "reject") {
+          await forge.submitReview(pr.number, "REQUEST_CHANGES", params.comment ?? "Requesting changes.");
+          return result(`Requested changes on #${pr.number}.`, { pr });
+        }
+        await forge.closePr(pr.number, params.comment);
+        return result(`Closed #${pr.number}.`, { pr });
+      }
+    }),
+    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_complete accept",
+      promptGuidelines: ["This is intentionally GitHub-only until GitLab merge support is added."],
+      parameters: parameters(contextSchema.extend({ subject: z4.string().optional() })),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = contextSchema.extend({ subject: z4.string().optional() }).parse(input);
+        const cwd = cwdOf(params);
+        const vcs = await detectVcs(cwd);
+        if (vcs.provider !== "github")
+          return result("review_merge currently supports GitHub only.");
+        const pr = await createForge(vcs).viewPr(vcs.branch);
+        if (!pr)
+          return result("No open PR/MR for this branch.");
+        const subject = params.subject ?? pr.title;
+        const guard = conventionalMergeGuard(subject);
+        if (guard.status !== "pass") {
+          return result(`Merge blocked: ${guard.detail}`, { pr, guard });
+        }
+        const readiness = await runChecked("gh", [
+          "pr",
+          "view",
+          String(pr.number),
+          "--repo",
+          `${vcs.owner}/${vcs.repo}`,
+          "--json",
+          "isDraft,state,reviewDecision,mergeStateStatus,statusCheckRollup"
+        ], { capture: "unbounded" });
+        assertGitHubMergeReady(readiness.stdout);
+        await runChecked("gh", [
+          "pr",
+          "merge",
+          String(pr.number),
+          "--repo",
+          `${vcs.owner}/${vcs.repo}`,
+          "--squash",
+          "--subject",
+          subject
+        ]);
+        return result(`Merged #${pr.number} with subject: ${subject}.`, { pr, guard });
+      }
+    }),
+    defineTool3({
+      name: "review_launch",
+      label: "review launch",
+      description: "Open tuicr in a mux tab, configure its Zed task, 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 launchResult = await launch(cwdOf(params));
+        return result(launchResult.launched ? `Opened tuicr (${launchResult.via}).` : launchResult.instruction ?? `Run: ${launchResult.command}`, {
+          launch: launchResult
+        });
+      }
+    })
+  ];
+}
+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 = join5(dir, `${base}.md`);
+  let count = 2;
+  while (existsSync2(path))
+    path = join5(dir, `${base}-${count++}.md`);
+  return path;
+}
+
+// src/tools/setup.ts
+import { defineTool as defineTool4 } from "@earendil-works/pi-coding-agent";
+import { z as z6 } from "zod";
+
+// src/setup.ts
+import { parseFrontmatter as parseFrontmatter2 } from "@earendil-works/pi-coding-agent";
+import { readdir as readdir2, readFile as readFile6 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { basename as basename4, join as join11 } from "node:path";
+
+// src/assets.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname2, join as join6 } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
+  const moduleDir = dirname2(fileURLToPath(moduleUrl));
+  const candidates = [
+    join6(moduleDir, "agents"),
+    join6(moduleDir, "..", "agents"),
+    join6(moduleDir, "..", "..", "agents")
+  ];
+  return candidates.find((path) => existsSync3(path)) ?? candidates[1];
+}
+
+// src/config.ts
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { z as z5 } from "zod";
+import { homedir as homedir3 } from "node:os";
+import { join as join7 } from "node:path";
+
+// src/fsx.ts
+import { readdir, readFile as readFile3 } from "node:fs/promises";
+async function readTextIfExists(path) {
+  try {
+    return await readFile3(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 = z5.string().trim().min(1);
+var agentConfigSchema = z5.object({
+  models: z5.array(modelReferenceSchema).optional()
+}).strict();
+var diffpiConfigSchema = z5.object({
+  agents: z5.record(z5.string(), agentConfigSchema).optional()
+}).strict();
+function diffpiConfigPaths(homeDir = homedir3()) {
+  const directory = join7(homeDir, ".difflab", "diffpi");
+  return {
+    yaml: join7(directory, "config.yaml"),
+    json: join7(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 as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join8 } from "node:path";
+var mcp = {
+  globalConfigPath(homeDir = homedir4()) {
+    return join8(homeDir, ".config", "mcp", "mcp.json");
+  },
+  async serversEnsure(servers, options = {}) {
+    const path = options.path ?? mcp.globalConfigPath();
+    const currentText = await getOptionalFile(path);
+    const current = getParsedConfig(currentText, path);
+    const nextServers = { ...current.mcpServers };
+    for (const [name, entry] of Object.entries(servers)) {
+      nextServers[name] = mergeEntry(nextServers[name], entry);
+    }
+    const next = { ...current, mcpServers: nextServers };
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (changed && !options.dryRun) {
+      await mkdir4(dirname3(path), { recursive: true });
+      await writeFile3(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    }
+    return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
+  }
+};
+function mergeEntry(current, required) {
+  const merged = { ...current, ...required };
+  if (current?.env || required.env)
+    merged.env = { ...current?.env, ...required.env };
+  return merged;
+}
+function getParsedConfig(content, path) {
+  if (!content?.trim())
+    return { mcpServers: {} };
+  try {
+    const value = JSON.parse(content);
+    if (!isRecord(value))
+      throw new Error("not an object");
+    const servers = value.mcpServers;
+    if (servers !== undefined && !isRecord(servers))
+      throw new Error("mcpServers is not an object");
+    return { ...value, mcpServers: servers ?? {} };
+  } catch {
+    throw new Error(`Expected a valid pi-mcp-adapter configuration in ${path}.`);
+  }
+}
+async function getOptionalFile(path) {
+  try {
+    return await readFile4(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/mise.ts
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename3, dirname as dirname4, join as join9 } from "node:path";
 var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
 var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
 var mise = {
@@ -163,11 +1631,11 @@ var mise = {
     return findExecutable(name);
   },
   async install(options = {}) {
-    const homeDir = options.homeDir ?? homedir2();
+    const homeDir = options.homeDir ?? homedir5();
     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 = join9(homeDir, ".local", "bin", "mise");
     if (options.dryRun)
       return installedPath;
     await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
@@ -177,8 +1645,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 ?? homedir5();
+    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 +1655,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(dirname4(hook.path), { recursive: true });
+    await writeFile4(hook.path, `${current}${separator}${hook.content}`, "utf8");
     return { path: hook.path, changed: true, planned: false };
   },
   async toolCheckGlobal(executable, tool, minimumVersion) {
@@ -205,7 +1673,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 = homedir5()) {
     await runChecked(executable, ["upgrade"], { cwd: homeDir });
   }
 };
@@ -214,7 +1682,7 @@ function getShellHook(shell, executable, homeDir) {
   switch (shell.toLowerCase()) {
     case "zsh":
       return {
-        path: join3(homeDir, ".zshrc"),
+        path: join9(homeDir, ".zshrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate zsh)"
 ${MISE_HOOK_END}
@@ -222,7 +1690,7 @@ ${MISE_HOOK_END}
       };
     case "fish":
       return {
-        path: join3(homeDir, ".config", "fish", "config.fish"),
+        path: join9(homeDir, ".config", "fish", "config.fish"),
         content: `${MISE_HOOK_START}
 ${command} activate fish | source
 ${MISE_HOOK_END}
@@ -231,7 +1699,7 @@ ${MISE_HOOK_END}
     case "nu":
     case "nushell":
       return {
-        path: join3(homeDir, ".config", "nushell", "config.nu"),
+        path: join9(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 +1710,7 @@ ${MISE_HOOK_END}
       };
     case "xonsh":
       return {
-        path: join3(homeDir, ".xonshrc"),
+        path: join9(homeDir, ".xonshrc"),
         content: `${MISE_HOOK_START}
 execx($(${command} activate xonsh))
 ${MISE_HOOK_END}
@@ -250,7 +1718,7 @@ ${MISE_HOOK_END}
       };
     case "elvish":
       return {
-        path: join3(homeDir, ".config", "elvish", "rc.elv"),
+        path: join9(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 +1729,7 @@ ${MISE_HOOK_END}
     case "pwsh":
     case "powershell":
       return {
-        path: join3(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        path: join9(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
         content: `${MISE_HOOK_START}
 (& ${command} activate pwsh) | Out-String | Invoke-Expression
 ${MISE_HOOK_END}
@@ -270,7 +1738,7 @@ ${MISE_HOOK_END}
     case "bash":
     default:
       return {
-        path: join3(homeDir, ".bashrc"),
+        path: join9(homeDir, ".bashrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate bash)"
 ${MISE_HOOK_END}
@@ -309,7 +1777,7 @@ function isVersionAtLeast(version, minimumVersion) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile5(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return "";
@@ -321,79 +1789,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 writeFile5 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname5, join as join10 } 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 = join10(agentDir, "agents", filename);
+  const currentText = await readTextIfExists(path);
+  const changed = currentText !== content;
+  if (changed && !dryRun) {
+    await mkdir6(dirname5(path), { recursive: true });
+    await writeFile5(path, content, "utf8");
+  }
+  return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
+}
+async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join10(homedir6(), ".agents", "skills")) {
+  const roots = [join10(agentDir, "skills"), sharedSkillsDir];
+  for (const root of roots) {
+    if (await readTextIfExists(join10(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(dirname5(path), { recursive: true });
+    await writeFile5(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
   }
+  return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
+}
+async function findPiExecutable() {
+  return findExecutable("pi");
+}
+async function listPiPackages(executable) {
+  return (await runChecked(executable, ["list"])).stdout;
 }
-function getParsedObject(content, path) {
+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 = homedir6()) {
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join10(process.env.XDG_CONFIG_HOME, "pi") : join10(homeDir, ".pi", "agent"));
+}
+function parseJsonObject(content, path) {
   if (!content?.trim())
     return {};
   try {
@@ -435,9 +1910,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 ?? homedir7();
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join11(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -466,7 +1946,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 +1965,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(join11(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(join11(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 readdir2(bundledAgentsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
+  const actions = [];
+  for (const entry of entries) {
+    const id = basename4(entry.name, ".md").replace(/^diffpi-/, "");
+    const source = await readFile6(join11(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 = join11(options.homeDir ?? homedir7(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -537,6 +2035,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 +2054,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 +2150,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 +2172,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 = z6.object({
+  issueTracker: z6.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
+  forge: z6.enum(["none", "github", "gitlab"]).default("none").describe("Forge to configure for /review. Installs gh or glab and registers its MCP server."),
+  bindZedKey: z6.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 = z6.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 +2191,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 +2206,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 +2218,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.");
@@ -663,12 +2247,20 @@ ${lines.join(`
 }
 
 // src/tools/index.ts
-function createPiTools(pi) {
-  return [diffpiSetupTool, diffpiValidateTool, createDiffpiReloadTool(pi)];
+function createPiTools(pi, modes) {
+  return [
+    diffpiSetupTool,
+    diffpiValidateTool,
+    createDiffpiReloadTool(pi),
+    ...createModeTools(modes),
+    ...createReviewTools()
+  ];
 }
 export {
   createDiffpiReloadTool,
+  createModeTools,
   createPiTools,
+  createReviewTools,
   diffpiSetupTool,
   diffpiValidateTool
 };