@difflab/pi 0.3.0-rc.202609200047.ac3661a → 0.3.0

package/dist/extensions/index.js

@@ -13731,473 +13731,6 @@ async function handleModeCommand(args, ctx, modes) {
   ctx.ui.notify(`${result.message} Changes apply on the next turn.`, result.ok ? "info" : "error");
 }
 
-// src/commands/plan.ts
-import { join as join10 } from "node:path";
-
-// src/extensions/processx.ts
-import { spawn as spawn2 } from "node:child_process";
-import { constants } from "node:fs";
-import { access } from "node:fs/promises";
-import { delimiter, join as join6 } from "node:path";
-async function findExecutable(name) {
-  if (name.includes("/")) {
-    try {
-      await access(name, constants.X_OK);
-      return name;
-    } catch {
-      return;
-    }
-  }
-  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
-    if (!directory)
-      continue;
-    const candidate = join6(directory, name);
-    try {
-      await access(candidate, constants.X_OK);
-      return candidate;
-    } catch {}
-  }
-  return;
-}
-function run(command, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const child = spawn2(command, args, {
-      cwd: options.cwd,
-      env: options.env ?? process.env,
-      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    const unbounded = options.capture === "unbounded";
-    child.stdout?.on("data", (chunk) => {
-      const text = chunk.toString();
-      if (unbounded)
-        stdoutChunks.push(text);
-      else
-        stdout = appendBounded(stdout, text);
-    });
-    child.stderr?.on("data", (chunk) => {
-      const text = chunk.toString();
-      if (unbounded)
-        stderrChunks.push(text);
-      else
-        stderr = appendBounded(stderr, text);
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve({
-      code: code ?? 1,
-      stdout: unbounded ? stdoutChunks.join("") : stdout,
-      stderr: unbounded ? stderrChunks.join("") : stderr
-    }));
-    if (options.input !== undefined && child.stdin)
-      child.stdin.end(options.input);
-  });
-}
-async function runChecked(command, args, options = {}) {
-  const result = await run(command, args, options);
-  if (result.code === 0)
-    return result;
-  const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
-  throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
-}
-var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
-function appendBounded(current, next) {
-  const combined = current + next;
-  return combined.length <= MAX_CAPTURED_OUTPUT_LENGTH ? combined : combined.slice(-MAX_CAPTURED_OUTPUT_LENGTH);
-}
-
-// src/commands/background.ts
-import { chmod, mkdir as mkdir2, readdir as readdir2, rm, stat, writeFile } from "node:fs/promises";
-import { join as join9 } from "node:path";
-
-// src/store.ts
-import { createHash } from "node:crypto";
-import { lstat, mkdir, readlink, realpath as realpath2, symlink, unlink } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname3, isAbsolute as isAbsolute3, join as join8, resolve as resolve3 } from "node:path";
-
-// src/extensions/gitx.ts
-import { realpath } from "node:fs/promises";
-import { basename as basename2, isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } 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 : resolve2(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 ? resolve2(isAbsolute2(common) ? common : join7(root, common)) : root;
-  const commonDir = await canonicalPath(commonPath);
-  return {
-    root,
-    commonDir,
-    ...remote ? { remote } : {},
-    name: remote ? repositoryName(remote) : basename2(resolve2(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 resolve2(path);
-  }
-}
-
-// src/store.ts
-var STORE_LINK = ".diffpi";
-var LEGACY_STORE_LINK = join8(".pi", "diffpi");
-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 mkdir(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 plansDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "plan");
-  await mkdir(dir, { recursive: true });
-  return dir;
-}
-async function reviewsDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "review");
-  await mkdir(dir, { recursive: true });
-  return dir;
-}
-async function completedReviewsDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "reviews");
-  await mkdir(dir, { recursive: true });
-  return dir;
-}
-async function sessionsDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "sessions");
-  await mkdir(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 canonicalPath2(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 canonicalPath2(dest))
-      await unlink(path);
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-  }
-}
-async function symlinkTarget(path) {
-  const target = await readlink(path);
-  return canonicalPath2(isAbsolute3(target) ? target : resolve3(dirname3(path), target));
-}
-async function canonicalPath2(path) {
-  try {
-    return await realpath2(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/commands/background.ts
-async function launchBackgroundPi(pi, options) {
-  const child = shellCommand([
-    "pi",
-    "--mode",
-    "json",
-    "--print",
-    "--no-session",
-    "--offline",
-    "--approve",
-    "--model",
-    options.model,
-    "--thinking",
-    options.thinking,
-    "--append-system-prompt",
-    options.agentPath,
-    "--",
-    options.prompt
-  ]);
-  const command = options.packetPath ? `sh -c ${shellQuote(`trap 'rm -f -- "$1"' EXIT HUP INT TERM; cd -- "$2" || exit; ${child}`)} sh ${shellQuote(options.packetPath)} ${shellQuote(options.cwd)}` : `cd ${shellQuote(options.cwd)} && ${child}`;
-  await pi.sendUserMessage(`/bg --agent --name ${shellQuote(options.name)} -- ${command}`, {
-    deliverAs: "followUp",
-    expandPromptTemplates: true
-  });
-  return { name: options.name, command, queued: true };
-}
-async function createBackgroundPacket(cwd, payload, limits = {}) {
-  const root = await plansDir(cwd);
-  const temp = join9(root, ".tmp");
-  await mkdir2(temp, { recursive: true, mode: 448 });
-  await cleanupBackgroundPackets(temp, limits.retentionMs);
-  const packet = { ...payload, version: 1, createdAt: new Date().toISOString() };
-  const content = `${JSON.stringify(packet)}
-`;
-  const maxBytes = limits.maxBytes ?? 64 * 1024;
-  if (Buffer.byteLength(content) > maxBytes)
-    throw new Error(`Background packet exceeds ${maxBytes} bytes.`);
-  const path = join9(temp, `context-${crypto.randomUUID()}.json`);
-  await writeFile(path, content, { mode: 384, flag: "wx" });
-  await chmod(path, 384);
-  return path;
-}
-function normalizeConversation(entries, maxMessages = 12, maxBytes = 48 * 1024) {
-  const messages = entries.flatMap((entry) => {
-    if (!entry || typeof entry !== "object")
-      return [];
-    const candidate = entry;
-    if (candidate.secret === true || candidate.type !== "message" || !candidate.message || typeof candidate.message !== "object")
-      return [];
-    const message = candidate.message;
-    if (message.role !== "user" && message.role !== "assistant")
-      return [];
-    const text = messageText(message.content);
-    return text ? [{ role: message.role, text }] : [];
-  });
-  const selected = messages.slice(-Math.max(0, maxMessages));
-  while (Buffer.byteLength(JSON.stringify(selected)) > maxBytes && selected.length)
-    selected.shift();
-  return selected;
-}
-function shellQuote(value) {
-  return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-function shellCommand(args) {
-  return args.map(shellQuote).join(" ");
-}
-async function cleanupBackgroundPackets(dir, retentionMs = 24 * 60 * 60 * 1000) {
-  const cutoff = Date.now() - retentionMs;
-  for (const name of await readdir2(dir)) {
-    if (!/^context-[a-f0-9-]+\.json$/i.test(name))
-      continue;
-    const path = join9(dir, name);
-    if ((await stat(path)).mtimeMs < cutoff)
-      await rm(path, { force: true });
-  }
-}
-function messageText(content) {
-  if (typeof content === "string")
-    return content.trim();
-  if (!Array.isArray(content))
-    return "";
-  return content.flatMap((part) => {
-    if (!part || typeof part !== "object")
-      return [];
-    const candidate = part;
-    return candidate.type === "text" && typeof candidate.text === "string" && candidate.source !== "secret" ? [candidate.text] : [];
-  }).join(`
-`).trim();
-}
-
-// src/commands/plan.ts
-var PLANNER_PATH = join10(resolveBundledAgentsDir(), "diffpi-planner.md");
-var ORCHESTRATOR_PATH = join10(resolveBundledAgentsDir(), "diffpi-orchestrator.md");
-var HELP = "Usage: /plan init|new|update|annotate|finalize|go|help. Run /plan help for exact grammar.";
-function registerPlanCommand(pi, modes) {
-  pi.registerCommand("plan", {
-    description: "Durable planning: init, new, update, annotate, finalize, go, help",
-    handler: async (args, ctx) => handlePlanCommand(args, ctx, pi, modes)
-  });
-}
-function parsePlanArgs(raw) {
-  const tokens = tokenizePlanArgs(raw);
-  const verb = tokens.shift() ?? "help";
-  if (!["init", "new", "update", "annotate", "finalize", "go", "help"].includes(verb))
-    throw new Error(`Unknown plan verb: ${verb}. ${HELP}`);
-  let branch;
-  let background = false;
-  let policy;
-  const positional = [];
-  while (tokens.length) {
-    const token = tokens.shift();
-    if (token === "--branch") {
-      if (branch)
-        throw new Error(`Duplicate --branch. ${HELP}`);
-      branch = tokens.shift();
-      if (!branch || branch.startsWith("--"))
-        throw new Error(`--branch requires a value. ${HELP}`);
-    } else if (token === "--bg") {
-      if (background)
-        throw new Error(`Duplicate --bg. ${HELP}`);
-      background = true;
-    } else if (token === "--commit" || token === "--no-commit") {
-      const next = token === "--commit" ? "commit-per-phase" : "no-commit";
-      if (policy)
-        throw new Error(`Conflicting or duplicate commit policy. ${HELP}`);
-      policy = next;
-    } else if (token.startsWith("--"))
-      throw new Error(`Unknown flag: ${token}. ${HELP}`);
-    else
-      positional.push(token);
-  }
-  if (verb === "go") {
-    if (branch)
-      throw new Error(`go does not accept --branch. ${HELP}`);
-    if (positional.length !== 1)
-      throw new Error(`go requires exactly one plan slug. ${HELP}`);
-    return { verb, plan: positional[0], background, policy, instructions: "" };
-  }
-  if (policy)
-    throw new Error(`${verb} does not accept a commit policy. ${HELP}`);
-  if (verb === "help") {
-    if (positional.length || branch || background)
-      throw new Error(`help does not accept arguments. ${HELP}`);
-    return { verb, background: false, instructions: "" };
-  }
-  if (verb === "init") {
-    if (background || positional.length !== 1)
-      throw new Error(`init requires one slug and does not accept --bg. ${HELP}`);
-    return { verb, plan: positional[0], branch, background: false, instructions: "" };
-  }
-  if (verb === "annotate" || verb === "finalize") {
-    if (background || branch || positional.length > 1)
-      throw new Error(`${verb} accepts only an optional plan slug. ${HELP}`);
-    return { verb, plan: positional[0], background: false, instructions: "" };
-  }
-  const plan = positional.shift();
-  if (verb === "new" && !plan)
-    throw new Error(`new requires a plan slug. ${HELP}`);
-  return { verb, plan, branch, background, instructions: positional.join(" ") };
-}
-function tokenizePlanArgs(raw) {
-  const tokens = [];
-  let value = "";
-  let quote;
-  let escaped = false;
-  const push = () => {
-    if (value)
-      tokens.push(value);
-    value = "";
-  };
-  for (const char of raw.trim()) {
-    if (escaped) {
-      value += char;
-      escaped = false;
-    } else if (char === "\\" && quote !== "'")
-      escaped = true;
-    else if (quote) {
-      if (char === quote)
-        quote = undefined;
-      else
-        value += char;
-    } else if (char === '"' || char === "'")
-      quote = char;
-    else if (/\s/.test(char))
-      push();
-    else
-      value += char;
-  }
-  if (escaped || quote)
-    throw new Error(`Unterminated quote or escape. ${HELP}`);
-  push();
-  return tokens;
-}
-async function handlePlanCommand(args, ctx, pi, modes) {
-  let request;
-  try {
-    request = parsePlanArgs(args);
-  } catch (error) {
-    ctx.ui.notify(error.message, "error");
-    return;
-  }
-  if (request.background && (request.verb === "new" || request.verb === "update")) {
-    const branch = request.branch ?? await currentBranch(ctx.cwd);
-    const packet = await createBackgroundPacket(ctx.cwd, {
-      cwd: ctx.cwd,
-      branch,
-      command: request,
-      conversation: normalizeConversation(ctx.sessionManager.getBranch())
-    });
-    await launchBackgroundPi(pi, {
-      name: `Plan ${request.verb}`,
-      agentPath: PLANNER_PATH,
-      model: "openai-codex/gpt-5.6-sol",
-      thinking: "high",
-      cwd: ctx.cwd,
-      packetPath: packet,
-      prompt: `Run the plan skill ${request.verb} workflow non-interactively using context packet ${packet}. Do not ask questions. Persist unresolved ambiguity as a blocker.`
-    });
-    return;
-  }
-  if (request.verb === "go" && request.background && request.policy) {
-    await launchBackgroundPi(pi, {
-      name: `Plan go ${request.plan}`,
-      agentPath: ORCHESTRATOR_PATH,
-      model: "openai-codex/gpt-5.6-luna",
-      thinking: "medium",
-      cwd: ctx.cwd,
-      prompt: planPrompt(request, "orchestrator")
-    });
-    return;
-  }
-  const directInlineGo = request.verb === "go" && !request.background && request.policy;
-  const agent = directInlineGo ? "worker" : "planner";
-  const activation = await modes.set(agent, ctx);
-  pi.sendMessage({
-    customType: "diffpi-plan-command",
-    display: false,
-    content: `${planPrompt(request, agent)} ${activation.message}`
-  }, { triggerTurn: true });
-}
-function planPrompt(request, agent) {
-  const args = [request.verb];
-  if (request.plan)
-    args.push(request.plan);
-  if ("branch" in request && request.branch)
-    args.push("--branch", request.branch);
-  if (request.verb === "go" && request.policy)
-    args.push(request.policy === "commit-per-phase" ? "--commit" : "--no-commit");
-  if (request.instructions)
-    args.push(request.instructions);
-  return `The user ran /plan ${args.join(" ")}. Active inline agent: ${agent}. Follow the plan skill dispatcher and use structured plan tools. Do not perform unrelated work.`;
-}
-async function currentBranch(cwd) {
-  return (await runChecked("git", ["-C", cwd, "branch", "--show-current"])).stdout.trim();
-}
-
 // src/commands/reload.ts
 function registerReloadCommand(pi) {
   pi.registerCommand("diffpi-reload", {
@@ -14209,9 +13742,9 @@ function registerReloadCommand(pi) {
 }
 
 // src/commands/review.ts
-import { join as join11 } from "node:path";
+import { join as join6 } from "node:path";
 var REVIEWER_VERBS = new Set(["address", "auto", "launch"]);
-var ORCHESTRATOR_AGENT_PATH = join11(resolveBundledAgentsDir(), "diffpi-orchestrator.md");
+var ORCHESTRATOR_AGENT_PATH = join6(resolveBundledAgentsDir(), "diffpi-orchestrator.md");
 function registerReviewCommand(pi, modes) {
   pi.registerCommand("review", {
     description: "Code review: auto, new, edit, address, publish, complete, merge (add --local or --bg)",
@@ -14223,13 +13756,28 @@ async function handleReviewCommand(args, ctx, pi, modes) {
   const invocation = withoutFlag(args, "--bg") || "help";
   const verb = reviewVerb(invocation);
   if (background) {
-    await launchBackgroundPi(pi, {
-      name: `Review ${verb}`,
-      agentPath: ORCHESTRATOR_AGENT_PATH,
-      model: "openai-codex/gpt-5.6-luna",
-      thinking: "medium",
-      cwd: ctx.cwd,
-      prompt: reviewPrompt(invocation, "orchestrator")
+    const name = `Review ${verb}`;
+    const prompt = reviewPrompt(invocation, "orchestrator");
+    const command = shellCommand([
+      "pi",
+      "--mode",
+      "json",
+      "--print",
+      "--no-session",
+      "--offline",
+      "--approve",
+      "--model",
+      "openai-codex/gpt-5.6-luna",
+      "--thinking",
+      "medium",
+      "--append-system-prompt",
+      ORCHESTRATOR_AGENT_PATH,
+      "--",
+      prompt
+    ]);
+    await pi.sendUserMessage(`/bg --agent --name ${shellQuote(name)} -- ${command}`, {
+      deliverAs: "followUp",
+      expandPromptTemplates: true
     });
     return;
   }
@@ -14254,13 +13802,18 @@ function hasFlag(input, flag) {
 function withoutFlag(input, flag) {
   return input.split(/\s+/).filter((token) => token && token !== flag).join(" ").trim();
 }
+function shellCommand(args) {
+  return args.map(shellQuote).join(" ");
+}
+function shellQuote(value) {
+  return "'" + value.replaceAll("'", `'"'"'`) + "'";
+}
 
 // src/commands/index.ts
 function registerCommands(pi, modes) {
   registerReloadCommand(pi);
   registerModeCommand(pi, modes);
   registerReviewCommand(pi, modes);
-  registerPlanCommand(pi, modes);
 }
 
 // src/tools/reload.ts
@@ -14389,76 +13942,123 @@ function sanitize(value) {
   return value.replace(/[\r\n\t]+/g, " ").replace(/\s+/g, " ").trim();
 }
 
-// src/tools/plan.ts
-import { join as join19 } from "node:path";
+// src/tools/review.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir4, readdir as readdir2, readFile as readFile9, rename as rename2, stat, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join14 } from "node:path";
 import { defineTool as defineTool3 } from "@earendil-works/pi-coding-agent";
-import { z as z5 } from "zod";
+import { z as z7 } from "zod";
 
 // src/environment.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import { basename as basename3, join as join13 } from "node:path";
+import { basename as basename2 } from "node:path";
 
-// src/extensions/zedx.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname4, join as join12 } from "node:path";
-var ZED_LOCAL_REVIEW_TASK_NAME = "diffpi: tuicr local review";
-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 = homedir5()) {
-  return join12(homeDir, ".config", "zed", "tasks.json");
-}
-function zedKeymapPath(homeDir = homedir5()) {
-  return join12(homeDir, ".config", "zed", "keymap.json");
-}
-async function ensureZedReviewTask(homeDir = homedir5(), _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 = homedir5()) {
-  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(packageVersion)) {
-    throw new Error(`Invalid @difflab/pi package version: ${packageVersion}.`);
+// src/extensions/processx.ts
+import { spawn as spawn2 } from "node:child_process";
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { delimiter, join as join7 } from "node:path";
+async function findExecutable(name) {
+  if (name.includes("/")) {
+    try {
+      await access(name, constants.X_OK);
+      return name;
+    } catch {
+      return;
+    }
+  }
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!directory)
+      continue;
+    const candidate = join7(directory, name);
+    try {
+      await access(candidate, constants.X_OK);
+      return candidate;
+    } catch {}
   }
+  return;
+}
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, args, {
+      cwd: options.cwd,
+      env: options.env ?? process.env,
+      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    const unbounded = options.capture === "unbounded";
+    child.stdout?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (unbounded)
+        stdoutChunks.push(text);
+      else
+        stdout = appendBounded(stdout, text);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text = chunk.toString();
+      if (unbounded)
+        stderrChunks.push(text);
+      else
+        stderr = appendBounded(stderr, text);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({
+      code: code ?? 1,
+      stdout: unbounded ? stdoutChunks.join("") : stdout,
+      stderr: unbounded ? stderrChunks.join("") : stderr
+    }));
+    if (options.input !== undefined && child.stdin)
+      child.stdin.end(options.input);
+  });
+}
+async function runChecked(command, args, options = {}) {
+  const result = await run(command, args, options);
+  if (result.code === 0)
+    return result;
+  const detail = result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+  throw new Error(`${command} ${args.join(" ")} failed: ${detail}`);
+}
+var MAX_CAPTURED_OUTPUT_LENGTH = 65536;
+function appendBounded(current, next) {
+  const combined = current + next;
+  return combined.length <= MAX_CAPTURED_OUTPUT_LENGTH ? combined : combined.slice(-MAX_CAPTURED_OUTPUT_LENGTH);
+}
+
+// src/extensions/zedx.ts
+import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname3, join as join8 } from "node:path";
+var ZED_LOCAL_REVIEW_TASK_NAME = "diffpi: tuicr local review";
+var ZED_PR_REVIEW_TASK_NAME = "diffpi: tuicr PR review";
+var LEGACY_ZED_REVIEW_TASK_NAME = "diffpi: tuicr review";
+var REVIEW_KEYBINDING = "cmd-alt-r";
+function zedTasksPath(homeDir = homedir4()) {
+  return join8(homeDir, ".config", "zed", "tasks.json");
+}
+function zedKeymapPath(homeDir = homedir4()) {
+  return join8(homeDir, ".config", "zed", "keymap.json");
+}
+async function ensureZedReviewTask(homeDir = homedir4(), _command = ["tuicr", "-w", "-r", "main..HEAD"]) {
   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 migrated = tasks.filter((task) => task.label !== LEGACY_ZED_REVIEW_TASK_NAME);
+  const next = [...migrated];
+  for (const task of [localReviewTask(), prReviewTask()]) {
+    const index = next.findIndex((existing) => existing.label === task.label);
+    if (index >= 0)
+      next[index] = { ...next[index], ...task };
+    else
+      next.push(task);
+  }
   const changed = JSON.stringify(tasks) !== JSON.stringify(next);
   if (changed)
     await writeJson(path, next);
   return { path, changed, existed: currentText !== undefined };
 }
-async function ensureZedReviewKeybinding(homeDir = homedir5()) {
+async function ensureZedReviewKeybinding(homeDir = homedir4()) {
   const path = zedKeymapPath(homeDir);
   const currentText = await readOptional(path);
   const entries = parseJsonArray(currentText, path);
@@ -14477,9 +14077,6 @@ async function ensureZedReviewKeybinding(homeDir = homedir5()) {
   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
@@ -14561,2030 +14158,113 @@ function parseJsonArray(content, path) {
   return value;
 }
 async function writeJson(path, value) {
-  await mkdir3(dirname4(path), { recursive: true });
-  await writeFile2(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 ? basename3(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 readFile4(join13(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/misex.ts
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename4, dirname as dirname5, join as join14 } 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 ?? homedir6();
-    const platform = options.platform ?? process.platform;
-    if (platform === "win32")
-      throw new Error("Automatic mise installation supports macOS and Linux only.");
-    const installedPath = join14(homeDir, ".local", "bin", "mise");
-    if (options.dryRun)
-      return installedPath;
-    await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
-    const executable = await findExecutable(installedPath) ?? await findExecutable("mise");
-    if (!executable)
-      throw new Error(`mise installation completed, but ${installedPath} was not found.`);
-    return executable;
-  },
-  async hookEnsure(executable, options = {}) {
-    const homeDir = options.homeDir ?? homedir6();
-    const hook = getShellHook(basename4(options.shell ?? process.env.SHELL ?? ""), executable, homeDir);
-    const current = await getOptionalFile(hook.path);
-    if (current.includes(MISE_HOOK_START))
-      return { path: hook.path, changed: false, planned: false };
-    if (options.dryRun)
-      return { path: hook.path, changed: true, planned: true };
-    const separator = current.length === 0 || current.endsWith(`
-`) ? "" : `
-`;
-    await mkdir4(dirname5(hook.path), { recursive: true });
-    await writeFile3(hook.path, `${current}${separator}${hook.content}`, "utf8");
-    return { path: hook.path, changed: true, planned: false };
-  },
-  async toolCheckGlobal(executable, tool, minimumVersion) {
-    const result = await run(executable, ["ls", "--global", "--installed", tool, "--json"]);
-    return result.code === 0 && isToolInstalled(result.stdout, minimumVersion);
-  },
-  async toolInstallGlobal(executable, specification) {
-    await runChecked(executable, ["use", "--global", specification]);
-  },
-  async toolCheckLocal(executable, tool, cwd = process.cwd()) {
-    const result = await run(executable, ["ls", "--local", "--installed", tool, "--json"], { cwd });
-    return result.code === 0 && isToolInstalled(result.stdout);
-  },
-  async toolInstallLocal(executable, specification, cwd = process.cwd()) {
-    await runChecked(executable, ["use", "--path", cwd, specification], { cwd });
-  },
-  async toolUpdateAllGlobal(executable, homeDir = homedir6()) {
-    await runChecked(executable, ["upgrade"], { cwd: homeDir });
-  }
-};
-function getShellHook(shell, executable, homeDir) {
-  const command = getShellQuoted(executable);
-  switch (shell.toLowerCase()) {
-    case "zsh":
-      return {
-        path: join14(homeDir, ".zshrc"),
-        content: `${MISE_HOOK_START}
-eval "$(${command} activate zsh)"
-${MISE_HOOK_END}
-`
-      };
-    case "fish":
-      return {
-        path: join14(homeDir, ".config", "fish", "config.fish"),
-        content: `${MISE_HOOK_START}
-${command} activate fish | source
-${MISE_HOOK_END}
-`
-      };
-    case "nu":
-    case "nushell":
-      return {
-        path: join14(homeDir, ".config", "nushell", "config.nu"),
-        content: `${MISE_HOOK_START}
-let mise_bin = ${command}
-let mise_path = $nu.default-config-dir | path join mise.nu
-^$mise_bin activate nu | save $mise_path --force
-use ($nu.default-config-dir | path join mise.nu)
-${MISE_HOOK_END}
-`
-      };
-    case "xonsh":
-      return {
-        path: join14(homeDir, ".xonshrc"),
-        content: `${MISE_HOOK_START}
-execx($(${command} activate xonsh))
-${MISE_HOOK_END}
-`
-      };
-    case "elvish":
-      return {
-        path: join14(homeDir, ".config", "elvish", "rc.elv"),
-        content: `${MISE_HOOK_START}
-var mise: = (ns [&])
-eval (${command} activate elvish | slurp) &ns=$mise: &on-end={|ns| set mise: = $ns }
-mise:activate
-${MISE_HOOK_END}
-`
-      };
-    case "pwsh":
-    case "powershell":
-      return {
-        path: join14(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
-        content: `${MISE_HOOK_START}
-(& ${command} activate pwsh) | Out-String | Invoke-Expression
-${MISE_HOOK_END}
-`
-      };
-    case "bash":
-    default:
-      return {
-        path: join14(homeDir, ".bashrc"),
-        content: `${MISE_HOOK_START}
-eval "$(${command} activate bash)"
-${MISE_HOOK_END}
-`
-      };
-  }
-}
-function isToolInstalled(output, minimumVersion) {
-  try {
-    const value = JSON.parse(output);
-    if (!Array.isArray(value))
-      return false;
-    return value.some((entry) => {
-      if (!entry || typeof entry !== "object" || !("installed" in entry) || entry.installed !== true)
-        return false;
-      if (!minimumVersion)
-        return true;
-      if (!("version" in entry) || typeof entry.version !== "string")
-        return false;
-      return isVersionAtLeast(entry.version, minimumVersion);
-    });
-  } catch {
-    return false;
-  }
-}
-function isVersionAtLeast(version, minimumVersion) {
-  const current = version.match(/^v?(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
-  const minimum = minimumVersion.match(/^v?(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
-  if (!current || !minimum)
-    return false;
-  for (let index = 0;index < minimum.length; index += 1) {
-    if (current[index] !== minimum[index])
-      return current[index] > minimum[index];
-  }
-  return true;
-}
-async function getOptionalFile(path) {
-  try {
-    return await readFile5(path, "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return "";
-    throw error;
-  }
-}
-function getShellQuoted(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`;
-}
-
-// src/gates.ts
-var CONVENTIONAL_COMMIT = /^(feat|fix|perf|refactor|docs|chore|test|build|ci|style|revert)(\([^)]+\))?!?: .+/;
-var MISE_GATES = ["format:check", "lint", "test"];
-function checkConventionalSubject(subject) {
-  const trimmed = subject.trim();
-  const ok = CONVENTIONAL_COMMIT.test(trimmed);
-  return {
-    name: "conventional-subject",
-    status: ok ? "pass" : "warn",
-    detail: ok ? trimmed : `not a conventional-commit subject: "${trimmed}"`
-  };
-}
-async function runMiseGates(cwd) {
-  const tasks = await discoverMiseTasks(cwd);
-  const results = [];
-  for (const gate of MISE_GATES) {
-    const targets = tasks.get(gate) ?? [];
-    if (targets.length === 0) {
-      results.push({ name: gate, status: "skip", detail: "no mise recipe" });
-      continue;
-    }
-    const invocations = targets.flatMap((target, index) => index === 0 ? [target] : [":::", target]);
-    const result = await mise.run(["run", ...invocations], { cwd });
-    results.push({
-      name: gate,
-      status: result.code === 0 ? "pass" : "fail",
-      detail: result.code === 0 ? "clean" : (result.stderr.trim() || result.stdout.trim()).slice(-400)
-    });
-  }
-  return results;
-}
-function ciGate(checksOutput) {
-  const text = checksOutput.toLowerCase();
-  if (!text.trim())
-    return { name: "ci", status: "skip", detail: "no CI output" };
-  if (/\bfail|error\b/.test(text))
-    return { name: "ci", status: "warn", detail: "CI failing" };
-  if (/\bpending|in progress|queued\b/.test(text))
-    return { name: "ci", status: "warn", detail: "CI pending" };
-  return { name: "ci", status: "pass", detail: "CI green" };
-}
-function parseMiseTasks(input) {
-  let tasks;
-  try {
-    tasks = JSON.parse(input);
-  } catch {
-    return new Map;
-  }
-  if (!Array.isArray(tasks))
-    return new Map;
-  const found = new Map;
-  for (const gate of MISE_GATES) {
-    const targets = tasks.flatMap((task) => {
-      if (typeof task.name !== "string")
-        return [];
-      return task.name === gate || task.name.endsWith(`:${gate}`) || task.aliases?.includes(gate) ? [task.name] : [];
-    });
-    if (targets.length > 0)
-      found.set(gate, [...new Set(targets)]);
-  }
-  return found;
-}
-async function discoverMiseTasks(cwd) {
-  const result = await mise.run(["tasks", "--json", "--all"], { cwd });
-  if (result.code !== 0)
-    return new Map;
-  return parseMiseTasks(result.stdout);
-}
-
-// src/plan/annotations.ts
-import { spawn as spawn3 } from "node:child_process";
-import { readFile as readFile8, rename, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname6, join as join16 } from "node:path";
-
-// src/plan/log.ts
-import { randomUUID } from "node:crypto";
-import { appendFile, readFile as readFile6 } 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;
-}
-
-// src/plan/lock.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir5, readFile as readFile7, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
-import { hostname as hostname2 } from "node:os";
-import { join as join15 } from "node:path";
-async function withPlanLock(planDir, operation, options = {}) {
-  const lockDir = join15(planDir, ".lock");
-  const waitMs = options.waitMs ?? 5000;
-  const pollMs = options.pollMs ?? 25;
-  const owner = {
-    token: randomUUID2(),
-    pid: process.pid,
-    hostname: hostname2(),
-    operation: options.operation ?? "plan mutation",
-    acquiredAt: new Date().toISOString()
-  };
-  const started = Date.now();
-  while (true) {
-    try {
-      await mkdir5(lockDir);
-      await writeFile4(join15(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 readFile7(join15(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 readFile7(join15(lockDir, "owner.json"), "utf8"));
-    } catch {}
-    if (current?.token === owner.token)
-      await rm2(lockDir, { recursive: true, force: true });
-  }
-}
-
-// src/plan/annotations.ts
-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 join16(record.dir, "annotations.json");
-}
-async function readAnnotationState(record) {
-  const value = JSON.parse(await readFile8(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 = integer5(raw.start_line) ?? integer5(raw.line);
-  const endLine = integer5(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 = spawn3(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 = join16(dirname6(path), `.${basename5(path)}.${crypto.randomUUID()}.tmp`);
-  await writeFile5(temp, `${JSON.stringify(value, null, 2)}
-`, { mode: 384, flag: "wx" });
-  await rename(temp, path);
-}
-function integer5(value) {
-  return typeof value === "number" && Number.isInteger(value) ? value : undefined;
-}
-// src/plan/escalation.ts
-import { z as z4 } from "zod";
-var escalationSchema = z4.object({
-  planId: z4.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  executionId: z4.string().min(1),
-  phaseId: z4.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  taskId: z4.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
-  blocker: z4.string().min(1),
-  attempts: z4.array(z4.string()),
-  evidence: z4.array(z4.string()),
-  needsUserDecision: z4.boolean()
-}).strict();
-var OPEN = "<diffpi-planner-escalation>";
-var CLOSE = "</diffpi-planner-escalation>";
-function renderPlannerEscalation(value) {
-  return `${OPEN}${JSON.stringify(escalationSchema.parse(value))}${CLOSE}`;
-}
-// 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.`;
-}
-// 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 mkdir6, readdir as readdir3, readFile as readFile10, realpath as realpath3, rename as rename2, rm as rm3 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname7, join as join18, resolve as resolve4, sep } from "node:path";
-
-// src/templates.ts
-import { readFile as readFile9 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { join as join17, normalize } from "node:path";
-async function loadTemplate(name, options = {}) {
-  const relative = templateRelativePath(name);
-  const userPath = join17(options.homeDir ?? homedir7(), ".difflab", "diffpi", "templates", relative);
-  const bundledPath = join17(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 readFile9(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 readdir3(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 = join18(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 = join18(root, id);
-      await assertContained(root, dirname7(dir));
-      try {
-        await mkdir6(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, join18(dir, "PLAN.md"));
-        await atomicWrite(join18(dir, "PLAN.md"), source);
-        await atomicWrite(join18(dir, "logs.txt"), "");
-        await appendPlanLog(join18(dir, "logs.txt"), {
-          planRevision: document.revision,
-          kind: "created",
-          actor: "diffpi",
-          message: `Created plan ${id}.`
-        });
-        return { id, dir, planPath: join18(dir, "PLAN.md"), logPath: join18(dir, "logs.txt"), document, source };
-      } catch (error) {
-        await rm3(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 = join18(dir, "PLAN.md");
-  const logPath = join18(dir, "logs.txt");
-  const source = await readFile10(planPath, "utf8");
-  const document = parsePlanDocument(source, planPath);
-  return { id: basename6(dir), dir, planPath, logPath, document, source };
-}
-async function atomicWrite(path, content) {
-  const temp = join18(dirname7(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 rename2(temp, path);
-  try {
-    const directory = await open(dirname7(path), "r");
-    try {
-      await directory.sync();
-    } finally {
-      await directory.close();
-    }
-  } catch {}
-}
-async function assertContained(root, candidate) {
-  const canonicalRoot = await realpath3(root);
-  let canonicalCandidate;
-  try {
-    canonicalCandidate = await realpath3(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/tools/plan.ts
-var id2 = z5.string().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
-var text = z5.string().trim().min(1);
-var revision = z5.number().int().nonnegative();
-var cwd = z5.string().optional();
-var taskDraft = z5.object({
-  id: id2,
-  title: text,
-  steps: z5.array(text).optional(),
-  dependencies: z5.array(id2).optional(),
-  fileScopes: z5.array(text).optional(),
-  acceptanceCriteria: z5.array(text).optional()
-}).strict();
-var phaseDraft = z5.object({
-  id: id2,
-  title: text,
-  objective: text,
-  dependencies: z5.array(id2).optional(),
-  tasks: z5.array(taskDraft).optional()
-}).strict();
-var reference = z5.object({ id: id2, value: text }).strict();
-var design = z5.object({ bigIdeas: z5.string(), keyApiUpdates: z5.string(), consequences: z5.string() }).strict();
-function createPlanTools(pi, modes, store = createPlanStore()) {
-  return [
-    defineTool3({
-      name: "plan_context",
-      label: "plan context",
-      description: "Resolve one plan and summarize all matching plans without guessing among ambiguous matches.",
-      parameters: parameters5(z5.object({
-        cwd,
-        plan: z5.string().optional(),
-        branch: z5.string().optional(),
-        statuses: z5.array(z5.enum(["draft", "ready", "in_progress", "blocked", "completed"])).optional()
-      }).strict()),
-      executionMode: "parallel",
-      async execute(_id, input) {
-        const params = z5.object({
-          cwd,
-          plan: z5.string().optional(),
-          branch: z5.string().optional(),
-          statuses: z5.array(z5.enum(["draft", "ready", "in_progress", "blocked", "completed"])).optional()
-        }).strict().parse(input);
-        const resolution = await store.context(params.cwd ?? process.cwd(), params.plan, {
-          branch: params.branch,
-          statuses: params.statuses
-        });
-        return result(resolution.candidates.length ? resolution.candidates.map((record) => `${record.id}: ${record.document.status} r${record.document.revision} (${record.document.branch})`).join(`
-`) : "No matching plans.", { selected: resolution.record, candidates: resolution.candidates, ambiguous: resolution.ambiguous });
-      }
-    }),
-    defineTool3({
-      name: "plan_init",
-      label: "plan init",
-      description: "Create a phase-less editable plan draft.",
-      parameters: parameters5(z5.object({
-        cwd,
-        shortSlug: id2,
-        branch: z5.string().min(1).optional(),
-        title: text.optional(),
-        intent: text.optional(),
-        open: z5.boolean().optional()
-      }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = z5.object({
-          cwd,
-          shortSlug: id2,
-          branch: z5.string().min(1).optional(),
-          title: text.optional(),
-          intent: text.optional(),
-          open: z5.boolean().optional()
-        }).strict().parse(input);
-        const workingDirectory = params.cwd ?? process.cwd();
-        const branch = params.branch ?? await currentBranch2(workingDirectory);
-        const record = await store.init({ ...params, cwd: workingDirectory, branch });
-        return result(`Created ${record.id} at ${record.planPath}.`, { record, openRequested: params.open === true });
-      }
-    }),
-    defineTool3({
-      name: "plan_update_overview",
-      label: "plan update overview",
-      description: "Replace selected plan overview fields using an expected plan revision.",
-      parameters: parameters5(z5.object({
-        cwd,
-        plan: text,
-        expectedPlanRevision: revision,
-        intent: text.optional(),
-        requirements: z5.array(text).optional(),
-        design: design.optional(),
-        references: z5.array(reference).optional()
-      }).strict().refine((value) => value.intent || value.requirements || value.design || value.references, "At least one overview field is required.")),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const schema = z5.object({
-          cwd,
-          plan: text,
-          expectedPlanRevision: revision,
-          intent: text.optional(),
-          requirements: z5.array(text).optional(),
-          design: design.optional(),
-          references: z5.array(reference).optional()
-        }).strict().refine((value) => value.intent || value.requirements || value.design || value.references, "At least one overview field is required.");
-        const params = schema.parse(input);
-        const record = await store.mutate(params.cwd ?? process.cwd(), params.plan, "update overview", (plan) => {
-          assertAuthoringRevision(plan, params.expectedPlanRevision);
-          assertAuthorable(plan);
-          return resetDraft({
-            ...plan,
-            intent: params.intent ?? plan.intent,
-            requirements: params.requirements ?? plan.requirements,
-            design: params.design ?? plan.design,
-            references: params.references ?? plan.references
-          });
-        });
-        return result(`Updated ${record.id} to revision ${record.document.revision}.`, { record });
-      }
-    }),
-    defineTool3({
-      name: "plan_add_phase",
-      label: "plan add phase",
-      description: "Add an ordered phase with stable IDs.",
-      parameters: parameters5(z5.object({ cwd, plan: text, expectedPlanRevision: revision, afterPhaseId: id2.optional(), phase: phaseDraft }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = z5.object({ cwd, plan: text, expectedPlanRevision: revision, afterPhaseId: id2.optional(), phase: phaseDraft }).strict().parse(input);
-        const record = await store.mutate(params.cwd ?? process.cwd(), params.plan, "add phase", (plan) => {
-          assertAuthoringRevision(plan, params.expectedPlanRevision);
-          assertAuthorable(plan);
-          if (allIds(plan).has(params.phase.id))
-            throw new Error(`Duplicate stable ID: ${params.phase.id}.`);
-          const phase = newPhase(params.phase);
-          const phases = [...plan.phases];
-          if (params.afterPhaseId) {
-            const index = phases.findIndex((item) => item.id === params.afterPhaseId);
-            if (index < 0)
-              throw new Error(`Unknown phase: ${params.afterPhaseId}.`);
-            phases.splice(index + 1, 0, phase);
-          } else
-            phases.push(phase);
-          assertNewIds(plan, phase);
-          return resetDraft({ ...plan, phases });
-        });
-        return result(`Added phase ${params.phase.id} to ${record.id}.`, { record });
-      }
-    }),
-    defineTool3({
-      name: "plan_remove_phase",
-      label: "plan remove phase",
-      description: "Remove an unfinished phase that has no dependents.",
-      parameters: parameters5(z5.object({ cwd, plan: text, expectedPlanRevision: revision, phaseId: id2, reason: text }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = z5.object({ cwd, plan: text, expectedPlanRevision: revision, phaseId: id2, reason: text }).strict().parse(input);
-        const record = await store.mutate(params.cwd ?? process.cwd(), params.plan, "remove phase", (plan) => {
-          assertAuthoringRevision(plan, params.expectedPlanRevision);
-          assertAuthorable(plan);
-          const phase = getPhase(plan, params.phaseId);
-          if (phase.status === "completed" || phase.tasks.some((task) => task.status === "completed"))
-            throw new Error(`Completed phase ${phase.id} cannot be removed.`);
-          if (plan.phases.some((item) => item.dependencies.includes(phase.id)))
-            throw new Error(`Phase ${phase.id} has dependents and cannot be removed.`);
-          return resetDraft({ ...plan, phases: plan.phases.filter((item) => item.id !== phase.id) });
-        });
-        await store.log(params.cwd ?? process.cwd(), record.id, {
-          planRevision: record.document.revision,
-          kind: "updated",
-          actor: "planner",
-          message: `Removed phase ${params.phaseId}: ${params.reason}`,
-          phaseId: params.phaseId
-        });
-        return result(`Removed phase ${params.phaseId}.`, { record });
-      }
-    }),
-    defineTool3({
-      name: "plan_update_phase",
-      label: "plan update phase",
-      description: "Update an unfinished phase and its ordered tasks.",
-      parameters: parameters5(z5.object({
-        cwd,
-        plan: text,
-        expectedPlanRevision: revision,
-        phaseId: id2,
-        patch: z5.object({
-          title: text.optional(),
-          objective: text.optional(),
-          dependencies: z5.array(id2).optional(),
-          tasks: z5.array(taskDraft).optional()
-        }).strict()
-      }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = z5.object({
-          cwd,
-          plan: text,
-          expectedPlanRevision: revision,
-          phaseId: id2,
-          patch: z5.object({
-            title: text.optional(),
-            objective: text.optional(),
-            dependencies: z5.array(id2).optional(),
-            tasks: z5.array(taskDraft).optional()
-          }).strict()
-        }).strict().parse(input);
-        const record = await store.mutate(params.cwd ?? process.cwd(), params.plan, "update phase", (plan) => {
-          assertAuthoringRevision(plan, params.expectedPlanRevision);
-          assertAuthorable(plan, params.phaseId);
-          const existing = getPhase(plan, params.phaseId);
-          if (existing.status === "completed")
-            throw new Error(`Completed phase ${existing.id} cannot be changed.`);
-          const tasks = params.patch.tasks ? reconcileTasks(existing.tasks, params.patch.tasks) : existing.tasks;
-          const updated = {
-            ...existing,
-            title: params.patch.title ?? existing.title,
-            objective: params.patch.objective ?? existing.objective,
-            dependencies: params.patch.dependencies ?? existing.dependencies,
-            tasks,
-            revision: existing.revision + 1,
-            status: existing.status === "blocked" ? "in_progress" : existing.status,
-            blocker: existing.status === "blocked" ? undefined : existing.blocker
-          };
-          assertNewIds({ ...plan, phases: plan.phases.filter((phase) => phase.id !== existing.id) }, updated);
-          return resetDraft({
-            ...plan,
-            phases: plan.phases.map((phase) => phase.id === existing.id ? updated : phase)
-          });
-        });
-        return result(`Updated phase ${params.phaseId}.`, { record });
-      }
-    }),
-    defineTool3({
-      name: "plan_validate",
-      label: "plan validate",
-      description: "Validate plan markers, dependencies, completeness, annotations, and Design length.",
-      parameters: parameters5(z5.object({ cwd, plan: text, strict: z5.boolean().optional() }).strict()),
-      executionMode: "parallel",
-      async execute(_id, input) {
-        const params = z5.object({ cwd, plan: text, strict: z5.boolean().optional() }).strict().parse(input);
-        const record = await store.read(params.cwd ?? process.cwd(), params.plan);
-        const annotations = params.strict ? await readPlanAnnotations(record) : { pending: [] };
-        const issues = validatePlanDocument(record.document, {
-          strict: params.strict,
-          pendingAnnotations: annotations.pending.length
-        });
-        const words = countDesignWords(record.document);
-        return result(issues.length ? issues.map((issue) => `- ${issue.severity}: ${issue.message}`).join(`
-`) : "Plan is valid.", { record, issues, designWordCount: words, ready: !issues.some((issue) => issue.severity === "error") });
-      }
-    }),
-    defineTool3({
-      name: "plan_log_progress",
-      label: "plan log progress",
-      description: "Append a progress event without changing plan revision.",
-      parameters: parameters5(z5.object({
-        cwd,
-        plan: text,
-        actor: text,
-        message: text,
-        executionId: id2.optional(),
-        phaseId: id2.optional(),
-        taskId: id2.optional(),
-        evidence: z5.array(text).optional(),
-        data: z5.record(z5.string(), z5.unknown()).optional()
-      }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = z5.object({
-          cwd,
-          plan: text,
-          actor: text,
-          message: text,
-          executionId: id2.optional(),
-          phaseId: id2.optional(),
-          taskId: id2.optional(),
-          evidence: z5.array(text).optional(),
-          data: z5.record(z5.string(), z5.unknown()).optional()
-        }).strict().parse(input);
-        const record = await store.read(params.cwd ?? process.cwd(), params.plan);
-        const entry = await store.log(params.cwd ?? process.cwd(), params.plan, {
-          planRevision: record.document.revision,
-          kind: "progress",
-          actor: params.actor,
-          message: params.message,
-          executionId: params.executionId,
-          phaseId: params.phaseId,
-          taskId: params.taskId,
-          evidence: params.evidence,
-          data: params.data
-        });
-        return result(`Logged ${entry.eventId}.`, { entry });
-      }
-    }),
-    createStatusTool(pi, modes, store),
-    defineTool3({
-      name: "plan_run_gates",
-      label: "plan run gates",
-      description: "Run format check, lint, and tests without holding the plan lock, then persist non-stale results.",
-      parameters: parameters5(z5.object({ cwd, plan: text, phaseId: id2, expectedPhaseRevision: revision, executionId: id2, actor: text }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = z5.object({ cwd, plan: text, phaseId: id2, expectedPhaseRevision: revision, executionId: id2, actor: text }).strict().parse(input);
-        const workingDirectory = params.cwd ?? process.cwd();
-        const before = await store.read(workingDirectory, params.plan);
-        const phase = getPhase(before.document, params.phaseId);
-        if (phase.revision !== params.expectedPhaseRevision)
-          throw new Error(`Stale phase revision for ${phase.id}.`);
-        if (!before.document.execution?.active || before.document.execution.id !== params.executionId)
-          throw new Error(`Execution ${params.executionId} does not own this plan.`);
-        if (phase.tasks.some((task) => task.status !== "completed" && task.status !== "skipped"))
-          throw new Error(`Phase ${phase.id} still has incomplete tasks.`);
-        const results = await runMiseGates(workingDirectory);
-        const passed = results.every((gate) => gate.status === "pass" || gate.status === "skip");
-        const record = await store.mutate(workingDirectory, params.plan, "persist gates", (plan) => {
-          const current = getPhase(plan, params.phaseId);
-          if (current.revision !== params.expectedPhaseRevision)
-            throw new Error(`Gate results for ${current.id} are stale.`);
-          if (current.tasks.some((task) => task.status !== "completed" && task.status !== "skipped"))
-            throw new Error(`Gate results for ${current.id} are stale because task state changed.`);
-          const updated = {
-            ...current,
-            revision: current.revision + 1,
-            gate: {
-              phaseRevision: params.expectedPhaseRevision,
-              status: passed ? "passed" : "failed",
-              results,
-              completedAt: new Date().toISOString()
-            }
-          };
-          return {
-            ...heartbeat(plan),
-            phases: plan.phases.map((item) => item.id === updated.id ? updated : item)
-          };
-        });
-        await store.log(workingDirectory, record.id, {
-          planRevision: record.document.revision,
-          kind: "gate",
-          actor: params.actor,
-          message: `Phase ${phase.id} gates ${passed ? "passed" : "failed"}.`,
-          executionId: params.executionId,
-          phaseId: phase.id,
-          data: { results }
-        });
-        return result(results.map((gate) => `${gate.name}: ${gate.status} — ${gate.detail}`).join(`
-`), {
-          results,
-          passed,
-          record
-        });
-      }
-    }),
-    defineTool3({
-      name: "plan_annotate",
-      label: "plan annotate",
-      description: "Launch the selected PLAN.md in tuicr standalone file annotation mode.",
-      parameters: parameters5(z5.object({ cwd, plan: z5.string().optional() }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = z5.object({ cwd, plan: z5.string().optional() }).strict().parse(input);
-        const workingDirectory = params.cwd ?? process.cwd();
-        const resolution = await store.context(workingDirectory, params.plan);
-        if (!resolution.record)
-          throw new Error(resolution.ambiguous ? `Plan is ambiguous: ${resolution.candidates.map((item) => item.id).join(", ")}.` : "No matching plan.");
-        const cliPath = join19(resolveBundledAgentsDir(), "..", "dist", "cli.js");
-        const command = [
-          process.execPath,
-          cliPath,
-          "plan",
-          "annotate",
-          resolution.record.id,
-          "--cwd",
-          workingDirectory
-        ];
-        const launched = await openInNewTab(command, { cwd: workingDirectory, name: "plan-annotate" });
-        const fallbackCommand = `npx --yes @difflab/pi plan annotate ${resolution.record.id} --cwd ${JSON.stringify(workingDirectory)}`;
-        return result(launched.launched ? `Opened ${resolution.record.id} for annotation.` : launched.instruction ?? `Run: ${fallbackCommand}`, { record: resolution.record, launched, fallbackCommand, followUp: `/plan update ${resolution.record.id}` });
-      }
-    }),
-    defineTool3({
-      name: "plan_annotations",
-      label: "plan annotations",
-      description: "Read normalized pending comments from the selected plan annotation session.",
-      parameters: parameters5(z5.object({ cwd, plan: z5.string().optional(), includeApplied: z5.boolean().optional() }).strict()),
-      executionMode: "parallel",
-      async execute(_id, input) {
-        const params = z5.object({ cwd, plan: z5.string().optional(), includeApplied: z5.boolean().optional() }).strict().parse(input);
-        const workingDirectory = params.cwd ?? process.cwd();
-        const resolution = await store.context(workingDirectory, params.plan);
-        if (!resolution.record)
-          throw new Error(resolution.ambiguous ? `Plan is ambiguous: ${resolution.candidates.map((item) => item.id).join(", ")}.` : "No matching plan.");
-        const annotations = await readPlanAnnotations(resolution.record, { includeApplied: params.includeApplied });
-        return result(annotations.comments.length ? annotations.comments.map((comment) => `${comment.id}: ${comment.body}`).join(`
-`) : "No pending annotations.", { record: resolution.record, ...annotations });
-      }
-    }),
-    defineTool3({
-      name: "plan_ack_annotations",
-      label: "plan acknowledge annotations",
-      description: "Acknowledge only annotation comments successfully applied to the plan.",
-      parameters: parameters5(z5.object({ cwd, plan: text, commentIds: z5.array(text).min(1), summary: text }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = z5.object({ cwd, plan: text, commentIds: z5.array(text).min(1), summary: text }).strict().parse(input);
-        const record = await store.read(params.cwd ?? process.cwd(), params.plan);
-        const state = await acknowledgePlanAnnotations(record, params.commentIds, params.summary);
-        return result(`Acknowledged ${params.commentIds.length} annotations for ${record.id}.`, {
-          record,
-          state,
-          acknowledged: params.commentIds
-        });
-      }
-    }),
-    defineTool3({
-      name: "plan_start_execution",
-      label: "plan start execution",
-      description: "Start one inline or background plan execution.",
-      parameters: parameters5(z5.object({
-        cwd,
-        plan: text,
-        mode: z5.enum(["inline", "background"]),
-        policy: z5.enum(["commit-per-phase", "no-commit"]),
-        actor: text
-      }).strict()),
-      executionMode: "sequential",
-      async execute(_id, input, _signal, _onUpdate, ctx) {
-        const params = z5.object({
-          cwd,
-          plan: text,
-          mode: z5.enum(["inline", "background"]),
-          policy: z5.enum(["commit-per-phase", "no-commit"]),
-          actor: text
-        }).strict().parse(input);
-        return startExecution(pi, modes, store, params, ctx);
-      }
-    })
-  ];
-}
-function createStatusTool(pi, modes, store) {
-  const schema = z5.object({
-    cwd,
-    plan: text,
-    target: z5.object({ type: z5.enum(["plan", "phase", "task"]), id: id2.optional() }).strict().refine((value) => value.type === "plan" || value.id, "Phase and task targets require an ID."),
-    expectedStatus: z5.enum(["draft", "ready", "in_progress", "blocked", "completed", "pending", "skipped"]),
-    status: z5.enum(["draft", "ready", "in_progress", "blocked", "completed", "pending", "skipped"]),
-    actor: text,
-    message: text,
-    executionId: id2.optional(),
-    evidence: z5.array(text).optional(),
-    blockedReason: text.optional(),
-    attempts: z5.array(text).optional(),
-    needsUserDecision: z5.boolean().optional(),
-    commit: z5.object({ sha: z5.string().regex(/^[a-f0-9]{7,64}$/i), subject: text, completedAt: z5.string().datetime() }).strict().optional()
-  }).strict();
-  return defineTool3({
-    name: "plan_update_status",
-    label: "plan update status",
-    description: "Apply an ownership-checked plan, phase, or task status transition and append an audit event.",
-    parameters: parameters5(schema),
-    executionMode: "sequential",
-    async execute(_id, input, _signal, _onUpdate, ctx) {
-      const params = schema.parse(input);
-      const workingDirectory = params.cwd ?? process.cwd();
-      let escalation;
-      if (params.commit) {
-        if (params.target.type !== "phase" || params.status !== "completed")
-          throw new Error("Commit metadata is accepted only when completing a phase.");
-        const verified = await verifyCommit(workingDirectory, params.commit.sha);
-        if (verified.sha !== params.commit.sha && !verified.sha.startsWith(params.commit.sha))
-          throw new Error(`Commit ${params.commit.sha} is not the current HEAD ${verified.sha}.`);
-        if (verified.subject !== params.commit.subject)
-          throw new Error(`Commit subject does not match HEAD: ${verified.subject}.`);
-      }
-      const record = await store.mutate(workingDirectory, params.plan, "update status", (plan) => {
-        if (params.target.type === "plan") {
-          if (plan.status !== params.expectedStatus)
-            throw new Error(`Expected plan status ${params.expectedStatus}, found ${plan.status}.`);
-          assertPlanTransition(plan.status, params.status);
-          if (params.status === "ready") {
-            const errors = validatePlanDocument(plan, { strict: true }).filter((issue) => issue.severity === "error");
-            if (errors.length)
-              throw new Error(`Plan cannot become ready: ${errors.map((issue) => issue.message).join(" ")}`);
-          }
-          if ((params.status === "blocked" || params.status === "completed") && plan.status === "in_progress") {
-            assertExecutionOwner(plan, params.executionId);
-          }
-          if (params.status === "completed" && plan.phases.some((phase) => phase.status !== "completed" && phase.status !== "skipped"))
-            throw new Error("Every phase must be complete or skipped before the plan completes.");
-          return {
-            ...heartbeat(plan),
-            status: params.status,
-            execution: params.status === "completed" || params.status === "blocked" ? plan.execution && { ...plan.execution, active: false, heartbeatAt: new Date().toISOString() } : plan.execution
-          };
-        }
-        if (!params.target.id)
-          throw new Error("Target ID is required.");
-        const phase = params.target.type === "phase" ? getPhase(plan, params.target.id) : findTaskPhase(plan, params.target.id);
-        if (params.target.type === "phase") {
-          if (phase.status !== params.expectedStatus)
-            throw new Error(`Expected phase status ${params.expectedStatus}, found ${phase.status}.`);
-          assertExecutionOwner(plan, params.executionId);
-          assertPhaseTransition(phase.status, params.status);
-          if (params.status === "completed") {
-            if (phase.tasks.some((task) => task.status !== "completed" && task.status !== "skipped"))
-              throw new Error("All phase tasks must be complete or skipped.");
-            if (phase.gate.status !== "passed")
-              throw new Error("Phase gates must pass before completion.");
-            if (plan.execution?.policy === "commit-per-phase" && !params.commit)
-              throw new Error("Commit-per-phase execution requires commit metadata before phase completion.");
-            if (plan.execution?.policy === "no-commit" && params.commit)
-              throw new Error("No-commit execution cannot record a phase commit.");
-          }
-          const updated = {
-            ...phase,
-            status: params.status,
-            revision: phase.revision + 1,
-            commit: params.commit ?? phase.commit,
-            blocker: params.blockedReason ? blocker(params) : phase.blocker
-          };
-          if (params.status === "blocked" && params.blockedReason)
-            escalation = escalationFor(plan, updated.id, undefined, params);
-          return {
-            ...heartbeat(plan),
-            phases: plan.phases.map((item) => item.id === updated.id ? updated : item)
-          };
-        }
-        const task = getTask(phase, params.target.id);
-        if (task.status !== params.expectedStatus)
-          throw new Error(`Expected task status ${params.expectedStatus}, found ${task.status}.`);
-        assertExecutionOwner(plan, params.executionId);
-        assertTaskTransition(task, params.status, params.executionId, params.actor);
-        const updatedTask = {
-          ...task,
-          status: params.status,
-          revision: task.revision + 1,
-          owner: params.status === "in_progress" ? params.actor : task.owner,
-          executionId: params.status === "in_progress" ? params.executionId : task.executionId,
-          blocker: params.blockedReason ? blocker(params) : task.blocker
-        };
-        if (params.status === "blocked" && params.blockedReason)
-          escalation = escalationFor(plan, phase.id, task.id, params);
-        const updatedPhase = {
-          ...phase,
-          revision: phase.revision + 1,
-          tasks: phase.tasks.map((item) => item.id === updatedTask.id ? updatedTask : item)
-        };
-        return {
-          ...heartbeat(plan),
-          phases: plan.phases.map((item) => item.id === updatedPhase.id ? updatedPhase : item)
-        };
-      });
-      await store.log(workingDirectory, record.id, {
-        planRevision: record.document.revision,
-        kind: params.status === "blocked" ? "blocker" : "status",
-        actor: params.actor,
-        message: params.message,
-        executionId: params.executionId,
-        phaseId: params.target.type === "phase" ? params.target.id : escalation?.phaseId,
-        taskId: params.target.type === "task" ? params.target.id : undefined,
-        evidence: params.evidence
-      });
-      if (escalation && record.document.execution?.mode !== "background") {
-        const selected = await modes.set("planner", ctx);
-        if (selected.ok)
-          pi.sendUserMessage(renderPlannerEscalation(escalation), {
-            deliverAs: "followUp"
-          });
-      }
-      return result(`Updated ${params.target.type} to ${params.status}.`, { record, escalation });
-    }
-  });
-}
-async function startExecution(pi, modes, store, params, ctx) {
-  const workingDirectory = params.cwd ?? process.cwd();
-  const before = await store.read(workingDirectory, params.plan);
-  if (before.document.status !== "ready" && before.document.status !== "blocked")
-    throw new Error(`Plan ${before.id} must be ready or blocked before execution.`);
-  if (before.document.execution?.active)
-    throw new Error(`Plan ${before.id} already has an active execution.`);
-  const branch = await currentBranch2(workingDirectory);
-  if (branch !== before.document.branch)
-    throw new Error(`Plan branch is ${before.document.branch}; current branch is ${branch}.`);
-  if (params.policy === "commit-per-phase") {
-    const dirty = await runChecked("git", ["-C", workingDirectory, "status", "--porcelain"]);
-    if (dirty.stdout.trim())
-      throw new Error(`Commit-per-phase requires a clean worktree:
-${dirty.stdout.trim()}`);
-  }
-  const head = (await runChecked("git", ["-C", workingDirectory, "rev-parse", "HEAD"])).stdout.trim();
-  const executionId = crypto.randomUUID();
-  const timestamp = new Date().toISOString();
-  const record = await store.mutate(workingDirectory, before.id, "start execution", (plan) => ({
-    ...plan,
-    status: "in_progress",
-    execution: {
-      id: executionId,
-      mode: params.mode,
-      policy: params.policy,
-      cwd: workingDirectory,
-      branch: plan.branch,
-      baseHead: head,
-      actor: params.actor,
-      startedAt: timestamp,
-      heartbeatAt: timestamp,
-      active: true
-    }
-  }));
-  await store.log(workingDirectory, record.id, {
-    planRevision: record.document.revision,
-    kind: "execution",
-    actor: params.actor,
-    message: `Started ${params.mode} execution ${executionId}.`,
-    executionId
-  });
-  const coordinator = params.mode === "inline" ? "worker" : "orchestrator";
-  const prompt = renderExecutionPrompt(createExecutionPacket(record.document, coordinator));
-  if (params.mode === "inline") {
-    const selected = await modes.set("worker", ctx);
-    if (!selected.ok)
-      throw new Error(selected.message);
-    if (!pi.sendMessage)
-      throw new Error("Inline execution dispatch is unavailable.");
-    pi.sendMessage({ customType: "diffpi-plan-execution", display: false, content: prompt }, { triggerTurn: true, deliverAs: "followUp" });
-  } else {
-    await launchBackgroundPi(pi, {
-      name: `Plan go ${record.id}`,
-      agentPath: join19(resolveBundledAgentsDir(), "diffpi-orchestrator.md"),
-      model: "openai-codex/gpt-5.6-luna",
-      thinking: "medium",
-      cwd: workingDirectory,
-      prompt
-    });
-  }
-  return result(`Started ${params.mode} execution ${executionId}.`, {
-    record,
-    executionId,
-    dispatched: true,
-    queued: true,
-    foregroundModeChanged: params.mode === "inline"
-  });
-}
-function newPhase(input) {
-  return {
-    id: input.id,
-    revision: 0,
-    title: input.title,
-    objective: input.objective,
-    dependencies: input.dependencies ?? [],
-    tasks: (input.tasks ?? []).map(newTask),
-    status: "pending",
-    gate: { phaseRevision: 0, status: "pending", results: [] }
-  };
-}
-function newTask(input) {
-  return {
-    id: input.id,
-    revision: 0,
-    title: input.title,
-    steps: input.steps,
-    dependencies: input.dependencies ?? [],
-    fileScopes: input.fileScopes ?? [],
-    acceptanceCriteria: input.acceptanceCriteria ?? [],
-    status: "pending"
-  };
-}
-function reconcileTasks(existing, drafts) {
-  const byId = new Map(existing.map((task) => [task.id, task]));
-  const requested = new Set(drafts.map((task) => task.id));
-  const removedCompleted = existing.find((task) => task.status === "completed" && !requested.has(task.id));
-  if (removedCompleted)
-    throw new Error(`Completed task ${removedCompleted.id} cannot be removed.`);
-  return drafts.map((draft) => {
-    const current = byId.get(draft.id);
-    if (current?.status === "completed")
-      return current;
-    return current ? {
-      ...newTask(draft),
-      revision: current.revision + 1,
-      status: current.status === "blocked" ? "pending" : current.status,
-      owner: current.status === "blocked" ? undefined : current.owner,
-      executionId: current.status === "blocked" ? undefined : current.executionId,
-      blocker: current.status === "blocked" ? undefined : current.blocker
-    } : newTask(draft);
-  });
+  await mkdir(dirname3(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
 }
-function assertAuthoringRevision(plan, expected) {
-  if (plan.revision !== expected)
-    throw new Error(`Stale plan revision: expected ${expected}, found ${plan.revision}.`);
+
+// 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 assertAuthorable(plan, blockedPhaseId) {
-  if (plan.status === "completed")
-    throw new Error("Completed plans cannot be structurally changed.");
-  if (!plan.execution?.active)
-    return;
-  if (!blockedPhaseId)
-    throw new Error("An active execution owns this plan.");
-  const phase = getPhase(plan, blockedPhaseId);
-  if (phase.status !== "blocked" && !phase.tasks.some((task) => task.status === "blocked"))
-    throw new Error("Planner may amend only blocked work during an active execution.");
-}
-function resetDraft(plan) {
-  return plan.status === "ready" || plan.status === "blocked" ? { ...plan, status: "draft" } : plan;
-}
-function allIds(plan) {
-  return new Set([plan.id, ...plan.phases.flatMap((phase) => [phase.id, ...phase.tasks.map((task) => task.id)])]);
-}
-function assertNewIds(plan, phase) {
-  const known = allIds(plan);
-  for (const candidate of [phase.id, ...phase.tasks.map((task) => task.id)]) {
-    assertStableId(candidate);
-    if (known.has(candidate))
-      throw new Error(`Duplicate stable ID: ${candidate}.`);
-    known.add(candidate);
-  }
-}
-function getPhase(plan, phaseId) {
-  const phase = plan.phases.find((item) => item.id === phaseId);
-  if (!phase)
-    throw new Error(`Unknown phase: ${phaseId}.`);
-  return phase;
-}
-function findTaskPhase(plan, taskId) {
-  const phase = plan.phases.find((item) => item.tasks.some((task) => task.id === taskId));
-  if (!phase)
-    throw new Error(`Unknown task: ${taskId}.`);
-  return phase;
-}
-function getTask(phase, taskId) {
-  const task = phase.tasks.find((item) => item.id === taskId);
-  if (!task)
-    throw new Error(`Unknown task: ${taskId}.`);
-  return task;
-}
-function assertExecutionOwner(plan, executionId) {
-  if (!plan.execution?.active || !executionId || plan.execution.id !== executionId)
-    throw new Error(`Execution ${executionId ?? "(missing)"} does not own this plan.`);
-}
-function blocker(params) {
-  return {
-    reason: params.blockedReason,
-    attempts: params.attempts,
-    evidence: params.evidence,
-    needsUserDecision: params.needsUserDecision
-  };
+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 escalationFor(plan, phaseId, taskId, params) {
-  return {
-    planId: plan.id,
-    executionId: params.executionId,
-    phaseId,
-    taskId,
-    blocker: params.blockedReason,
-    attempts: params.attempts ?? [],
-    evidence: params.evidence ?? [],
-    needsUserDecision: params.needsUserDecision ?? false
-  };
+function detectShell(env = process.env) {
+  return env.SHELL ? basename2(env.SHELL) : "unknown";
 }
-function heartbeat(plan) {
-  return plan.execution?.active ? { ...plan, execution: { ...plan.execution, heartbeatAt: new Date().toISOString() } } : plan;
+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 };
 }
-async function verifyCommit(cwd, requestedSha) {
-  await runChecked("git", ["-C", cwd, "cat-file", "-e", `${requestedSha}^{commit}`]);
-  const [sha, subject] = await Promise.all([
-    runChecked("git", ["-C", cwd, "rev-parse", "HEAD"]),
-    runChecked("git", ["-C", cwd, "log", "-1", "--format=%s"])
-  ]);
-  return { sha: sha.stdout.trim(), subject: subject.stdout.trim() };
+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 currentBranch2(cwd) {
-  const result = await run("git", ["-C", cwd, "branch", "--show-current"]);
-  if (result.code !== 0 || !result.stdout.trim())
-    throw new Error(`Cannot determine current branch in ${cwd}.`);
-  return result.stdout.trim();
+async function openInNewTab(command, opts) {
+  const env = opts.env ?? process.env;
+  const name = opts.name ?? "review";
+  const printable = command.join(" ");
+  const mux = detectMux(env);
+  if (mux !== "none") {
+    const opened = await openMuxTab(mux, command, opts.cwd, name, printable);
+    if (opened)
+      return opened;
+  }
+  if (detectIde(env) === "zed") {
+    try {
+      const taskName = zedReviewTaskName(command);
+      await ensureZedReviewTask(opts.homeDir, command);
+      return {
+        launched: false,
+        configured: true,
+        via: "zed-task",
+        command: printable,
+        taskName,
+        instruction: `Run the Zed task "${taskName}".`
+      };
+    } catch {}
+  }
+  return { launched: false, via: "print", command: printable };
 }
-function parameters5(schema) {
-  return z5.toJSONSchema(schema, { io: "input" });
+function screenWindowArgs(command, cwd, name) {
+  return ["-X", "screen", "-t", name, "sh", "-lc", 'cd -- "$1" && shift && exec "$@"', "sh", cwd, ...command];
 }
-function result(text, details = {}) {
-  return { content: [{ type: "text", text }], details };
+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/tools/review.ts
-import { existsSync as existsSync3 } from "node:fs";
-import { mkdir as mkdir7, readdir as readdir4, readFile as readFile14, rename as rename4, stat as stat2, unlink as unlink2, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join21 } from "node:path";
-import { defineTool as defineTool4 } from "@earendil-works/pi-coding-agent";
-import { z as z9 } from "zod";
-
 // src/extensions/ghx.ts
 function gh(args, options) {
   return run("gh", args, options);
@@ -16822,26 +14502,266 @@ function GitLabVcsBackend(vcs) {
   };
 }
 
-// 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.");
+// src/vcs/forge-backend.ts
+function createForgeBackend(vcs) {
+  if (vcs.provider === "github")
+    return GitHubVcsBackend(vcs);
+  if (vcs.provider === "gitlab")
+    return GitLabVcsBackend(vcs);
+  throw new Error("No supported forge detected from the git remote. Use --local for an offline review.");
+}
+var createVcsBackend = createForgeBackend;
+// src/extensions/misex.ts
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename3, dirname as dirname4, join as join9 } from "node:path";
+var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
+var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
+var mise = {
+  async executableCheck(name = "mise") {
+    return findExecutable(name);
+  },
+  async run(args, options = {}) {
+    return run("mise", args, options);
+  },
+  async install(options = {}) {
+    const homeDir = options.homeDir ?? homedir5();
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32")
+      throw new Error("Automatic mise installation supports macOS and Linux only.");
+    const installedPath = join9(homeDir, ".local", "bin", "mise");
+    if (options.dryRun)
+      return installedPath;
+    await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
+    const executable = await findExecutable(installedPath) ?? await findExecutable("mise");
+    if (!executable)
+      throw new Error(`mise installation completed, but ${installedPath} was not found.`);
+    return executable;
+  },
+  async hookEnsure(executable, options = {}) {
+    const homeDir = options.homeDir ?? homedir5();
+    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)
+      return { path: hook.path, changed: true, planned: true };
+    const separator = current.length === 0 || current.endsWith(`
+`) ? "" : `
+`;
+    await mkdir2(dirname4(hook.path), { recursive: true });
+    await writeFile2(hook.path, `${current}${separator}${hook.content}`, "utf8");
+    return { path: hook.path, changed: true, planned: false };
+  },
+  async toolCheckGlobal(executable, tool, minimumVersion) {
+    const result = await run(executable, ["ls", "--global", "--installed", tool, "--json"]);
+    return result.code === 0 && isToolInstalled(result.stdout, minimumVersion);
+  },
+  async toolInstallGlobal(executable, specification) {
+    await runChecked(executable, ["use", "--global", specification]);
+  },
+  async toolCheckLocal(executable, tool, cwd = process.cwd()) {
+    const result = await run(executable, ["ls", "--local", "--installed", tool, "--json"], { cwd });
+    return result.code === 0 && isToolInstalled(result.stdout);
+  },
+  async toolInstallLocal(executable, specification, cwd = process.cwd()) {
+    await runChecked(executable, ["use", "--path", cwd, specification], { cwd });
+  },
+  async toolUpdateAllGlobal(executable, homeDir = homedir5()) {
+    await runChecked(executable, ["upgrade"], { cwd: homeDir });
+  }
+};
+function getShellHook(shell, executable, homeDir) {
+  const command = getShellQuoted(executable);
+  switch (shell.toLowerCase()) {
+    case "zsh":
+      return {
+        path: join9(homeDir, ".zshrc"),
+        content: `${MISE_HOOK_START}
+eval "$(${command} activate zsh)"
+${MISE_HOOK_END}
+`
+      };
+    case "fish":
+      return {
+        path: join9(homeDir, ".config", "fish", "config.fish"),
+        content: `${MISE_HOOK_START}
+${command} activate fish | source
+${MISE_HOOK_END}
+`
+      };
+    case "nu":
+    case "nushell":
+      return {
+        path: join9(homeDir, ".config", "nushell", "config.nu"),
+        content: `${MISE_HOOK_START}
+let mise_bin = ${command}
+let mise_path = $nu.default-config-dir | path join mise.nu
+^$mise_bin activate nu | save $mise_path --force
+use ($nu.default-config-dir | path join mise.nu)
+${MISE_HOOK_END}
+`
+      };
+    case "xonsh":
+      return {
+        path: join9(homeDir, ".xonshrc"),
+        content: `${MISE_HOOK_START}
+execx($(${command} activate xonsh))
+${MISE_HOOK_END}
+`
+      };
+    case "elvish":
+      return {
+        path: join9(homeDir, ".config", "elvish", "rc.elv"),
+        content: `${MISE_HOOK_START}
+var mise: = (ns [&])
+eval (${command} activate elvish | slurp) &ns=$mise: &on-end={|ns| set mise: = $ns }
+mise:activate
+${MISE_HOOK_END}
+`
+      };
+    case "pwsh":
+    case "powershell":
+      return {
+        path: join9(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        content: `${MISE_HOOK_START}
+(& ${command} activate pwsh) | Out-String | Invoke-Expression
+${MISE_HOOK_END}
+`
+      };
+    case "bash":
+    default:
+      return {
+        path: join9(homeDir, ".bashrc"),
+        content: `${MISE_HOOK_START}
+eval "$(${command} activate bash)"
+${MISE_HOOK_END}
+`
+      };
+  }
+}
+function isToolInstalled(output, minimumVersion) {
+  try {
+    const value = JSON.parse(output);
+    if (!Array.isArray(value))
+      return false;
+    return value.some((entry) => {
+      if (!entry || typeof entry !== "object" || !("installed" in entry) || entry.installed !== true)
+        return false;
+      if (!minimumVersion)
+        return true;
+      if (!("version" in entry) || typeof entry.version !== "string")
+        return false;
+      return isVersionAtLeast(entry.version, minimumVersion);
+    });
+  } catch {
+    return false;
+  }
+}
+function isVersionAtLeast(version, minimumVersion) {
+  const current = version.match(/^v?(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
+  const minimum = minimumVersion.match(/^v?(\d+)\.(\d+)\.(\d+)/)?.slice(1).map(Number);
+  if (!current || !minimum)
+    return false;
+  for (let index = 0;index < minimum.length; index += 1) {
+    if (current[index] !== minimum[index])
+      return current[index] > minimum[index];
+  }
+  return true;
+}
+async function getOptionalFile(path) {
+  try {
+    return await readFile4(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT")
+      return "";
+    throw error;
+  }
+}
+function getShellQuoted(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// src/gates.ts
+var CONVENTIONAL_COMMIT = /^(feat|fix|perf|refactor|docs|chore|test|build|ci|style|revert)(\([^)]+\))?!?: .+/;
+var MISE_GATES = ["format:check", "lint", "test"];
+function checkConventionalSubject(subject) {
+  const trimmed = subject.trim();
+  const ok = CONVENTIONAL_COMMIT.test(trimmed);
+  return {
+    name: "conventional-subject",
+    status: ok ? "pass" : "warn",
+    detail: ok ? trimmed : `not a conventional-commit subject: "${trimmed}"`
+  };
 }
-var createVcsBackend = createForgeBackend;
+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 z6 } from "zod";
-var severitySchema = z6.enum(["BLOCKING", "CONSIDER", "NOTE"]);
-var findingSchema = z6.object({
-  file: z6.string().min(1),
-  line: z6.number().int().nonnegative(),
+import { z as z4 } from "zod";
+var severitySchema = z4.enum(["BLOCKING", "CONSIDER", "NOTE"]);
+var findingSchema = z4.object({
+  file: z4.string().min(1),
+  line: z4.number().int().nonnegative(),
   severity: severitySchema,
-  body: z6.string().min(1),
-  reference: z6.string().optional().default("")
+  body: z4.string().min(1),
+  reference: z4.string().optional().default("")
 });
-var findingsSchema = z6.array(findingSchema);
+var findingsSchema = z4.array(findingSchema);
 function reviewSlug(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
 }
@@ -16905,17 +14825,17 @@ function renderCommentBody(finding) {
   return `${prefix}${finding.body}${reference}`;
 }
 // src/review/review-markdown.ts
-import { z as z7 } from "zod";
-var reviewThreadRecordSchema = z7.object({
-  id: z7.string().min(1),
-  file: z7.string().optional(),
-  line: z7.number().int().positive().optional(),
-  body: z7.string(),
-  author: z7.string().optional(),
-  resolved: z7.boolean(),
-  addressed: z7.boolean().optional(),
-  question: z7.boolean(),
-  replies: z7.array(z7.string()).optional()
+import { z as z5 } from "zod";
+var reviewThreadRecordSchema = z5.object({
+  id: z5.string().min(1),
+  file: z5.string().optional(),
+  line: z5.number().int().positive().optional(),
+  body: z5.string(),
+  author: z5.string().optional(),
+  resolved: z5.boolean(),
+  addressed: z5.boolean().optional(),
+  question: z5.boolean(),
+  replies: z5.array(z5.string()).optional()
 });
 function renderReviewDoc(input) {
   const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
@@ -17002,7 +14922,7 @@ function parseThreadArtifact(content) {
   let threads;
   try {
     const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-    threads = z7.array(reviewThreadRecordSchema).parse(decoded);
+    threads = z5.array(reviewThreadRecordSchema).parse(decoded);
   } catch {
     throw new Error("Cannot parse the Diffpi thread artifact payload.");
   }
@@ -17375,11 +15295,52 @@ function hasGitlabDraftNotes(input) {
 }
 
 // src/review/local-review-backend.ts
-import { readFile as readFile12, writeFile as writeFile6 } from "node:fs/promises";
+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 resolve3 } from "node:path";
+
+// src/extensions/gitx.ts
+import { realpath } from "node:fs/promises";
+import { basename as basename4, isAbsolute as isAbsolute2, join as join10, resolve as resolve2 } 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 : resolve2(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 ? resolve2(isAbsolute2(common) ? common : join10(root, common)) : root;
+  const commonDir = await canonicalPath(commonPath);
+  return {
+    root,
+    commonDir,
+    ...remote ? { remote } : {},
+    name: remote ? repositoryName(remote) : basename4(resolve2(commonDir, "..")) || basename4(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 resolve2(path);
+  }
+}
 
 // src/extensions/tuicrx.ts
-import { readFile as readFile11, realpath as realpath4 } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
 async function tuicrAvailable() {
   return Boolean(await findExecutable("tuicr"));
 }
@@ -17454,7 +15415,7 @@ async function resolvePrSession(cwd, owner, repo, number) {
   });
 }
 async function findMatchingSession(sessions, cwd, branch) {
-  const repository = await canonicalPath3(await gitToplevel(cwd));
+  const repository = await canonicalPath2(await gitToplevel(cwd));
   for (const session of sessions) {
     if (session.kind !== "local")
       continue;
@@ -17462,14 +15423,14 @@ async function findMatchingSession(sessions, cwd, branch) {
       const data = await readSession(session.path);
       if (data.branch_name !== branch || !data.repo_path)
         continue;
-      if (await canonicalPath3(data.repo_path) === repository)
+      if (await canonicalPath2(data.repo_path) === repository)
         return session;
     } catch {}
   }
   return;
 }
 async function readSession(path) {
-  const content = await readFile11(path, "utf8");
+  const content = await readFile5(path, "utf8");
   try {
     return JSON.parse(content);
   } catch {
@@ -17549,11 +15510,11 @@ async function requireTuicr() {
 function commentAuthor(comment) {
   return comment.username ?? comment.author;
 }
-async function canonicalPath3(path) {
+async function canonicalPath2(path) {
   try {
-    return await realpath4(path);
+    return await realpath2(path);
   } catch {
-    return resolve5(path);
+    return resolve3(path);
   }
 }
 
@@ -17578,7 +15539,7 @@ function LocalReviewBackend(options) {
     },
     async listThreads() {
       try {
-        return parseThreadArtifact(await readFile12(options.artifactPath, "utf8"));
+        return parseThreadArtifact(await readFile6(options.artifactPath, "utf8"));
       } catch (error) {
         if (error.code === "ENOENT")
           return [];
@@ -17586,8 +15547,8 @@ function LocalReviewBackend(options) {
       }
     },
     async reply(input) {
-      const content = await readFile12(options.artifactPath, "utf8");
-      await writeFile6(options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question, input.resolve), "utf8");
+      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.");
@@ -17608,15 +15569,100 @@ function createLocalReviewBackend(options) {
 }
 // src/review/review-state.ts
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile13, rename as rename3, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join20 } from "node:path";
-import { z as z8 } from "zod";
-var reviewPublicationStateSchema = z8.object({
-  target: z8.string().optional(),
-  bodies: z8.array(z8.string()).default([]),
-  comments: z8.array(z8.string()).default([]),
-  replies: z8.array(z8.string()).default([]),
-  overlayPath: z8.string().optional()
+import { readFile as readFile7, rename, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join12 } from "node:path";
+import { z as z6 } 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 homedir6 } from "node:os";
+import { dirname as dirname5, isAbsolute as isAbsolute3, join as join11, resolve as resolve4 } from "node:path";
+var STORE_LINK = ".diffpi";
+var LEGACY_STORE_LINK = join11(".pi", "diffpi");
+function storeGlobalRoot(homeDir = homedir6()) {
+  return join11(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir6()) {
+  const repository = await inspectGitRepository(cwd);
+  const root = repository.root;
+  const slug = projectSlug(repository);
+  const dest = join11(storeGlobalRoot(homeDir), slug);
+  const link = join11(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(join11(root, LEGACY_STORE_LINK), dest);
+  return { slug, root, dest, link, linked: true };
+}
+async function reviewsDir(cwd, homeDir = homedir6()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join11(store.link, "review");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function completedReviewsDir(cwd, homeDir = homedir6()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join11(store.link, "reviews");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir6()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join11(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(isAbsolute3(target) ? target : resolve4(dirname5(path), target));
+}
+async function canonicalPath3(path) {
+  try {
+    return await realpath3(path);
+  } catch {
+    return resolve4(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 = z6.object({
+  target: z6.string().optional(),
+  bodies: z6.array(z6.string()).default([]),
+  comments: z6.array(z6.string()).default([]),
+  replies: z6.array(z6.string()).default([]),
+  overlayPath: z6.string().optional()
 });
 function reviewBodyFingerprint(body) {
   return digest(body);
@@ -17632,15 +15678,15 @@ function unpublishedReviewComments(comments, knownFingerprints) {
 }
 async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
   const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
-  const path = join20(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  const path = join12(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
   try {
-    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile13(path, "utf8")));
+    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 z8.ZodError) {
+    if (error instanceof SyntaxError || error instanceof z6.ZodError) {
       throw new Error(`Cannot parse review publication state: ${path}`);
     }
     throw error;
@@ -17648,49 +15694,85 @@ async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
 }
 async function saveReviewPublicationState(path, state) {
   const temp = `${path}.${process.pid}.tmp`;
-  await writeFile7(temp, `${JSON.stringify(state, null, 2)}
+  await writeFile4(temp, `${JSON.stringify(state, null, 2)}
 `, "utf8");
-  await rename3(temp, path);
+  await rename(temp, path);
 }
 function digest(value) {
   return createHash2("sha256").update(value).digest("hex");
 }
+// src/templates.ts
+import { readFile as readFile8 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join13, normalize } from "node:path";
+async function loadTemplate(name, options = {}) {
+  const relative = templateRelativePath(name);
+  const userPath = join13(options.homeDir ?? homedir7(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join13(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 readFile8(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+
 // src/tools/review.ts
-var contextSchema = z9.object({
-  cwd: z9.string().optional(),
-  target: z9.string().optional(),
-  workingTree: z9.boolean().optional()
+var contextSchema = z7.object({
+  cwd: z7.string().optional(),
+  target: z7.string().optional(),
+  workingTree: z7.boolean().optional()
 });
-var localSchema = contextSchema.extend({ local: z9.boolean().optional() });
+var localSchema = contextSchema.extend({ local: z7.boolean().optional() });
 var openSchema = localSchema.extend({
-  title: z9.string().optional(),
-  intent: z9.string().optional(),
-  issueUrl: z9.string().url().optional(),
-  base: z9.string().optional()
+  title: z7.string().optional(),
+  intent: z7.string().optional(),
+  issueUrl: z7.string().url().optional(),
+  base: z7.string().optional()
 });
 var submitSchema = localSchema.extend({
   findings: findingsSchema,
-  overallIssues: z9.array(z9.string()).optional(),
-  notVerified: z9.array(z9.string()).optional(),
-  title: z9.string().optional()
+  overallIssues: z7.array(z7.string()).optional(),
+  notVerified: z7.array(z7.string()).optional(),
+  title: z7.string().optional()
 });
 var addCommentSchema = localSchema.extend({
-  body: z9.string().min(1),
-  file: z9.string().min(1),
-  line: z9.number().int().positive(),
-  side: z9.enum(["LEFT", "RIGHT"]).optional()
+  body: z7.string().min(1),
+  file: z7.string().min(1),
+  line: z7.number().int().positive(),
+  side: z7.enum(["LEFT", "RIGHT"]).optional()
 });
 var respondSchema = localSchema.extend({
-  threadId: z9.string().min(1),
-  body: z9.string().min(1),
-  question: z9.boolean().optional(),
-  resolve: z9.boolean().optional()
+  threadId: z7.string().min(1),
+  body: z7.string().min(1),
+  question: z7.boolean().optional(),
+  resolve: z7.boolean().optional()
 });
 var publishSchema = localSchema.extend({
-  status: z9.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
+  status: z7.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
 });
 var completeSchema = localSchema.extend({
-  action: z9.enum(["approve", "reject", "abandon"]).optional()
+  action: z7.enum(["approve", "reject", "abandon"]).optional()
 });
 function hasReviewDraft(comments, body) {
   return comments.length > 0 || body.trim().length > 0;
@@ -17714,13 +15796,13 @@ async function workingTreeDiff(cwd) {
 }
 function createReviewTools() {
   return [
-    defineTool4({
+    defineTool3({
       name: "review_context",
       label: "review context",
       description: "Orient to the target, backend, forge, environment, shared store, PR/MR, and tuicr session.",
       promptSnippet: "Call review_context first",
       promptGuidelines: ["Call this before every review workflow."],
-      parameters: parameters6(localSchema),
+      parameters: parameters5(localSchema),
       executionMode: "parallel",
       async execute(_id, input) {
         const params = localSchema.parse(input);
@@ -17730,7 +15812,7 @@ function createReviewTools() {
         const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
         const baseRef = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "local");
         const backend = params.local || params.workingTree ? "tuicr" : review.forge?.provider ?? "unsupported";
-        return result2([
+        return result([
           `Backend: ${backend}`,
           `Forge: ${review.vcs.provider}${review.vcs.provider === "none" ? "" : ` (${review.vcs.owner}/${review.vcs.repo})`}`,
           `Branch: ${review.vcs.branch} → ${baseRef}`,
@@ -17742,13 +15824,13 @@ function createReviewTools() {
 `), { ...review, env, store, session, baseRef, backend });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_new",
       label: "review new",
       description: "Create a new local tuicr review or a remote draft PR/MR and open it in tuicr.",
       promptSnippet: "Call review_new to start",
       promptGuidelines: ["Use local to select tuicr as the review backend."],
-      parameters: parameters6(openSchema),
+      parameters: parameters5(openSchema),
       executionMode: "sequential",
       async execute(_id, input) {
         const params = openSchema.parse(input);
@@ -17757,9 +15839,9 @@ function createReviewTools() {
         if (params.local || params.workingTree)
           return launchLocalReview(review, true, params.base);
         if (!review.forge)
-          return result2(unsupportedForgeMessage());
+          return result(unsupportedForgeMessage());
         if (review.pr)
-          return result2(`A remote review already exists for this branch: ${review.pr.url}. Use review_edit to open it.`);
+          return result(`A remote review already exists for this branch: ${review.pr.url}. Use review_edit to open it.`);
         await assertRemoteBranchReady(review.cwd);
         const base = params.base ?? await review.forge.defaultBranch();
         const template = await loadTemplate("review/draft-pr");
@@ -17777,7 +15859,7 @@ function createReviewTools() {
         });
         const launched = await launch(review.cwd, pr.number);
         const openMessage = launched.launched ? `Opened PR/MR #${pr.number} in tuicr (${launched.via}).` : launched.instruction ?? `Run: ${launched.command}`;
-        return result2(`Draft PR/MR created from ${template.source} template: ${pr.url}
+        return result(`Draft PR/MR created from ${template.source} template: ${pr.url}
 ${openMessage}`, {
           pr,
           template,
@@ -17785,13 +15867,13 @@ ${openMessage}`, {
         });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_edit",
       label: "review edit",
       description: "Open an existing local tuicr session or remote PR/MR in tuicr without generating findings.",
       promptSnippet: "Call review_edit to continue an existing review",
       promptGuidelines: ["This tool never creates review findings or a PR/MR."],
-      parameters: parameters6(localSchema),
+      parameters: parameters5(localSchema),
       executionMode: "sequential",
       async execute(_id, input) {
         const params = localSchema.parse(input);
@@ -17799,46 +15881,46 @@ ${openMessage}`, {
         await ensureStore(review.cwd);
         if (params.local || params.workingTree) {
           if (!await resolveTuicrSession(review, true))
-            return result2("No local tuicr review exists. Use review_new with local=true to create one.");
+            return result("No local tuicr review exists. Use review_new with local=true to create one.");
           return launchLocalReview(review, true);
         }
         if (!review.forge)
-          return result2(unsupportedForgeMessage());
+          return result(unsupportedForgeMessage());
         if (!review.pr)
-          return result2("No remote PR/MR exists. Use review_new to create a draft review first.");
+          return result("No remote PR/MR exists. Use review_new to create a draft review first.");
         return launchLocalReview(review, false);
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_diff",
       label: "review diff",
       description: "Fetch the target PR/MR diff or auto-detected local working-tree diff.",
       promptSnippet: "Call review_diff for the code under review",
       promptGuidelines: ["Ground findings in this diff."],
-      parameters: parameters6(localSchema),
+      parameters: parameters5(localSchema),
       executionMode: "parallel",
       async execute(_id, input) {
         const params = localSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         if (params.local || params.workingTree) {
           const diff = await workingTreeDiff(review.cwd);
-          return result2(diff || "No working-tree changes.", { diff, target: "local" });
+          return result(diff || "No working-tree changes.", { diff, target: "local" });
         }
         if (!review.forge)
-          return result2(unsupportedForgeMessage());
+          return result(unsupportedForgeMessage());
         if (!review.pr)
-          return result2("No PR/MR matches this remote review target.");
+          return result("No PR/MR matches this remote review target.");
         const diff = await review.forge.prDiff(review.pr.number);
-        return result2(diff || "Empty diff.", { diff, pr: review.pr });
+        return result(diff || "Empty diff.", { diff, pr: review.pr });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_gates",
       label: "review gates",
       description: "Run format, lint, test, conventional-subject, and available CI checks.",
       promptSnippet: "Call review_gates before submitting findings",
       promptGuidelines: ["Report skipped gates as skipped."],
-      parameters: parameters6(localSchema),
+      parameters: parameters5(localSchema),
       executionMode: "parallel",
       async execute(_id, input) {
         const params = localSchema.parse(input);
@@ -17850,19 +15932,19 @@ ${openMessage}`, {
           gates.push(checkConventionalSubject(subject));
         if (!params.local && review.pr && review.forge)
           gates.push(ciGate(await review.forge.prChecks(review.pr.number)));
-        return result2(gates.map((gate) => `- ${gate.name}: ${gate.status} — ${gate.detail}`).join(`
+        return result(gates.map((gate) => `- ${gate.name}: ${gate.status} — ${gate.detail}`).join(`
 `), {
           results: gates
         });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_submit",
       label: "review submit",
       description: "Write the review artifact and stage comments in the selected local or remote backend.",
       promptSnippet: "Call review_submit with the findings JSON",
       promptGuidelines: ["Remote comments remain pending until review_publish."],
-      parameters: parameters6(submitSchema),
+      parameters: parameters5(submitSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = submitSchema.parse(input);
@@ -17870,12 +15952,12 @@ ${openMessage}`, {
         const model = modelRoute(ctx);
         const useLocalBackend = Boolean(params.local || params.workingTree);
         if (!useLocalBackend && !review.forge)
-          return result2(unsupportedForgeMessage());
+          return result(unsupportedForgeMessage());
         const findings = dedupeFindings(params.findings);
         const gates = await runMiseGates(review.cwd);
         const baseRef = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "local");
         const artifact = await newReviewArtifactPath(review.cwd, params.local || params.workingTree || !review.pr ? "uncommitted" : await reviewTargetId(review));
-        await writeFile8(artifact, renderReviewDoc({
+        await writeFile5(artifact, renderReviewDoc({
           title: params.title ?? review.pr?.title ?? review.vcs.branch,
           number: useLocalBackend ? undefined : review.pr?.number,
           url: useLocalBackend ? undefined : review.pr?.url,
@@ -17893,7 +15975,7 @@ ${openMessage}`, {
         if (useLocalBackend) {
           const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
           if (!session) {
-            return result2(`Review written: ${artifact}. Open tuicr, then call review_submit again to seed comments.`, {
+            return result(`Review written: ${artifact}. Open tuicr, then call review_submit again to seed comments.`, {
               artifact,
               count: findings.length
             });
@@ -17904,28 +15986,28 @@ ${openMessage}`, {
             author: localReviewAuthor(model)
           });
           await backend.stage({ comments, body });
-          return result2(`Local review staged in tuicr: ${artifact}`, { artifact, count: findings.length, session });
+          return result(`Local review staged in tuicr: ${artifact}`, { artifact, count: findings.length, session });
         }
         if (!review.pr)
-          return result2(`Review written: ${artifact}. No PR/MR matches this remote target.`, { artifact });
+          return result(`Review written: ${artifact}. No PR/MR matches this remote target.`, { artifact });
         const hasDraft = hasReviewDraft(comments, body);
         if (hasDraft) {
           await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments, body });
         }
-        return result2(`${hasDraft ? "Pending review staged" : "Clean review recorded"} on #${review.pr.number}. Artifact: ${artifact}`, {
+        return result(`${hasDraft ? "Pending review staged" : "Clean review recorded"} on #${review.pr.number}. Artifact: ${artifact}`, {
           artifact,
           pr: review.pr,
           count: findings.length
         });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_add_comment",
       label: "review add comment",
       description: "Add one provenance-marked comment through tuicr or the remote pending-review backend.",
       promptSnippet: "Call review_add_comment for incremental comments",
       promptGuidelines: ["Pass local=true when tuicr owns the draft."],
-      parameters: parameters6(addCommentSchema),
+      parameters: parameters5(addCommentSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = addCommentSchema.parse(input);
@@ -17933,7 +16015,7 @@ ${openMessage}`, {
         const model = modelRoute(ctx);
         const useLocalBackend = Boolean(params.local || params.workingTree);
         if (!useLocalBackend && !review.forge)
-          return result2(unsupportedForgeMessage());
+          return result(unsupportedForgeMessage());
         const comment = {
           file: params.file,
           line: params.line,
@@ -17943,28 +16025,28 @@ ${openMessage}`, {
         if (useLocalBackend) {
           const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
           if (!session)
-            return result2("No matching tuicr session. Open review_new or review_launch_ui first.");
+            return result("No matching tuicr session. Open review_new or review_launch_ui first.");
           const backend = createLocalReviewBackend({
             session: session.path,
             artifactPath: "",
             author: localReviewAuthor(model)
           });
           await backend.stage({ comments: [comment], body: "" });
-          return result2(`Comment added to tuicr session ${session.slug}.`, { session, comment });
+          return result(`Comment added to tuicr session ${session.slug}.`, { session, comment });
         }
         if (!review.pr)
-          return result2("No PR/MR matches this remote review target.");
+          return result("No PR/MR matches this remote review target.");
         await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments: [comment], body: "" });
-        return result2(`Draft comment added to #${review.pr.number}.`, { pr: review.pr, comment });
+        return result(`Draft comment added to #${review.pr.number}.`, { pr: review.pr, comment });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_comments",
       label: "review comments",
       description: "Pull review threads or local tuicr comments and write a target-named artifact.",
       promptSnippet: "Call review_comments before addressing findings",
       promptGuidelines: ["Pass local=true to prepare the local reply overlay."],
-      parameters: parameters6(localSchema),
+      parameters: parameters5(localSchema),
       executionMode: "sequential",
       async execute(_id, input) {
         const params = localSchema.parse(input);
@@ -17974,28 +16056,28 @@ ${openMessage}`, {
         if (params.local || params.workingTree) {
           const session = await resolveTuicrSession(review, true);
           if (!session)
-            return result2("No matching tuicr session found.");
+            return result("No matching tuicr session found.");
           artifact = await localThreadArtifactPath(review.cwd, session.slug);
           threads = await syncLocalThreadArtifact(artifact, review.pr?.title ?? review.vcs.branch, session.slug, toLocalReviewThreads(await readSession(session.path)));
         } else if (review.pr && review.forge) {
           threads = await createRemoteReviewBackend(review.vcs, review.pr.number).listThreads();
           const target = await reviewTargetId(review);
           artifact = await newReviewArtifactPath(review.cwd, target);
-          await writeFile8(artifact, renderThreadArtifact(review.pr.title, target, threads, { number: review.pr.number, url: review.pr.url }), "utf8");
+          await writeFile5(artifact, renderThreadArtifact(review.pr.title, target, threads, { number: review.pr.number, url: review.pr.url }), "utf8");
         } else {
-          return result2(review.forge ? "No PR/MR matches this remote review target." : unsupportedForgeMessage());
+          return result(review.forge ? "No PR/MR matches this remote review target." : unsupportedForgeMessage());
         }
-        return result2(threads.map((thread) => `${thread.id} ${thread.file ?? "review"}:${thread.line ?? "-"} — ${thread.body}`).join(`
+        return result(threads.map((thread) => `${thread.id} ${thread.file ?? "review"}:${thread.line ?? "-"} — ${thread.body}`).join(`
 `) || "No comments.", { artifact, threads });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_respond",
       label: "review respond",
       description: "Post local question replies to tuicr and record their publish overlay, or reply to remote threads.",
       promptSnippet: "Call review_respond after addressing a comment",
       promptGuidelines: ["Question replies remain unresolved."],
-      parameters: parameters6(respondSchema),
+      parameters: parameters5(respondSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = respondSchema.parse(input);
@@ -18004,10 +16086,10 @@ ${openMessage}`, {
         if (params.local) {
           const tuicrSession = await resolveTuicrSession(review, true);
           if (!tuicrSession)
-            return result2("No matching tuicr session. Open review_new or review_launch_ui first.");
+            return result("No matching tuicr session. Open review_new or review_launch_ui first.");
           const artifact = await localThreadArtifactPath(review.cwd, tuicrSession.slug);
           if (!existsSync3(artifact))
-            return result2("No local review artifact. Run review_comments with local=true first.");
+            return result("No local review artifact. Run review_comments with local=true first.");
           const threads = await readThreadArtifact(artifact);
           const known = threads.find((thread) => thread.id === params.threadId);
           const question = known?.question === true || params.question === true || !known && params.question === undefined;
@@ -18029,10 +16111,10 @@ ${params.body}`, {
             resolve: false,
             question
           });
-          return result2(`Local ${question ? "answer" : "response"} posted to tuicr and recorded in ${artifact}${awaitUserDeletion ? "; delete the source comment in tuicr to resolve it" : ""}.`, { artifact, question, awaitUserDeletion, session: tuicrSession });
+          return result(`Local ${question ? "answer" : "response"} posted to tuicr and recorded in ${artifact}${awaitUserDeletion ? "; delete the source comment in tuicr to resolve it" : ""}.`, { artifact, question, awaitUserDeletion, session: tuicrSession });
         }
         if (!review.pr || !review.forge)
-          return result2("No remote PR/MR for this reply.");
+          return result("No remote PR/MR for this reply.");
         const remote = createRemoteReviewBackend(review.vcs, review.pr.number);
         const remoteThreads = await remote.listThreads();
         const known = remoteThreads.find((thread) => thread.id === params.threadId);
@@ -18044,35 +16126,35 @@ ${params.body}`, {
           resolve,
           question
         });
-        return result2(`Replied to ${params.threadId}${resolve ? " and resolved it" : " and left it open"}.`, {
+        return result(`Replied to ${params.threadId}${resolve ? " and resolved it" : " and left it open"}.`, {
           pr: review.pr,
           resolve
         });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_publish",
       label: "review publish",
       description: "Publish pending remote draft PR/MR review comments and status, or promote a local tuicr draft before publishing.",
       promptSnippet: "Call review_publish to make remote review work public",
       promptGuidelines: ["Statuses are COMMENT, APPROVE, REQUEST_CHANGES, or CLOSE."],
-      parameters: parameters6(publishSchema),
+      parameters: parameters5(publishSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = publishSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         if (!review.pr || !review.forge)
-          return result2("No remote PR/MR to publish.");
+          return result("No remote PR/MR to publish.");
         return publishResolvedReview(review, params, modelRoute(ctx));
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_complete",
       label: "review complete",
       description: "Approve, reject, or abandon a remote review, or archive a local review artifact.",
       promptSnippet: "Call review_complete to finish a review without merging it.",
       promptGuidelines: ["A local completion archives the Diffpi artifact and deletes the matching tuicr session."],
-      parameters: parameters6(completeSchema),
+      parameters: parameters5(completeSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = completeSchema.parse(input);
@@ -18080,63 +16162,63 @@ ${params.body}`, {
         if (params.local) {
           const session = await resolveTuicrSession(review, true);
           if (!session)
-            return result2("No matching local tuicr session to close.");
+            return result("No matching local tuicr session to close.");
           const artifact = await localThreadArtifactPath(review.cwd, session.slug);
           if (!existsSync3(artifact))
-            return result2("No local review artifact. Run review_comments with local=true first.");
+            return result("No local review artifact. Run review_comments with local=true first.");
           const archived = await uniqueRecordPath(await completedReviewsDir(review.cwd), reviewSlug(session.slug));
-          await rename4(artifact, archived);
+          await rename2(artifact, archived);
           await unlink2(session.path);
-          return result2(`Archived ${archived} and deleted the tuicr session ${session.slug}.`, {
+          return result(`Archived ${archived} and deleted the tuicr session ${session.slug}.`, {
             artifact: archived,
             session
           });
         }
         if (!review.pr || !review.forge)
-          return result2("No remote PR/MR to complete.");
+          return result("No remote PR/MR to complete.");
         if (!params.action)
-          return result2("Choose a complete action: approve, reject, or abandon.");
+          return result("Choose a complete action: approve, reject, or abandon.");
         const status = { approve: "APPROVE", reject: "REQUEST_CHANGES", abandon: "CLOSE" }[params.action];
         return publishResolvedReview(review, { ...params, status }, modelRoute(ctx));
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_merge",
       label: "review merge",
       description: "Squash-merge an approved GitHub PR after checking its conventional subject.",
       promptSnippet: "Call review_merge only after review_publish APPROVE",
       promptGuidelines: ["This is intentionally GitHub-only until GitLab merge support is added."],
-      parameters: parameters6(contextSchema.extend({ subject: z9.string().optional() })),
+      parameters: parameters5(contextSchema.extend({ subject: z7.string().optional() })),
       executionMode: "sequential",
       async execute(_id, input) {
-        const params = contextSchema.extend({ subject: z9.string().optional() }).parse(input);
+        const params = contextSchema.extend({ subject: z7.string().optional() }).parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         if (review.vcs.provider !== "github" || !review.forge)
-          return result2("review_merge currently supports GitHub only.");
+          return result("review_merge currently supports GitHub only.");
         if (!review.pr)
-          return result2("No open PR/MR for this branch.");
+          return result("No open PR/MR for this branch.");
         const subject = params.subject ?? review.pr.title;
         const guard = checkConventionalSubject(subject);
         if (guard.status !== "pass")
-          return result2(`Merge blocked: ${guard.detail}`, { pr: review.pr, guard });
+          return result(`Merge blocked: ${guard.detail}`, { pr: review.pr, guard });
         await review.forge.mergePr(review.pr.number, subject);
-        return result2(`Merged #${review.pr.number} with subject: ${subject}.`, { pr: review.pr, guard });
+        return result(`Merged #${review.pr.number} with subject: ${subject}.`, { pr: review.pr, guard });
       }
     }),
-    defineTool4({
+    defineTool3({
       name: "review_launch_ui",
       label: "review launch UI",
       description: "Open a tuicr UI in a mux tab, configure Zed, or return the command to run.",
       promptSnippet: "Call review_launch_ui for the interactive tuicr TUI",
       promptGuidelines: ["Show the returned command when launch cannot open a tab."],
-      parameters: parameters6(localSchema),
+      parameters: parameters5(localSchema),
       executionMode: "sequential",
       async execute(_id, input) {
         const params = localSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         const workingTree = Boolean(params.local || params.workingTree);
         if (!workingTree && !review.forge)
-          return result2(unsupportedForgeMessage());
+          return result(unsupportedForgeMessage());
         return launchLocalReview(review, workingTree);
       }
     })
@@ -18145,7 +16227,7 @@ ${params.body}`, {
 async function syncLocalThreadArtifact(path, title, sessionSlug, threads) {
   let previous = [];
   try {
-    previous = parseThreadArtifact(await readFile14(path, "utf8"));
+    previous = parseThreadArtifact(await readFile9(path, "utf8"));
   } catch (error) {
     if (error.code !== "ENOENT")
       throw error;
@@ -18163,16 +16245,16 @@ async function syncLocalThreadArtifact(path, title, sessionSlug, threads) {
   });
   const removed = previous.filter((thread) => !currentIds.has(thread.id)).map((thread) => ({ ...thread, resolved: true }));
   const merged = [...current, ...removed];
-  await writeFile8(path, renderThreadArtifact(title, sessionSlug, merged), "utf8");
+  await writeFile5(path, renderThreadArtifact(title, sessionSlug, merged), "utf8");
   return merged;
 }
-function parameters6(schema) {
-  return z9.toJSONSchema(schema, { io: "input" });
+function parameters5(schema) {
+  return z7.toJSONSchema(schema, { io: "input" });
 }
 function resolveWorkingDirectory(params) {
   return params.cwd ?? process.cwd();
 }
-function result2(text, details = {}) {
+function result(text, details = {}) {
   return { content: [{ type: "text", text }], details };
 }
 function unsupportedForgeMessage() {
@@ -18207,7 +16289,7 @@ async function publishResolvedReview(review, params, model) {
   const promotedBodies = promotion?.promotedBodies ?? 0;
   const promotedComments = promotion?.promotedComments ?? 0;
   const promotedReplies = promotion?.promotedReplies ?? 0;
-  return result2(`Published #${review.pr.number} (${status}); promoted ${promotedBodies} review bodies, ${promotedComments} comments, and ${promotedReplies} replies.`, { pr: finalPr ?? review.pr, status, promotedBodies, promotedComments, promotedReplies });
+  return result(`Published #${review.pr.number} (${status}); promoted ${promotedBodies} review bodies, ${promotedComments} comments, and ${promotedReplies} replies.`, { pr: finalPr ?? review.pr, status, promotedBodies, promotedComments, promotedReplies });
 }
 async function promoteLocalReview(review, remote, model, workingTree) {
   const publication = await loadReviewPublicationState(review.cwd, review.vcs, review.pr.number);
@@ -18296,7 +16378,7 @@ async function launchLocalReview(review, workingTree, requestedBase) {
   const base = workingTree ? requestedBase ?? review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : undefined) : undefined;
   const launched = await launch(review.cwd, workingTree ? undefined : review.pr?.number, base);
   const commandTarget = workingTree || !review.pr ? "full branch" : `PR/MR #${review.pr.number}`;
-  return result2(launched.launched ? `Opened ${commandTarget} in tuicr (${launched.via}).` : launched.instruction ?? `Run: ${launched.command}`, { launched, pr: review.pr, target: commandTarget });
+  return result(launched.launched ? `Opened ${commandTarget} in tuicr (${launched.via}).` : launched.instruction ?? `Run: ${launched.command}`, { launched, pr: review.pr, target: commandTarget });
 }
 async function assertRemoteBranchReady(cwd) {
   const dirty = await runChecked("git", ["-C", cwd, "status", "--porcelain"]);
@@ -18328,16 +16410,16 @@ async function headSha(cwd) {
 }
 async function newReviewArtifactPath(cwd, target) {
   const dir = await reviewsDir(cwd);
-  await mkdir7(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
   return uniqueRecordPath(dir, reviewRecordName(target));
 }
 async function localThreadArtifactPath(cwd, sessionSlug) {
   const dir = await reviewsDir(cwd);
-  return join21(dir, `${reviewSlug(sessionSlug) || "local-review"}.md`);
+  return join14(dir, `${reviewSlug(sessionSlug) || "local-review"}.md`);
 }
 async function readThreadArtifact(path) {
   try {
-    return parseThreadArtifact(await readFile14(path, "utf8"));
+    return parseThreadArtifact(await readFile9(path, "utf8"));
   } catch (error) {
     if (error.code === "ENOENT") {
       throw new Error(`Expected local reply overlay is missing: ${path}`);
@@ -18361,9 +16443,9 @@ async function findLatestThreadArtifact(cwd, review, target) {
       return [];
     return [
       (async () => {
-        const path = join21(dir, name);
-        const info = await stat2(path);
-        return { path, name, content: await readFile14(path, "utf8"), modified: info.mtimeMs };
+        const path = join14(dir, name);
+        const info = await stat(path);
+        return { path, name, content: await readFile9(path, "utf8"), modified: info.mtimeMs };
       })()
     ];
   }));
@@ -18377,7 +16459,7 @@ async function findLatestThreadArtifact(cwd, review, target) {
 }
 async function listReviewArtifactNames(dir) {
   try {
-    return await readdir4(dir);
+    return await readdir2(dir);
   } catch (error) {
     throw new Error(`Cannot read review artifacts in ${dir}.`, { cause: error });
   }
@@ -18386,10 +16468,10 @@ function deriveTitle(branch) {
   return branch.replace(/^(feature|feat|fix|bug|chore)\//, "").replace(/^eng-\d+-/i, "").replace(/[-_]+/g, " ").replace(/^\w/, (char) => char.toUpperCase());
 }
 function uniqueRecordPath(dir, base) {
-  let path = join21(dir, `${base}.md`);
+  let path = join14(dir, `${base}.md`);
   let count = 2;
   while (existsSync3(path))
-    path = join21(dir, `${base}-${count++}.md`);
+    path = join14(dir, `${base}-${count++}.md`);
   return path;
 }
 function artifactNameMatches(name, suffix) {
@@ -18405,22 +16487,22 @@ function artifactNameMatches(name, suffix) {
 }
 
 // src/tools/setup.ts
-import { defineTool as defineTool5 } from "@earendil-works/pi-coding-agent";
-import { z as z10 } from "zod";
+import { defineTool as defineTool4 } from "@earendil-works/pi-coding-agent";
+import { z as z8 } from "zod";
 
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter3 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir5, readFile as readFile16 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile11 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import { basename as basename7, join as join24 } from "node:path";
+import { basename as basename5, join as join17 } from "node:path";
 
 // src/mcp.ts
-import { mkdir as mkdir8, readFile as readFile15, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile10, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { dirname as dirname8, join as join22 } from "node:path";
+import { dirname as dirname6, join as join15 } from "node:path";
 var mcp = {
   globalConfigPath(homeDir = homedir8()) {
-    return join22(homeDir, ".config", "mcp", "mcp.json");
+    return join15(homeDir, ".config", "mcp", "mcp.json");
   },
   async serversEnsure(servers, options = {}) {
     const path = options.path ?? mcp.globalConfigPath();
@@ -18433,8 +16515,8 @@ var mcp = {
     const next = { ...current, mcpServers: nextServers };
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
-      await mkdir8(dirname8(path), { recursive: true });
-      await writeFile9(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 && options.dryRun === true };
@@ -18463,7 +16545,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile15(path, "utf8");
+    return await readFile10(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -18475,9 +16557,9 @@ function isRecord(value) {
 }
 
 // src/pi.ts
-import { mkdir as mkdir9, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname9, join as join23 } from "node:path";
+import { dirname as dirname7, join as join16 } from "node:path";
 var pi = {
   executableCheck: findPiExecutable,
   packageList: listPiPackages,
@@ -18490,19 +16572,19 @@ var pi = {
   configEnsure: ensurePiConfig
 };
 async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
-  const path = join23(agentDir, "agents", filename);
+  const path = join16(agentDir, "agents", filename);
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
-    await mkdir9(dirname9(path), { recursive: true });
-    await writeFile10(path, content, "utf8");
+    await mkdir6(dirname7(path), { recursive: true });
+    await writeFile7(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
-async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join23(homedir9(), ".agents", "skills")) {
-  const roots = [join23(agentDir, "skills"), sharedSkillsDir];
+async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join16(homedir9(), ".agents", "skills")) {
+  const roots = [join16(agentDir, "skills"), sharedSkillsDir];
   for (const root of roots) {
-    if (await readTextIfExists(join23(root, name, "SKILL.md")) !== undefined)
+    if (await readTextIfExists(join16(root, name, "SKILL.md")) !== undefined)
       return true;
   }
   return false;
@@ -18531,8 +16613,8 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const next = update(current);
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
-    await mkdir9(dirname9(path), { recursive: true });
-    await writeFile10(path, `${JSON.stringify(next, null, 2)}
+    await mkdir6(dirname7(path), { recursive: true });
+    await writeFile7(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -18552,7 +16634,7 @@ async function installPiPackage(executable, source) {
   await runChecked(executable, ["install", source]);
 }
 function resolvePiAgentDir(homeDir = homedir9()) {
-  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join23(process.env.XDG_CONFIG_HOME, "pi") : join23(homeDir, ".pi", "agent"));
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join16(process.env.XDG_CONFIG_HOME, "pi") : join16(homeDir, ".pi", "agent"));
 }
 function parseJsonObject(content, path) {
   if (!content?.trim())
@@ -18604,7 +16686,7 @@ var FORGE_DEPENDENCIES = {
 };
 async function ensureMise(options = {}) {
   const homeDir = options.homeDir ?? homedir10();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join24(homeDir, ".local", "bin", "mise"));
+  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");
@@ -18653,9 +16735,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(join24(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(join24(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);
@@ -18666,11 +16748,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 readdir5(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 = basename7(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile16(join24(bundledAgentsDir, entry.name), "utf8");
+    const id = basename5(entry.name, ".md").replace(/^diffpi-/, "");
+    const source = await readFile11(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));
@@ -18679,7 +16761,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join24(options.homeDir ?? homedir10(), ".agents", "skills");
+  const sharedSkillsDir = join17(options.homeDir ?? homedir10(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -18760,8 +16842,7 @@ function setupRequiresRestart(actions) {
 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")
+      createSetupAction("Zed review tasks", "planned", "global static runtime-resolver tasks in tasks.json")
     ];
     if (options.bindZedKey)
       actions.push(createSetupAction("Zed review keybinding", "planned", "keymap.json"));
@@ -18771,8 +16852,6 @@ async function ensureZedIntegration(options = {}) {
   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)));
   }
@@ -18874,26 +16953,19 @@ function createSetupAction(name, status, detail) {
 function reportProgress(options, message) {
   options.onProgress?.(message);
 }
-async function packageVersion2() {
-  const source = await readFile16(join24(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 : {};
 }
 
 // src/tools/setup.ts
-var setupParametersSchema = z10.object({
-  issueTracker: z10.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
-  forges: z10.array(z10.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
-  forge: z10.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
-  bindZedKey: z10.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
-});
-var setupParameters = z10.toJSONSchema(setupParametersSchema, { io: "input" });
-var diffpiSetupTool = defineTool5({
+var setupParametersSchema = z8.object({
+  issueTracker: z8.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
+  forges: z8.array(z8.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
+  forge: z8.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
+  bindZedKey: z8.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
+});
+var setupParameters = z8.toJSONSchema(setupParametersSchema, { io: "input" });
+var diffpiSetupTool = defineTool4({
   name: "diffpi_setup",
   label: "diffpi setup",
   description: "Install or repair the @difflab/pi environment. This mutates user-level tool installations and configuration files.",
@@ -18922,7 +16994,7 @@ var diffpiSetupTool = defineTool5({
     return formatResult(result, "Setup complete.");
   }
 });
-var diffpiValidateTool = defineTool5({
+var diffpiValidateTool = defineTool4({
   name: "diffpi_validate",
   label: "diffpi validate",
   description: "Inspect the @difflab/pi environment without installing software or changing configuration files.",
@@ -18964,20 +17036,20 @@ ${lines.join(`
 }
 
 // src/tools/templates.ts
-import { defineTool as defineTool6 } from "@earendil-works/pi-coding-agent";
-import { z as z11 } from "zod";
-var templateSchema = z11.object({
-  name: z11.string().min(1),
-  variables: z11.record(z11.string(), z11.string()).optional(),
-  homeDir: z11.string().optional()
-});
-var diffpiTemplateTool = defineTool6({
+import { defineTool as defineTool5 } from "@earendil-works/pi-coding-agent";
+import { z as z9 } from "zod";
+var templateSchema = z9.object({
+  name: z9.string().min(1),
+  variables: z9.record(z9.string(), z9.string()).optional(),
+  homeDir: z9.string().optional()
+});
+var diffpiTemplateTool = defineTool5({
   name: "diffpi_template",
   label: "diffpi template",
   description: "Load a bundled Diffpi template or a user override and render named variables.",
   promptSnippet: "Use diffpi_template for package workflow templates",
   promptGuidelines: ["User overrides live under ~/.difflab/diffpi/templates."],
-  parameters: z11.toJSONSchema(templateSchema, { io: "input" }),
+  parameters: z9.toJSONSchema(templateSchema, { io: "input" }),
   executionMode: "parallel",
   async execute(_id, input) {
     const params = templateSchema.parse(input);
@@ -18998,8 +17070,7 @@ function createPiTools(pi, modes) {
     createDiffpiReloadTool(pi),
     diffpiTemplateTool,
     ...createModeTools(modes),
-    ...createReviewTools(),
-    ...createPlanTools(pi, modes)
+    ...createReviewTools()
   ];
 }