@difflab/pi 0.2.0 → 0.3.0-rc.202609201609.21ba1d2

package/dist/index.js

@@ -94,76 +94,31 @@ ${document}
 function normalizeModelReference(value) {
   return value.toLowerCase().replace(/^~/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-// src/mcp.ts
-import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
+// src/environment.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { basename, join as join5 } from "node:path";
+
+// src/assets.ts
+import { existsSync } from "node:fs";
 import { dirname, join as join2 } from "node:path";
-var mcp = {
-  globalConfigPath(homeDir = homedir2()) {
-    return join2(homeDir, ".config", "mcp", "mcp.json");
-  },
-  async serversEnsure(servers, options = {}) {
-    const path = options.path ?? mcp.globalConfigPath();
-    const currentText = await getOptionalFile(path);
-    const current = getParsedConfig(currentText, path);
-    const nextServers = { ...current.mcpServers };
-    for (const [name, entry] of Object.entries(servers)) {
-      nextServers[name] = mergeEntry(nextServers[name], entry);
-    }
-    const next = { ...current, mcpServers: nextServers };
-    const changed = JSON.stringify(current) !== JSON.stringify(next);
-    if (changed && !options.dryRun) {
-      await mkdir(dirname(path), { recursive: true });
-      await writeFile(path, `${JSON.stringify(next, null, 2)}
-`, "utf8");
-    }
-    return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
-  }
-};
-function mergeEntry(current, required) {
-  const merged = { ...current, ...required };
-  if (current?.env || required.env)
-    merged.env = { ...current?.env, ...required.env };
-  return merged;
-}
-function getParsedConfig(content, path) {
-  if (!content?.trim())
-    return { mcpServers: {} };
-  try {
-    const value = JSON.parse(content);
-    if (!isRecord(value))
-      throw new Error("not an object");
-    const servers = value.mcpServers;
-    if (servers !== undefined && !isRecord(servers))
-      throw new Error("mcpServers is not an object");
-    return { ...value, mcpServers: servers ?? {} };
-  } catch {
-    throw new Error(`Expected a valid pi-mcp-adapter configuration in ${path}.`);
-  }
+import { fileURLToPath } from "node:url";
+function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
+  const moduleDir = dirname(fileURLToPath(moduleUrl));
+  const candidates = [join2(moduleDir, name), join2(moduleDir, "..", name), join2(moduleDir, "..", "..", name)];
+  return candidates.find((path) => existsSync(path)) ?? candidates[1];
 }
-async function getOptionalFile(path) {
-  try {
-    return await readFile2(path, "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return;
-    throw error;
-  }
+function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("agents", moduleUrl);
 }
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+function resolveBundledTemplatesDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("templates", moduleUrl);
 }
-// src/mise.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { basename, dirname as dirname2, join as join4 } from "node:path";
 
-// src/process.ts
+// src/extensions/processx.ts
+import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
 import { delimiter, join as join3 } from "node:path";
-import { spawn } from "node:child_process";
-var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
 async function findExecutable(name) {
   if (name.includes("/")) {
     try {
@@ -189,18 +144,35 @@ function run(command, args, options = {}) {
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: options.env ?? process.env,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
     });
     let stdout = "";
     let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout = appendBounded(stdout, chunk.toString());
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const unbounded = options.capture === "unbounded";
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (unbounded)
+        stdoutChunks.push(text);
+      else
+        stdout = appendBounded(stdout, text);
     });
-    child.stderr.on("data", (chunk) => {
-      stderr = appendBounded(stderr, chunk.toString());
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (unbounded)
+        stderrChunks.push(text);
+      else
+        stderr = appendBounded(stderr, text);
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    child.on("close", (code) => resolve({
+      code: code ?? 1,
+      stdout: unbounded ? stdoutChunks.join("") : stdout,
+      stderr: unbounded ? stderrChunks.join("") : stderr
+    }));
+    if (options.input !== undefined && child.stdin)
+      child.stdin.end(options.input);
   });
 }
 async function runChecked(command, args, options = {}) {
@@ -210,24 +182,595 @@ async function runChecked(command, args, options = {}) {
   const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
   throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
 }
+var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
 function appendBounded(current, next) {
   const combined = current + next;
   return combined.length <= MAX_CAPTURED_OUTPUT_LENGTH ? combined : combined.slice(-MAX_CAPTURED_OUTPUT_LENGTH);
 }
 
-// src/mise.ts
+// src/extensions/zedx.ts
+import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join4 } from "node:path";
+var ZED_LOCAL_REVIEW_TASK_NAME = "diffpi: tuicr local review";
+var ZED_REVIEW_TASK_NAME = ZED_LOCAL_REVIEW_TASK_NAME;
+var ZED_PR_REVIEW_TASK_NAME = "diffpi: tuicr PR review";
+var ZED_PLAN_ANNOTATE_TASK_NAME = "diffpi: annotate plan";
+var LEGACY_ZED_REVIEW_TASK_NAME = "diffpi: tuicr review";
+var REVIEW_KEYBINDING = "cmd-alt-r";
+function zedTasksPath(homeDir = homedir2()) {
+  return join4(homeDir, ".config", "zed", "tasks.json");
+}
+function zedKeymapPath(homeDir = homedir2()) {
+  return join4(homeDir, ".config", "zed", "keymap.json");
+}
+async function ensureZedReviewTask(homeDir = homedir2(), _command = ["tuicr", "-w", "-r", "main..HEAD"]) {
+  const path = zedTasksPath(homeDir);
+  const currentText = await readOptional(path);
+  const tasks = parseJsonArray(currentText, path);
+  const migrated = tasks.filter((task) => task.label !== LEGACY_ZED_REVIEW_TASK_NAME);
+  const next = [...migrated];
+  for (const task of [localReviewTask(), prReviewTask()]) {
+    const index = next.findIndex((existing) => existing.label === task.label);
+    if (index >= 0)
+      next[index] = { ...next[index], ...task };
+    else
+      next.push(task);
+  }
+  const changed = JSON.stringify(tasks) !== JSON.stringify(next);
+  if (changed)
+    await writeJson(path, next);
+  return { path, changed, existed: currentText !== undefined };
+}
+async function ensureZedPlanTask(packageVersion, homeDir = homedir2()) {
+  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(packageVersion)) {
+    throw new Error(`Invalid @difflab/pi package version: ${packageVersion}.`);
+  }
+  const path = zedTasksPath(homeDir);
+  const currentText = await readOptional(path);
+  const tasks = parseJsonArray(currentText, path);
+  const task = {
+    label: ZED_PLAN_ANNOTATE_TASK_NAME,
+    command: "npx",
+    args: ["--yes", `@difflab/pi@${packageVersion}`, "plan", "annotate", "--cwd", "$ZED_WORKTREE_ROOT"],
+    cwd: "$ZED_WORKTREE_ROOT",
+    use_new_terminal: true,
+    reveal: "always",
+    reveal_target: "center"
+  };
+  const next = [...tasks];
+  const index = next.findIndex((candidate) => candidate.label === task.label);
+  if (index >= 0)
+    next[index] = { ...next[index], ...task };
+  else
+    next.push(task);
+  const changed = JSON.stringify(tasks) !== JSON.stringify(next);
+  if (changed)
+    await writeJson(path, next);
+  return { path, changed, existed: currentText !== undefined };
+}
+async function ensureZedReviewKeybinding(homeDir = homedir2()) {
+  const path = zedKeymapPath(homeDir);
+  const currentText = await readOptional(path);
+  const entries = parseJsonArray(currentText, path);
+  const migrated = entries.map(migrateReviewKeymapEntry);
+  const alreadyBound = migrated.some((entry) => Object.values(entry.bindings ?? {}).some((action) => Array.isArray(action) && action[0] === "task::Spawn" && bindsReviewTask(action[1])));
+  const next = alreadyBound ? migrated : [
+    ...migrated,
+    {
+      context: "Workspace",
+      bindings: { [REVIEW_KEYBINDING]: ["task::Spawn", { task_name: ZED_LOCAL_REVIEW_TASK_NAME }] }
+    }
+  ];
+  const changed = JSON.stringify(entries) !== JSON.stringify(next);
+  if (changed)
+    await writeJson(path, next);
+  return { path, changed, existed: currentText !== undefined };
+}
+function zedReviewTaskName(command) {
+  if (command.some((value, index) => value === "plan" && command[index + 1] === "annotate")) {
+    return ZED_PLAN_ANNOTATE_TASK_NAME;
+  }
+  return command[0] === "tuicr" && command[1] === "pr" ? ZED_PR_REVIEW_TASK_NAME : ZED_LOCAL_REVIEW_TASK_NAME;
+}
+var LOCAL_REVIEW_SCRIPT = `set -eu
+remote=$(git remote get-url origin 2>/dev/null || true)
+branch=$(git branch --show-current)
+base=
+case "$remote" in
+  *github.com*)
+    base=$(gh pr list --head "$branch" --state open --limit 100 --json baseRefName,createdAt --jq 'sort_by(.createdAt) | reverse | .[0].baseRefName // empty' 2>/dev/null || true)
+    [ -n "$base" ] || base=$(gh repo view --json defaultBranchRef --jq .defaultBranchRef.name 2>/dev/null || true)
+    ;;
+  *gitlab*)
+    mr=$(glab mr list --source-branch "$branch" --order created_at --sort desc --per-page 100 --output json 2>/dev/null || true)
+    base=$(printf '%s' "$mr" | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{let a=JSON.parse(s);process.stdout.write(a[0]?.target_branch||"")}catch{}})')
+    [ -n "$base" ] || base=$(glab repo view --output json 2>/dev/null | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).default_branch||"")}catch{}})' || true)
+    ;;
+esac
+[ -n "$base" ] || { echo 'diffpi: could not resolve a GitHub/GitLab review base' >&2; exit 1; }
+exec tuicr -w -r "$base..HEAD"`;
+var PR_REVIEW_SCRIPT = `set -eu
+remote=$(git remote get-url origin 2>/dev/null || true)
+branch=$(git branch --show-current)
+case "$remote" in
+  *github.com*) number=$(gh pr list --head "$branch" --state open --limit 100 --json number,createdAt --jq 'sort_by(.createdAt) | reverse | .[0].number // empty' 2>/dev/null || true) ;;
+  *gitlab*) number=$(glab mr list --source-branch "$branch" --order created_at --sort desc --per-page 100 --output json 2>/dev/null | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{let a=JSON.parse(s);process.stdout.write(String(a[0]?.iid||a[0]?.number||""))}catch{}})' || true) ;;
+  *) number= ;;
+esac
+[ -n "$number" ] || { echo 'diffpi: could not resolve the current GitHub PR or GitLab MR' >&2; exit 1; }
+exec tuicr pr "$number"`;
+function staticReviewTask(label, script) {
+  return {
+    label,
+    command: "sh",
+    args: ["-lc", script],
+    cwd: "$ZED_WORKTREE_ROOT",
+    use_new_terminal: true,
+    reveal: "always",
+    reveal_target: "center"
+  };
+}
+function localReviewTask() {
+  return staticReviewTask(ZED_LOCAL_REVIEW_TASK_NAME, LOCAL_REVIEW_SCRIPT);
+}
+function prReviewTask() {
+  return staticReviewTask(ZED_PR_REVIEW_TASK_NAME, PR_REVIEW_SCRIPT);
+}
+function bindsReviewTask(payload) {
+  return typeof payload === "object" && payload !== null && payload.task_name === ZED_LOCAL_REVIEW_TASK_NAME;
+}
+function migrateReviewKeymapEntry(entry) {
+  const bindings = Object.fromEntries(Object.entries(entry.bindings ?? {}).map(([key, action]) => {
+    if (Array.isArray(action) && action[0] === "task::Spawn" && typeof action[1] === "object" && action[1] !== null && action[1].task_name === LEGACY_ZED_REVIEW_TASK_NAME) {
+      return [key, ["task::Spawn", { ...action[1], task_name: ZED_LOCAL_REVIEW_TASK_NAME }]];
+    }
+    return [key, action];
+  }));
+  return entry.bindings ? { ...entry, bindings } : entry;
+}
+async function readOptional(path) {
+  try {
+    return await readFile2(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function parseJsonArray(content, path) {
+  if (!content?.trim())
+    return [];
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch {
+    throw new Error(`Cannot safely edit ${path}: not strict JSON (it may contain JSONC comments).`);
+  }
+  if (!Array.isArray(value))
+    throw new Error(`Expected a JSON array in ${path}.`);
+  return value;
+}
+async function writeJson(path, value) {
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+
+// src/environment.ts
+function detectIde(env = process.env) {
+  const program = (env.TERM_PROGRAM ?? "").toLowerCase();
+  if (env.ZED_TERM === "true" || program === "zed")
+    return "zed";
+  if (env.CURSOR_TRACE_ID || program === "cursor")
+    return "cursor";
+  if (env.WINDSURF_ENV || program === "windsurf")
+    return "windsurf";
+  if (env.TERMINAL_EMULATOR?.toLowerCase().includes("jetbrains"))
+    return "jetbrains";
+  if (env.VSCODE_PID || env.VSCODE_GIT_IPC_HANDLE || program === "vscode")
+    return "vscode";
+  return "unknown";
+}
+function detectMux(env = process.env) {
+  if (env.ZELLIJ || env.ZELLIJ_SESSION_NAME)
+    return "zellij";
+  if (env.TMUX)
+    return "tmux";
+  if (env.STY)
+    return "screen";
+  return "none";
+}
+function detectShell(env = process.env) {
+  return env.SHELL ? basename(env.SHELL) : "unknown";
+}
+async function detectVcs(cwd) {
+  const root = (await run("git", ["-C", cwd, "rev-parse", "--show-toplevel"])).stdout.trim() || cwd;
+  const branch = (await run("git", ["-C", root, "rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
+  const remote = (await run("git", ["-C", root, "remote", "get-url", "origin"])).stdout.trim();
+  return { ...parseRemote(remote), branch, root };
+}
+function parseRemote(remote) {
+  const empty = { provider: "none", host: "", owner: "", repo: "" };
+  if (!remote)
+    return empty;
+  const scp = remote.match(/^[^@]+@([^:]+):(.+?)(?:\.git)?$/);
+  const url = remote.match(/^[a-z]+:\/\/(?:[^@]+@)?([^/]+)\/(.+?)(?:\.git)?$/i);
+  const match = scp ?? url;
+  if (!match)
+    return empty;
+  const host = match[1];
+  const segments = match[2].split("/").filter(Boolean);
+  if (segments.length < 2)
+    return { ...empty, host };
+  const repo = segments.at(-1) ?? "";
+  const owner = segments.slice(0, -1).join("/");
+  const provider = /github/i.test(host) ? "github" : /gitlab/i.test(host) ? "gitlab" : "none";
+  return { provider, host, owner, repo };
+}
+async function openInNewTab(command, opts) {
+  const env = opts.env ?? process.env;
+  const name = opts.name ?? "review";
+  const printable = command.join(" ");
+  const mux = detectMux(env);
+  if (mux !== "none") {
+    const opened = await openMuxTab(mux, command, opts.cwd, name, printable);
+    if (opened)
+      return opened;
+  }
+  if (detectIde(env) === "zed") {
+    try {
+      const taskName = zedReviewTaskName(command);
+      if (taskName === ZED_PLAN_ANNOTATE_TASK_NAME)
+        await ensureZedPlanTask(await packageVersion(), opts.homeDir);
+      else
+        await ensureZedReviewTask(opts.homeDir, command);
+      return {
+        launched: false,
+        configured: true,
+        via: "zed-task",
+        command: printable,
+        taskName,
+        instruction: `Run the Zed task "${taskName}".`
+      };
+    } catch {}
+  }
+  return { launched: false, via: "print", command: printable };
+}
+function screenWindowArgs(command, cwd, name) {
+  return ["-X", "screen", "-t", name, "sh", "-lc", 'cd -- "$1" && shift && exec "$@"', "sh", cwd, ...command];
+}
+async function packageVersion() {
+  const value = JSON.parse(await readFile3(join5(resolveBundledAgentsDir(), "..", "package.json"), "utf8"));
+  if (typeof value.version !== "string")
+    throw new Error("Cannot resolve the installed @difflab/pi version.");
+  return value.version;
+}
+async function openMuxTab(mux, command, cwd, name, printable) {
+  if (mux === "zellij" && await findExecutable("zellij")) {
+    const result = await run("zellij", ["action", "new-tab", "--cwd", cwd, "--name", name, "--", ...command]);
+    if (result.code === 0)
+      return { launched: true, via: "zellij", command: printable };
+    const fallback = await run("zellij", ["run", "--cwd", cwd, "--name", name, "--", ...command]);
+    if (fallback.code === 0)
+      return { launched: true, via: "zellij-run", command: printable };
+  }
+  if (mux === "tmux" && await findExecutable("tmux")) {
+    const result = await run("tmux", ["new-window", "-c", cwd, "-n", name, printable]);
+    if (result.code === 0)
+      return { launched: true, via: "tmux", command: printable };
+  }
+  if (mux === "screen" && await findExecutable("screen")) {
+    const result = await run("screen", screenWindowArgs(command, cwd, name));
+    if (result.code === 0)
+      return { launched: true, via: "screen", command: printable };
+  }
+  return;
+}
+// src/extensions/gitx.ts
+import { realpath } from "node:fs/promises";
+import { basename as basename2, isAbsolute, join as join6, resolve } from "node:path";
+async function gitToplevel(cwd) {
+  const result = await run("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
+  const top = result.stdout.trim();
+  return result.code === 0 && top ? top : resolve(cwd);
+}
+async function inspectGitRepository(cwd) {
+  const root = await gitToplevel(cwd);
+  const remoteResult = await run("git", ["-C", root, "remote", "get-url", "origin"]);
+  const remote = remoteResult.code === 0 ? remoteResult.stdout.trim() : "";
+  const commonResult = await run("git", ["-C", root, "rev-parse", "--git-common-dir"]);
+  const common = commonResult.stdout.trim();
+  const commonPath = commonResult.code === 0 && common ? resolve(isAbsolute(common) ? common : join6(root, common)) : root;
+  const commonDir = await canonicalPath(commonPath);
+  return {
+    root,
+    commonDir,
+    ...remote ? { remote } : {},
+    name: remote ? repositoryName(remote) : basename2(resolve(commonDir, "..")) || basename2(root),
+    identity: remote ? `remote:${normalizeRemote(remote)}` : `git-common-dir:${commonDir}`
+  };
+}
+function normalizeRemote(remote) {
+  return remote.trim().replace(/\.git\/?$/i, "").replace(/\/+$/, "").toLowerCase();
+}
+function repositoryName(remote) {
+  const normalized = remote.trim().replace(/\.git\/?$/i, "").replace(/\/+$/, "");
+  return normalized.split(/[/\\:]/).filter(Boolean).at(-1) ?? "";
+}
+async function canonicalPath(path) {
+  try {
+    return await realpath(path);
+  } catch {
+    return resolve(path);
+  }
+}
+// src/extensions/ghx.ts
+function gh(args, options) {
+  return run("gh", args, options);
+}
+function ghChecked(args, options) {
+  return runChecked("gh", args, options);
+}
+
+// src/vcs/helpers.ts
+function isConfirmedMissingChange(provider, output) {
+  const message = output.toLowerCase();
+  return provider === "github" ? message.includes("no pull requests found for branch") || message.includes("could not find pull request") || message.includes("could not resolve to a pullrequest") : provider === "gitlab" ? message.includes("no open merge request") || /failed to get open merge request/.test(message) && /404(?: not found)?/.test(message) : false;
+}
+function parseJson(value, name) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`Cannot parse the ${name} response as JSON.`);
+  }
+}
+function commandFailure(command, args, result) {
+  return new Error(`${command} ${args.join(" ")} failed: ${result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`}`);
+}
+function requireBranchName(output, provider) {
+  const branch = output.trim();
+  if (!branch || branch === "null")
+    throw new Error(`${provider} did not return a default branch.`);
+  return branch;
+}
+
+// src/vcs/github.ts
+function GitHubVcsBackend(vcs) {
+  const repo = ["--repo", `${vcs.owner}/${vcs.repo}`];
+  const viewPr = async (idOrBranch) => {
+    const args = [
+      "pr",
+      "view",
+      idOrBranch,
+      ...repo,
+      "--json",
+      "number,title,url,isDraft,baseRefName,headRefName,headRefOid"
+    ];
+    const result = await gh(args);
+    if (result.code !== 0) {
+      if (isConfirmedMissingChange("github", result.stderr || result.stdout))
+        return;
+      throw commandFailure("gh", args, result);
+    }
+    if (!result.stdout.trim())
+      throw new Error("GitHub returned an empty pull request response.");
+    const data = parseJson(result.stdout, "GitHub pull request");
+    if (typeof data.number !== "number" || typeof data.title !== "string" || typeof data.url !== "string" || typeof data.isDraft !== "boolean" || typeof data.baseRefName !== "string" || typeof data.headRefName !== "string")
+      throw new Error("GitHub returned an invalid pull request response.");
+    return {
+      number: data.number,
+      title: data.title,
+      url: data.url,
+      isDraft: data.isDraft,
+      baseRef: data.baseRefName,
+      headRef: data.headRefName,
+      headSha: data.headRefOid
+    };
+  };
+  return {
+    provider: "github",
+    async createDraftPr(options) {
+      const args = [
+        "pr",
+        "create",
+        ...repo,
+        "--title",
+        options.title,
+        "--body",
+        options.body,
+        "--base",
+        options.base,
+        "--head",
+        options.head
+      ];
+      if (options.draft !== false)
+        args.push("--draft");
+      await ghChecked(args);
+      const ref = await viewPr(options.head);
+      if (!ref)
+        throw new Error("Draft PR created but could not be resolved.");
+      return ref;
+    },
+    viewPr,
+    async defaultBranch() {
+      return requireBranchName((await ghChecked([
+        "repo",
+        "view",
+        `${vcs.owner}/${vcs.repo}`,
+        "--json",
+        "defaultBranchRef",
+        "--jq",
+        ".defaultBranchRef.name"
+      ])).stdout, "GitHub");
+    },
+    async prDiff(id) {
+      return (await ghChecked(["pr", "diff", String(id), ...repo], { capture: "unbounded" })).stdout;
+    },
+    async prChecks(id) {
+      return (await gh(["pr", "checks", String(id), ...repo])).stdout;
+    },
+    async markReady(id) {
+      await ghChecked(["pr", "ready", String(id), ...repo]);
+    },
+    async closePr(id, comment) {
+      const args = ["pr", "close", String(id), ...repo];
+      if (comment)
+        args.push("--comment", comment);
+      await ghChecked(args);
+    },
+    async mergePr(id, subject) {
+      const readiness = await ghChecked([
+        "pr",
+        "view",
+        String(id),
+        ...repo,
+        "--json",
+        "isDraft,state,reviewDecision,mergeStateStatus,statusCheckRollup"
+      ]);
+      assertGitHubMergeReady(readiness.stdout);
+      await ghChecked(["pr", "merge", String(id), ...repo, "--squash", "--subject", subject]);
+    }
+  };
+}
+function assertGitHubMergeReady(input) {
+  const data = parseJson(input, "GitHub readiness");
+  const blockers = [];
+  if (data.state !== "OPEN")
+    blockers.push(`pull request state is ${data.state ?? "unknown"}`);
+  if (data.isDraft)
+    blockers.push("pull request is still a draft");
+  if (data.reviewDecision !== "APPROVED")
+    blockers.push(`review decision is ${data.reviewDecision || "not approved"}`);
+  if (data.mergeStateStatus !== "CLEAN")
+    blockers.push(`merge state is ${data.mergeStateStatus ?? "unknown"}`);
+  for (const check of data.statusCheckRollup ?? []) {
+    const name = check.name ?? check.context ?? "unnamed check";
+    if (check.__typename === "CheckRun") {
+      if (check.status !== "COMPLETED")
+        blockers.push(`${name} is ${check.status?.toLowerCase() ?? "pending"}`);
+      else if (!["SUCCESS", "SKIPPED", "NEUTRAL"].includes(check.conclusion ?? ""))
+        blockers.push(`${name} concluded ${(check.conclusion ?? "unknown").toLowerCase()}`);
+    } else if (check.state !== "SUCCESS")
+      blockers.push(`${name} is ${(check.state ?? "pending").toLowerCase()}`);
+  }
+  if (blockers.length > 0)
+    throw new Error(`Merge blocked: ${blockers.join("; ")}.`);
+}
+
+// src/extensions/glabx.ts
+function glab(args, options) {
+  return run("glab", args, options);
+}
+function glabChecked(args, options) {
+  return runChecked("glab", args, options);
+}
+
+// src/vcs/gitlab.ts
+function GitLabVcsBackend(vcs) {
+  const project = `${vcs.owner}/${vcs.repo}`;
+  const viewPr = async (idOrBranch) => {
+    const args = ["mr", "view", idOrBranch, "--repo", project, "--output", "json"];
+    const result = await glab(args);
+    if (result.code !== 0) {
+      if (isConfirmedMissingChange("gitlab", result.stderr || result.stdout))
+        return;
+      throw commandFailure("glab", args, result);
+    }
+    if (!result.stdout.trim())
+      throw new Error("GitLab returned an empty merge request response.");
+    const data = parseJson(result.stdout, "GitLab merge request");
+    if (typeof data.iid !== "number" || typeof data.title !== "string" || typeof data.web_url !== "string" || typeof data.target_branch !== "string" || typeof data.source_branch !== "string")
+      throw new Error("GitLab returned an invalid merge request response.");
+    return {
+      number: data.iid,
+      title: data.title,
+      url: data.web_url,
+      isDraft: Boolean(data.draft ?? data.work_in_progress),
+      baseRef: data.target_branch,
+      headRef: data.source_branch,
+      headSha: data.sha
+    };
+  };
+  return {
+    provider: "gitlab",
+    async createDraftPr(options) {
+      await glabChecked([
+        "mr",
+        "create",
+        "--repo",
+        project,
+        "--title",
+        `Draft: ${options.title}`,
+        "--description",
+        options.body,
+        "--target-branch",
+        options.base,
+        "--source-branch",
+        options.head,
+        "--yes"
+      ]);
+      const ref = await viewPr(options.head);
+      if (!ref)
+        throw new Error("Draft MR created but could not be resolved.");
+      return ref;
+    },
+    viewPr,
+    async defaultBranch() {
+      return requireBranchName((await glabChecked(["api", `projects/${encodeURIComponent(project)}`, "--jq", ".default_branch"])).stdout, "GitLab");
+    },
+    async prDiff(id) {
+      return (await glabChecked(["mr", "diff", String(id), "--repo", project], { capture: "unbounded" })).stdout;
+    },
+    async prChecks(id) {
+      return (await glabChecked([
+        "api",
+        `projects/${encodeURIComponent(project)}/merge_requests/${id}/pipelines?per_page=100`
+      ])).stdout;
+    },
+    async markReady(id) {
+      await glabChecked(["mr", "update", String(id), "--repo", project, "--ready"]);
+    },
+    async closePr(id, comment) {
+      if (comment)
+        await glabChecked(["mr", "note", String(id), "--repo", project, "--message", comment]);
+      await glabChecked(["mr", "close", String(id), "--repo", project]);
+    },
+    async mergePr() {
+      throw new Error("Merge is not supported by the GitLab forge adapter.");
+    }
+  };
+}
+
+// src/vcs/forge-backend.ts
+function createForgeBackend(vcs) {
+  if (vcs.provider === "github")
+    return GitHubVcsBackend(vcs);
+  if (vcs.provider === "gitlab")
+    return GitLabVcsBackend(vcs);
+  throw new Error("No supported forge detected from the git remote. Use --local for an offline review.");
+}
+var createVcsBackend = createForgeBackend;
+var createForge = createForgeBackend;
+// src/extensions/misex.ts
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { basename as basename3, dirname as dirname3, join as join7 } from "node:path";
 var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
 var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
 var mise = {
   async executableCheck(name = "mise") {
     return findExecutable(name);
   },
+  async run(args, options = {}) {
+    return run("mise", args, options);
+  },
   async install(options = {}) {
     const homeDir = options.homeDir ?? homedir3();
     const platform = options.platform ?? process.platform;
     if (platform === "win32")
       throw new Error("Automatic mise installation supports macOS and Linux only.");
-    const installedPath = join4(homeDir, ".local", "bin", "mise");
+    const installedPath = join7(homeDir, ".local", "bin", "mise");
     if (options.dryRun)
       return installedPath;
     await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
@@ -238,8 +781,8 @@ var mise = {
   },
   async hookEnsure(executable, options = {}) {
     const homeDir = options.homeDir ?? homedir3();
-    const hook = getShellHook(basename(options.shell ?? process.env.SHELL ?? ""), executable, homeDir);
-    const current = await getOptionalFile2(hook.path);
+    const hook = getShellHook(basename3(options.shell ?? process.env.SHELL ?? ""), executable, homeDir);
+    const current = await getOptionalFile(hook.path);
     if (current.includes(MISE_HOOK_START))
       return { path: hook.path, changed: false, planned: false };
     if (options.dryRun)
@@ -247,7 +790,7 @@ var mise = {
     const separator = current.length === 0 || current.endsWith(`
 `) ? "" : `
 `;
-    await mkdir2(dirname2(hook.path), { recursive: true });
+    await mkdir2(dirname3(hook.path), { recursive: true });
     await writeFile2(hook.path, `${current}${separator}${hook.content}`, "utf8");
     return { path: hook.path, changed: true, planned: false };
   },
@@ -274,7 +817,7 @@ function getShellHook(shell, executable, homeDir) {
   switch (shell.toLowerCase()) {
     case "zsh":
       return {
-        path: join4(homeDir, ".zshrc"),
+        path: join7(homeDir, ".zshrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate zsh)"
 ${MISE_HOOK_END}
@@ -282,7 +825,7 @@ ${MISE_HOOK_END}
       };
     case "fish":
       return {
-        path: join4(homeDir, ".config", "fish", "config.fish"),
+        path: join7(homeDir, ".config", "fish", "config.fish"),
         content: `${MISE_HOOK_START}
 ${command} activate fish | source
 ${MISE_HOOK_END}
@@ -291,7 +834,7 @@ ${MISE_HOOK_END}
     case "nu":
     case "nushell":
       return {
-        path: join4(homeDir, ".config", "nushell", "config.nu"),
+        path: join7(homeDir, ".config", "nushell", "config.nu"),
         content: `${MISE_HOOK_START}
 let mise_bin = ${command}
 let mise_path = $nu.default-config-dir | path join mise.nu
@@ -302,7 +845,7 @@ ${MISE_HOOK_END}
       };
     case "xonsh":
       return {
-        path: join4(homeDir, ".xonshrc"),
+        path: join7(homeDir, ".xonshrc"),
         content: `${MISE_HOOK_START}
 execx($(${command} activate xonsh))
 ${MISE_HOOK_END}
@@ -310,7 +853,7 @@ ${MISE_HOOK_END}
       };
     case "elvish":
       return {
-        path: join4(homeDir, ".config", "elvish", "rc.elv"),
+        path: join7(homeDir, ".config", "elvish", "rc.elv"),
         content: `${MISE_HOOK_START}
 var mise: = (ns [&])
 eval (${command} activate elvish | slurp) &ns=$mise: &on-end={|ns| set mise: = $ns }
@@ -321,7 +864,7 @@ ${MISE_HOOK_END}
     case "pwsh":
     case "powershell":
       return {
-        path: join4(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        path: join7(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
         content: `${MISE_HOOK_START}
 (& ${command} activate pwsh) | Out-String | Invoke-Expression
 ${MISE_HOOK_END}
@@ -330,7 +873,7 @@ ${MISE_HOOK_END}
     case "bash":
     default:
       return {
-        path: join4(homeDir, ".bashrc"),
+        path: join7(homeDir, ".bashrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate bash)"
 ${MISE_HOOK_END}
@@ -367,9 +910,9 @@ function isVersionAtLeast(version, minimumVersion) {
   }
   return true;
 }
-async function getOptionalFile2(path) {
+async function getOptionalFile(path) {
   try {
-    return await readFile3(path, "utf8");
+    return await readFile4(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return "";
@@ -379,48 +922,1044 @@ async function getOptionalFile2(path) {
 function getShellQuoted(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
-// src/modes.ts
-import {
-  getAgentDir,
-  parseFrontmatter as parseFrontmatter2
-} from "@earendil-works/pi-coding-agent";
-import { readFile as readFile4 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { basename as basename2, extname, join as join6 } from "node:path";
 
-// src/assets.ts
-import { existsSync } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
-import { fileURLToPath } from "node:url";
-function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
-  const moduleDir = dirname3(fileURLToPath(moduleUrl));
-  const candidates = [
-    join5(moduleDir, "agents"),
-    join5(moduleDir, "..", "agents"),
-    join5(moduleDir, "..", "..", "agents")
+// src/gates.ts
+var CONVENTIONAL_COMMIT = /^(feat|fix|perf|refactor|docs|chore|test|build|ci|style|revert)(\([^)]+\))?!?: .+/;
+var MISE_GATES = ["format:check", "lint", "test"];
+function checkConventionalSubject(subject) {
+  const trimmed = subject.trim();
+  const ok = CONVENTIONAL_COMMIT.test(trimmed);
+  return {
+    name: "conventional-subject",
+    status: ok ? "pass" : "warn",
+    detail: ok ? trimmed : `not a conventional-commit subject: "${trimmed}"`
+  };
+}
+async function runMiseGates(cwd) {
+  const tasks = await discoverMiseTasks(cwd);
+  const results = [];
+  for (const gate of MISE_GATES) {
+    const targets = tasks.get(gate) ?? [];
+    if (targets.length === 0) {
+      results.push({ name: gate, status: "skip", detail: "no mise recipe" });
+      continue;
+    }
+    const invocations = targets.flatMap((target, index) => index === 0 ? [target] : [":::", target]);
+    const result = await mise.run(["run", ...invocations], { cwd });
+    results.push({
+      name: gate,
+      status: result.code === 0 ? "pass" : "fail",
+      detail: result.code === 0 ? "clean" : (result.stderr.trim() || result.stdout.trim()).slice(-400)
+    });
+  }
+  return results;
+}
+function ciGate(checksOutput) {
+  const text = checksOutput.toLowerCase();
+  if (!text.trim())
+    return { name: "ci", status: "skip", detail: "no CI output" };
+  if (/\bfail|error\b/.test(text))
+    return { name: "ci", status: "warn", detail: "CI failing" };
+  if (/\bpending|in progress|queued\b/.test(text))
+    return { name: "ci", status: "warn", detail: "CI pending" };
+  return { name: "ci", status: "pass", detail: "CI green" };
+}
+function parseMiseTasks(input) {
+  let tasks;
+  try {
+    tasks = JSON.parse(input);
+  } catch {
+    return new Map;
+  }
+  if (!Array.isArray(tasks))
+    return new Map;
+  const found = new Map;
+  for (const gate of MISE_GATES) {
+    const targets = tasks.flatMap((task) => {
+      if (typeof task.name !== "string")
+        return [];
+      return task.name === gate || task.name.endsWith(`:${gate}`) || task.aliases?.includes(gate) ? [task.name] : [];
+    });
+    if (targets.length > 0)
+      found.set(gate, [...new Set(targets)]);
+  }
+  return found;
+}
+async function discoverMiseTasks(cwd) {
+  const result = await mise.run(["tasks", "--json", "--all"], { cwd });
+  if (result.code !== 0)
+    return new Map;
+  return parseMiseTasks(result.stdout);
+}
+// src/review/types.ts
+import { z as z2 } from "zod";
+var severitySchema = z2.enum(["BLOCKING", "CONSIDER", "NOTE"]);
+var findingSchema = z2.object({
+  file: z2.string().min(1),
+  line: z2.number().int().nonnegative(),
+  severity: severitySchema,
+  body: z2.string().min(1),
+  reference: z2.string().optional().default("")
+});
+var findingsSchema = z2.array(findingSchema);
+function reviewSlug(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+function yymmdd(date = new Date) {
+  const yy = String(date.getFullYear() % 100).padStart(2, "0");
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  return `${yy}${mm}${dd}`;
+}
+function reviewRecordName(target, date = new Date) {
+  return `${yymmdd(date)}-${reviewSlug(target) || "uncommitted"}`;
+}
+function isLocalResponse(body) {
+  return /^<!-- diffpi(?:-local-response:[A-Za-z0-9_-]+)? -->\n/m.test(body);
+}
+function dedupeFindings(findings) {
+  const rank = { BLOCKING: 3, CONSIDER: 2, NOTE: 1 };
+  const byKey = new Map;
+  for (const finding of findings) {
+    const key = `${finding.file}:${finding.line}`;
+    const existing = byKey.get(key);
+    if (!existing || rank[finding.severity] > rank[existing.severity])
+      byKey.set(key, finding);
+  }
+  return [...byKey.values()].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || rank[b.severity] - rank[a.severity]);
+}
+function toReviewComments(findings, model) {
+  const comments = [];
+  for (const finding of findings) {
+    if (finding.line <= 0)
+      continue;
+    const body = renderCommentBody(finding);
+    comments.push({
+      file: finding.file,
+      line: finding.line,
+      side: "RIGHT",
+      body: model ? withRemoteProvenance(body, model) : body
+    });
+  }
+  return comments;
+}
+function withRemoteProvenance(body, model) {
+  const normalized = body.trimEnd();
+  if (/Generated review by Diffpi using `[^`]+`\.$/.test(normalized))
+    return body;
+  return `${normalized}
+
+Generated review by Diffpi using \`${model}\`.`;
+}
+function localReviewAuthor(model) {
+  return `Agent: ${model}`;
+}
+function renderCommentBody(finding) {
+  const prefix = finding.severity === "BLOCKING" ? "**BLOCKING** " : "";
+  const reference = finding.reference ? `
+
+> **Reference:** ${finding.reference}` : "";
+  return `${prefix}${finding.body}${reference}`;
+}
+// src/review/review-markdown.ts
+import { z as z3 } from "zod";
+var reviewThreadRecordSchema = z3.object({
+  id: z3.string().min(1),
+  file: z3.string().optional(),
+  line: z3.number().int().positive().optional(),
+  body: z3.string(),
+  author: z3.string().optional(),
+  resolved: z3.boolean(),
+  addressed: z3.boolean().optional(),
+  question: z3.boolean(),
+  replies: z3.array(z3.string()).optional()
+});
+function renderReviewDoc(input) {
+  const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
+  const lines = [`# Review: ${input.title}`, "", "## Metadata"];
+  if (input.number !== undefined)
+    lines.push(`- **PR/MR**: #${input.number}${input.url ? ` — ${input.url}` : ""}`);
+  if (input.author)
+    lines.push(`- **Author**: ${input.author}`);
+  if (input.model)
+    lines.push(`- **Review agent**: ${input.model}`);
+  if (input.headRef && input.baseRef)
+    lines.push(`- **Branch**: ${input.headRef} → ${input.baseRef}`);
+  if (input.additions !== undefined)
+    lines.push(`- **Stats**: +${input.additions} -${input.deletions ?? 0} across ${input.changedFiles ?? 0} files`);
+  lines.push(`- **Reviewed**: ${input.timestamp ?? new Date().toISOString()}`, "");
+  if (input.overallIssues.length > 0) {
+    lines.push("## Overall issues", "");
+    for (const issue of input.overallIssues)
+      lines.push(`- ${issue}`);
+    lines.push("");
+  }
+  lines.push("## Verification", "");
+  for (const gate of input.gates)
+    lines.push(`- ${gate.name}: ${gate.status} — ${gate.detail}`);
+  lines.push("");
+  if (input.notVerified.length > 0) {
+    lines.push("## What was NOT verified", "");
+    for (const item of input.notVerified)
+      lines.push(`- ${item}`);
+    lines.push("");
+  }
+  lines.push("## Inline Comments", "");
+  for (const finding of anchored) {
+    lines.push(`### ${finding.file}:${finding.line} — ${finding.severity}`, "", finding.body, "");
+    if (finding.reference)
+      lines.push(`> **Reference:** ${finding.reference}`, "");
+    lines.push("---", "");
+  }
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+function renderThreadArtifact(title, target, threads, options = {}) {
+  const records = threads.map((thread) => ({
+    id: thread.id,
+    file: thread.file,
+    line: thread.line,
+    body: thread.body,
+    author: thread.author,
+    resolved: thread.resolved,
+    addressed: thread.addressed,
+    question: thread.question,
+    replies: thread.replies
+  }));
+  const payload = Buffer.from(JSON.stringify(records), "utf8").toString("base64url");
+  const lines = [
+    `<!-- diffpi-threads:${payload} -->`,
+    `# Review threads: ${title}`,
+    "",
+    "## Metadata",
+    "",
+    `- Target: ${target}`,
+    `- Pulled: ${options.timestamp ?? new Date().toISOString()}`
   ];
-  return candidates.find((path) => existsSync(path)) ?? candidates[1];
+  if (options.number !== undefined)
+    lines.push(`- PR/MR: #${options.number}${options.url ? ` — ${options.url}` : ""}`);
+  lines.push("", "## Replies", "");
+  for (const thread of threads) {
+    const id = Buffer.from(thread.id, "utf8").toString("base64url");
+    lines.push(`### ${thread.file ?? "review"}:${thread.line ?? "n/a"} (${thread.id})`, "", `<!-- diffpi-reply-start:${id} -->`, thread.reply ?? "", `<!-- diffpi-reply-end:${id} -->`, "");
+  }
+  lines.push("## Source comments", "");
+  for (const thread of threads) {
+    lines.push(`### ${thread.file ?? "review"}:${thread.line ?? "n/a"} — ${thread.author ?? "unknown"}`, "", `Thread: ${thread.id}`, `Status: ${thread.resolved ? "resolved" : thread.addressed ? "addressed" : "open"}`, "", thread.body, "", "---", "");
+  }
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+function parseThreadArtifact(content) {
+  const payload = content.match(/^<!-- diffpi-threads:([A-Za-z0-9_-]+) -->$/m)?.[1];
+  if (!payload)
+    throw new Error("This file is not a Diffpi thread artifact.");
+  let threads;
+  try {
+    const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    threads = z3.array(reviewThreadRecordSchema).parse(decoded);
+  } catch {
+    throw new Error("Cannot parse the Diffpi thread artifact payload.");
+  }
+  const replies = content.split(/^## Source comments$/m, 1)[0] ?? "";
+  return threads.map((thread) => {
+    const id = Buffer.from(thread.id, "utf8").toString("base64url");
+    const startMarker = `<!-- diffpi-reply-start:${id} -->
+`;
+    const endMarker = `
+<!-- diffpi-reply-end:${id} -->`;
+    const start = replies.indexOf(startMarker);
+    const end = start < 0 ? -1 : replies.indexOf(endMarker, start + startMarker.length);
+    const reply = start >= 0 && end >= 0 ? replies.slice(start + startMarker.length, end).trim() : "";
+    return reply ? { ...thread, reply } : thread;
+  });
+}
+function upsertThreadReply(content, threadId, body, question, resolved) {
+  const threads = parseThreadArtifact(content);
+  const thread = threads.find((candidate) => candidate.id === threadId);
+  if (!thread)
+    throw new Error(`Review thread ${threadId} was not found in the local artifact.`);
+  thread.reply = body;
+  thread.addressed = true;
+  if (question !== undefined)
+    thread.question = question;
+  if (resolved !== undefined)
+    thread.resolved = resolved;
+  const title = content.match(/^# Review threads: (.+)$/m)?.[1] ?? "review";
+  const target = content.match(/^- Target: (.+)$/m)?.[1] ?? "local";
+  const timestamp = content.match(/^- Pulled: (.+)$/m)?.[1];
+  const pr = content.match(/^- PR\/MR: #(\d+)(?: — (.+))?$/m);
+  return renderThreadArtifact(title, target, threads, {
+    timestamp,
+    number: pr ? Number.parseInt(pr[1], 10) : undefined,
+    url: pr?.[2]
+  });
+}
+// src/review/github-review-backend.ts
+function GitHubReviewBackend(vcs, number) {
+  const pendingReview = async () => {
+    const result = await ghChecked([
+      "api",
+      `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews`,
+      "--jq",
+      '[.[] | select(.state=="PENDING")] | last | {id: (.id | tostring), nodeId: .node_id}'
+    ]);
+    if (!result.stdout.trim())
+      return;
+    let pending;
+    try {
+      pending = JSON.parse(result.stdout);
+    } catch {
+      throw new Error("Cannot parse the pending GitHub review identifier as JSON.");
+    }
+    if (!pending.id || !pending.nodeId)
+      return;
+    return { id: pending.id, nodeId: pending.nodeId };
+  };
+  const listThreads = async () => {
+    const threads = [];
+    let cursor;
+    do {
+      const args = [
+        "api",
+        "graphql",
+        "-f",
+        `query=${GITHUB_THREADS_QUERY}`,
+        "-f",
+        `owner=${vcs.owner}`,
+        "-f",
+        `repo=${vcs.repo}`,
+        "-F",
+        `number=${number}`
+      ];
+      if (cursor)
+        args.push("-f", `after=${cursor}`);
+      const result = await ghChecked(args);
+      let data;
+      try {
+        data = JSON.parse(result.stdout);
+      } catch {
+        throw new Error("Cannot parse GitHub review threads as JSON.");
+      }
+      const connection = data.data?.repository?.pullRequest?.reviewThreads;
+      threads.push(...connection?.nodes ?? []);
+      cursor = connection?.pageInfo?.hasNextPage ? connection.pageInfo.endCursor : undefined;
+      if (connection?.pageInfo?.hasNextPage && !cursor) {
+        throw new Error("GitHub review thread pagination did not return an end cursor.");
+      }
+    } while (cursor);
+    return threads.map((thread) => {
+      const nodes = thread.comments?.nodes ?? [];
+      const comment = nodes[0];
+      const body = comment?.body ?? "";
+      return {
+        id: thread.id,
+        file: thread.path,
+        line: thread.line,
+        body,
+        author: comment?.author?.login,
+        resolved: thread.isResolved,
+        question: /\?\s*$/.test(body.trim()),
+        replies: nodes.slice(1).map((node) => node.body)
+      };
+    });
+  };
+  return {
+    kind: "remote",
+    async stage(draft) {
+      const pending = await pendingReview();
+      if (!pending) {
+        const payload = {
+          body: draft.body,
+          comments: draft.comments.map((comment) => ({
+            path: comment.file,
+            line: comment.line,
+            side: comment.side ?? "RIGHT",
+            body: comment.body
+          }))
+        };
+        await ghChecked(["api", "--method", "POST", `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews`, "--input", "-"], { input: JSON.stringify(payload) });
+        return;
+      }
+      if (draft.body.trim()) {
+        await ghChecked([
+          "api",
+          "--method",
+          "PUT",
+          `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}`,
+          "-f",
+          `body=${draft.body}`
+        ]);
+      }
+      for (const comment of draft.comments) {
+        await ghChecked([
+          "api",
+          "graphql",
+          "-f",
+          `query=${GITHUB_ADD_THREAD_MUTATION}`,
+          "-f",
+          `reviewId=${pending.nodeId}`,
+          "-f",
+          `body=${comment.body}`,
+          "-f",
+          `path=${comment.file}`,
+          "-F",
+          `line=${comment.line}`,
+          "-f",
+          `side=${comment.side ?? "RIGHT"}`
+        ]);
+      }
+    },
+    async readDraft() {
+      const pending = await pendingReview();
+      if (!pending)
+        return { comments: [], body: "" };
+      const review = await ghChecked(["api", `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}`]);
+      const comments = await ghChecked([
+        "api",
+        `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}/comments`
+      ]);
+      let reviewData;
+      let commentData;
+      try {
+        reviewData = JSON.parse(review.stdout);
+        commentData = JSON.parse(comments.stdout);
+      } catch {
+        throw new Error("Cannot parse the pending GitHub review as JSON.");
+      }
+      return {
+        body: reviewData.body ?? "",
+        comments: commentData.map((comment) => ({
+          file: comment.path,
+          line: comment.line ?? comment.original_line ?? 1,
+          side: comment.side,
+          body: comment.body
+        }))
+      };
+    },
+    listThreads,
+    async reply(input) {
+      const threads = await listThreads();
+      const existing = threads.find((thread) => thread.id === input.threadId);
+      if (!existing?.replies?.includes(input.body)) {
+        await ghChecked([
+          "api",
+          "graphql",
+          "-f",
+          `query=${GITHUB_REPLY_MUTATION}`,
+          "-f",
+          `threadId=${input.threadId}`,
+          "-f",
+          `body=${input.body}`
+        ]);
+      }
+      if (input.resolve) {
+        await ghChecked([
+          "api",
+          "graphql",
+          "-f",
+          `query=${GITHUB_RESOLVE_MUTATION}`,
+          "-f",
+          `threadId=${input.threadId}`
+        ]);
+      }
+    },
+    async publish(event) {
+      const pending = await pendingReview();
+      if (!pending && event === "COMMENT")
+        return;
+      if (!pending && event === "REQUEST_CHANGES") {
+        throw new Error("GitHub requires pending comments before publishing a request-changes review without a body.");
+      }
+      const endpoint = githubReviewSubmissionEndpoint(vcs.owner, vcs.repo, number, pending?.id ?? "");
+      await ghChecked(["api", "--method", "POST", endpoint, "-f", `event=${event}`]);
+    }
+  };
 }
+function githubReviewSubmissionEndpoint(owner, repo, id, pendingReviewId) {
+  return pendingReviewId ? `/repos/${owner}/${repo}/pulls/${id}/reviews/${pendingReviewId}/events` : `/repos/${owner}/${repo}/pulls/${id}/reviews`;
+}
+var GITHUB_THREADS_QUERY = `query($owner:String!,$repo:String!,$number:Int!,$after:String){repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewThreads(first:100,after:$after){nodes{id,isResolved,path,line,comments(first:100){nodes{body,author{login}}}}pageInfo{hasNextPage,endCursor}}}}}`;
+var GITHUB_ADD_THREAD_MUTATION = `mutation($reviewId:ID!,$body:String!,$path:String!,$line:Int!,$side:DiffSide!){addPullRequestReviewThread(input:{pullRequestReviewId:$reviewId,body:$body,path:$path,line:$line,side:$side}){thread{id}}}`;
+var GITHUB_REPLY_MUTATION = `mutation($threadId:ID!,$body:String!){addPullRequestReviewThreadReply(input:{pullRequestReviewThreadId:$threadId,body:$body}){comment{id}}}`;
+var GITHUB_RESOLVE_MUTATION = `mutation($threadId:ID!){resolveReviewThread(input:{threadId:$threadId}){thread{isResolved}}}`;
 
+// src/review/gitlab-review-backend.ts
+function GitLabReviewBackend(vcs, number) {
+  const project = () => `${vcs.owner}/${vcs.repo}`;
+  const mergeRequestEndpoint = () => `projects/${encodeURIComponent(project())}/merge_requests/${number}`;
+  const listThreads = async () => {
+    const discussions = [];
+    for (let page = 1;; page += 1) {
+      const result = await glabChecked(["api", `${mergeRequestEndpoint()}/discussions?per_page=100&page=${page}`]);
+      let batch;
+      try {
+        batch = JSON.parse(result.stdout);
+      } catch {
+        throw new Error("Cannot parse GitLab review discussions as JSON.");
+      }
+      discussions.push(...batch);
+      if (batch.length < 100)
+        break;
+    }
+    return discussions.map((discussion) => {
+      const notes = discussion.notes ?? [];
+      const note = notes[0];
+      const body = note?.body ?? "";
+      return {
+        id: discussion.id,
+        file: note?.position?.new_path ?? note?.position?.old_path,
+        line: note?.position?.new_line ?? note?.position?.old_line,
+        body,
+        author: note?.author?.username,
+        resolved: Boolean(discussion.resolved),
+        question: /\?\s*$/.test(body.trim()),
+        replies: notes.slice(1).map((reply) => reply.body)
+      };
+    });
+  };
+  return {
+    kind: "remote",
+    async stage(draft) {
+      const endpoint = `${mergeRequestEndpoint()}/draft_notes`;
+      if (draft.body.trim()) {
+        await glabChecked(["api", "--method", "POST", endpoint, "--input", "-"], {
+          input: JSON.stringify({ note: draft.body })
+        });
+      }
+      if (draft.comments.length === 0)
+        return;
+      const response = await glabChecked(["api", mergeRequestEndpoint()]);
+      const diffRefs = parseGitlabDiffRefs(response.stdout);
+      for (const comment of draft.comments) {
+        const payload = {
+          note: comment.body,
+          position: {
+            ...diffRefs,
+            position_type: "text",
+            new_path: comment.file,
+            old_path: comment.file,
+            new_line: comment.side === "LEFT" ? undefined : comment.line,
+            old_line: comment.side === "LEFT" ? comment.line : undefined
+          }
+        };
+        await glabChecked(["api", "--method", "POST", endpoint, "--input", "-"], {
+          input: JSON.stringify(payload)
+        });
+      }
+    },
+    async readDraft() {
+      const result = await glabChecked(["api", `${mergeRequestEndpoint()}/draft_notes`]);
+      let notes;
+      try {
+        notes = JSON.parse(result.stdout);
+      } catch {
+        throw new Error("Cannot parse GitLab draft notes as JSON.");
+      }
+      const comments = [];
+      const body = [];
+      for (const note of notes) {
+        if (!note.note)
+          continue;
+        const file = note.position?.new_path ?? note.position?.old_path;
+        const line = note.position?.new_line ?? note.position?.old_line;
+        if (file && line) {
+          comments.push({
+            file,
+            line,
+            side: note.position?.new_line ? "RIGHT" : "LEFT",
+            body: note.note
+          });
+        } else {
+          body.push(note.note);
+        }
+      }
+      return { comments, body: body.join(`
+
+`) };
+    },
+    listThreads,
+    async reply(input) {
+      const endpoint = `${mergeRequestEndpoint()}/discussions/${encodeURIComponent(input.threadId)}`;
+      const threads = await listThreads();
+      const existing = threads.find((thread) => thread.id === input.threadId);
+      if (!existing?.replies?.includes(input.body)) {
+        await glabChecked(["api", "--method", "POST", `${endpoint}/notes`, "--input", "-"], {
+          input: JSON.stringify({ body: input.body })
+        });
+      }
+      if (input.resolve)
+        await glabChecked(["api", "--method", "PUT", `${endpoint}?resolved=true`]);
+    },
+    async publish(event) {
+      assertReviewEventSupported(vcs.provider, event);
+      const drafts = await glabChecked(["api", `${mergeRequestEndpoint()}/draft_notes`]);
+      if (hasGitlabDraftNotes(drafts.stdout)) {
+        await glabChecked(["api", "--method", "POST", `${mergeRequestEndpoint()}/draft_notes/bulk_publish`]);
+      }
+      if (event === "APPROVE")
+        await glabChecked(["mr", "approve", String(number), "--repo", project()]);
+    }
+  };
+}
+function assertReviewEventSupported(provider, event) {
+  if (provider === "gitlab" && event === "REQUEST_CHANGES") {
+    throw new Error("GitLab does not support REQUEST_CHANGES reviews; post a comment or reject the merge request manually.");
+  }
+}
+function parseGitlabDiffRefs(input) {
+  let data;
+  try {
+    data = JSON.parse(input);
+  } catch {
+    throw new Error("Cannot create positioned GitLab draft notes: the merge request response was not valid JSON.");
+  }
+  const { base_sha, start_sha, head_sha } = data.diff_refs ?? {};
+  if (!base_sha || !start_sha || !head_sha) {
+    throw new Error("Cannot create positioned GitLab draft notes: merge request diff refs are unavailable.");
+  }
+  return { base_sha, start_sha, head_sha };
+}
+function hasGitlabDraftNotes(input) {
+  try {
+    const data = JSON.parse(input);
+    return Array.isArray(data) && data.length > 0;
+  } catch {
+    throw new Error("Cannot publish the GitLab review: the draft notes response was not valid JSON.");
+  }
+}
+
+// src/review/local-review-backend.ts
+import { readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+
+// src/extensions/tuicrx.ts
+import { readFile as readFile5, realpath as realpath2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+async function tuicrAvailable() {
+  return Boolean(await findExecutable("tuicr"));
+}
+async function listSessions(repo = ".") {
+  await requireTuicr();
+  const result = await run("tuicr", ["review", "list", "--repo", repo]);
+  if (result.code !== 0 || !result.stdout.trim())
+    return [];
+  try {
+    const raw = JSON.parse(result.stdout);
+    return raw.map((entry) => ({
+      slug: entry.slug,
+      kind: entry.kind,
+      path: entry.path,
+      updatedAt: entry.updated_at,
+      commentCount: entry.comment_count,
+      anchor: entry.anchor,
+      active: entry.active
+    }));
+  } catch {
+    throw new Error("Cannot parse tuicr review list output.");
+  }
+}
+async function addComment(session, body, opts = {}) {
+  await requireTuicr();
+  const args = ["review", "add", "--session", session, body];
+  if (opts.targetFile)
+    args.push("--target-file", opts.targetFile);
+  if (opts.line !== undefined)
+    args.push("--line", String(opts.line));
+  if (opts.side)
+    args.push("--side", opts.side);
+  if (opts.username)
+    args.push("--username", opts.username);
+  await runChecked("tuicr", args);
+}
+async function launch(cwd, pr, localBase) {
+  let command;
+  if (pr !== undefined)
+    command = ["tuicr", "pr", String(pr)];
+  else if (localBase)
+    command = ["tuicr", "-w", "-r", `${localBase}..HEAD`];
+  else
+    throw new Error("Cannot launch a local tuicr review: no base branch could be determined.");
+  if (!await tuicrAvailable()) {
+    return {
+      launched: false,
+      via: "print",
+      command: command.join(" "),
+      reason: "tuicr is not installed or is not available on PATH.",
+      instruction: `Install tuicr, then run: ${command.join(" ")}`
+    };
+  }
+  const name = pr === undefined ? "diffpi: local review" : `diffpi: PR #${pr}`;
+  return openInNewTab(command, { cwd, name });
+}
+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 readFile5(path, "utf8");
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`Cannot parse tuicr session JSON: ${path}`);
+  }
+}
+function toFindings(session, options = {}) {
+  const comments = [];
+  const include = (comment) => (!options.agentOnly || commentAuthor(comment)?.startsWith("Agent: ")) && (!options.excludeLocalResponses || !isLocalResponse(comment.content));
+  const bodyParts = (session.review_comments ?? []).flatMap((comment) => include(comment) ? [comment.content] : []);
+  for (const [file, entry] of Object.entries(session.files ?? {})) {
+    const fileComments = (entry.file_comments ?? []).flatMap((comment) => include(comment) ? [comment.content] : []);
+    if (fileComments.length > 0)
+      bodyParts.push(`File: ${file}
+
+${fileComments.join(`
+
+`)}`);
+    for (const [lineKey, lineComments] of Object.entries(entry.line_comments ?? {})) {
+      const line = Number.parseInt(lineKey, 10);
+      if (!Number.isFinite(line))
+        continue;
+      for (const lineComment of lineComments) {
+        if (!include(lineComment))
+          continue;
+        const comment = {
+          file,
+          line,
+          side: lineComment.side === "old" ? "LEFT" : "RIGHT",
+          body: lineComment.content
+        };
+        const author = commentAuthor(lineComment);
+        if (author)
+          comment.author = author;
+        comments.push(comment);
+      }
+    }
+  }
+  return { comments, body: bodyParts.join(`
+
+`) };
+}
+async function requireTuicr() {
+  if (!await tuicrAvailable())
+    throw new Error("tuicr is not installed or is not available on PATH.");
+}
+function commentAuthor(comment) {
+  return comment.username ?? comment.author;
+}
+async function canonicalPath2(path) {
+  try {
+    return await realpath2(path);
+  } catch {
+    return resolve2(path);
+  }
+}
+
+// src/review/local-review-backend.ts
+function LocalReviewBackend(options) {
+  return {
+    kind: "local",
+    async stage(draft) {
+      for (const comment of draft.comments) {
+        await addComment(options.session, comment.body, {
+          targetFile: comment.file,
+          line: comment.line,
+          side: comment.side === "LEFT" ? "old" : "new",
+          username: options.author
+        });
+      }
+      if (draft.body.trim())
+        await addComment(options.session, draft.body, { username: options.author });
+    },
+    async readDraft() {
+      return toFindings(await readSession(options.session), { excludeLocalResponses: true });
+    },
+    async listThreads() {
+      try {
+        return parseThreadArtifact(await readFile6(options.artifactPath, "utf8"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          return [];
+        throw error;
+      }
+    },
+    async reply(input) {
+      const content = await readFile6(options.artifactPath, "utf8");
+      await writeFile3(options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question, input.resolve), "utf8");
+    },
+    async publish() {
+      throw new Error("Promote a local draft through a remote review backend before publishing it.");
+    }
+  };
+}
+
+// src/review/review-backend.ts
+function createRemoteReviewBackend(vcs, number) {
+  if (vcs.provider === "github")
+    return GitHubReviewBackend(vcs, number);
+  if (vcs.provider === "gitlab")
+    return GitLabReviewBackend(vcs, number);
+  throw new Error("A remote review backend requires a GitHub or GitLab repository.");
+}
+function createLocalReviewBackend(options) {
+  return LocalReviewBackend(options);
+}
+// src/review/review-state.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile7, rename, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+import { z as z4 } from "zod";
+
+// src/store.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir as mkdir3, readlink, realpath as realpath3, symlink, unlink } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join8, resolve as resolve3 } from "node:path";
+var STORE_LINK = ".diffpi";
+var LEGACY_STORE_LINK = join8(".pi", "diffpi");
+async function computeProjectSlug(cwd) {
+  return projectSlug(await inspectGitRepository(cwd));
+}
+function storeGlobalRoot(homeDir = homedir4()) {
+  return join8(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir4()) {
+  const repository = await inspectGitRepository(cwd);
+  const root = repository.root;
+  const slug = projectSlug(repository);
+  const dest = join8(storeGlobalRoot(homeDir), slug);
+  const link = join8(root, STORE_LINK);
+  await mkdir3(dest, { recursive: true });
+  try {
+    await assertStoreLink(link, dest);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    await symlink(dest, link);
+  }
+  await removeLegacyStoreLink(join8(root, LEGACY_STORE_LINK), dest);
+  return { slug, root, dest, link, linked: true };
+}
+async function storeDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  return store.dest;
+}
+async function plansDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join8(store.link, "plan");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function reviewsDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join8(store.link, "review");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join8(store.link, "sessions");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function assertStoreLink(path, dest) {
+  const entry = await lstat(path);
+  if (!entry.isSymbolicLink())
+    throw new Error(`${path} exists and is not a symlink.`);
+  const target = await symlinkTarget(path);
+  if (target !== await canonicalPath3(dest))
+    throw new Error(`${path} points to ${target}, not ${dest}.`);
+}
+async function removeLegacyStoreLink(path, dest) {
+  try {
+    const entry = await lstat(path);
+    if (!entry.isSymbolicLink())
+      return;
+    const target = await symlinkTarget(path);
+    if (target === await canonicalPath3(dest))
+      await unlink(path);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+}
+async function symlinkTarget(path) {
+  const target = await readlink(path);
+  return canonicalPath3(isAbsolute2(target) ? target : resolve3(dirname4(path), target));
+}
+async function canonicalPath3(path) {
+  try {
+    return await realpath3(path);
+  } catch {
+    return resolve3(path);
+  }
+}
+function projectSlug(repository) {
+  const readable = repository.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed";
+  const digest = createHash("sha256").update(repository.identity).digest("hex").slice(0, 12);
+  return `${readable}-${digest}`;
+}
+
+// src/review/review-state.ts
+var reviewPublicationStateSchema = z4.object({
+  target: z4.string().optional(),
+  bodies: z4.array(z4.string()).default([]),
+  comments: z4.array(z4.string()).default([]),
+  replies: z4.array(z4.string()).default([]),
+  overlayPath: z4.string().optional()
+});
+function reviewBodyFingerprint(body) {
+  return digest(body);
+}
+function reviewCommentFingerprint(comment) {
+  return digest([comment.file, String(comment.line), comment.side ?? "RIGHT", comment.body].join("\x00"));
+}
+function reviewReplyFingerprint(threadId, body) {
+  return digest(`${threadId}\x00${body}`);
+}
+function unpublishedReviewComments(comments, knownFingerprints) {
+  return comments.filter((comment) => !knownFingerprints.has(reviewCommentFingerprint(comment)));
+}
+async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
+  const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
+  const path = join9(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  try {
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile7(path, "utf8")));
+    return { path, state: { ...parsed, target } };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { path, state: { target, bodies: [], comments: [], replies: [] } };
+    }
+    if (error instanceof SyntaxError || error instanceof z4.ZodError) {
+      throw new Error(`Cannot parse review publication state: ${path}`);
+    }
+    throw error;
+  }
+}
+async function saveReviewPublicationState(path, state) {
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile4(temp, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  await rename(temp, path);
+}
+function digest(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
+// src/mcp.ts
+import { mkdir as mkdir4, readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { dirname as dirname5, join as join10 } from "node:path";
+var mcp = {
+  globalConfigPath(homeDir = homedir5()) {
+    return join10(homeDir, ".config", "mcp", "mcp.json");
+  },
+  async serversEnsure(servers, options = {}) {
+    const path = options.path ?? mcp.globalConfigPath();
+    const currentText = await getOptionalFile2(path);
+    const current = getParsedConfig(currentText, path);
+    const nextServers = { ...current.mcpServers };
+    for (const [name, entry] of Object.entries(servers)) {
+      nextServers[name] = mergeEntry(nextServers[name], entry);
+    }
+    const next = { ...current, mcpServers: nextServers };
+    const changed = JSON.stringify(current) !== JSON.stringify(next);
+    if (changed && !options.dryRun) {
+      await mkdir4(dirname5(path), { recursive: true });
+      await writeFile5(path, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+    }
+    return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
+  }
+};
+function mergeEntry(current, required) {
+  const merged = { ...current, ...required };
+  if (current?.env || required.env)
+    merged.env = { ...current?.env, ...required.env };
+  return merged;
+}
+function getParsedConfig(content, path) {
+  if (!content?.trim())
+    return { mcpServers: {} };
+  try {
+    const value = JSON.parse(content);
+    if (!isRecord(value))
+      throw new Error("not an object");
+    const servers = value.mcpServers;
+    if (servers !== undefined && !isRecord(servers))
+      throw new Error("mcpServers is not an object");
+    return { ...value, mcpServers: servers ?? {} };
+  } catch {
+    throw new Error(`Expected a valid pi-mcp-adapter configuration in ${path}.`);
+  }
+}
+async function getOptionalFile2(path) {
+  try {
+    return await readFile8(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 // src/modes.ts
+import {
+  getAgentDir,
+  parseFrontmatter as parseFrontmatter2
+} from "@earendil-works/pi-coding-agent";
+import { readFile as readFile9 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { basename as basename4, extname, join as join11 } from "node:path";
 async function discoverAgentModes(options) {
   const agentDir = options.agentDir ?? getAgentDir();
-  const homeDir = options.homeDir ?? homedir4();
+  const homeDir = options.homeDir ?? homedir6();
   const modes = new Map;
   const diagnostics = [];
   await loadAgentModes(options.bundledAgentsDir ?? BUNDLED_AGENTS_DIR, "diffpi agent", modes, diagnostics);
-  await loadAgentModes(join6(agentDir, "agents"), "user agent", modes, diagnostics);
+  await loadAgentModes(join11(agentDir, "agents"), "user agent", modes, diagnostics);
   if (options.includeSkills) {
-    await loadSkillModes(join6(homeDir, ".agents", "skills"), "user skill", modes, diagnostics);
-    await loadSkillModes(join6(agentDir, "skills"), "pi user skill", modes, diagnostics);
+    await loadSkillModes(join11(homeDir, ".agents", "skills"), "user skill", modes, diagnostics);
+    await loadSkillModes(join11(agentDir, "skills"), "pi user skill", modes, diagnostics);
   }
   if (options.projectTrusted === true) {
     if (options.includeSkills) {
-      await loadSkillModes(join6(options.cwd, ".agents", "skills"), "project skill", modes, diagnostics);
-      await loadSkillModes(join6(options.cwd, ".pi", "skills"), "pi project skill", modes, diagnostics);
+      await loadSkillModes(join11(options.cwd, ".agents", "skills"), "project skill", modes, diagnostics);
+      await loadSkillModes(join11(options.cwd, ".pi", "skills"), "pi project skill", modes, diagnostics);
     }
-    await loadAgentModes(join6(options.cwd, ".agents", "agents"), "project agent", modes, diagnostics);
-    await loadAgentModes(join6(options.cwd, ".pi", "agents"), "pi project agent", modes, diagnostics);
+    await loadAgentModes(join11(options.cwd, ".agents", "agents"), "project agent", modes, diagnostics);
+    await loadAgentModes(join11(options.cwd, ".pi", "agents"), "pi project agent", modes, diagnostics);
   }
   const userConfig = await loadDiffpiConfig({ homeDir });
   const configuredModes = [...modes.values()].map((mode) => ({
@@ -457,7 +1996,11 @@ function createModeController(pi, options = {}) {
   let active;
   let baseline;
   const updateStatus = (ctx) => {
-    ctx.ui.setStatus(MODE_STATUS_KEY, active ? `mode: ${active.id}` : undefined);
+    const model = ctx.model ? ` · ${ctx.model.provider}/${ctx.model.id}` : "";
+    const label = active?.label.toUpperCase() ?? "DEFAULT";
+    const badge = `AGENT ${label}${model}`;
+    ctx.ui.setStatus(MODE_STATUS_KEY, undefined);
+    ctx.ui.setWidget?.(MODE_WIDGET_KEY, [badge], { placement: "belowEditor" });
   };
   const list = (ctx, listOptions = {}) => discoverAgentModes({
     cwd: ctx.cwd,
@@ -512,6 +2055,9 @@ function createModeController(pi, options = {}) {
       }
       updateStatus(ctx);
     },
+    refresh(ctx) {
+      updateStatus(ctx);
+    },
     apply(systemPrompt) {
       if (!active)
         return systemPrompt;
@@ -530,6 +2076,7 @@ ${active.systemPrompt}`;
 }
 var MODE_STATE_ENTRY = "diffpi-mode-state";
 var MODE_STATUS_KEY = "diffpi-mode";
+var MODE_WIDGET_KEY = "diffpi-mode-badge";
 var MODE_CONTROL_TOOLS = ["ask_user_question", "diffpi_modes_list", "diffpi_modes_set", "diffpi_modes_unset"];
 var BUNDLED_AGENTS_DIR = resolveBundledAgentsDir();
 var THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
@@ -583,19 +2130,19 @@ function captureRuntime(pi, ctx) {
 async function loadSkillModes(skillsDir, source, modes, diagnostics) {
   const entries = await readDirectoryIfExists(skillsDir);
   for (const entry of entries.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-    await loadAgentModes(join6(skillsDir, entry.name, "agents"), `${source} ${entry.name}`, modes, diagnostics, entry.name);
+    await loadAgentModes(join11(skillsDir, entry.name, "agents"), `${source} ${entry.name}`, modes, diagnostics, entry.name);
   }
 }
 async function loadAgentModes(directory, source, modes, diagnostics, skillName) {
   const entries = await readDirectoryIfExists(directory);
   for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name))) {
-    const path = join6(directory, entry.name);
+    const path = join11(directory, entry.name);
     try {
-      const content = await readFile4(path, "utf8");
+      const content = await readFile9(path, "utf8");
       const { frontmatter, body } = parseFrontmatter2(content.startsWith("\uFEFF") ? content.slice(1) : content);
       if (frontmatter.enabled === false || frontmatter.inline === false)
         continue;
-      const name = getFrontmatterText(frontmatter.name) ?? basename2(path, extname(path));
+      const name = getFrontmatterText(frontmatter.name) ?? basename4(path, extname(path));
       const systemPrompt = body.trim();
       if (!name || name.includes(":") || !systemPrompt) {
         diagnostics.push(`Skipped ${path}: agent name must not contain ":" and prompt body is required.`);
@@ -605,7 +2152,7 @@ async function loadAgentModes(directory, source, modes, diagnostics, skillName)
       modes.set(id, {
         id,
         label: getFrontmatterText(frontmatter.display_name) ?? name,
-        description: getFrontmatterText(frontmatter.description) ?? `Inline agent from ${basename2(path)}`,
+        description: getFrontmatterText(frontmatter.description) ?? `Inline agent from ${basename4(path)}`,
         systemPrompt,
         promptStrategy: frontmatter.prompt_mode === "append" ? "append" : "replace",
         modelPreferences: [
@@ -647,9 +2194,9 @@ function isModeBaseline(value) {
   return (model === undefined || typeof model.provider === "string" && typeof model.id === "string") && candidate.thinkingLevel !== undefined && THINKING_LEVELS.has(candidate.thinkingLevel) && Array.isArray(candidate.tools) && candidate.tools.every((tool) => typeof tool === "string");
 }
 // src/pi.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname4, join as join7 } from "node:path";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname6, join as join12 } from "node:path";
 var pi = {
   executableCheck: findPiExecutable,
   packageList: listPiPackages,
@@ -662,19 +2209,19 @@ var pi = {
   configEnsure: ensurePiConfig
 };
 async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
-  const path = join7(agentDir, "agents", filename);
+  const path = join12(agentDir, "agents", filename);
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
-    await mkdir3(dirname4(path), { recursive: true });
-    await writeFile3(path, content, "utf8");
+    await mkdir5(dirname6(path), { recursive: true });
+    await writeFile6(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
-async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join7(homedir5(), ".agents", "skills")) {
-  const roots = [join7(agentDir, "skills"), sharedSkillsDir];
+async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join12(homedir7(), ".agents", "skills")) {
+  const roots = [join12(agentDir, "skills"), sharedSkillsDir];
   for (const root of roots) {
-    if (await readTextIfExists(join7(root, name, "SKILL.md")) !== undefined)
+    if (await readTextIfExists(join12(root, name, "SKILL.md")) !== undefined)
       return true;
   }
   return false;
@@ -703,8 +2250,8 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const next = update(current);
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
-    await mkdir3(dirname4(path), { recursive: true });
-    await writeFile3(path, `${JSON.stringify(next, null, 2)}
+    await mkdir5(dirname6(path), { recursive: true });
+    await writeFile6(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -723,8 +2270,8 @@ function hasPiPackage(listOutput, source) {
 async function installPiPackage(executable, source) {
   await runChecked(executable, ["install", source]);
 }
-function resolvePiAgentDir(homeDir = homedir5()) {
-  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join7(process.env.XDG_CONFIG_HOME, "pi") : join7(homeDir, ".pi", "agent"));
+function resolvePiAgentDir(homeDir = homedir7()) {
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join12(process.env.XDG_CONFIG_HOME, "pi") : join12(homeDir, ".pi", "agent"));
 }
 function parseJsonObject(content, path) {
   if (!content?.trim())
@@ -736,11 +2283,975 @@ function parseJsonObject(content, path) {
   } catch {}
   throw new Error(`Expected valid JSON object in ${path}.`);
 }
+// src/plan/annotations.ts
+import { spawn as spawn2 } from "node:child_process";
+import { readFile as readFile12, rename as rename2, writeFile as writeFile8 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname7, join as join14 } from "node:path";
+
+// src/plan/log.ts
+import { randomUUID } from "node:crypto";
+import { appendFile, readFile as readFile10 } from "node:fs/promises";
+async function appendPlanLog(logPath, event) {
+  const entry = {
+    ...event,
+    version: 1,
+    eventId: event.eventId ?? randomUUID(),
+    timestamp: event.timestamp ?? new Date().toISOString()
+  };
+  await appendFile(logPath, `${JSON.stringify(entry)}
+`, { encoding: "utf8", mode: 384 });
+  return entry;
+}
+async function readPlanLog(logPath) {
+  let source;
+  try {
+    source = await readFile10(logPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  }
+  return source.split(`
+`).filter(Boolean).map((line, index) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      throw new Error(`Malformed plan log entry at line ${index + 1}.`);
+    }
+  });
+}
+
+// src/plan/lock.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir6, readFile as readFile11, rm, writeFile as writeFile7 } from "node:fs/promises";
+import { hostname } from "node:os";
+import { join as join13 } from "node:path";
+async function withPlanLock(planDir, operation, options = {}) {
+  const lockDir = join13(planDir, ".lock");
+  const waitMs = options.waitMs ?? 5000;
+  const pollMs = options.pollMs ?? 25;
+  const owner = {
+    token: randomUUID2(),
+    pid: process.pid,
+    hostname: hostname(),
+    operation: options.operation ?? "plan mutation",
+    acquiredAt: new Date().toISOString()
+  };
+  const started = Date.now();
+  while (true) {
+    try {
+      await mkdir6(lockDir);
+      await writeFile7(join13(lockDir, "owner.json"), `${JSON.stringify(owner)}
+`, { mode: 384 });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+      if (Date.now() - started >= waitMs) {
+        let existing = "unknown owner";
+        try {
+          existing = (await readFile11(join13(lockDir, "owner.json"), "utf8")).trim();
+        } catch {}
+        throw new Error(`Timed out waiting for plan lock ${lockDir}; owner: ${existing}. Remove it only after confirming the owner is stale.`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+  }
+  try {
+    return await operation();
+  } finally {
+    let current;
+    try {
+      current = JSON.parse(await readFile11(join13(lockDir, "owner.json"), "utf8"));
+    } catch {}
+    if (current?.token === owner.token)
+      await rm(lockDir, { recursive: true, force: true });
+  }
+}
+
+// src/plan/annotations.ts
+async function annotatePlan(record, runtime = {}) {
+  const execute = runtime.execute ?? executeProcess;
+  const result = await execute("tuicr", ["--file", record.planPath], dirname7(record.planPath), true);
+  const sessionSlug = [...result.stderr.matchAll(/^tuicr-session:\s*(\S+)\s*$/gm)].at(-1)?.[1];
+  if (result.code !== 0)
+    throw new Error(result.stderr.trim() || `tuicr exited with status ${result.code}.`);
+  if (!sessionSlug)
+    throw new Error("tuicr did not report a tuicr-session marker.");
+  const state = await withPlanLock(record.dir, async () => {
+    const previous = await readAnnotationState(record).catch(() => {
+      return;
+    });
+    const next = {
+      schemaVersion: 1,
+      sessionSlug,
+      updatedAt: new Date().toISOString(),
+      appliedCommentIds: previous?.appliedCommentIds ?? []
+    };
+    await atomicJson(annotationStatePath(record), next);
+    return next;
+  }, { operation: "save annotation session" });
+  return { sessionSlug, code: result.code, state };
+}
+async function readPlanAnnotations(record, options = {}) {
+  const state = await readAnnotationState(record).catch((error) => {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  });
+  if (!state)
+    return { comments: [], pending: [] };
+  const execute = options.runtime?.execute ?? executeProcess;
+  const response = await execute("tuicr", ["review", "comments", "--session", state.sessionSlug], record.dir, false);
+  if (response.code !== 0) {
+    if (/not found|no session|deleted/i.test(response.stderr))
+      return { state, comments: [], pending: [] };
+    throw new Error(response.stderr.trim() || "Cannot read tuicr comments.");
+  }
+  let raw;
+  try {
+    raw = JSON.parse(response.stdout);
+  } catch {
+    throw new Error("tuicr returned malformed comment JSON.");
+  }
+  if (!Array.isArray(raw))
+    throw new Error("tuicr comment output must be a JSON array.");
+  const lines = record.source.split(`
+`);
+  const applied = new Set(state.appliedCommentIds);
+  const comments = raw.map((value, index) => normalizeComment(value, index, lines, applied));
+  const pending = comments.filter((comment) => !comment.applied);
+  return { state, comments: options.includeApplied ? comments : pending, pending };
+}
+async function acknowledgePlanAnnotations(record, commentIds, summary) {
+  if (!summary.trim())
+    throw new Error("Annotation acknowledgement summary is required.");
+  return withPlanLock(record.dir, async () => {
+    const state = await readAnnotationState(record);
+    const next = {
+      ...state,
+      updatedAt: new Date().toISOString(),
+      appliedCommentIds: [...new Set([...state.appliedCommentIds, ...commentIds])]
+    };
+    await atomicJson(annotationStatePath(record), next);
+    await appendPlanLog(record.logPath, {
+      planRevision: record.document.revision,
+      kind: "annotation",
+      actor: "planner",
+      message: summary,
+      data: { commentIds: [...commentIds], sessionSlug: state.sessionSlug }
+    });
+    return next;
+  }, { operation: "acknowledge annotations" });
+}
+function annotationStatePath(record) {
+  return join14(record.dir, "annotations.json");
+}
+async function readAnnotationState(record) {
+  const value = JSON.parse(await readFile12(annotationStatePath(record), "utf8"));
+  if (value.schemaVersion !== 1 || typeof value.sessionSlug !== "string" || !Array.isArray(value.appliedCommentIds)) {
+    throw new Error(`Malformed annotation state: ${annotationStatePath(record)}.`);
+  }
+  return value;
+}
+function normalizeComment(value, index, lines, applied) {
+  if (!value || typeof value !== "object")
+    throw new Error(`Malformed tuicr comment at index ${index}.`);
+  const raw = value;
+  if (typeof raw.id !== "string" || typeof raw.content !== "string")
+    throw new Error(`Malformed tuicr comment at index ${index}.`);
+  const line = integer(raw.start_line) ?? integer(raw.line);
+  const endLine = integer(raw.end_line) ?? line;
+  const targetPath = typeof raw.path === "string" ? raw.path : undefined;
+  const appliesToPlan = !targetPath || basename5(targetPath) === basename5("PLAN.md");
+  const validAnchor = appliesToPlan && line !== undefined && line > 0 && line <= lines.length;
+  return {
+    id: raw.id,
+    body: raw.content,
+    file: targetPath,
+    line,
+    endLine,
+    context: validAnchor ? lines.slice(line - 1, Math.min(endLine ?? line, lines.length)).join(`
+`) : undefined,
+    stale: line !== undefined && !validAnchor,
+    applied: applied.has(raw.id)
+  };
+}
+async function executeProcess(command, args, cwd, interactive) {
+  if (!interactive) {
+    const result = await run(command, args, { cwd, capture: "unbounded" });
+    return { code: result.code, stdout: result.stdout, stderr: result.stderr };
+  }
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, args, { cwd, stdio: ["inherit", "inherit", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr += text;
+      process.stderr.write(text);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ code: code ?? 1, stdout: "", stderr }));
+  });
+}
+async function atomicJson(path, value) {
+  const temp = join14(dirname7(path), `.${basename5(path)}.${crypto.randomUUID()}.tmp`);
+  await writeFile8(temp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384, flag: "wx" });
+  await rename2(temp, path);
+}
+function integer(value) {
+  return typeof value === "number" && Number.isInteger(value) ? value : undefined;
+}
+// src/plan/escalation.ts
+import { z as z5 } from "zod";
+var escalationSchema = z5.object({
+  planId: z5.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  executionId: z5.string().min(1),
+  phaseId: z5.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  taskId: z5.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
+  blocker: z5.string().min(1),
+  attempts: z5.array(z5.string()),
+  evidence: z5.array(z5.string()),
+  needsUserDecision: z5.boolean()
+}).strict();
+var OPEN = "<diffpi-planner-escalation>";
+var CLOSE = "</diffpi-planner-escalation>";
+function renderPlannerEscalation(value) {
+  return `${OPEN}${JSON.stringify(escalationSchema.parse(value))}${CLOSE}`;
+}
+function parsePlannerEscalation(output) {
+  const start = output.indexOf(OPEN);
+  const end = output.indexOf(CLOSE, start + OPEN.length);
+  if (start < 0 || end < 0 || output.indexOf(OPEN, start + OPEN.length) >= 0)
+    throw new Error("Missing or ambiguous planner escalation payload.");
+  const payload = output.slice(start + OPEN.length, end);
+  try {
+    return escalationSchema.parse(JSON.parse(payload));
+  } catch (error) {
+    throw new Error(`Malformed planner escalation payload: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+// src/plan/execution.ts
+function createExecutionPacket(plan, coordinator) {
+  if (!plan.execution?.active)
+    throw new Error(`Plan ${plan.id} has no active execution.`);
+  return {
+    version: 1,
+    planId: plan.id,
+    executionId: plan.execution.id,
+    policy: plan.execution.policy,
+    cwd: plan.execution.cwd,
+    branch: plan.execution.branch,
+    coordinator
+  };
+}
+function renderExecutionPrompt(packet) {
+  return `Execute the durable Diffpi plan using this packet: ${JSON.stringify(packet)}. Call plan_context first. Coordinate eligible work, persist every transition and progress event, run phase gates, and honor the commit policy. Do not edit PLAN.md directly. Delegated workers never commit or restructure the plan.`;
+}
+function eligiblePlanTasks(plan) {
+  const completedPhases = new Set(plan.phases.filter((phase) => phase.status === "completed" || phase.status === "skipped").map((phase) => phase.id));
+  const completedTasks = new Set(plan.phases.flatMap((phase) => phase.tasks).filter((task) => task.status === "completed" || task.status === "skipped").map((task) => task.id));
+  for (const phase of plan.phases) {
+    if (phase.status === "completed" || phase.status === "skipped")
+      continue;
+    if (!phase.dependencies.every((dependency) => completedPhases.has(dependency)))
+      continue;
+    return phase.tasks.filter((task) => task.status === "pending" && task.dependencies.every((dependency) => completedTasks.has(dependency))).map((task) => ({ phase, task }));
+  }
+  return [];
+}
+function tasksMayRunInParallel(left, right) {
+  if (!left.fileScopes.length || !right.fileScopes.length)
+    return false;
+  if (left.dependencies.includes(right.id) || right.dependencies.includes(left.id))
+    return false;
+  return left.fileScopes.every((scope) => right.fileScopes.every((other) => !scopesOverlap(scope, other)));
+}
+function phaseCommitCommand(policy) {
+  return policy === "commit-per-phase" ? "/git commit --yes --no-push" : undefined;
+}
+function scopesOverlap(left, right) {
+  const normalize = (value) => value.replace(/^\.\//, "").replace(/\*.*$/, "").replace(/\/$/, "");
+  const a = normalize(left);
+  const b = normalize(right);
+  return !a || !b || a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+// src/plan/transitions.ts
+var STABLE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var PLAN_TRANSITIONS = {
+  draft: ["ready"],
+  ready: ["draft", "in_progress"],
+  in_progress: ["blocked", "completed"],
+  blocked: ["draft", "ready", "in_progress"],
+  completed: []
+};
+var WORK_TRANSITIONS = {
+  pending: ["in_progress", "skipped"],
+  in_progress: ["blocked", "completed"],
+  blocked: ["pending", "in_progress", "skipped"],
+  completed: [],
+  skipped: []
+};
+function isStableId(value) {
+  return STABLE_ID.test(value) && value.length <= 80;
+}
+function assertStableId(value, label = "identifier") {
+  if (!isStableId(value))
+    throw new Error(`${label} must be a lowercase stable slug, not a path: ${value}`);
+}
+function assertPlanTransition(from, to) {
+  if (from === to)
+    return;
+  if (!PLAN_TRANSITIONS[from].includes(to))
+    throw new Error(`Invalid plan status transition: ${from} -> ${to}.`);
+}
+function assertPhaseTransition(from, to) {
+  if (from === to)
+    return;
+  if (!WORK_TRANSITIONS[from].includes(to))
+    throw new Error(`Invalid phase status transition: ${from} -> ${to}.`);
+}
+function assertTaskTransition(task, to, executionId, actor) {
+  if (task.status !== to && !WORK_TRANSITIONS[task.status].includes(to)) {
+    throw new Error(`Invalid task status transition: ${task.status} -> ${to}.`);
+  }
+  if (task.status === "in_progress" && task.executionId && executionId !== task.executionId) {
+    throw new Error(`Task ${task.id} is owned by execution ${task.executionId}.`);
+  }
+  if (task.status === "in_progress" && task.owner && actor && actor !== task.owner) {
+    throw new Error(`Task ${task.id} is owned by ${task.owner}.`);
+  }
+}
+function assertUniqueIds(ids, label) {
+  const seen = new Set;
+  for (const id of ids) {
+    assertStableId(id, label);
+    if (seen.has(id))
+      throw new Error(`Duplicate ${label}: ${id}.`);
+    seen.add(id);
+  }
+}
+
+// src/plan/markdown.ts
+var PLAN_MARKER = /<!-- diffpi-plan: (\{[^\n]+\}) -->/;
+var PHASE_MARKER = /<!-- diffpi-phase: (\{[^\n]+\}) -->/g;
+var TASK_MARKER = /<!-- diffpi-task: (\{[^\n]+\}) -->/g;
+var SUPPORTED_SCHEMA = 1;
+function countDesignWords(plan) {
+  return [plan.design.bigIdeas, plan.design.keyApiUpdates, plan.design.consequences].join(" ").trim().split(/\s+/).filter(Boolean).length;
+}
+function validatePlanDocument(plan, options = {}) {
+  const issues = [];
+  const add = (code, severity, message, path) => issues.push({ code, severity, message, path });
+  try {
+    assertStableId(plan.id, "plan id");
+    assertUniqueIds(plan.phases.map((phase) => phase.id), "phase id");
+    assertUniqueIds(plan.phases.flatMap((phase) => phase.tasks.map((task) => task.id)), "task id");
+  } catch (error) {
+    add("invalid-id", "error", error.message);
+  }
+  if (plan.schemaVersion !== SUPPORTED_SCHEMA)
+    add("schema", "error", `Unsupported plan schema: ${plan.schemaVersion}.`);
+  const phaseIds = new Set(plan.phases.map((phase) => phase.id));
+  const taskIds = new Set(plan.phases.flatMap((phase) => phase.tasks.map((task) => task.id)));
+  for (const phase of plan.phases) {
+    for (const dependency of phase.dependencies) {
+      if (!phaseIds.has(dependency))
+        add("dangling-dependency", "error", `Phase ${phase.id} depends on missing ${dependency}.`);
+    }
+    for (const task of phase.tasks) {
+      for (const dependency of task.dependencies) {
+        if (!taskIds.has(dependency))
+          add("dangling-dependency", "error", `Task ${task.id} depends on missing ${dependency}.`);
+      }
+      if (options.strict && task.acceptanceCriteria.length === 0)
+        add("acceptance", "error", `Task ${task.id} has no acceptance criteria.`, task.id);
+    }
+    if (options.strict && phase.tasks.length === 0)
+      add("empty-phase", "error", `Phase ${phase.id} has no tasks.`, phase.id);
+  }
+  for (const cycle of dependencyCycles(plan))
+    add("dependency-cycle", "error", `Dependency cycle: ${cycle.join(" -> ")}.`);
+  const designWords = countDesignWords(plan);
+  if (designWords > 300)
+    add("design-length", "warning", `Design is ${designWords} words; prefer 300 or fewer.`);
+  if (options.strict && designWords > 800)
+    add("design-too-long", "error", `Design is ${designWords} words; finalization allows at most 800.`);
+  if (options.strict && plan.phases.length === 0)
+    add("no-phases", "error", "Finalization requires at least one phase.");
+  if (options.strict && (options.pendingAnnotations ?? 0) > 0)
+    add("pending-annotations", "error", `${options.pendingAnnotations} annotations remain pending.`);
+  return issues;
+}
+function renderPlanDocument(plan, previousSource) {
+  if (previousSource && canPatch(previousSource, plan))
+    return patchMarkers(previousSource, plan);
+  const marker = {
+    schemaVersion: plan.schemaVersion,
+    id: plan.id,
+    revision: plan.revision,
+    branch: plan.branch,
+    status: plan.status,
+    execution: plan.execution,
+    createdAt: plan.createdAt,
+    updatedAt: plan.updatedAt
+  };
+  const requirements = plan.requirements.length ? plan.requirements.map((item) => `- ${item}`).join(`
+`) : "<!-- Add requirements. -->";
+  const phases = plan.phases.map(renderPhase).join(`
+
+`);
+  const references = plan.references.length ? plan.references.map((reference) => `- <!-- diffpi-reference: ${json(reference)} --> ${reference.value}`).join(`
+`) : "<!-- Add references. -->";
+  return `<!-- diffpi-plan: ${json(marker)} -->
+# ${plan.title}
+
+- **Plan ID:** ${plan.id}
+- **Branch:** ${plan.branch}
+- **Status:** ${plan.status}
+- **Revision:** ${plan.revision}
+
+## Intent
+
+${plan.intent || "<!-- Describe the intended outcome. -->"}
+
+## Requirements
+
+${requirements}
+
+## Design
+
+### Big Ideas
+
+${plan.design.bigIdeas || "<!-- Describe the main approach. -->"}
+
+### Key API Addition/Updates
+
+${plan.design.keyApiUpdates || "<!-- Describe public API changes. -->"}
+
+### Consequences
+
+${plan.design.consequences || "<!-- Describe trade-offs and limitations. -->"}
+
+## Implementation
+
+${phases || "<!-- Add phases with plan_add_phase. -->"}
+
+## References
+
+${references}
+`;
+}
+function parsePlanDocument(source, ref = "PLAN.md") {
+  const planMatch = source.match(PLAN_MARKER);
+  if (!planMatch)
+    throw new Error(`${ref}: missing or malformed diffpi-plan marker.`);
+  if ((source.match(new RegExp(PLAN_MARKER.source, "g")) ?? []).length !== 1)
+    throw new Error(`${ref}: duplicate diffpi-plan marker.`);
+  const marker = parseMarker(planMatch[1], `${ref} plan`);
+  if (marker.schemaVersion !== SUPPORTED_SCHEMA)
+    throw new Error(`${ref}: unsupported plan schema ${String(marker.schemaVersion)}.`);
+  assertStableId(marker.id, "plan id");
+  const title = source.match(/^# (.+)$/m)?.[1]?.trim();
+  if (!title)
+    throw new Error(`${ref}: missing plan title.`);
+  const phases = parsePhases(section(source, "Implementation"), ref);
+  const document = {
+    ...marker,
+    schemaVersion: 1,
+    title,
+    intent: cleanPlaceholder(section(source, "Intent")),
+    requirements: parseBullets(section(source, "Requirements")),
+    design: {
+      bigIdeas: cleanPlaceholder(subsection(source, "Design", "Big Ideas")),
+      keyApiUpdates: cleanPlaceholder(subsection(source, "Design", "Key API Addition/Updates")),
+      consequences: cleanPlaceholder(subsection(source, "Design", "Consequences"))
+    },
+    phases,
+    references: parseReferences(section(source, "References"))
+  };
+  const errors = validatePlanDocument(document).filter((issue) => issue.severity === "error");
+  if (errors.length)
+    throw new Error(`${ref}: ${errors.map((issue) => issue.message).join(" ")}`);
+  return document;
+}
+function renderPhase(phase) {
+  const marker = {
+    id: phase.id,
+    revision: phase.revision,
+    status: phase.status,
+    gate: phase.gate,
+    commit: phase.commit,
+    blocker: phase.blocker
+  };
+  const dependencies = phase.dependencies.length ? phase.dependencies.join(", ") : "none";
+  return `<!-- diffpi-phase: ${json(marker)} -->
+### Phase: ${phase.title}
+
+**Objective:** ${phase.objective}
+
+**Dependencies:** ${dependencies}
+
+${phase.tasks.map(renderTask).join(`
+
+`)}
+
+<!-- /diffpi-phase -->`;
+}
+function renderTask(task) {
+  const marker = {
+    id: task.id,
+    revision: task.revision,
+    status: task.status,
+    owner: task.owner,
+    executionId: task.executionId,
+    blocker: task.blocker
+  };
+  const checked = task.status === "completed" || task.status === "skipped" ? "x" : " ";
+  return `<!-- diffpi-task: ${json(marker)} -->
+- [${checked}] **${task.title}**
+  - Steps: ${list(task.steps ?? [])}
+  - Dependencies: ${list(task.dependencies)}
+  - File scopes: ${list(task.fileScopes)}
+  - Acceptance criteria: ${list(task.acceptanceCriteria)}
+<!-- /diffpi-task -->`;
+}
+function parsePhases(input, ref) {
+  const starts = [...input.matchAll(PHASE_MARKER)];
+  const phases = starts.map((match, index) => {
+    const start = match.index;
+    const end = input.indexOf("<!-- /diffpi-phase -->", start);
+    if (end < 0)
+      throw new Error(`${ref}: phase marker has no closing marker.`);
+    const next = starts[index + 1]?.index;
+    if (next !== undefined && next < end)
+      throw new Error(`${ref}: nested or unclosed phase marker.`);
+    const body = input.slice(start + match[0].length, end);
+    const marker = parseMarker(match[1], `${ref} phase`);
+    assertStableId(marker.id, "phase id");
+    const title = body.match(/^### Phase: (.+)$/m)?.[1]?.trim();
+    const objective = body.match(/^\*\*Objective:\*\*\s*(.*)$/m)?.[1]?.trim();
+    if (!title || !objective)
+      throw new Error(`${ref}: phase ${marker.id} is missing title or objective.`);
+    return {
+      ...marker,
+      title,
+      objective,
+      dependencies: parseCsv(body.match(/^\*\*Dependencies:\*\*\s*(.*)$/m)?.[1]),
+      tasks: parseTasks(body, ref)
+    };
+  });
+  assertUniqueIds(phases.map((phase) => phase.id), "phase id");
+  return phases;
+}
+function parseTasks(input, ref) {
+  const starts = [...input.matchAll(TASK_MARKER)];
+  const tasks = starts.map((match, index) => {
+    const start = match.index;
+    const end = input.indexOf("<!-- /diffpi-task -->", start);
+    if (end < 0)
+      throw new Error(`${ref}: task marker has no closing marker.`);
+    const next = starts[index + 1]?.index;
+    if (next !== undefined && next < end)
+      throw new Error(`${ref}: nested or unclosed task marker.`);
+    const body = input.slice(start + match[0].length, end);
+    const marker = parseMarker(match[1], `${ref} task`);
+    assertStableId(marker.id, "task id");
+    const title = body.match(/^- \[[ xX]\] \*\*(.+)\*\*$/m)?.[1]?.trim();
+    if (!title)
+      throw new Error(`${ref}: task ${marker.id} is missing its checkbox title.`);
+    return {
+      ...marker,
+      title,
+      steps: parseListValue(body, "Steps"),
+      dependencies: parseListValue(body, "Dependencies"),
+      fileScopes: parseListValue(body, "File scopes"),
+      acceptanceCriteria: parseListValue(body, "Acceptance criteria")
+    };
+  });
+  assertUniqueIds(tasks.map((task) => task.id), "task id");
+  return tasks;
+}
+function parseReferences(input) {
+  return [...input.matchAll(/^- <!-- diffpi-reference: (\{[^\n]+\}) -->\s*(.*)$/gm)].map((match) => {
+    const marker = parseMarker(match[1], "reference");
+    assertStableId(marker.id, "reference id");
+    return { id: marker.id, value: match[2].trim() || marker.value };
+  });
+}
+function canPatch(source, next) {
+  try {
+    const old = parsePlanDocument(source);
+    return JSON.stringify(contentShape(old)) === JSON.stringify(contentShape(next));
+  } catch {
+    return false;
+  }
+}
+function patchMarkers(source, plan) {
+  const planMarker = {
+    schemaVersion: plan.schemaVersion,
+    id: plan.id,
+    revision: plan.revision,
+    branch: plan.branch,
+    status: plan.status,
+    execution: plan.execution,
+    createdAt: plan.createdAt,
+    updatedAt: plan.updatedAt
+  };
+  let output = source.replace(PLAN_MARKER, `<!-- diffpi-plan: ${json(planMarker)} -->`);
+  output = output.replace(/^- \*\*Status:\*\* .*$/m, `- **Status:** ${plan.status}`);
+  output = output.replace(/^- \*\*Revision:\*\* .*$/m, `- **Revision:** ${plan.revision}`);
+  for (const phase of plan.phases) {
+    const marker = {
+      id: phase.id,
+      revision: phase.revision,
+      status: phase.status,
+      gate: phase.gate,
+      commit: phase.commit,
+      blocker: phase.blocker
+    };
+    output = replaceMarkerById(output, "phase", phase.id, marker);
+    for (const task of phase.tasks) {
+      const taskMarker = {
+        id: task.id,
+        revision: task.revision,
+        status: task.status,
+        owner: task.owner,
+        executionId: task.executionId,
+        blocker: task.blocker
+      };
+      output = replaceMarkerById(output, "task", task.id, taskMarker);
+      const checked = task.status === "completed" || task.status === "skipped" ? "x" : " ";
+      const escaped = escapeRegExp(task.title);
+      output = output.replace(new RegExp(`^- \\[[ xX]\\] \\*\\*${escaped}\\*\\*$`, "m"), `- [${checked}] **${task.title}**`);
+    }
+  }
+  return output;
+}
+function replaceMarkerById(source, kind, id, marker) {
+  const pattern = new RegExp(`<!-- diffpi-${kind}: \\{[^\\n]*"id":"${escapeRegExp(id)}"[^\\n]*\\} -->`);
+  if (!pattern.test(source))
+    throw new Error(`Cannot update missing ${kind} marker ${id}.`);
+  return source.replace(pattern, `<!-- diffpi-${kind}: ${json(marker)} -->`);
+}
+function contentShape(plan) {
+  return {
+    title: plan.title,
+    branch: plan.branch,
+    intent: plan.intent,
+    requirements: plan.requirements,
+    design: plan.design,
+    references: plan.references,
+    phases: plan.phases.map(({ id, title, objective, dependencies, tasks }) => ({
+      id,
+      title,
+      objective,
+      dependencies,
+      tasks: tasks.map(({ id: taskId, title: taskTitle, steps, dependencies: taskDependencies, fileScopes, acceptanceCriteria }) => ({
+        id: taskId,
+        title: taskTitle,
+        steps,
+        dependencies: taskDependencies,
+        fileScopes,
+        acceptanceCriteria
+      }))
+    }))
+  };
+}
+function dependencyCycles(plan) {
+  const graph = new Map;
+  for (const phase of plan.phases)
+    graph.set(phase.id, phase.dependencies);
+  for (const task of plan.phases.flatMap((phase) => phase.tasks))
+    graph.set(task.id, task.dependencies);
+  const cycles = [];
+  const visiting = new Set;
+  const visited = new Set;
+  const walk = (id, path) => {
+    if (visiting.has(id)) {
+      cycles.push([...path.slice(path.indexOf(id)), id]);
+      return;
+    }
+    if (visited.has(id))
+      return;
+    visiting.add(id);
+    for (const dependency of graph.get(id) ?? [])
+      walk(dependency, [...path, id]);
+    visiting.delete(id);
+    visited.add(id);
+  };
+  for (const id of graph.keys())
+    walk(id, []);
+  return cycles;
+}
+function section(source, heading) {
+  const match = source.match(new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m"));
+  if (!match?.index) {
+    if (match?.index === 0)
+      return "";
+    throw new Error(`Missing required heading: ${heading}.`);
+  }
+  const start = match.index + match[0].length;
+  const rest = source.slice(start);
+  const end = rest.search(/^## /m);
+  return (end < 0 ? rest : rest.slice(0, end)).trim();
+}
+function subsection(source, parent, heading) {
+  const body = section(source, parent);
+  const match = body.match(new RegExp(`^### ${escapeRegExp(heading)}\\s*$`, "m"));
+  if (match?.index === undefined)
+    throw new Error(`Missing required heading: ${parent}/${heading}.`);
+  const rest = body.slice(match.index + match[0].length);
+  const end = rest.search(/^### /m);
+  return (end < 0 ? rest : rest.slice(0, end)).trim();
+}
+function parseBullets(input) {
+  return [...input.matchAll(/^- (?!<!--)(.+)$/gm)].map((match) => match[1].trim());
+}
+function parseListValue(body, label) {
+  const value = body.match(new RegExp(`^  - ${escapeRegExp(label)}:\\s*(.*)$`, "m"))?.[1];
+  return parseCsv(value);
+}
+function parseCsv(value) {
+  if (!value || value.trim().toLowerCase() === "none")
+    return [];
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function cleanPlaceholder(value) {
+  return value.replace(/<!--[^]*?-->/g, "").trim();
+}
+function parseMarker(value, label) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`Malformed ${label} marker JSON.`);
+  }
+}
+function list(values) {
+  return values.length ? values.join(", ") : "none";
+}
+function json(value) {
+  return JSON.stringify(value, (_key, entry) => entry === undefined ? undefined : entry);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// src/plan/store.ts
+import { open, mkdir as mkdir7, readdir as readdir2, readFile as readFile14, realpath as realpath4, rename as rename3, rm as rm2 } from "node:fs/promises";
+import { basename as basename6, dirname as dirname8, join as join16, resolve as resolve4, sep } from "node:path";
+
+// src/templates.ts
+import { readFile as readFile13 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { join as join15, normalize } from "node:path";
+async function loadTemplate(name, options = {}) {
+  const relative = templateRelativePath(name);
+  const userPath = join15(options.homeDir ?? homedir8(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join15(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 readFile13(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+
+// src/plan/store.ts
+function planRecordName(shortSlug, date = new Date) {
+  const slug = normalizeSlug(shortSlug);
+  return `${date.toISOString().slice(2, 10).replaceAll("-", "")}-${slug}`;
+}
+async function resolvePlan(cwd, query, filters = {}, options = {}) {
+  const root = await plansDir(cwd, options.homeDir);
+  const entries = await readdir2(root, { withFileTypes: true });
+  const normalizedQuery = query ? normalizeQuery(query) : undefined;
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === ".tmp" || entry.name === ".lock")
+      continue;
+    if (normalizedQuery && entry.name !== normalizedQuery && stripDate(entry.name) !== normalizedQuery)
+      continue;
+    const dir = join16(root, entry.name);
+    await assertContained(root, dir);
+    try {
+      const record = await readRecord(dir);
+      if (filters.branch && record.document.branch !== filters.branch)
+        continue;
+      if (filters.statuses && !filters.statuses.includes(record.document.status))
+        continue;
+      records.push(record);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+  }
+  records.sort((left, right) => left.id.localeCompare(right.id));
+  return { candidates: records, record: records.length === 1 ? records[0] : undefined, ambiguous: records.length > 1 };
+}
+function createPlanStore(options = {}) {
+  const now = options.now ?? (() => new Date);
+  return {
+    context(cwd, query, filters) {
+      return resolvePlan(cwd, query, filters, options);
+    },
+    async init(input) {
+      const root = await plansDir(input.cwd, options.homeDir);
+      const id = planRecordName(input.shortSlug, now());
+      const dir = join16(root, id);
+      await assertContained(root, dirname8(dir));
+      try {
+        await mkdir7(dir);
+      } catch (error) {
+        if (error.code === "EEXIST")
+          throw new Error(`Plan ${id} already exists.`);
+        throw error;
+      }
+      try {
+        const timestamp = now().toISOString();
+        const template = await loadTemplate("plan/PLAN", {
+          homeDir: options.homeDir,
+          bundledDir: options.bundledTemplatesDir
+        });
+        const source = renderTemplate(template.content, {
+          id,
+          branch: input.branch,
+          title: input.title?.trim() || titleFromSlug(input.shortSlug),
+          intent: input.intent?.trim() || "<!-- Describe the intended outcome. -->",
+          created_at: timestamp,
+          updated_at: timestamp
+        });
+        const document = parsePlanDocument(source, join16(dir, "PLAN.md"));
+        await atomicWrite(join16(dir, "PLAN.md"), source);
+        await atomicWrite(join16(dir, "logs.txt"), "");
+        await appendPlanLog(join16(dir, "logs.txt"), {
+          planRevision: document.revision,
+          kind: "created",
+          actor: "diffpi",
+          message: `Created plan ${id}.`
+        });
+        return { id, dir, planPath: join16(dir, "PLAN.md"), logPath: join16(dir, "logs.txt"), document, source };
+      } catch (error) {
+        await rm2(dir, { recursive: true, force: true });
+        throw error;
+      }
+    },
+    async read(cwd, query, filters) {
+      const result = await resolvePlan(cwd, query, filters, options);
+      if (!result.record) {
+        if (result.ambiguous)
+          throw new Error(`Plan query "${query}" is ambiguous: ${result.candidates.map((item) => item.id).join(", ")}.`);
+        throw new Error(`Plan "${query}" was not found.`);
+      }
+      return result.record;
+    },
+    async mutate(cwd, query, operation, update) {
+      const initial = await this.read(cwd, query);
+      return withPlanLock(initial.dir, async () => {
+        const current = await readRecord(initial.dir);
+        const next = await update(structuredClone(current.document));
+        if (next.id !== current.id)
+          throw new Error("A plan mutation cannot change the plan ID.");
+        const document = {
+          ...next,
+          revision: current.document.revision + 1,
+          updatedAt: now().toISOString()
+        };
+        const source = renderPlanDocument(document, current.source);
+        parsePlanDocument(source, current.planPath);
+        await atomicWrite(current.planPath, source);
+        return { ...current, document, source };
+      }, { operation });
+    },
+    async log(cwd, query, event) {
+      const record = await this.read(cwd, query);
+      return withPlanLock(record.dir, () => appendPlanLog(record.logPath, event), { operation: "append log" });
+    }
+  };
+}
+async function readRecord(dir) {
+  const planPath = join16(dir, "PLAN.md");
+  const logPath = join16(dir, "logs.txt");
+  const source = await readFile14(planPath, "utf8");
+  const document = parsePlanDocument(source, planPath);
+  return { id: basename6(dir), dir, planPath, logPath, document, source };
+}
+async function atomicWrite(path, content) {
+  const temp = join16(dirname8(path), `.${basename6(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  const file = await open(temp, "wx", 384);
+  try {
+    await file.writeFile(content, "utf8");
+    await file.sync();
+  } finally {
+    await file.close();
+  }
+  await rename3(temp, path);
+  try {
+    const directory = await open(dirname8(path), "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  } catch {}
+}
+async function assertContained(root, candidate) {
+  const canonicalRoot = await realpath4(root);
+  let canonicalCandidate;
+  try {
+    canonicalCandidate = await realpath4(candidate);
+  } catch {
+    canonicalCandidate = resolve4(candidate);
+  }
+  if (canonicalCandidate !== canonicalRoot && !canonicalCandidate.startsWith(`${canonicalRoot}${sep}`)) {
+    throw new Error(`Plan path escapes the shared store: ${candidate}.`);
+  }
+}
+function normalizeSlug(value) {
+  if (!value || value.includes("\x00") || value.includes("/") || value.includes("\\") || value.includes("..")) {
+    throw new Error(`Invalid plan slug: ${value}.`);
+  }
+  const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  assertStableId(slug, "plan slug");
+  return slug;
+}
+function normalizeQuery(value) {
+  if (!value || value.includes("\x00") || value.includes("/") || value.includes("\\") || value.includes("..")) {
+    throw new Error(`Invalid plan query: ${value}.`);
+  }
+  return value.toLowerCase();
+}
+function stripDate(value) {
+  return value.replace(/^\d{6}-/, "");
+}
+function titleFromSlug(value) {
+  return normalizeSlug(value).replace(/^(?:[a-z]+-\d+-)/, "").split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter3 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir2, readFile as readFile5 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename3, join as join8 } from "node:path";
+import { readdir as readdir3, readFile as readFile15 } from "node:fs/promises";
+import { homedir as homedir9 } from "node:os";
+import { basename as basename7, join as join17 } from "node:path";
 var MISE_DEPENDENCIES = [
   { name: "node", tool: "node", spec: "node@22", minimumVersion: "22.19.0" },
   { name: "zellij", tool: "zellij", spec: "zellij@latest", minimumVersion: undefined },
@@ -768,13 +3279,18 @@ var PI_PACKAGES = [
 ];
 var PI_SKILL_SOURCES = [
   { repository: "arabold/docs-mcp-server", skills: ["docs-manage", "docs-search", "fetch-url"] },
-  { repository: "AminBlg/SimpleEnglish", skills: ["simple-english"] }
+  { repository: "AminBlg/SimpleEnglish", skills: ["simple-english"] },
+  { repository: "cloudvoyant/codevoyant", skills: ["git"] }
 ];
 var MCP_ADAPTER_PACKAGE = "npm:pi-mcp-adapter";
 var BUNDLED_AGENTS_DIR2 = resolveBundledAgentsDir();
+var FORGE_DEPENDENCIES = {
+  github: { name: "gh", tool: "gh", spec: "gh@latest", minimumVersion: undefined },
+  gitlab: { name: "glab", tool: "glab", spec: "glab@latest", minimumVersion: undefined }
+};
 async function ensureMise(options = {}) {
-  const homeDir = options.homeDir ?? homedir6();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join8(homeDir, ".local", "bin", "mise"));
+  const homeDir = options.homeDir ?? homedir9();
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join17(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -803,7 +3319,11 @@ async function ensureMiseHooks(miseExecutable, options = {}) {
 async function ensureMiseDeps(miseExecutable, options = {}) {
   const canRunMise = Boolean(await mise.executableCheck(miseExecutable));
   const actions = [];
-  for (const dependency of MISE_DEPENDENCIES) {
+  const dependencies = [
+    ...MISE_DEPENDENCIES,
+    ...configuredForges(options).map((forge) => FORGE_DEPENDENCIES[forge])
+  ];
+  for (const dependency of dependencies) {
     const installed = canRunMise && await mise.toolCheckGlobal(miseExecutable, dependency.tool, dependency.minimumVersion);
     if (installed) {
       actions.push(createSetupAction(dependency.name, "ready", dependency.spec));
@@ -819,9 +3339,9 @@ async function ensureMiseDeps(miseExecutable, options = {}) {
 async function ensurePiPlugins(options = {}) {
   const actions = await ensurePiPackages(PI_PACKAGES, options);
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const webSearch = await pi.configEnsure(join8(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  const webSearch = await pi.configEnsure(join17(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
   actions.push(getConfigSetupAction("web search settings", webSearch));
-  const lsp = await pi.configEnsure(join8(agentDir, "pi-lsp.json"), (config) => ({
+  const lsp = await pi.configEnsure(join17(agentDir, "pi-lsp.json"), (config) => ({
     ...config,
     progressive: { ...getRecord(config.progressive), enabled: true, inject: "none" }
   }), options.dryRun);
@@ -832,11 +3352,11 @@ 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 entries = (await readdir3(bundledAgentsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
   const actions = [];
   for (const entry of entries) {
-    const id = basename3(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile5(join8(bundledAgentsDir, entry.name), "utf8");
+    const id = basename7(entry.name, ".md").replace(/^diffpi-/, "");
+    const source = await readFile15(join17(bundledAgentsDir, entry.name), "utf8");
     const content = materializeAgentModels(source, id, userConfig.config, options.availableModels);
     const result = await pi.agentEnsure(entry.name, content, agentDir, options.dryRun);
     actions.push(getConfigSetupAction(`pi agent ${id}`, result));
@@ -845,7 +3365,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join8(options.homeDir ?? homedir6(), ".agents", "skills");
+  const sharedSkillsDir = join17(options.homeDir ?? homedir9(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -889,6 +3409,14 @@ async function ensureMcpAdapters(miseExecutable, options = {}) {
   } else if (options.issueTracker === "jira") {
     servers.atlassian = { url: "https://mcp.atlassian.com/v1/mcp", auth: "oauth", protocolVersion: "auto" };
   }
+  for (const forge of configuredForges(options)) {
+    if (forge === "github") {
+      servers.github = { url: "https://api.githubcopilot.com/mcp/", auth: "oauth", protocolVersion: "auto" };
+      continue;
+    }
+    const host = await gitlabMcpHost(projectDir);
+    servers.gitlab = { url: `https://${host}/api/v4/mcp`, auth: "oauth", protocolVersion: "auto" };
+  }
   const result = await mcp.serversEnsure(servers, {
     dryRun: options.dryRun,
     path: mcp.globalConfigPath(options.homeDir)
@@ -905,6 +3433,8 @@ async function setupPi(options = {}) {
   actions.push(...await ensurePiAgents(options));
   actions.push(...await ensurePiSkills(miseResult.executable, options));
   actions.push(...await ensureMcpAdapters(miseResult.executable, options));
+  if (options.bindZedKey)
+    actions.push(...await ensureZedIntegration(options));
   return {
     actions,
     restartPi: setupRequiresRestart(actions)
@@ -913,6 +3443,43 @@ async function setupPi(options = {}) {
 function setupRequiresRestart(actions) {
   return actions.some((item) => (item.status === "installed" || item.status === "updated") && (item.name.startsWith("pi package ") || item.name.startsWith("pi agent ") || item.name.startsWith("pi skill ") || item.name === "MCP configuration" || item.name === "web search settings" || item.name === "pi-lsp settings"));
 }
+async function ensureZedIntegration(options = {}) {
+  if (options.dryRun) {
+    const actions = [
+      createSetupAction("Zed review tasks", "planned", "global static runtime-resolver tasks in tasks.json"),
+      createSetupAction("Zed plan task", "planned", "pinned package CLI task in tasks.json")
+    ];
+    if (options.bindZedKey)
+      actions.push(createSetupAction("Zed review keybinding", "planned", "keymap.json"));
+    return actions;
+  }
+  const actions = [];
+  try {
+    const tasks = await ensureZedReviewTask(options.homeDir);
+    actions.push(createSetupAction("Zed review tasks", tasks.changed ? "installed" : "ready", tasks.path));
+    const planTask = await ensureZedPlanTask(await packageVersion2(), options.homeDir);
+    actions.push(createSetupAction("Zed plan task", planTask.changed ? "installed" : "ready", planTask.path));
+  } catch (error) {
+    actions.push(createSetupAction("Zed review tasks", "skipped", error instanceof Error ? error.message : String(error)));
+  }
+  if (options.bindZedKey) {
+    try {
+      const key = await ensureZedReviewKeybinding(options.homeDir);
+      actions.push(createSetupAction("Zed review keybinding", key.changed ? "installed" : "ready", key.path));
+    } catch (error) {
+      actions.push(createSetupAction("Zed review keybinding", "skipped", error instanceof Error ? error.message : String(error)));
+    }
+  }
+  return actions;
+}
+async function gitlabMcpHost(projectDir) {
+  try {
+    const vcs = await detectVcs(projectDir);
+    return vcs.provider === "gitlab" && vcs.host ? vcs.host : "gitlab.com";
+  } catch {
+    return "gitlab.com";
+  }
+}
 function materializeAgentModels(content, agentId, config, availableModels) {
   const { frontmatter } = parseFrontmatter3(content.startsWith("\uFEFF") ? content.slice(1) : content);
   const profilePreferences = [...getTextList(frontmatter.model), ...getTextList(frontmatter.model_fallbacks)];
@@ -972,6 +3539,10 @@ ${source}`;
   }
   return actions;
 }
+function configuredForges(options) {
+  const selected = options.forges ?? (options.forge && options.forge !== "none" ? [options.forge] : []);
+  return [...new Set(selected)];
+}
 function getTextList(value) {
   const values = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
   return values.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean);
@@ -989,13 +3560,55 @@ function createSetupAction(name, status, detail) {
 function reportProgress(options, message) {
   options.onProgress?.(message);
 }
+async function packageVersion2() {
+  const source = await readFile15(join17(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
+  const value = JSON.parse(source);
+  if (typeof value.version !== "string")
+    throw new Error("Cannot resolve the installed @difflab/pi version.");
+  return value.version;
+}
 function getRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 export {
+  CONVENTIONAL_COMMIT,
+  GitHubVcsBackend,
+  GitLabVcsBackend,
+  ZED_LOCAL_REVIEW_TASK_NAME,
+  ZED_PLAN_ANNOTATE_TASK_NAME,
+  ZED_PR_REVIEW_TASK_NAME,
+  ZED_REVIEW_TASK_NAME,
+  acknowledgePlanAnnotations,
+  addComment,
+  annotatePlan,
+  annotationStatePath,
+  appendPlanLog,
+  assertGitHubMergeReady,
+  assertPhaseTransition,
+  assertPlanTransition,
+  assertReviewEventSupported,
+  assertStableId,
+  assertTaskTransition,
+  checkConventionalSubject,
+  ciGate,
+  computeProjectSlug,
+  countDesignWords,
+  createExecutionPacket,
+  createForge,
+  createForgeBackend,
+  createLocalReviewBackend,
   createModeController,
+  createPlanStore,
+  createRemoteReviewBackend,
+  createVcsBackend,
+  dedupeFindings,
+  detectIde,
+  detectMux,
+  detectShell,
+  detectVcs,
   diffpiConfigPaths,
   discoverAgentModes,
+  eligiblePlanTasks,
   ensureMcpAdapters,
   ensureMise,
   ensureMiseDeps,
@@ -1003,12 +3616,74 @@ export {
   ensurePiAgents,
   ensurePiPlugins,
   ensurePiSkills,
+  ensureStore,
+  ensureZedPlanTask,
+  ensureZedReviewKeybinding,
+  ensureZedReviewTask,
   findPreferredModel,
+  findingSchema,
+  findingsSchema,
+  gitToplevel,
+  githubReviewSubmissionEndpoint,
+  hasGitlabDraftNotes,
+  launch,
+  listSessions,
   loadDiffpiConfig,
+  loadReviewPublicationState,
+  loadTemplate,
+  localReviewAuthor,
   mcp,
   mise,
+  openInNewTab,
+  parseGitlabDiffRefs,
+  parsePlanDocument,
+  parsePlannerEscalation,
+  parseRemote,
+  parseThreadArtifact,
+  phaseCommitCommand,
   pi,
+  planRecordName,
+  plansDir,
+  readPlanAnnotations,
+  readPlanLog,
+  readSession,
+  renderExecutionPrompt,
+  renderPlanDocument,
+  renderPlannerEscalation,
+  renderReviewDoc,
+  renderTemplate,
+  renderThreadArtifact,
   resolveAgentMode,
   resolveAgentModelPreferences,
-  setupPi
+  resolvePlan,
+  resolvePrSession,
+  resolveReviewSession,
+  resolveSession,
+  reviewBodyFingerprint,
+  reviewCommentFingerprint,
+  reviewRecordName,
+  reviewReplyFingerprint,
+  reviewSlug,
+  reviewsDir,
+  runMiseGates,
+  saveReviewPublicationState,
+  sessionsDir,
+  setupPi,
+  severitySchema,
+  storeDir,
+  storeGlobalRoot,
+  tasksMayRunInParallel,
+  templateRelativePath,
+  toFindings,
+  toReviewComments,
+  tuicrAvailable,
+  unpublishedReviewComments,
+  upsertThreadReply,
+  validatePlanDocument,
+  withPlanLock,
+  withRemoteProvenance,
+  yymmdd,
+  zedKeymapPath,
+  zedReviewTaskName,
+  zedTasksPath
 };