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

package/dist/index.js

@@ -95,30 +95,13 @@ function normalizeModelReference(value) {
   return value.toLowerCase().replace(/^~/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
 // src/environment.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { basename, join as join5 } from "node:path";
-
-// src/assets.ts
-import { existsSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
-import { fileURLToPath } from "node:url";
-function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
-  const moduleDir = dirname(fileURLToPath(moduleUrl));
-  const candidates = [join2(moduleDir, name), join2(moduleDir, "..", name), join2(moduleDir, "..", "..", name)];
-  return candidates.find((path) => existsSync(path)) ?? candidates[1];
-}
-function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
-  return resolveBundledAssetDir("agents", moduleUrl);
-}
-function resolveBundledTemplatesDir(moduleUrl = import.meta.url) {
-  return resolveBundledAssetDir("templates", moduleUrl);
-}
+import { basename } from "node:path";
 
 // src/extensions/processx.ts
 import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
-import { delimiter, join as join3 } from "node:path";
+import { delimiter, join as join2 } from "node:path";
 async function findExecutable(name) {
   if (name.includes("/")) {
     try {
@@ -131,7 +114,7 @@ async function findExecutable(name) {
   for (const directory of (process.env.PATH ?? "").split(delimiter)) {
     if (!directory)
       continue;
-    const candidate = join3(directory, name);
+    const candidate = join2(directory, name);
     try {
       await access(candidate, constants.X_OK);
       return candidate;
@@ -191,18 +174,17 @@ function appendBounded(current, next) {
 // src/extensions/zedx.ts
 import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { dirname, join as join3 } from "node:path";
 var ZED_LOCAL_REVIEW_TASK_NAME = "diffpi: tuicr local review";
 var ZED_REVIEW_TASK_NAME = ZED_LOCAL_REVIEW_TASK_NAME;
 var ZED_PR_REVIEW_TASK_NAME = "diffpi: tuicr PR review";
-var ZED_PLAN_ANNOTATE_TASK_NAME = "diffpi: annotate plan";
 var LEGACY_ZED_REVIEW_TASK_NAME = "diffpi: tuicr review";
 var REVIEW_KEYBINDING = "cmd-alt-r";
 function zedTasksPath(homeDir = homedir2()) {
-  return join4(homeDir, ".config", "zed", "tasks.json");
+  return join3(homeDir, ".config", "zed", "tasks.json");
 }
 function zedKeymapPath(homeDir = homedir2()) {
-  return join4(homeDir, ".config", "zed", "keymap.json");
+  return join3(homeDir, ".config", "zed", "keymap.json");
 }
 async function ensureZedReviewTask(homeDir = homedir2(), _command = ["tuicr", "-w", "-r", "main..HEAD"]) {
   const path = zedTasksPath(homeDir);
@@ -222,33 +204,6 @@ async function ensureZedReviewTask(homeDir = homedir2(), _command = ["tuicr", "-
     await writeJson(path, next);
   return { path, changed, existed: currentText !== undefined };
 }
-async function ensureZedPlanTask(packageVersion, homeDir = homedir2()) {
-  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(packageVersion)) {
-    throw new Error(`Invalid @difflab/pi package version: ${packageVersion}.`);
-  }
-  const path = zedTasksPath(homeDir);
-  const currentText = await readOptional(path);
-  const tasks = parseJsonArray(currentText, path);
-  const task = {
-    label: ZED_PLAN_ANNOTATE_TASK_NAME,
-    command: "npx",
-    args: ["--yes", `@difflab/pi@${packageVersion}`, "plan", "annotate", "--cwd", "$ZED_WORKTREE_ROOT"],
-    cwd: "$ZED_WORKTREE_ROOT",
-    use_new_terminal: true,
-    reveal: "always",
-    reveal_target: "center"
-  };
-  const next = [...tasks];
-  const index = next.findIndex((candidate) => candidate.label === task.label);
-  if (index >= 0)
-    next[index] = { ...next[index], ...task };
-  else
-    next.push(task);
-  const changed = JSON.stringify(tasks) !== JSON.stringify(next);
-  if (changed)
-    await writeJson(path, next);
-  return { path, changed, existed: currentText !== undefined };
-}
 async function ensureZedReviewKeybinding(homeDir = homedir2()) {
   const path = zedKeymapPath(homeDir);
   const currentText = await readOptional(path);
@@ -268,9 +223,6 @@ async function ensureZedReviewKeybinding(homeDir = homedir2()) {
   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
@@ -352,7 +304,7 @@ function parseJsonArray(content, path) {
   return value;
 }
 async function writeJson(path, value) {
-  await mkdir(dirname2(path), { recursive: true });
+  await mkdir(dirname(path), { recursive: true });
   await writeFile(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
@@ -421,10 +373,7 @@ async function openInNewTab(command, opts) {
   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);
+      await ensureZedReviewTask(opts.homeDir, command);
       return {
         launched: false,
         configured: true,
@@ -440,12 +389,6 @@ async function openInNewTab(command, opts) {
 function screenWindowArgs(command, cwd, name) {
   return ["-X", "screen", "-t", name, "sh", "-lc", 'cd -- "$1" && shift && exec "$@"', "sh", cwd, ...command];
 }
-async function packageVersion() {
-  const value = JSON.parse(await readFile3(join5(resolveBundledAgentsDir(), "..", "package.json"), "utf8"));
-  if (typeof value.version !== "string")
-    throw new Error("Cannot resolve the installed @difflab/pi version.");
-  return value.version;
-}
 async function openMuxTab(mux, command, cwd, name, printable) {
   if (mux === "zellij" && await findExecutable("zellij")) {
     const result = await run("zellij", ["action", "new-tab", "--cwd", cwd, "--name", name, "--", ...command]);
@@ -469,7 +412,7 @@ async function openMuxTab(mux, command, cwd, name, printable) {
 }
 // src/extensions/gitx.ts
 import { realpath } from "node:fs/promises";
-import { basename as basename2, isAbsolute, join as join6, resolve } from "node:path";
+import { basename as basename2, isAbsolute, join as join4, resolve } from "node:path";
 async function gitToplevel(cwd) {
   const result = await run("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
   const top = result.stdout.trim();
@@ -481,7 +424,7 @@ async function inspectGitRepository(cwd) {
   const remote = remoteResult.code === 0 ? remoteResult.stdout.trim() : "";
   const commonResult = await run("git", ["-C", root, "rev-parse", "--git-common-dir"]);
   const common = commonResult.stdout.trim();
-  const commonPath = commonResult.code === 0 && common ? resolve(isAbsolute(common) ? common : join6(root, common)) : root;
+  const commonPath = commonResult.code === 0 && common ? resolve(isAbsolute(common) ? common : join4(root, common)) : root;
   const commonDir = await canonicalPath(commonPath);
   return {
     root,
@@ -753,9 +696,9 @@ function createForgeBackend(vcs) {
 var createVcsBackend = createForgeBackend;
 var createForge = createForgeBackend;
 // src/extensions/misex.ts
-import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename3, dirname as dirname3, join as join7 } from "node:path";
+import { basename as basename3, dirname as dirname2, join as join5 } from "node:path";
 var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
 var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
 var mise = {
@@ -770,7 +713,7 @@ var mise = {
     const platform = options.platform ?? process.platform;
     if (platform === "win32")
       throw new Error("Automatic mise installation supports macOS and Linux only.");
-    const installedPath = join7(homeDir, ".local", "bin", "mise");
+    const installedPath = join5(homeDir, ".local", "bin", "mise");
     if (options.dryRun)
       return installedPath;
     await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
@@ -790,7 +733,7 @@ var mise = {
     const separator = current.length === 0 || current.endsWith(`
 `) ? "" : `
 `;
-    await mkdir2(dirname3(hook.path), { recursive: true });
+    await mkdir2(dirname2(hook.path), { recursive: true });
     await writeFile2(hook.path, `${current}${separator}${hook.content}`, "utf8");
     return { path: hook.path, changed: true, planned: false };
   },
@@ -817,7 +760,7 @@ function getShellHook(shell, executable, homeDir) {
   switch (shell.toLowerCase()) {
     case "zsh":
       return {
-        path: join7(homeDir, ".zshrc"),
+        path: join5(homeDir, ".zshrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate zsh)"
 ${MISE_HOOK_END}
@@ -825,7 +768,7 @@ ${MISE_HOOK_END}
       };
     case "fish":
       return {
-        path: join7(homeDir, ".config", "fish", "config.fish"),
+        path: join5(homeDir, ".config", "fish", "config.fish"),
         content: `${MISE_HOOK_START}
 ${command} activate fish | source
 ${MISE_HOOK_END}
@@ -834,7 +777,7 @@ ${MISE_HOOK_END}
     case "nu":
     case "nushell":
       return {
-        path: join7(homeDir, ".config", "nushell", "config.nu"),
+        path: join5(homeDir, ".config", "nushell", "config.nu"),
         content: `${MISE_HOOK_START}
 let mise_bin = ${command}
 let mise_path = $nu.default-config-dir | path join mise.nu
@@ -845,7 +788,7 @@ ${MISE_HOOK_END}
       };
     case "xonsh":
       return {
-        path: join7(homeDir, ".xonshrc"),
+        path: join5(homeDir, ".xonshrc"),
         content: `${MISE_HOOK_START}
 execx($(${command} activate xonsh))
 ${MISE_HOOK_END}
@@ -853,7 +796,7 @@ ${MISE_HOOK_END}
       };
     case "elvish":
       return {
-        path: join7(homeDir, ".config", "elvish", "rc.elv"),
+        path: join5(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 }
@@ -864,7 +807,7 @@ ${MISE_HOOK_END}
     case "pwsh":
     case "powershell":
       return {
-        path: join7(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        path: join5(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
         content: `${MISE_HOOK_START}
 (& ${command} activate pwsh) | Out-String | Invoke-Expression
 ${MISE_HOOK_END}
@@ -873,7 +816,7 @@ ${MISE_HOOK_END}
     case "bash":
     default:
       return {
-        path: join7(homeDir, ".bashrc"),
+        path: join5(homeDir, ".bashrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate bash)"
 ${MISE_HOOK_END}
@@ -912,7 +855,7 @@ function isVersionAtLeast(version, minimumVersion) {
 }
 async function getOptionalFile(path) {
   try {
-    return await readFile4(path, "utf8");
+    return await readFile3(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return "";
@@ -1532,10 +1475,10 @@ function hasGitlabDraftNotes(input) {
 }
 
 // src/review/local-review-backend.ts
-import { readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
 
 // src/extensions/tuicrx.ts
-import { readFile as readFile5, realpath as realpath2 } from "node:fs/promises";
+import { readFile as readFile4, realpath as realpath2 } from "node:fs/promises";
 import { resolve as resolve2 } from "node:path";
 async function tuicrAvailable() {
   return Boolean(await findExecutable("tuicr"));
@@ -1626,7 +1569,7 @@ async function findMatchingSession(sessions, cwd, branch) {
   return;
 }
 async function readSession(path) {
-  const content = await readFile5(path, "utf8");
+  const content = await readFile4(path, "utf8");
   try {
     return JSON.parse(content);
   } catch {
@@ -1705,7 +1648,7 @@ function LocalReviewBackend(options) {
     },
     async listThreads() {
       try {
-        return parseThreadArtifact(await readFile6(options.artifactPath, "utf8"));
+        return parseThreadArtifact(await readFile5(options.artifactPath, "utf8"));
       } catch (error) {
         if (error.code === "ENOENT")
           return [];
@@ -1713,7 +1656,7 @@ function LocalReviewBackend(options) {
       }
     },
     async reply(input) {
-      const content = await readFile6(options.artifactPath, "utf8");
+      const content = await readFile5(options.artifactPath, "utf8");
       await writeFile3(options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question, input.resolve), "utf8");
     },
     async publish() {
@@ -1735,29 +1678,29 @@ function createLocalReviewBackend(options) {
 }
 // src/review/review-state.ts
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile7, rename, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { readFile as readFile6, rename, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 import { z as z4 } from "zod";
 
 // src/store.ts
 import { createHash } from "node:crypto";
 import { lstat, mkdir as mkdir3, readlink, realpath as realpath3, symlink, unlink } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join8, resolve as resolve3 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join6, resolve as resolve3 } from "node:path";
 var STORE_LINK = ".diffpi";
-var LEGACY_STORE_LINK = join8(".pi", "diffpi");
+var LEGACY_STORE_LINK = join6(".pi", "diffpi");
 async function computeProjectSlug(cwd) {
   return projectSlug(await inspectGitRepository(cwd));
 }
 function storeGlobalRoot(homeDir = homedir4()) {
-  return join8(homeDir, ".difflab", "diffpi", "projects");
+  return join6(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);
+  const dest = join6(storeGlobalRoot(homeDir), slug);
+  const link = join6(root, STORE_LINK);
   await mkdir3(dest, { recursive: true });
   try {
     await assertStoreLink(link, dest);
@@ -1766,28 +1709,22 @@ async function ensureStore(cwd, homeDir = homedir4()) {
       throw error;
     await symlink(dest, link);
   }
-  await removeLegacyStoreLink(join8(root, LEGACY_STORE_LINK), dest);
+  await removeLegacyStoreLink(join6(root, LEGACY_STORE_LINK), dest);
   return { slug, root, dest, link, linked: true };
 }
 async function storeDir(cwd, homeDir = homedir4()) {
   const store = await ensureStore(cwd, homeDir);
   return store.dest;
 }
-async function plansDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "plan");
-  await mkdir3(dir, { recursive: true });
-  return dir;
-}
 async function reviewsDir(cwd, homeDir = homedir4()) {
   const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "review");
+  const dir = join6(store.link, "review");
   await mkdir3(dir, { recursive: true });
   return dir;
 }
 async function sessionsDir(cwd, homeDir = homedir4()) {
   const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "sessions");
+  const dir = join6(store.link, "sessions");
   await mkdir3(dir, { recursive: true });
   return dir;
 }
@@ -1814,7 +1751,7 @@ async function removeLegacyStoreLink(path, dest) {
 }
 async function symlinkTarget(path) {
   const target = await readlink(path);
-  return canonicalPath3(isAbsolute2(target) ? target : resolve3(dirname4(path), target));
+  return canonicalPath3(isAbsolute2(target) ? target : resolve3(dirname3(path), target));
 }
 async function canonicalPath3(path) {
   try {
@@ -1851,9 +1788,9 @@ function unpublishedReviewComments(comments, knownFingerprints) {
 }
 async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
   const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
-  const path = join9(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  const path = join7(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
   try {
-    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile7(path, "utf8")));
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile6(path, "utf8")));
     return { path, state: { ...parsed, target } };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -1875,12 +1812,12 @@ function digest(value) {
   return createHash2("sha256").update(value).digest("hex");
 }
 // src/mcp.ts
-import { mkdir as mkdir4, readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname5, join as join10 } from "node:path";
+import { dirname as dirname4, join as join8 } from "node:path";
 var mcp = {
   globalConfigPath(homeDir = homedir5()) {
-    return join10(homeDir, ".config", "mcp", "mcp.json");
+    return join8(homeDir, ".config", "mcp", "mcp.json");
   },
   async serversEnsure(servers, options = {}) {
     const path = options.path ?? mcp.globalConfigPath();
@@ -1893,7 +1830,7 @@ var mcp = {
     const next = { ...current, mcpServers: nextServers };
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
-      await mkdir4(dirname5(path), { recursive: true });
+      await mkdir4(dirname4(path), { recursive: true });
       await writeFile5(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
@@ -1923,7 +1860,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile8(path, "utf8");
+    return await readFile7(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -1938,27 +1875,45 @@ import {
   getAgentDir,
   parseFrontmatter as parseFrontmatter2
 } from "@earendil-works/pi-coding-agent";
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { basename as basename4, extname, join as join11 } from "node:path";
+import { basename as basename4, extname, join as join10 } from "node:path";
+
+// src/assets.ts
+import { existsSync } from "node:fs";
+import { dirname as dirname5, join as join9 } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
+  const moduleDir = dirname5(fileURLToPath(moduleUrl));
+  const candidates = [join9(moduleDir, name), join9(moduleDir, "..", name), join9(moduleDir, "..", "..", name)];
+  return candidates.find((path) => existsSync(path)) ?? candidates[1];
+}
+function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("agents", moduleUrl);
+}
+function resolveBundledTemplatesDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("templates", moduleUrl);
+}
+
+// src/modes.ts
 async function discoverAgentModes(options) {
   const agentDir = options.agentDir ?? getAgentDir();
   const homeDir = options.homeDir ?? homedir6();
   const modes = new Map;
   const diagnostics = [];
   await loadAgentModes(options.bundledAgentsDir ?? BUNDLED_AGENTS_DIR, "diffpi agent", modes, diagnostics);
-  await loadAgentModes(join11(agentDir, "agents"), "user agent", modes, diagnostics);
+  await loadAgentModes(join10(agentDir, "agents"), "user agent", modes, diagnostics);
   if (options.includeSkills) {
-    await loadSkillModes(join11(homeDir, ".agents", "skills"), "user skill", modes, diagnostics);
-    await loadSkillModes(join11(agentDir, "skills"), "pi user skill", modes, diagnostics);
+    await loadSkillModes(join10(homeDir, ".agents", "skills"), "user skill", modes, diagnostics);
+    await loadSkillModes(join10(agentDir, "skills"), "pi user skill", modes, diagnostics);
   }
   if (options.projectTrusted === true) {
     if (options.includeSkills) {
-      await loadSkillModes(join11(options.cwd, ".agents", "skills"), "project skill", modes, diagnostics);
-      await loadSkillModes(join11(options.cwd, ".pi", "skills"), "pi project skill", modes, diagnostics);
+      await loadSkillModes(join10(options.cwd, ".agents", "skills"), "project skill", modes, diagnostics);
+      await loadSkillModes(join10(options.cwd, ".pi", "skills"), "pi project skill", modes, diagnostics);
     }
-    await loadAgentModes(join11(options.cwd, ".agents", "agents"), "project agent", modes, diagnostics);
-    await loadAgentModes(join11(options.cwd, ".pi", "agents"), "pi project agent", modes, diagnostics);
+    await loadAgentModes(join10(options.cwd, ".agents", "agents"), "project agent", modes, diagnostics);
+    await loadAgentModes(join10(options.cwd, ".pi", "agents"), "pi project agent", modes, diagnostics);
   }
   const userConfig = await loadDiffpiConfig({ homeDir });
   const configuredModes = [...modes.values()].map((mode) => ({
@@ -2129,15 +2084,15 @@ function captureRuntime(pi, ctx) {
 async function loadSkillModes(skillsDir, source, modes, diagnostics) {
   const entries = await readDirectoryIfExists(skillsDir);
   for (const entry of entries.filter((item) => item.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
-    await loadAgentModes(join11(skillsDir, entry.name, "agents"), `${source} ${entry.name}`, modes, diagnostics, entry.name);
+    await loadAgentModes(join10(skillsDir, entry.name, "agents"), `${source} ${entry.name}`, modes, diagnostics, entry.name);
   }
 }
 async function loadAgentModes(directory, source, modes, diagnostics, skillName) {
   const entries = await readDirectoryIfExists(directory);
   for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name))) {
-    const path = join11(directory, entry.name);
+    const path = join10(directory, entry.name);
     try {
-      const content = await readFile9(path, "utf8");
+      const content = await readFile8(path, "utf8");
       const { frontmatter, body } = parseFrontmatter2(content.startsWith("\uFEFF") ? content.slice(1) : content);
       if (frontmatter.enabled === false || frontmatter.inline === false)
         continue;
@@ -2195,7 +2150,7 @@ function isModeBaseline(value) {
 // src/pi.ts
 import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { dirname as dirname6, join as join11 } from "node:path";
 var pi = {
   executableCheck: findPiExecutable,
   packageList: listPiPackages,
@@ -2208,7 +2163,7 @@ var pi = {
   configEnsure: ensurePiConfig
 };
 async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
-  const path = join12(agentDir, "agents", filename);
+  const path = join11(agentDir, "agents", filename);
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
@@ -2217,10 +2172,10 @@ async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(),
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
-async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join12(homedir7(), ".agents", "skills")) {
-  const roots = [join12(agentDir, "skills"), sharedSkillsDir];
+async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join11(homedir7(), ".agents", "skills")) {
+  const roots = [join11(agentDir, "skills"), sharedSkillsDir];
   for (const root of roots) {
-    if (await readTextIfExists(join12(root, name, "SKILL.md")) !== undefined)
+    if (await readTextIfExists(join11(root, name, "SKILL.md")) !== undefined)
       return true;
   }
   return false;
@@ -2270,7 +2225,7 @@ async function installPiPackage(executable, source) {
   await runChecked(executable, ["install", source]);
 }
 function resolvePiAgentDir(homeDir = homedir7()) {
-  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join12(process.env.XDG_CONFIG_HOME, "pi") : join12(homeDir, ".pi", "agent"));
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join11(process.env.XDG_CONFIG_HOME, "pi") : join11(homeDir, ".pi", "agent"));
 }
 function parseJsonObject(content, path) {
   if (!content?.trim())
@@ -2282,975 +2237,11 @@ function parseJsonObject(content, path) {
   } catch {}
   throw new Error(`Expected valid JSON object in ${path}.`);
 }
-// src/plan/annotations.ts
-import { spawn as spawn2 } from "node:child_process";
-import { readFile as readFile12, rename as rename2, writeFile as writeFile8 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname7, join as join14 } from "node:path";
-
-// src/plan/log.ts
-import { randomUUID } from "node:crypto";
-import { appendFile, readFile as readFile10 } from "node:fs/promises";
-async function appendPlanLog(logPath, event) {
-  const entry = {
-    ...event,
-    version: 1,
-    eventId: event.eventId ?? randomUUID(),
-    timestamp: event.timestamp ?? new Date().toISOString()
-  };
-  await appendFile(logPath, `${JSON.stringify(entry)}
-`, { encoding: "utf8", mode: 384 });
-  return entry;
-}
-async function readPlanLog(logPath) {
-  let source;
-  try {
-    source = await readFile10(logPath, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return [];
-    throw error;
-  }
-  return source.split(`
-`).filter(Boolean).map((line, index) => {
-    try {
-      return JSON.parse(line);
-    } catch {
-      throw new Error(`Malformed plan log entry at line ${index + 1}.`);
-    }
-  });
-}
-
-// src/plan/lock.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile11, rm, writeFile as writeFile7 } from "node:fs/promises";
-import { hostname } from "node:os";
-import { join as join13 } from "node:path";
-async function withPlanLock(planDir, operation, options = {}) {
-  const lockDir = join13(planDir, ".lock");
-  const waitMs = options.waitMs ?? 5000;
-  const pollMs = options.pollMs ?? 25;
-  const owner = {
-    token: randomUUID2(),
-    pid: process.pid,
-    hostname: hostname(),
-    operation: options.operation ?? "plan mutation",
-    acquiredAt: new Date().toISOString()
-  };
-  const started = Date.now();
-  while (true) {
-    try {
-      await mkdir6(lockDir);
-      await writeFile7(join13(lockDir, "owner.json"), `${JSON.stringify(owner)}
-`, { mode: 384 });
-      break;
-    } catch (error) {
-      if (error.code !== "EEXIST")
-        throw error;
-      if (Date.now() - started >= waitMs) {
-        let existing = "unknown owner";
-        try {
-          existing = (await readFile11(join13(lockDir, "owner.json"), "utf8")).trim();
-        } catch {}
-        throw new Error(`Timed out waiting for plan lock ${lockDir}; owner: ${existing}. Remove it only after confirming the owner is stale.`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollMs));
-    }
-  }
-  try {
-    return await operation();
-  } finally {
-    let current;
-    try {
-      current = JSON.parse(await readFile11(join13(lockDir, "owner.json"), "utf8"));
-    } catch {}
-    if (current?.token === owner.token)
-      await rm(lockDir, { recursive: true, force: true });
-  }
-}
-
-// src/plan/annotations.ts
-async function annotatePlan(record, runtime = {}) {
-  const execute = runtime.execute ?? executeProcess;
-  const result = await execute("tuicr", ["--file", record.planPath], dirname7(record.planPath), true);
-  const sessionSlug = [...result.stderr.matchAll(/^tuicr-session:\s*(\S+)\s*$/gm)].at(-1)?.[1];
-  if (result.code !== 0)
-    throw new Error(result.stderr.trim() || `tuicr exited with status ${result.code}.`);
-  if (!sessionSlug)
-    throw new Error("tuicr did not report a tuicr-session marker.");
-  const state = await withPlanLock(record.dir, async () => {
-    const previous = await readAnnotationState(record).catch(() => {
-      return;
-    });
-    const next = {
-      schemaVersion: 1,
-      sessionSlug,
-      updatedAt: new Date().toISOString(),
-      appliedCommentIds: previous?.appliedCommentIds ?? []
-    };
-    await atomicJson(annotationStatePath(record), next);
-    return next;
-  }, { operation: "save annotation session" });
-  return { sessionSlug, code: result.code, state };
-}
-async function readPlanAnnotations(record, options = {}) {
-  const state = await readAnnotationState(record).catch((error) => {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  });
-  if (!state)
-    return { comments: [], pending: [] };
-  const execute = options.runtime?.execute ?? executeProcess;
-  const response = await execute("tuicr", ["review", "comments", "--session", state.sessionSlug], record.dir, false);
-  if (response.code !== 0) {
-    if (/not found|no session|deleted/i.test(response.stderr))
-      return { state, comments: [], pending: [] };
-    throw new Error(response.stderr.trim() || "Cannot read tuicr comments.");
-  }
-  let raw;
-  try {
-    raw = JSON.parse(response.stdout);
-  } catch {
-    throw new Error("tuicr returned malformed comment JSON.");
-  }
-  if (!Array.isArray(raw))
-    throw new Error("tuicr comment output must be a JSON array.");
-  const lines = record.source.split(`
-`);
-  const applied = new Set(state.appliedCommentIds);
-  const comments = raw.map((value, index) => normalizeComment(value, index, lines, applied));
-  const pending = comments.filter((comment) => !comment.applied);
-  return { state, comments: options.includeApplied ? comments : pending, pending };
-}
-async function acknowledgePlanAnnotations(record, commentIds, summary) {
-  if (!summary.trim())
-    throw new Error("Annotation acknowledgement summary is required.");
-  return withPlanLock(record.dir, async () => {
-    const state = await readAnnotationState(record);
-    const next = {
-      ...state,
-      updatedAt: new Date().toISOString(),
-      appliedCommentIds: [...new Set([...state.appliedCommentIds, ...commentIds])]
-    };
-    await atomicJson(annotationStatePath(record), next);
-    await appendPlanLog(record.logPath, {
-      planRevision: record.document.revision,
-      kind: "annotation",
-      actor: "planner",
-      message: summary,
-      data: { commentIds: [...commentIds], sessionSlug: state.sessionSlug }
-    });
-    return next;
-  }, { operation: "acknowledge annotations" });
-}
-function annotationStatePath(record) {
-  return join14(record.dir, "annotations.json");
-}
-async function readAnnotationState(record) {
-  const value = JSON.parse(await readFile12(annotationStatePath(record), "utf8"));
-  if (value.schemaVersion !== 1 || typeof value.sessionSlug !== "string" || !Array.isArray(value.appliedCommentIds)) {
-    throw new Error(`Malformed annotation state: ${annotationStatePath(record)}.`);
-  }
-  return value;
-}
-function normalizeComment(value, index, lines, applied) {
-  if (!value || typeof value !== "object")
-    throw new Error(`Malformed tuicr comment at index ${index}.`);
-  const raw = value;
-  if (typeof raw.id !== "string" || typeof raw.content !== "string")
-    throw new Error(`Malformed tuicr comment at index ${index}.`);
-  const line = integer(raw.start_line) ?? integer(raw.line);
-  const endLine = integer(raw.end_line) ?? line;
-  const targetPath = typeof raw.path === "string" ? raw.path : undefined;
-  const appliesToPlan = !targetPath || basename5(targetPath) === basename5("PLAN.md");
-  const validAnchor = appliesToPlan && line !== undefined && line > 0 && line <= lines.length;
-  return {
-    id: raw.id,
-    body: raw.content,
-    file: targetPath,
-    line,
-    endLine,
-    context: validAnchor ? lines.slice(line - 1, Math.min(endLine ?? line, lines.length)).join(`
-`) : undefined,
-    stale: line !== undefined && !validAnchor,
-    applied: applied.has(raw.id)
-  };
-}
-async function executeProcess(command, args, cwd, interactive) {
-  if (!interactive) {
-    const result = await run(command, args, { cwd, capture: "unbounded" });
-    return { code: result.code, stdout: result.stdout, stderr: result.stderr };
-  }
-  return new Promise((resolve, reject) => {
-    const child = spawn2(command, args, { cwd, stdio: ["inherit", "inherit", "pipe"] });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      const text = chunk.toString();
-      stderr += text;
-      process.stderr.write(text);
-    });
-    child.on("error", reject);
-    child.on("close", (code) => resolve({ code: code ?? 1, stdout: "", stderr }));
-  });
-}
-async function atomicJson(path, value) {
-  const temp = join14(dirname7(path), `.${basename5(path)}.${crypto.randomUUID()}.tmp`);
-  await writeFile8(temp, `${JSON.stringify(value, null, 2)}
-`, { mode: 384, flag: "wx" });
-  await rename2(temp, path);
-}
-function integer(value) {
-  return typeof value === "number" && Number.isInteger(value) ? value : undefined;
-}
-// src/plan/escalation.ts
-import { z as z5 } from "zod";
-var escalationSchema = z5.object({
-  planId: z5.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  executionId: z5.string().min(1),
-  phaseId: z5.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  taskId: z5.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
-  blocker: z5.string().min(1),
-  attempts: z5.array(z5.string()),
-  evidence: z5.array(z5.string()),
-  needsUserDecision: z5.boolean()
-}).strict();
-var OPEN = "<diffpi-planner-escalation>";
-var CLOSE = "</diffpi-planner-escalation>";
-function renderPlannerEscalation(value) {
-  return `${OPEN}${JSON.stringify(escalationSchema.parse(value))}${CLOSE}`;
-}
-function parsePlannerEscalation(output) {
-  const start = output.indexOf(OPEN);
-  const end = output.indexOf(CLOSE, start + OPEN.length);
-  if (start < 0 || end < 0 || output.indexOf(OPEN, start + OPEN.length) >= 0)
-    throw new Error("Missing or ambiguous planner escalation payload.");
-  const payload = output.slice(start + OPEN.length, end);
-  try {
-    return escalationSchema.parse(JSON.parse(payload));
-  } catch (error) {
-    throw new Error(`Malformed planner escalation payload: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-// src/plan/execution.ts
-function createExecutionPacket(plan, coordinator) {
-  if (!plan.execution?.active)
-    throw new Error(`Plan ${plan.id} has no active execution.`);
-  return {
-    version: 1,
-    planId: plan.id,
-    executionId: plan.execution.id,
-    policy: plan.execution.policy,
-    cwd: plan.execution.cwd,
-    branch: plan.execution.branch,
-    coordinator
-  };
-}
-function renderExecutionPrompt(packet) {
-  return `Execute the durable Diffpi plan using this packet: ${JSON.stringify(packet)}. Call plan_context first. Coordinate eligible work, persist every transition and progress event, run phase gates, and honor the commit policy. Do not edit PLAN.md directly. Delegated workers never commit or restructure the plan.`;
-}
-function eligiblePlanTasks(plan) {
-  const completedPhases = new Set(plan.phases.filter((phase) => phase.status === "completed" || phase.status === "skipped").map((phase) => phase.id));
-  const completedTasks = new Set(plan.phases.flatMap((phase) => phase.tasks).filter((task) => task.status === "completed" || task.status === "skipped").map((task) => task.id));
-  for (const phase of plan.phases) {
-    if (phase.status === "completed" || phase.status === "skipped")
-      continue;
-    if (!phase.dependencies.every((dependency) => completedPhases.has(dependency)))
-      continue;
-    return phase.tasks.filter((task) => task.status === "pending" && task.dependencies.every((dependency) => completedTasks.has(dependency))).map((task) => ({ phase, task }));
-  }
-  return [];
-}
-function tasksMayRunInParallel(left, right) {
-  if (!left.fileScopes.length || !right.fileScopes.length)
-    return false;
-  if (left.dependencies.includes(right.id) || right.dependencies.includes(left.id))
-    return false;
-  return left.fileScopes.every((scope) => right.fileScopes.every((other) => !scopesOverlap(scope, other)));
-}
-function phaseCommitCommand(policy) {
-  return policy === "commit-per-phase" ? "/git commit --yes --no-push" : undefined;
-}
-function scopesOverlap(left, right) {
-  const normalize = (value) => value.replace(/^\.\//, "").replace(/\*.*$/, "").replace(/\/$/, "");
-  const a = normalize(left);
-  const b = normalize(right);
-  return !a || !b || a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
-}
-// src/plan/transitions.ts
-var STABLE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var PLAN_TRANSITIONS = {
-  draft: ["ready"],
-  ready: ["draft", "in_progress"],
-  in_progress: ["blocked", "completed"],
-  blocked: ["draft", "ready", "in_progress"],
-  completed: []
-};
-var WORK_TRANSITIONS = {
-  pending: ["in_progress", "skipped"],
-  in_progress: ["blocked", "completed"],
-  blocked: ["pending", "in_progress", "skipped"],
-  completed: [],
-  skipped: []
-};
-function isStableId(value) {
-  return STABLE_ID.test(value) && value.length <= 80;
-}
-function assertStableId(value, label = "identifier") {
-  if (!isStableId(value))
-    throw new Error(`${label} must be a lowercase stable slug, not a path: ${value}`);
-}
-function assertPlanTransition(from, to) {
-  if (from === to)
-    return;
-  if (!PLAN_TRANSITIONS[from].includes(to))
-    throw new Error(`Invalid plan status transition: ${from} -> ${to}.`);
-}
-function assertPhaseTransition(from, to) {
-  if (from === to)
-    return;
-  if (!WORK_TRANSITIONS[from].includes(to))
-    throw new Error(`Invalid phase status transition: ${from} -> ${to}.`);
-}
-function assertTaskTransition(task, to, executionId, actor) {
-  if (task.status !== to && !WORK_TRANSITIONS[task.status].includes(to)) {
-    throw new Error(`Invalid task status transition: ${task.status} -> ${to}.`);
-  }
-  if (task.status === "in_progress" && task.executionId && executionId !== task.executionId) {
-    throw new Error(`Task ${task.id} is owned by execution ${task.executionId}.`);
-  }
-  if (task.status === "in_progress" && task.owner && actor && actor !== task.owner) {
-    throw new Error(`Task ${task.id} is owned by ${task.owner}.`);
-  }
-}
-function assertUniqueIds(ids, label) {
-  const seen = new Set;
-  for (const id of ids) {
-    assertStableId(id, label);
-    if (seen.has(id))
-      throw new Error(`Duplicate ${label}: ${id}.`);
-    seen.add(id);
-  }
-}
-
-// src/plan/markdown.ts
-var PLAN_MARKER = /<!-- diffpi-plan: (\{[^\n]+\}) -->/;
-var PHASE_MARKER = /<!-- diffpi-phase: (\{[^\n]+\}) -->/g;
-var TASK_MARKER = /<!-- diffpi-task: (\{[^\n]+\}) -->/g;
-var SUPPORTED_SCHEMA = 1;
-function countDesignWords(plan) {
-  return [plan.design.bigIdeas, plan.design.keyApiUpdates, plan.design.consequences].join(" ").trim().split(/\s+/).filter(Boolean).length;
-}
-function validatePlanDocument(plan, options = {}) {
-  const issues = [];
-  const add = (code, severity, message, path) => issues.push({ code, severity, message, path });
-  try {
-    assertStableId(plan.id, "plan id");
-    assertUniqueIds(plan.phases.map((phase) => phase.id), "phase id");
-    assertUniqueIds(plan.phases.flatMap((phase) => phase.tasks.map((task) => task.id)), "task id");
-  } catch (error) {
-    add("invalid-id", "error", error.message);
-  }
-  if (plan.schemaVersion !== SUPPORTED_SCHEMA)
-    add("schema", "error", `Unsupported plan schema: ${plan.schemaVersion}.`);
-  const phaseIds = new Set(plan.phases.map((phase) => phase.id));
-  const taskIds = new Set(plan.phases.flatMap((phase) => phase.tasks.map((task) => task.id)));
-  for (const phase of plan.phases) {
-    for (const dependency of phase.dependencies) {
-      if (!phaseIds.has(dependency))
-        add("dangling-dependency", "error", `Phase ${phase.id} depends on missing ${dependency}.`);
-    }
-    for (const task of phase.tasks) {
-      for (const dependency of task.dependencies) {
-        if (!taskIds.has(dependency))
-          add("dangling-dependency", "error", `Task ${task.id} depends on missing ${dependency}.`);
-      }
-      if (options.strict && task.acceptanceCriteria.length === 0)
-        add("acceptance", "error", `Task ${task.id} has no acceptance criteria.`, task.id);
-    }
-    if (options.strict && phase.tasks.length === 0)
-      add("empty-phase", "error", `Phase ${phase.id} has no tasks.`, phase.id);
-  }
-  for (const cycle of dependencyCycles(plan))
-    add("dependency-cycle", "error", `Dependency cycle: ${cycle.join(" -> ")}.`);
-  const designWords = countDesignWords(plan);
-  if (designWords > 300)
-    add("design-length", "warning", `Design is ${designWords} words; prefer 300 or fewer.`);
-  if (options.strict && designWords > 800)
-    add("design-too-long", "error", `Design is ${designWords} words; finalization allows at most 800.`);
-  if (options.strict && plan.phases.length === 0)
-    add("no-phases", "error", "Finalization requires at least one phase.");
-  if (options.strict && (options.pendingAnnotations ?? 0) > 0)
-    add("pending-annotations", "error", `${options.pendingAnnotations} annotations remain pending.`);
-  return issues;
-}
-function renderPlanDocument(plan, previousSource) {
-  if (previousSource && canPatch(previousSource, plan))
-    return patchMarkers(previousSource, plan);
-  const marker = {
-    schemaVersion: plan.schemaVersion,
-    id: plan.id,
-    revision: plan.revision,
-    branch: plan.branch,
-    status: plan.status,
-    execution: plan.execution,
-    createdAt: plan.createdAt,
-    updatedAt: plan.updatedAt
-  };
-  const requirements = plan.requirements.length ? plan.requirements.map((item) => `- ${item}`).join(`
-`) : "<!-- Add requirements. -->";
-  const phases = plan.phases.map(renderPhase).join(`
-
-`);
-  const references = plan.references.length ? plan.references.map((reference) => `- <!-- diffpi-reference: ${json(reference)} --> ${reference.value}`).join(`
-`) : "<!-- Add references. -->";
-  return `<!-- diffpi-plan: ${json(marker)} -->
-# ${plan.title}
-
-- **Plan ID:** ${plan.id}
-- **Branch:** ${plan.branch}
-- **Status:** ${plan.status}
-- **Revision:** ${plan.revision}
-
-## Intent
-
-${plan.intent || "<!-- Describe the intended outcome. -->"}
-
-## Requirements
-
-${requirements}
-
-## Design
-
-### Big Ideas
-
-${plan.design.bigIdeas || "<!-- Describe the main approach. -->"}
-
-### Key API Addition/Updates
-
-${plan.design.keyApiUpdates || "<!-- Describe public API changes. -->"}
-
-### Consequences
-
-${plan.design.consequences || "<!-- Describe trade-offs and limitations. -->"}
-
-## Implementation
-
-${phases || "<!-- Add phases with plan_add_phase. -->"}
-
-## References
-
-${references}
-`;
-}
-function parsePlanDocument(source, ref = "PLAN.md") {
-  const planMatch = source.match(PLAN_MARKER);
-  if (!planMatch)
-    throw new Error(`${ref}: missing or malformed diffpi-plan marker.`);
-  if ((source.match(new RegExp(PLAN_MARKER.source, "g")) ?? []).length !== 1)
-    throw new Error(`${ref}: duplicate diffpi-plan marker.`);
-  const marker = parseMarker(planMatch[1], `${ref} plan`);
-  if (marker.schemaVersion !== SUPPORTED_SCHEMA)
-    throw new Error(`${ref}: unsupported plan schema ${String(marker.schemaVersion)}.`);
-  assertStableId(marker.id, "plan id");
-  const title = source.match(/^# (.+)$/m)?.[1]?.trim();
-  if (!title)
-    throw new Error(`${ref}: missing plan title.`);
-  const phases = parsePhases(section(source, "Implementation"), ref);
-  const document = {
-    ...marker,
-    schemaVersion: 1,
-    title,
-    intent: cleanPlaceholder(section(source, "Intent")),
-    requirements: parseBullets(section(source, "Requirements")),
-    design: {
-      bigIdeas: cleanPlaceholder(subsection(source, "Design", "Big Ideas")),
-      keyApiUpdates: cleanPlaceholder(subsection(source, "Design", "Key API Addition/Updates")),
-      consequences: cleanPlaceholder(subsection(source, "Design", "Consequences"))
-    },
-    phases,
-    references: parseReferences(section(source, "References"))
-  };
-  const errors = validatePlanDocument(document).filter((issue) => issue.severity === "error");
-  if (errors.length)
-    throw new Error(`${ref}: ${errors.map((issue) => issue.message).join(" ")}`);
-  return document;
-}
-function renderPhase(phase) {
-  const marker = {
-    id: phase.id,
-    revision: phase.revision,
-    status: phase.status,
-    gate: phase.gate,
-    commit: phase.commit,
-    blocker: phase.blocker
-  };
-  const dependencies = phase.dependencies.length ? phase.dependencies.join(", ") : "none";
-  return `<!-- diffpi-phase: ${json(marker)} -->
-### Phase: ${phase.title}
-
-**Objective:** ${phase.objective}
-
-**Dependencies:** ${dependencies}
-
-${phase.tasks.map(renderTask).join(`
-
-`)}
-
-<!-- /diffpi-phase -->`;
-}
-function renderTask(task) {
-  const marker = {
-    id: task.id,
-    revision: task.revision,
-    status: task.status,
-    owner: task.owner,
-    executionId: task.executionId,
-    blocker: task.blocker
-  };
-  const checked = task.status === "completed" || task.status === "skipped" ? "x" : " ";
-  return `<!-- diffpi-task: ${json(marker)} -->
-- [${checked}] **${task.title}**
-  - Steps: ${list(task.steps ?? [])}
-  - Dependencies: ${list(task.dependencies)}
-  - File scopes: ${list(task.fileScopes)}
-  - Acceptance criteria: ${list(task.acceptanceCriteria)}
-<!-- /diffpi-task -->`;
-}
-function parsePhases(input, ref) {
-  const starts = [...input.matchAll(PHASE_MARKER)];
-  const phases = starts.map((match, index) => {
-    const start = match.index;
-    const end = input.indexOf("<!-- /diffpi-phase -->", start);
-    if (end < 0)
-      throw new Error(`${ref}: phase marker has no closing marker.`);
-    const next = starts[index + 1]?.index;
-    if (next !== undefined && next < end)
-      throw new Error(`${ref}: nested or unclosed phase marker.`);
-    const body = input.slice(start + match[0].length, end);
-    const marker = parseMarker(match[1], `${ref} phase`);
-    assertStableId(marker.id, "phase id");
-    const title = body.match(/^### Phase: (.+)$/m)?.[1]?.trim();
-    const objective = body.match(/^\*\*Objective:\*\*\s*(.*)$/m)?.[1]?.trim();
-    if (!title || !objective)
-      throw new Error(`${ref}: phase ${marker.id} is missing title or objective.`);
-    return {
-      ...marker,
-      title,
-      objective,
-      dependencies: parseCsv(body.match(/^\*\*Dependencies:\*\*\s*(.*)$/m)?.[1]),
-      tasks: parseTasks(body, ref)
-    };
-  });
-  assertUniqueIds(phases.map((phase) => phase.id), "phase id");
-  return phases;
-}
-function parseTasks(input, ref) {
-  const starts = [...input.matchAll(TASK_MARKER)];
-  const tasks = starts.map((match, index) => {
-    const start = match.index;
-    const end = input.indexOf("<!-- /diffpi-task -->", start);
-    if (end < 0)
-      throw new Error(`${ref}: task marker has no closing marker.`);
-    const next = starts[index + 1]?.index;
-    if (next !== undefined && next < end)
-      throw new Error(`${ref}: nested or unclosed task marker.`);
-    const body = input.slice(start + match[0].length, end);
-    const marker = parseMarker(match[1], `${ref} task`);
-    assertStableId(marker.id, "task id");
-    const title = body.match(/^- \[[ xX]\] \*\*(.+)\*\*$/m)?.[1]?.trim();
-    if (!title)
-      throw new Error(`${ref}: task ${marker.id} is missing its checkbox title.`);
-    return {
-      ...marker,
-      title,
-      steps: parseListValue(body, "Steps"),
-      dependencies: parseListValue(body, "Dependencies"),
-      fileScopes: parseListValue(body, "File scopes"),
-      acceptanceCriteria: parseListValue(body, "Acceptance criteria")
-    };
-  });
-  assertUniqueIds(tasks.map((task) => task.id), "task id");
-  return tasks;
-}
-function parseReferences(input) {
-  return [...input.matchAll(/^- <!-- diffpi-reference: (\{[^\n]+\}) -->\s*(.*)$/gm)].map((match) => {
-    const marker = parseMarker(match[1], "reference");
-    assertStableId(marker.id, "reference id");
-    return { id: marker.id, value: match[2].trim() || marker.value };
-  });
-}
-function canPatch(source, next) {
-  try {
-    const old = parsePlanDocument(source);
-    return JSON.stringify(contentShape(old)) === JSON.stringify(contentShape(next));
-  } catch {
-    return false;
-  }
-}
-function patchMarkers(source, plan) {
-  const planMarker = {
-    schemaVersion: plan.schemaVersion,
-    id: plan.id,
-    revision: plan.revision,
-    branch: plan.branch,
-    status: plan.status,
-    execution: plan.execution,
-    createdAt: plan.createdAt,
-    updatedAt: plan.updatedAt
-  };
-  let output = source.replace(PLAN_MARKER, `<!-- diffpi-plan: ${json(planMarker)} -->`);
-  output = output.replace(/^- \*\*Status:\*\* .*$/m, `- **Status:** ${plan.status}`);
-  output = output.replace(/^- \*\*Revision:\*\* .*$/m, `- **Revision:** ${plan.revision}`);
-  for (const phase of plan.phases) {
-    const marker = {
-      id: phase.id,
-      revision: phase.revision,
-      status: phase.status,
-      gate: phase.gate,
-      commit: phase.commit,
-      blocker: phase.blocker
-    };
-    output = replaceMarkerById(output, "phase", phase.id, marker);
-    for (const task of phase.tasks) {
-      const taskMarker = {
-        id: task.id,
-        revision: task.revision,
-        status: task.status,
-        owner: task.owner,
-        executionId: task.executionId,
-        blocker: task.blocker
-      };
-      output = replaceMarkerById(output, "task", task.id, taskMarker);
-      const checked = task.status === "completed" || task.status === "skipped" ? "x" : " ";
-      const escaped = escapeRegExp(task.title);
-      output = output.replace(new RegExp(`^- \\[[ xX]\\] \\*\\*${escaped}\\*\\*$`, "m"), `- [${checked}] **${task.title}**`);
-    }
-  }
-  return output;
-}
-function replaceMarkerById(source, kind, id, marker) {
-  const pattern = new RegExp(`<!-- diffpi-${kind}: \\{[^\\n]*"id":"${escapeRegExp(id)}"[^\\n]*\\} -->`);
-  if (!pattern.test(source))
-    throw new Error(`Cannot update missing ${kind} marker ${id}.`);
-  return source.replace(pattern, `<!-- diffpi-${kind}: ${json(marker)} -->`);
-}
-function contentShape(plan) {
-  return {
-    title: plan.title,
-    branch: plan.branch,
-    intent: plan.intent,
-    requirements: plan.requirements,
-    design: plan.design,
-    references: plan.references,
-    phases: plan.phases.map(({ id, title, objective, dependencies, tasks }) => ({
-      id,
-      title,
-      objective,
-      dependencies,
-      tasks: tasks.map(({ id: taskId, title: taskTitle, steps, dependencies: taskDependencies, fileScopes, acceptanceCriteria }) => ({
-        id: taskId,
-        title: taskTitle,
-        steps,
-        dependencies: taskDependencies,
-        fileScopes,
-        acceptanceCriteria
-      }))
-    }))
-  };
-}
-function dependencyCycles(plan) {
-  const graph = new Map;
-  for (const phase of plan.phases)
-    graph.set(phase.id, phase.dependencies);
-  for (const task of plan.phases.flatMap((phase) => phase.tasks))
-    graph.set(task.id, task.dependencies);
-  const cycles = [];
-  const visiting = new Set;
-  const visited = new Set;
-  const walk = (id, path) => {
-    if (visiting.has(id)) {
-      cycles.push([...path.slice(path.indexOf(id)), id]);
-      return;
-    }
-    if (visited.has(id))
-      return;
-    visiting.add(id);
-    for (const dependency of graph.get(id) ?? [])
-      walk(dependency, [...path, id]);
-    visiting.delete(id);
-    visited.add(id);
-  };
-  for (const id of graph.keys())
-    walk(id, []);
-  return cycles;
-}
-function section(source, heading) {
-  const match = source.match(new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m"));
-  if (!match?.index) {
-    if (match?.index === 0)
-      return "";
-    throw new Error(`Missing required heading: ${heading}.`);
-  }
-  const start = match.index + match[0].length;
-  const rest = source.slice(start);
-  const end = rest.search(/^## /m);
-  return (end < 0 ? rest : rest.slice(0, end)).trim();
-}
-function subsection(source, parent, heading) {
-  const body = section(source, parent);
-  const match = body.match(new RegExp(`^### ${escapeRegExp(heading)}\\s*$`, "m"));
-  if (match?.index === undefined)
-    throw new Error(`Missing required heading: ${parent}/${heading}.`);
-  const rest = body.slice(match.index + match[0].length);
-  const end = rest.search(/^### /m);
-  return (end < 0 ? rest : rest.slice(0, end)).trim();
-}
-function parseBullets(input) {
-  return [...input.matchAll(/^- (?!<!--)(.+)$/gm)].map((match) => match[1].trim());
-}
-function parseListValue(body, label) {
-  const value = body.match(new RegExp(`^  - ${escapeRegExp(label)}:\\s*(.*)$`, "m"))?.[1];
-  return parseCsv(value);
-}
-function parseCsv(value) {
-  if (!value || value.trim().toLowerCase() === "none")
-    return [];
-  return value.split(",").map((item) => item.trim()).filter(Boolean);
-}
-function cleanPlaceholder(value) {
-  return value.replace(/<!--[^]*?-->/g, "").trim();
-}
-function parseMarker(value, label) {
-  try {
-    return JSON.parse(value);
-  } catch {
-    throw new Error(`Malformed ${label} marker JSON.`);
-  }
-}
-function list(values) {
-  return values.length ? values.join(", ") : "none";
-}
-function json(value) {
-  return JSON.stringify(value, (_key, entry) => entry === undefined ? undefined : entry);
-}
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-// src/plan/store.ts
-import { open, mkdir as mkdir7, readdir as readdir2, readFile as readFile14, realpath as realpath4, rename as rename3, rm as rm2 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname8, join as join16, resolve as resolve4, sep } from "node:path";
-
-// src/templates.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { join as join15, normalize } from "node:path";
-async function loadTemplate(name, options = {}) {
-  const relative = templateRelativePath(name);
-  const userPath = join15(options.homeDir ?? homedir8(), ".difflab", "diffpi", "templates", relative);
-  const bundledPath = join15(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
-  const user = await readOptionalFile(userPath);
-  if (user !== undefined)
-    return { name, path: userPath, source: "user", content: user };
-  const bundled = await readOptionalFile(bundledPath);
-  if (bundled !== undefined)
-    return { name, path: bundledPath, source: "bundled", content: bundled };
-  throw new Error(`Template "${name}" was not found at ${userPath} or ${bundledPath}.`);
-}
-function renderTemplate(content, variables) {
-  return content.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => variables[key] ?? match);
-}
-function templateRelativePath(name) {
-  const normalized = normalize(name.replaceAll("\\", "/")).replace(/^\.\//, "");
-  if (!normalized || normalized.startsWith("../") || normalized.includes("/../") || normalized.startsWith("/")) {
-    throw new Error(`Invalid template name: ${name}`);
-  }
-  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
-}
-async function readOptionalFile(path) {
-  try {
-    return await readFile13(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  }
-}
-
-// src/plan/store.ts
-function planRecordName(shortSlug, date = new Date) {
-  const slug = normalizeSlug(shortSlug);
-  return `${date.toISOString().slice(2, 10).replaceAll("-", "")}-${slug}`;
-}
-async function resolvePlan(cwd, query, filters = {}, options = {}) {
-  const root = await plansDir(cwd, options.homeDir);
-  const entries = await readdir2(root, { withFileTypes: true });
-  const normalizedQuery = query ? normalizeQuery(query) : undefined;
-  const records = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory() || entry.name === ".tmp" || entry.name === ".lock")
-      continue;
-    if (normalizedQuery && entry.name !== normalizedQuery && stripDate(entry.name) !== normalizedQuery)
-      continue;
-    const dir = join16(root, entry.name);
-    await assertContained(root, dir);
-    try {
-      const record = await readRecord(dir);
-      if (filters.branch && record.document.branch !== filters.branch)
-        continue;
-      if (filters.statuses && !filters.statuses.includes(record.document.status))
-        continue;
-      records.push(record);
-    } catch (error) {
-      if (error.code !== "ENOENT")
-        throw error;
-    }
-  }
-  records.sort((left, right) => left.id.localeCompare(right.id));
-  return { candidates: records, record: records.length === 1 ? records[0] : undefined, ambiguous: records.length > 1 };
-}
-function createPlanStore(options = {}) {
-  const now = options.now ?? (() => new Date);
-  return {
-    context(cwd, query, filters) {
-      return resolvePlan(cwd, query, filters, options);
-    },
-    async init(input) {
-      const root = await plansDir(input.cwd, options.homeDir);
-      const id = planRecordName(input.shortSlug, now());
-      const dir = join16(root, id);
-      await assertContained(root, dirname8(dir));
-      try {
-        await mkdir7(dir);
-      } catch (error) {
-        if (error.code === "EEXIST")
-          throw new Error(`Plan ${id} already exists.`);
-        throw error;
-      }
-      try {
-        const timestamp = now().toISOString();
-        const template = await loadTemplate("plan/PLAN", {
-          homeDir: options.homeDir,
-          bundledDir: options.bundledTemplatesDir
-        });
-        const source = renderTemplate(template.content, {
-          id,
-          branch: input.branch,
-          title: input.title?.trim() || titleFromSlug(input.shortSlug),
-          intent: input.intent?.trim() || "<!-- Describe the intended outcome. -->",
-          created_at: timestamp,
-          updated_at: timestamp
-        });
-        const document = parsePlanDocument(source, join16(dir, "PLAN.md"));
-        await atomicWrite(join16(dir, "PLAN.md"), source);
-        await atomicWrite(join16(dir, "logs.txt"), "");
-        await appendPlanLog(join16(dir, "logs.txt"), {
-          planRevision: document.revision,
-          kind: "created",
-          actor: "diffpi",
-          message: `Created plan ${id}.`
-        });
-        return { id, dir, planPath: join16(dir, "PLAN.md"), logPath: join16(dir, "logs.txt"), document, source };
-      } catch (error) {
-        await rm2(dir, { recursive: true, force: true });
-        throw error;
-      }
-    },
-    async read(cwd, query, filters) {
-      const result = await resolvePlan(cwd, query, filters, options);
-      if (!result.record) {
-        if (result.ambiguous)
-          throw new Error(`Plan query "${query}" is ambiguous: ${result.candidates.map((item) => item.id).join(", ")}.`);
-        throw new Error(`Plan "${query}" was not found.`);
-      }
-      return result.record;
-    },
-    async mutate(cwd, query, operation, update) {
-      const initial = await this.read(cwd, query);
-      return withPlanLock(initial.dir, async () => {
-        const current = await readRecord(initial.dir);
-        const next = await update(structuredClone(current.document));
-        if (next.id !== current.id)
-          throw new Error("A plan mutation cannot change the plan ID.");
-        const document = {
-          ...next,
-          revision: current.document.revision + 1,
-          updatedAt: now().toISOString()
-        };
-        const source = renderPlanDocument(document, current.source);
-        parsePlanDocument(source, current.planPath);
-        await atomicWrite(current.planPath, source);
-        return { ...current, document, source };
-      }, { operation });
-    },
-    async log(cwd, query, event) {
-      const record = await this.read(cwd, query);
-      return withPlanLock(record.dir, () => appendPlanLog(record.logPath, event), { operation: "append log" });
-    }
-  };
-}
-async function readRecord(dir) {
-  const planPath = join16(dir, "PLAN.md");
-  const logPath = join16(dir, "logs.txt");
-  const source = await readFile14(planPath, "utf8");
-  const document = parsePlanDocument(source, planPath);
-  return { id: basename6(dir), dir, planPath, logPath, document, source };
-}
-async function atomicWrite(path, content) {
-  const temp = join16(dirname8(path), `.${basename6(path)}.${process.pid}.${crypto.randomUUID()}.tmp`);
-  const file = await open(temp, "wx", 384);
-  try {
-    await file.writeFile(content, "utf8");
-    await file.sync();
-  } finally {
-    await file.close();
-  }
-  await rename3(temp, path);
-  try {
-    const directory = await open(dirname8(path), "r");
-    try {
-      await directory.sync();
-    } finally {
-      await directory.close();
-    }
-  } catch {}
-}
-async function assertContained(root, candidate) {
-  const canonicalRoot = await realpath4(root);
-  let canonicalCandidate;
-  try {
-    canonicalCandidate = await realpath4(candidate);
-  } catch {
-    canonicalCandidate = resolve4(candidate);
-  }
-  if (canonicalCandidate !== canonicalRoot && !canonicalCandidate.startsWith(`${canonicalRoot}${sep}`)) {
-    throw new Error(`Plan path escapes the shared store: ${candidate}.`);
-  }
-}
-function normalizeSlug(value) {
-  if (!value || value.includes("\x00") || value.includes("/") || value.includes("\\") || value.includes("..")) {
-    throw new Error(`Invalid plan slug: ${value}.`);
-  }
-  const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  assertStableId(slug, "plan slug");
-  return slug;
-}
-function normalizeQuery(value) {
-  if (!value || value.includes("\x00") || value.includes("/") || value.includes("\\") || value.includes("..")) {
-    throw new Error(`Invalid plan query: ${value}.`);
-  }
-  return value.toLowerCase();
-}
-function stripDate(value) {
-  return value.replace(/^\d{6}-/, "");
-}
-function titleFromSlug(value) {
-  return normalizeSlug(value).replace(/^(?:[a-z]+-\d+-)/, "").split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
-}
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter3 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir3, readFile as readFile15 } from "node:fs/promises";
-import { homedir as homedir9 } from "node:os";
-import { basename as basename7, join as join17 } from "node:path";
+import { readdir as readdir2, readFile as readFile9 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { basename as basename5, join as join12 } from "node:path";
 var MISE_DEPENDENCIES = [
   { name: "node", tool: "node", spec: "node@22", minimumVersion: "22.19.0" },
   { name: "zellij", tool: "zellij", spec: "zellij@latest", minimumVersion: undefined },
@@ -3288,8 +2279,8 @@ var FORGE_DEPENDENCIES = {
   gitlab: { name: "glab", tool: "glab", spec: "glab@latest", minimumVersion: undefined }
 };
 async function ensureMise(options = {}) {
-  const homeDir = options.homeDir ?? homedir9();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join17(homeDir, ".local", "bin", "mise"));
+  const homeDir = options.homeDir ?? homedir8();
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join12(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -3338,9 +2329,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(join17(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  const webSearch = await pi.configEnsure(join12(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
   actions.push(getConfigSetupAction("web search settings", webSearch));
-  const lsp = await pi.configEnsure(join17(agentDir, "pi-lsp.json"), (config) => ({
+  const lsp = await pi.configEnsure(join12(agentDir, "pi-lsp.json"), (config) => ({
     ...config,
     progressive: { ...getRecord(config.progressive), enabled: true, inject: "none" }
   }), options.dryRun);
@@ -3351,11 +2342,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 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 entries = (await readdir2(bundledAgentsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
   const actions = [];
   for (const entry of entries) {
-    const id = basename7(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile15(join17(bundledAgentsDir, entry.name), "utf8");
+    const id = basename5(entry.name, ".md").replace(/^diffpi-/, "");
+    const source = await readFile9(join12(bundledAgentsDir, entry.name), "utf8");
     const content = materializeAgentModels(source, id, userConfig.config, options.availableModels);
     const result = await pi.agentEnsure(entry.name, content, agentDir, options.dryRun);
     actions.push(getConfigSetupAction(`pi agent ${id}`, result));
@@ -3364,7 +2355,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join17(options.homeDir ?? homedir9(), ".agents", "skills");
+  const sharedSkillsDir = join12(options.homeDir ?? homedir8(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -3445,8 +2436,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"));
@@ -3456,8 +2446,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)));
   }
@@ -3559,45 +2547,61 @@ function createSetupAction(name, status, detail) {
 function reportProgress(options, message) {
   options.onProgress?.(message);
 }
-async function packageVersion2() {
-  const source = await readFile15(join17(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
-  const value = JSON.parse(source);
-  if (typeof value.version !== "string")
-    throw new Error("Cannot resolve the installed @difflab/pi version.");
-  return value.version;
-}
 function getRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+// src/templates.ts
+import { readFile as readFile10 } from "node:fs/promises";
+import { homedir as homedir9 } 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 ?? homedir9(), ".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 readFile10(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
 export {
   CONVENTIONAL_COMMIT,
   GitHubVcsBackend,
   GitLabVcsBackend,
   ZED_LOCAL_REVIEW_TASK_NAME,
-  ZED_PLAN_ANNOTATE_TASK_NAME,
   ZED_PR_REVIEW_TASK_NAME,
   ZED_REVIEW_TASK_NAME,
-  acknowledgePlanAnnotations,
   addComment,
-  annotatePlan,
-  annotationStatePath,
-  appendPlanLog,
   assertGitHubMergeReady,
-  assertPhaseTransition,
-  assertPlanTransition,
   assertReviewEventSupported,
-  assertStableId,
-  assertTaskTransition,
   checkConventionalSubject,
   ciGate,
   computeProjectSlug,
-  countDesignWords,
-  createExecutionPacket,
   createForge,
   createForgeBackend,
   createLocalReviewBackend,
   createModeController,
-  createPlanStore,
   createRemoteReviewBackend,
   createVcsBackend,
   dedupeFindings,
@@ -3607,7 +2611,6 @@ export {
   detectVcs,
   diffpiConfigPaths,
   discoverAgentModes,
-  eligiblePlanTasks,
   ensureMcpAdapters,
   ensureMise,
   ensureMiseDeps,
@@ -3616,7 +2619,6 @@ export {
   ensurePiPlugins,
   ensurePiSkills,
   ensureStore,
-  ensureZedPlanTask,
   ensureZedReviewKeybinding,
   ensureZedReviewTask,
   findPreferredModel,
@@ -3635,26 +2637,15 @@ export {
   mise,
   openInNewTab,
   parseGitlabDiffRefs,
-  parsePlanDocument,
-  parsePlannerEscalation,
   parseRemote,
   parseThreadArtifact,
-  phaseCommitCommand,
   pi,
-  planRecordName,
-  plansDir,
-  readPlanAnnotations,
-  readPlanLog,
   readSession,
-  renderExecutionPrompt,
-  renderPlanDocument,
-  renderPlannerEscalation,
   renderReviewDoc,
   renderTemplate,
   renderThreadArtifact,
   resolveAgentMode,
   resolveAgentModelPreferences,
-  resolvePlan,
   resolvePrSession,
   resolveReviewSession,
   resolveSession,
@@ -3671,15 +2662,12 @@ export {
   severitySchema,
   storeDir,
   storeGlobalRoot,
-  tasksMayRunInParallel,
   templateRelativePath,
   toFindings,
   toReviewComments,
   tuicrAvailable,
   unpublishedReviewComments,
   upsertThreadReply,
-  validatePlanDocument,
-  withPlanLock,
   withRemoteProvenance,
   yymmdd,
   zedKeymapPath,