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

package/dist/index.js

@@ -1,10 +1,1541 @@
+// src/config.ts
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { z } from "zod";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// src/fsx.ts
+import { readdir, readFile } from "node:fs/promises";
+async function readDirectoryIfExists(path) {
+  try {
+    return await readdir(path, { withFileTypes: true });
+  } catch (error) {
+    if (isMissingPath(error))
+      return [];
+    throw error;
+  }
+}
+async function readTextIfExists(path) {
+  try {
+    return await readFile(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 = z.string().trim().min(1);
+var agentConfigSchema = z.object({
+  models: z.array(modelReferenceSchema).optional()
+}).strict();
+var diffpiConfigSchema = z.object({
+  agents: z.record(z.string(), agentConfigSchema).optional()
+}).strict();
+function diffpiConfigPaths(homeDir = homedir()) {
+  const directory = join(homeDir, ".difflab", "diffpi");
+  return {
+    yaml: join(directory, "config.yaml"),
+    json: join(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/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 { 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: [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 as readFile2, writeFile } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join3 } 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 = homedir2()) {
+  return join3(homeDir, ".config", "zed", "tasks.json");
+}
+function zedKeymapPath(homeDir = homedir2()) {
+  return join3(homeDir, ".config", "zed", "keymap.json");
+}
+async function ensureZedReviewTask(homeDir = homedir2()) {
+  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 = homedir2()) {
+  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 readFile2(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function parseJsonArray(content, path) {
+  if (!content?.trim())
+    return [];
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch {
+    throw new Error(`Cannot safely edit ${path}: not strict JSON (it may contain JSONC comments).`);
+  }
+  if (!Array.isArray(value))
+    throw new Error(`Expected a JSON array in ${path}.`);
+  return value;
+}
+async function writeJson(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+
+// src/environment.ts
+function detectIde(env = process.env) {
+  const program = (env.TERM_PROGRAM ?? "").toLowerCase();
+  if (env.ZED_TERM === "true" || program === "zed")
+    return "zed";
+  if (env.CURSOR_TRACE_ID || program === "cursor")
+    return "cursor";
+  if (env.WINDSURF_ENV || program === "windsurf")
+    return "windsurf";
+  if (env.TERMINAL_EMULATOR?.toLowerCase().includes("jetbrains"))
+    return "jetbrains";
+  if (env.VSCODE_PID || env.VSCODE_GIT_IPC_HANDLE || program === "vscode")
+    return "vscode";
+  return "unknown";
+}
+function detectMux(env = process.env) {
+  if (env.ZELLIJ || env.ZELLIJ_SESSION_NAME)
+    return "zellij";
+  if (env.TMUX)
+    return "tmux";
+  if (env.STY)
+    return "screen";
+  return "none";
+}
+function detectShell(env = process.env) {
+  return env.SHELL ? basename(env.SHELL) : "unknown";
+}
+async function detectVcs(cwd) {
+  const root = (await run("git", ["-C", cwd, "rev-parse", "--show-toplevel"])).stdout.trim() || cwd;
+  const branch = (await run("git", ["-C", root, "rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
+  const remote = (await run("git", ["-C", root, "remote", "get-url", "origin"])).stdout.trim();
+  return { ...parseRemote(remote), branch, root };
+}
+function parseRemote(remote) {
+  const empty = { provider: "none", host: "", owner: "", repo: "" };
+  if (!remote)
+    return empty;
+  const scp = remote.match(/^[^@]+@([^:]+):(.+?)(?:\.git)?$/);
+  const url = remote.match(/^[a-z]+:\/\/(?:[^@]+@)?([^/]+)\/(.+?)(?:\.git)?$/i);
+  const match = scp ?? url;
+  if (!match)
+    return empty;
+  const host = match[1];
+  const segments = match[2].split("/").filter(Boolean);
+  if (segments.length < 2)
+    return { ...empty, host };
+  const repo = segments.at(-1) ?? "";
+  const owner = segments.slice(0, -1).join("/");
+  const provider = /github/i.test(host) ? "github" : /gitlab/i.test(host) ? "gitlab" : "none";
+  return { provider, host, owner, repo };
+}
+async function openInNewTab(command, opts) {
+  const env = opts.env ?? process.env;
+  const name = opts.name ?? "review";
+  const printable = command.join(" ");
+  const mux = detectMux(env);
+  if (mux !== "none") {
+    const opened = await openMuxTab(mux, command, opts.cwd, name, printable);
+    if (opened)
+      return opened;
+  }
+  if (detectIde(env) === "zed") {
+    try {
+      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 readFile4, writeFile as writeFile2 } from "node:fs/promises";
+
+// src/review.ts
+import { z as z2 } from "zod";
+var severitySchema = z2.enum(["BLOCKING", "CONSIDER", "NOTE"]);
+var findingSchema = z2.object({
+  file: z2.string().min(1),
+  line: z2.number().int().nonnegative(),
+  severity: severitySchema,
+  body: z2.string().min(1),
+  reference: z2.string().optional().default("")
+});
+var findingsSchema = z2.array(findingSchema);
+var reviewThreadRecordSchema = z2.object({
+  id: z2.string().min(1),
+  file: z2.string().optional(),
+  line: z2.number().int().positive().optional(),
+  body: z2.string(),
+  author: z2.string().optional(),
+  resolved: z2.boolean(),
+  question: z2.boolean(),
+  replies: z2.array(z2.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 = z2.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 readFile3, 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 homedir3 } from "node:os";
+import { dirname as dirname2, isAbsolute, join as join4, resolve } from "node:path";
+var STORE_LINK = ".diffpi";
+var LEGACY_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 = homedir3()) {
+  return join4(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir3()) {
+  const root = await gitToplevel(cwd);
+  const slug = await computeProjectSlug(root);
+  const dest = join4(storeGlobalRoot(homeDir), slug);
+  const link = join4(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(join4(root, LEGACY_STORE_LINK), dest);
+  return { slug, root, dest, link, linked: true };
+}
+async function storeDir(cwd, homeDir = homedir3()) {
+  const store = await ensureStore(cwd, homeDir);
+  return store.dest;
+}
+async function reviewsDir(cwd, homeDir = homedir3()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join4(store.link, "reviews");
+  await mkdir2(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir3()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join4(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 tuicrAvailable() {
+  const result = await run("tuicr", ["--version"]);
+  return result.code === 0;
+}
+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 readFile3(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 readFile4(this.options.artifactPath, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return [];
+      throw error;
+    }
+  }
+  async reply(input) {
+    const content = await readFile4(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/mcp.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join5 } from "node:path";
 var mcp = {
-  globalConfigPath(homeDir = homedir()) {
-    return join(homeDir, ".config", "mcp", "mcp.json");
+  globalConfigPath(homeDir = homedir4()) {
+    return join5(homeDir, ".config", "mcp", "mcp.json");
   },
   async serversEnsure(servers, options = {}) {
     const path = options.path ?? mcp.globalConfigPath();
@@ -17,8 +1548,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 mkdir3(dirname3(path), { recursive: true });
+      await writeFile3(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -47,7 +1578,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile(path) {
   try {
-    return await readFile(path, "utf8");
+    return await readFile5(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -58,68 +1589,9 @@ function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(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 mkdir4, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename3, dirname as dirname4, join as join6 } from "node:path";
 var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
 var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
 var mise = {
@@ -127,11 +1599,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 = join6(homeDir, ".local", "bin", "mise");
     if (options.dryRun)
       return installedPath;
     await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
@@ -141,8 +1613,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 };
@@ -151,8 +1623,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 mkdir4(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) {
@@ -169,7 +1641,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 });
   }
 };
@@ -178,7 +1650,7 @@ function getShellHook(shell, executable, homeDir) {
   switch (shell.toLowerCase()) {
     case "zsh":
       return {
-        path: join3(homeDir, ".zshrc"),
+        path: join6(homeDir, ".zshrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate zsh)"
 ${MISE_HOOK_END}
@@ -186,7 +1658,7 @@ ${MISE_HOOK_END}
       };
     case "fish":
       return {
-        path: join3(homeDir, ".config", "fish", "config.fish"),
+        path: join6(homeDir, ".config", "fish", "config.fish"),
         content: `${MISE_HOOK_START}
 ${command} activate fish | source
 ${MISE_HOOK_END}
@@ -195,7 +1667,7 @@ ${MISE_HOOK_END}
     case "nu":
     case "nushell":
       return {
-        path: join3(homeDir, ".config", "nushell", "config.nu"),
+        path: join6(homeDir, ".config", "nushell", "config.nu"),
         content: `${MISE_HOOK_START}
 let mise_bin = ${command}
 let mise_path = $nu.default-config-dir | path join mise.nu
@@ -206,7 +1678,7 @@ ${MISE_HOOK_END}
       };
     case "xonsh":
       return {
-        path: join3(homeDir, ".xonshrc"),
+        path: join6(homeDir, ".xonshrc"),
         content: `${MISE_HOOK_START}
 execx($(${command} activate xonsh))
 ${MISE_HOOK_END}
@@ -214,7 +1686,7 @@ ${MISE_HOOK_END}
       };
     case "elvish":
       return {
-        path: join3(homeDir, ".config", "elvish", "rc.elv"),
+        path: join6(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 }
@@ -225,7 +1697,7 @@ ${MISE_HOOK_END}
     case "pwsh":
     case "powershell":
       return {
-        path: join3(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        path: join6(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
         content: `${MISE_HOOK_START}
 (& ${command} activate pwsh) | Out-String | Invoke-Expression
 ${MISE_HOOK_END}
@@ -234,7 +1706,7 @@ ${MISE_HOOK_END}
     case "bash":
     default:
       return {
-        path: join3(homeDir, ".bashrc"),
+        path: join6(homeDir, ".bashrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate bash)"
 ${MISE_HOOK_END}
@@ -273,7 +1745,7 @@ function isVersionAtLeast(version, minimumVersion) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile2(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return "";
@@ -283,80 +1755,356 @@ async function getOptionalFile2(path) {
 function getShellQuoted(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
-// 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";
-var pi = {
-  async executableCheck() {
-    return findExecutable("pi");
-  },
-  async packageList(executable) {
-    return (await runChecked(executable, ["list"])).stdout;
-  },
-  packageCheck(listOutput, source) {
-    if (listOutput.includes(source))
-      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;
+// src/modes.ts
+import {
+  getAgentDir,
+  parseFrontmatter as parseFrontmatter2
+} from "@earendil-works/pi-coding-agent";
+import { readFile as readFile7 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { basename as basename4, extname, join as join8 } from "node:path";
+
+// src/assets.ts
+import { existsSync } from "node:fs";
+import { dirname as dirname5, join as join7 } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
+  const moduleDir = dirname5(fileURLToPath(moduleUrl));
+  const candidates = [join7(moduleDir, name), join7(moduleDir, "..", name), join7(moduleDir, "..", "..", name)];
+  return candidates.find((path) => existsSync(path)) ?? candidates[1];
+}
+function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("agents", moduleUrl);
+}
+function resolveBundledTemplatesDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("templates", moduleUrl);
+}
+
+// src/modes.ts
+async function discoverAgentModes(options) {
+  const agentDir = options.agentDir ?? getAgentDir();
+  const homeDir = options.homeDir ?? homedir6();
+  const modes = new Map;
+  const diagnostics = [];
+  await loadAgentModes(options.bundledAgentsDir ?? BUNDLED_AGENTS_DIR, "diffpi agent", modes, diagnostics);
+  await loadAgentModes(join8(agentDir, "agents"), "user agent", modes, diagnostics);
+  if (options.includeSkills) {
+    await loadSkillModes(join8(homeDir, ".agents", "skills"), "user skill", modes, diagnostics);
+    await loadSkillModes(join8(agentDir, "skills"), "pi user skill", modes, diagnostics);
+  }
+  if (options.projectTrusted === true) {
+    if (options.includeSkills) {
+      await loadSkillModes(join8(options.cwd, ".agents", "skills"), "project skill", modes, diagnostics);
+      await loadSkillModes(join8(options.cwd, ".pi", "skills"), "pi project skill", modes, diagnostics);
     }
-    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");
+    await loadAgentModes(join8(options.cwd, ".agents", "agents"), "project agent", modes, diagnostics);
+    await loadAgentModes(join8(options.cwd, ".pi", "agents"), "pi project agent", modes, diagnostics);
+  }
+  const userConfig = await loadDiffpiConfig({ homeDir });
+  const configuredModes = [...modes.values()].map((mode) => ({
+    ...mode,
+    modelPreferences: resolveAgentModelPreferences(mode.id, mode.modelPreferences, userConfig.config)
+  }));
+  return {
+    modes: configuredModes.sort((left, right) => left.id.localeCompare(right.id)),
+    diagnostics
+  };
+}
+function resolveAgentMode(modes, requested) {
+  const name = requested.trim();
+  if (!name)
+    return { ok: false, message: "Agent name is required." };
+  const exact = modes.find((mode) => mode.id === name);
+  if (exact)
+    return { ok: true, active: exact, message: `Active inline agent: ${exact.id}.` };
+  const lowerName = name.toLowerCase();
+  const matches = modes.filter((mode) => mode.id.toLowerCase() === lowerName);
+  if (matches.length === 1) {
+    const active = matches[0];
+    return { ok: true, active, message: `Active inline agent: ${active.id}.` };
+  }
+  if (matches.length > 1) {
+    return {
+      ok: false,
+      message: `Inline agent "${name}" is ambiguous. Use one of: ${matches.map((mode) => mode.id).join(", ")}.`
+    };
+  }
+  return { ok: false, message: `Unknown inline agent "${name}". Run /skill:mode or diffpi_modes_list.` };
+}
+function createModeController(pi, options = {}) {
+  let active;
+  let baseline;
+  const updateStatus = (ctx) => {
+    ctx.ui.setStatus(MODE_STATUS_KEY, active ? `mode: ${active.id}` : undefined);
+  };
+  const list = (ctx, listOptions = {}) => discoverAgentModes({
+    cwd: ctx.cwd,
+    agentDir: options.agentDir,
+    bundledAgentsDir: options.bundledAgentsDir,
+    homeDir: options.homeDir,
+    projectTrusted: ctx.isProjectTrusted(),
+    includeSkills: listOptions.includeSkills
+  });
+  return {
+    list,
+    async set(agent, ctx) {
+      const catalog = await list(ctx, { includeSkills: agent.includes(":") });
+      const result = resolveAgentMode(catalog.modes, agent);
+      if (!result.ok || !result.active)
+        return result;
+      baseline ??= captureRuntime(pi, ctx);
+      if (active && baseline)
+        await restoreRuntime(pi, baseline, ctx);
+      active = result.active;
+      const runtimeMessage = await applyModeRuntime(pi, active, ctx);
+      pi.appendEntry(MODE_STATE_ENTRY, { active, baseline });
+      updateStatus(ctx);
+      return { ...result, message: `${result.message} ${runtimeMessage}` };
+    },
+    async unset(ctx) {
+      if (!active)
+        return { ok: true, message: "Inline agent is already clear." };
+      if (baseline)
+        await restoreRuntime(pi, baseline, ctx);
+      active = undefined;
+      pi.appendEntry(MODE_STATE_ENTRY, { active: null });
+      baseline = undefined;
+      updateStatus(ctx);
+      return { ok: true, message: "Inline agent cleared. The previous model, thinking, tools, and prompt resume." };
+    },
+    async restore(ctx) {
+      const previousActive = active;
+      const previousBaseline = baseline;
+      const entry = [...ctx.sessionManager.getBranch()].reverse().find((candidate) => candidate.type === "custom" && candidate.customType === MODE_STATE_ENTRY);
+      const restored = entry?.data?.active;
+      const restoredBaseline = entry?.data?.baseline;
+      if (isAgentModeSnapshot(restored)) {
+        active = restored;
+        baseline = isModeBaseline(restoredBaseline) ? restoredBaseline : previousBaseline;
+        await applyModeRuntime(pi, active, ctx);
+      } else {
+        if (previousActive && previousBaseline)
+          pi.setActiveTools(previousBaseline.tools);
+        active = undefined;
+        baseline = undefined;
+      }
+      updateStatus(ctx);
+    },
+    apply(systemPrompt) {
+      if (!active)
+        return systemPrompt;
+      if (active.promptStrategy === "replace")
+        return active.systemPrompt;
+      return `${systemPrompt}
+
+## Active inline agent: ${active.label}
+
+${active.systemPrompt}`;
+    },
+    getActive() {
+      return active;
+    }
+  };
+}
+var MODE_STATE_ENTRY = "diffpi-mode-state";
+var MODE_STATUS_KEY = "diffpi-mode";
+var MODE_CONTROL_TOOLS = ["ask_user_question", "diffpi_modes_list", "diffpi_modes_set", "diffpi_modes_unset"];
+var BUNDLED_AGENTS_DIR = resolveBundledAgentsDir();
+var THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+async function applyModeRuntime(pi, mode, ctx) {
+  let selectedModel;
+  if (mode.modelPreferences.length > 0) {
+    const scoped = ctx.scopedModels.length > 0 ? ctx.scopedModels.map((entry) => entry.model) : undefined;
+    const availableModels = scoped ?? ctx.modelRegistry.getAvailable();
+    for (const preference of mode.modelPreferences) {
+      const model = findPreferredModel(availableModels, preference);
+      if (model && await pi.setModel(model)) {
+        selectedModel = `${model.provider}/${model.id}`;
+        break;
+      }
+    }
+  }
+  if (mode.thinkingLevel)
+    pi.setThinkingLevel(mode.thinkingLevel);
+  if (mode.tools.length > 0) {
+    const availableTools = new Set(pi.getAllTools().map((tool) => tool.name));
+    const selectedTools = [...new Set([...mode.tools, ...MODE_CONTROL_TOOLS])].filter((tool) => availableTools.has(tool));
+    if (selectedTools.length > 0)
+      pi.setActiveTools(selectedTools);
+  }
+  const parts = [];
+  if (mode.modelPreferences.length > 0) {
+    parts.push(selectedModel ? `Model: ${selectedModel}.` : "No preferred model was available; kept the current model.");
+  }
+  if (mode.thinkingLevel)
+    parts.push(`Thinking: ${mode.thinkingLevel}.`);
+  if (mode.tools.length > 0)
+    parts.push("Applied the profile tool set.");
+  return parts.join(" ") || "The profile changes the prompt only.";
+}
+async function restoreRuntime(pi, state, ctx) {
+  if (state.model) {
+    const model = ctx.modelRegistry.find(state.model.provider, state.model.id);
+    if (model)
+      await pi.setModel(model);
+  }
+  pi.setThinkingLevel(state.thinkingLevel);
+  pi.setActiveTools(state.tools);
+}
+function captureRuntime(pi, ctx) {
+  return {
+    model: ctx.model ? { provider: ctx.model.provider, id: ctx.model.id } : undefined,
+    thinkingLevel: pi.getThinkingLevel(),
+    tools: pi.getActiveTools()
+  };
+}
+async function loadSkillModes(skillsDir, source, modes, diagnostics) {
+  const entries = await readDirectoryIfExists(skillsDir);
+  for (const entry of entries.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
+    await loadAgentModes(join8(skillsDir, entry.name, "agents"), `${source} ${entry.name}`, modes, diagnostics, entry.name);
+  }
+}
+async function loadAgentModes(directory, source, modes, diagnostics, skillName) {
+  const entries = await readDirectoryIfExists(directory);
+  for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name))) {
+    const path = join8(directory, entry.name);
+    try {
+      const content = await readFile7(path, "utf8");
+      const { frontmatter, body } = parseFrontmatter2(content.startsWith("\uFEFF") ? content.slice(1) : content);
+      if (frontmatter.enabled === false || frontmatter.inline === false)
+        continue;
+      const name = getFrontmatterText(frontmatter.name) ?? basename4(path, extname(path));
+      const systemPrompt = body.trim();
+      if (!name || name.includes(":") || !systemPrompt) {
+        diagnostics.push(`Skipped ${path}: agent name must not contain ":" and prompt body is required.`);
+        continue;
+      }
+      const id = skillName ? `${skillName}:${name}` : name;
+      modes.set(id, {
+        id,
+        label: getFrontmatterText(frontmatter.display_name) ?? name,
+        description: getFrontmatterText(frontmatter.description) ?? `Inline agent from ${basename4(path)}`,
+        systemPrompt,
+        promptStrategy: frontmatter.prompt_mode === "append" ? "append" : "replace",
+        modelPreferences: [
+          ...getFrontmatterList(frontmatter.model),
+          ...getFrontmatterList(frontmatter.model_fallbacks)
+        ],
+        thinkingLevel: getThinkingLevel(frontmatter.thinking),
+        tools: getFrontmatterList(frontmatter.tools),
+        source,
+        sourcePath: path
+      });
+    } catch (error) {
+      diagnostics.push(`Skipped ${path}: ${error instanceof Error ? error.message : String(error)}`);
     }
-    return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
   }
+}
+function getFrontmatterText(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function getFrontmatterList(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 getThinkingLevel(value) {
+  const level = getFrontmatterText(value);
+  return level && THINKING_LEVELS.has(level) ? level : undefined;
+}
+function isAgentModeSnapshot(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  return typeof candidate.id === "string" && typeof candidate.label === "string" && typeof candidate.description === "string" && typeof candidate.systemPrompt === "string" && (candidate.promptStrategy === "append" || candidate.promptStrategy === "replace") && Array.isArray(candidate.modelPreferences) && (candidate.thinkingLevel === undefined || THINKING_LEVELS.has(candidate.thinkingLevel)) && Array.isArray(candidate.tools) && typeof candidate.source === "string" && typeof candidate.sourcePath === "string";
+}
+function isModeBaseline(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const candidate = value;
+  const model = candidate.model;
+  return (model === undefined || typeof model.provider === "string" && typeof model.id === "string") && candidate.thinkingLevel !== undefined && THINKING_LEVELS.has(candidate.thinkingLevel) && Array.isArray(candidate.tools) && candidate.tools.every((tool) => typeof tool === "string");
+}
+// src/pi.ts
+import { mkdir as mkdir5, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname6, join as join9 } from "node:path";
+var pi = {
+  executableCheck: findPiExecutable,
+  packageList: listPiPackages,
+  packageCheck: hasPiPackage,
+  packageInstall: installPiPackage,
+  agentDir: resolvePiAgentDir,
+  agentEnsure: ensurePiAgent,
+  skillCheckGlobal: checkGlobalPiSkill,
+  skillInstallGlobal: installGlobalPiSkills,
+  configEnsure: ensurePiConfig
 };
-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"));
+async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
+  const path = join9(agentDir, "agents", filename);
+  const currentText = await readTextIfExists(path);
+  const changed = currentText !== content;
+  if (changed && !dryRun) {
+    await mkdir5(dirname6(path), { recursive: true });
+    await writeFile5(path, content, "utf8");
+  }
+  return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
-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 checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join9(homedir7(), ".agents", "skills")) {
+  const roots = [join9(agentDir, "skills"), sharedSkillsDir];
+  for (const root of roots) {
+    if (await readTextIfExists(join9(root, name, "SKILL.md")) !== undefined)
+      return true;
+  }
+  return false;
+}
+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 mkdir5(dirname6(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 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 ? join9(process.env.XDG_CONFIG_HOME, "pi") : join9(homeDir, ".pi", "agent"));
 }
-function getParsedObject(content, path) {
+function parseJsonObject(content, path) {
   if (!content?.trim())
     return {};
   try {
@@ -366,9 +2114,56 @@ function getParsedObject(content, path) {
   } catch {}
   throw new Error(`Expected valid JSON object in ${path}.`);
 }
+// src/review-publication.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile8, rename, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join10 } from "node:path";
+import { z as z3 } from "zod";
+var reviewPublicationStateSchema = z3.object({
+  target: z3.string().optional(),
+  comments: z3.array(z3.string()).default([]),
+  replies: z3.array(z3.string()).default([]),
+  overlayPath: z3.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 = join10(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  try {
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile8(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 z3.ZodError) {
+      throw new Error(`Cannot parse review publication state: ${path}`);
+    }
+    throw error;
+  }
+}
+async function saveReviewPublicationState(path, state) {
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile6(temp, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  await rename(temp, path);
+}
+function digest(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
 // src/setup.ts
-import { homedir as homedir4 } from "node:os";
-import { join as join5 } from "node:path";
+import { parseFrontmatter as parseFrontmatter3 } from "@earendil-works/pi-coding-agent";
+import { readdir as readdir2, readFile as readFile9 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { basename as basename5, join as join11 } from "node:path";
 var MISE_DEPENDENCIES = [
   { name: "node", tool: "node", spec: "node@22", minimumVersion: "22.19.0" },
   { name: "zellij", tool: "zellij", spec: "zellij@latest", minimumVersion: undefined },
@@ -399,9 +2194,14 @@ var PI_SKILL_SOURCES = [
   { repository: "AminBlg/SimpleEnglish", skills: ["simple-english"] }
 ];
 var MCP_ADAPTER_PACKAGE = "npm:pi-mcp-adapter";
+var BUNDLED_AGENTS_DIR2 = resolveBundledAgentsDir();
+var FORGE_DEPENDENCIES = {
+  github: { name: "gh", tool: "gh", spec: "gh@latest", minimumVersion: undefined },
+  gitlab: { name: "glab", tool: "glab", spec: "glab@latest", minimumVersion: undefined }
+};
 async function ensureMise(options = {}) {
-  const homeDir = options.homeDir ?? 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(join11(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -430,7 +2230,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));
@@ -446,18 +2249,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_DIR2;
+  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 = basename5(entry.name, ".md").replace(/^diffpi-/, "");
+    const source = await readFile9(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 ?? homedir8(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -501,6 +2319,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)
@@ -514,13 +2338,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 } = parseFrontmatter3(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)
@@ -542,6 +2434,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);
@@ -558,15 +2454,119 @@ function reportProgress(options, message) {
 function getRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+// src/templates.ts
+import { readFile as readFile10 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { join as join12, normalize } from "node:path";
+async function loadTemplate(name, options = {}) {
+  const relative = templateRelativePath(name);
+  const userPath = join12(options.homeDir ?? homedir9(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join12(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
+  const user = await readOptionalFile(userPath);
+  if (user !== undefined)
+    return { name, path: userPath, source: "user", content: user };
+  const bundled = await readOptionalFile(bundledPath);
+  if (bundled !== undefined)
+    return { name, path: bundledPath, source: "bundled", content: bundled };
+  throw new Error(`Template "${name}" was not found at ${userPath} or ${bundledPath}.`);
+}
+function renderTemplate(content, variables) {
+  return content.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => variables[key] ?? match);
+}
+function templateRelativePath(name) {
+  const normalized = normalize(name.replaceAll("\\", "/")).replace(/^\.\//, "");
+  if (!normalized || normalized.startsWith("../") || normalized.includes("/../") || normalized.startsWith("/")) {
+    throw new Error(`Invalid template name: ${name}`);
+  }
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile10(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
 export {
+  CONVENTIONAL_COMMIT,
+  ZED_REVIEW_TASK_NAME,
+  addComment,
+  assertGitHubMergeReady,
+  assertReviewEventSupported,
+  checkConventionalSubject,
+  ciGate,
+  computeProjectSlug,
+  createForge,
+  createLocalReviewBackend,
+  createModeController,
+  createRemoteReviewBackend,
+  dedupeFindings,
+  detectIde,
+  detectMux,
+  detectShell,
+  detectVcs,
+  diffpiConfigPaths,
+  discoverAgentModes,
   ensureMcpAdapters,
   ensureMise,
   ensureMiseDeps,
   ensureMiseHooks,
+  ensurePiAgents,
   ensurePiPlugins,
   ensurePiSkills,
+  ensureStore,
+  ensureZedReviewKeybinding,
+  ensureZedReviewTask,
+  findPreferredModel,
+  findingSchema,
+  findingsSchema,
+  gitToplevel,
+  githubReviewSubmissionEndpoint,
+  hasGitlabDraftNotes,
+  launch,
+  listSessions,
+  loadDiffpiConfig,
+  loadReviewPublicationState,
+  loadTemplate,
+  localReviewAuthor,
   mcp,
   mise,
+  openInNewTab,
+  parseGitlabDiffRefs,
+  parseRemote,
+  parseThreadArtifact,
   pi,
-  setupPi
+  readSession,
+  renderReviewDoc,
+  renderTemplate,
+  renderThreadArtifact,
+  resolveAgentMode,
+  resolveAgentModelPreferences,
+  resolvePrSession,
+  resolveReviewSession,
+  resolveSession,
+  reviewCommentFingerprint,
+  reviewRecordName,
+  reviewReplyFingerprint,
+  reviewSlug,
+  reviewsDir,
+  runMiseGates,
+  saveReviewPublicationState,
+  sessionsDir,
+  setupPi,
+  severitySchema,
+  storeDir,
+  storeGlobalRoot,
+  templateRelativePath,
+  toFindings,
+  toReviewComments,
+  tuicrAvailable,
+  unpublishedReviewComments,
+  upsertThreadReply,
+  withRemoteProvenance,
+  yymmdd,
+  zedKeymapPath,
+  zedTasksPath
 };