@difflab/pi 0.4.0 → 0.5.0-rc.202609231313.eaf7fa0

package/dist/index.js

@@ -176,10 +176,19 @@ var require_extend = __commonJS(function(exports, module) {
 
 // src/config.ts
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { z } from "zod";
+import { z as z2 } from "zod";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
+// src/extensions/zodx.ts
+import { z } from "zod";
+var zx = {
+  cwd: z.string().optional(),
+  id: z.string().min(1).max(80).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  revision: z.number().int().nonnegative(),
+  text: z.string().trim().min(1)
+};
+
 // src/fsx.ts
 import { readdir, readFile } from "node:fs/promises";
 async function readDirectoryIfExists(path) {
@@ -205,12 +214,12 @@ function isMissingPath(error) {
 }
 
 // src/config.ts
-var modelReferenceSchema = z.string().trim().min(1);
-var agentConfigSchema = z.object({
-  models: z.array(modelReferenceSchema).optional()
+var modelReferenceSchema = zx.text;
+var agentConfigSchema = z2.object({
+  models: z2.array(modelReferenceSchema).optional()
 }).strict();
-var diffpiConfigSchema = z.object({
-  agents: z.record(z.string(), agentConfigSchema).optional()
+var diffpiConfigSchema = z2.object({
+  agents: z2.record(z2.string(), agentConfigSchema).optional()
 }).strict();
 function diffpiConfigPaths(homeDir = homedir()) {
   const directory = join(homeDir, ".difflab", "diffpi");
@@ -320,7 +329,11 @@ function run(command, args, options = {}) {
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: options.env ?? process.env,
-      stdio: [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+      stdio: [
+        options.interactive ? "inherit" : options.input === undefined ? "ignore" : "pipe",
+        options.interactive ? "inherit" : "pipe",
+        "pipe"
+      ],
       signal: options.signal
     });
     let stdout = "";
@@ -337,6 +350,8 @@ function run(command, args, options = {}) {
     });
     child.stderr?.on("data", (chunk) => {
       const text = chunk.toString();
+      if (options.interactive)
+        process.stderr.write(text);
       if (unbounded)
         stderrChunks.push(text);
       else
@@ -588,6 +603,29 @@ function parseRemote(remote) {
 function diffpiLaunchName(cwd, workflow) {
   return `diffpi: ${basename(cwd)} / ${workflow}`;
 }
+async function openFileAdjacent(path, opts) {
+  const env = opts.env ?? process.env;
+  const ide = detectIde(env);
+  if (ide !== "unknown") {
+    const ideCommand = { zed: "zed", vscode: "code", cursor: "cursor", windsurf: "windsurf", jetbrains: "idea" }[ide];
+    if (await findExecutable(ideCommand)) {
+      const result = await run(ideCommand, [path], { cwd: opts.cwd, env });
+      if (result.code === 0)
+        return { launched: true, via: ide, command: `${ideCommand} ${path}` };
+    }
+  }
+  const mux = detectMux(env);
+  if (mux !== "none") {
+    const editor = await resolveEditor(env);
+    if (editor) {
+      const command = [editor, path];
+      const opened = await openMuxTab(mux, command, opts.cwd, opts.name ?? "plan", command.join(" "));
+      if (opened)
+        return opened;
+    }
+  }
+  return { launched: false, via: "print", command: path, reason: "No supported IDE or multiplexer was available." };
+}
 async function openInNewTab(command, opts) {
   const env = opts.env ?? process.env;
   const name = opts.name ?? "review";
@@ -620,6 +658,15 @@ 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 resolveEditor(env) {
+  const configured = (env.VISUAL ?? env.EDITOR)?.trim().split(/\s+/)[0];
+  if (configured && await findExecutable(configured))
+    return configured;
+  for (const candidate of ["hx", "nvim", "vim"])
+    if (await findExecutable(candidate))
+      return candidate;
+  return;
+}
 async function packageVersion() {
   let value;
   try {
@@ -1232,16 +1279,16 @@ async function discoverMiseTasks(cwd) {
   return parseMiseTasks(result.stdout);
 }
 // src/review/types.ts
-import { z as z2 } from "zod";
-var severitySchema = z2.enum(["BLOCKING", "CONSIDER", "NOTE"]);
-var findingSchema = z2.object({
-  file: z2.string().min(1),
-  line: z2.number().int().nonnegative(),
+import { z as z3 } from "zod";
+var severitySchema = z3.enum(["BLOCKING", "CONSIDER", "NOTE"]);
+var findingSchema = z3.object({
+  file: z3.string().min(1),
+  line: z3.number().int().nonnegative(),
   severity: severitySchema,
-  body: z2.string().min(1),
-  reference: z2.string().optional().default("")
+  body: z3.string().min(1),
+  reference: z3.string().optional().default("")
 });
-var findingsSchema = z2.array(findingSchema);
+var findingsSchema = z3.array(findingSchema);
 function reviewSlug(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
 }
@@ -1254,9 +1301,6 @@ function yymmdd(date = new Date) {
 function reviewRecordName(target, date = new Date) {
   return `${yymmdd(date)}-${reviewSlug(target) || "uncommitted"}`;
 }
-function isLocalResponse(body) {
-  return /^<!-- diffpi(?:-local-response:[A-Za-z0-9_-]+)? -->\n/m.test(body);
-}
 function dedupeFindings(findings) {
   const rank = { BLOCKING: 3, CONSIDER: 2, NOTE: 1 };
   const byKey = new Map;
@@ -1302,18 +1346,6 @@ function renderCommentBody(finding) {
   return `${prefix}${finding.body}${reference}`;
 }
 // src/review/review-markdown.ts
-import { z as z3 } from "zod";
-var reviewThreadRecordSchema = z3.object({
-  id: z3.string().min(1),
-  file: z3.string().nullable().optional().transform((value) => value ?? undefined),
-  line: z3.number().int().positive().nullable().optional().transform((value) => value ?? undefined),
-  body: z3.string(),
-  author: z3.string().optional(),
-  resolved: z3.boolean(),
-  addressed: z3.boolean().optional(),
-  question: z3.boolean(),
-  replies: z3.array(z3.string()).optional()
-});
 function renderReviewDoc(input) {
   const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
   const lines = [`# Review: ${input.title}`, "", "## Metadata"];
@@ -1355,88 +1387,6 @@ function renderReviewDoc(input) {
 `).trimEnd()}
 `;
 }
-function renderThreadArtifact(title, target, threads, options = {}) {
-  const records = threads.map((thread) => ({
-    id: thread.id,
-    file: thread.file,
-    line: thread.line,
-    body: thread.body,
-    author: thread.author,
-    resolved: thread.resolved,
-    addressed: thread.addressed,
-    question: thread.question,
-    replies: thread.replies
-  }));
-  const payload = Buffer.from(JSON.stringify(records), "utf8").toString("base64url");
-  const lines = [
-    `<!-- diffpi-threads:${payload} -->`,
-    `# Review threads: ${title}`,
-    "",
-    "## Metadata",
-    "",
-    `- Target: ${target}`,
-    `- Pulled: ${options.timestamp ?? new Date().toISOString()}`
-  ];
-  if (options.number !== undefined)
-    lines.push(`- PR/MR: #${options.number}${options.url ? ` — ${options.url}` : ""}`);
-  lines.push("", "## Replies", "");
-  for (const thread of threads) {
-    const id = Buffer.from(thread.id, "utf8").toString("base64url");
-    lines.push(`### ${thread.file ?? "review"}:${thread.line ?? "n/a"} (${thread.id})`, "", `<!-- diffpi-reply-start:${id} -->`, thread.reply ?? "", `<!-- diffpi-reply-end:${id} -->`, "");
-  }
-  lines.push("## Source comments", "");
-  for (const thread of threads) {
-    lines.push(`### ${thread.file ?? "review"}:${thread.line ?? "n/a"} — ${thread.author ?? "unknown"}`, "", `Thread: ${thread.id}`, `Status: ${thread.resolved ? "resolved" : thread.addressed ? "addressed" : "open"}`, "", thread.body, "", "---", "");
-  }
-  return `${lines.join(`
-`).trimEnd()}
-`;
-}
-function parseThreadArtifact(content) {
-  const payload = content.match(/^<!-- diffpi-threads:([A-Za-z0-9_-]+) -->$/m)?.[1];
-  if (!payload)
-    throw new Error("This file is not a Diffpi thread artifact.");
-  let threads;
-  try {
-    const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-    threads = z3.array(reviewThreadRecordSchema).parse(decoded);
-  } catch {
-    throw new Error("Cannot parse the Diffpi thread artifact payload.");
-  }
-  const replies = content.split(/^## Source comments$/m, 1)[0] ?? "";
-  return threads.map((thread) => {
-    const id = Buffer.from(thread.id, "utf8").toString("base64url");
-    const startMarker = `<!-- diffpi-reply-start:${id} -->
-`;
-    const endMarker = `
-<!-- diffpi-reply-end:${id} -->`;
-    const start = replies.indexOf(startMarker);
-    const end = start < 0 ? -1 : replies.indexOf(endMarker, start + startMarker.length);
-    const reply = start >= 0 && end >= 0 ? replies.slice(start + startMarker.length, end).trim() : "";
-    return reply ? { ...thread, reply } : thread;
-  });
-}
-function upsertThreadReply(content, threadId, body, question, resolved) {
-  const threads = parseThreadArtifact(content);
-  const thread = threads.find((candidate) => candidate.id === threadId);
-  if (!thread)
-    throw new Error(`Review thread ${threadId} was not found in the local artifact.`);
-  thread.reply = body;
-  thread.addressed = true;
-  if (question !== undefined)
-    thread.question = question;
-  if (resolved !== undefined)
-    thread.resolved = resolved;
-  const title = content.match(/^# Review threads: (.+)$/m)?.[1] ?? "review";
-  const target = content.match(/^- Target: (.+)$/m)?.[1] ?? "local";
-  const timestamp = content.match(/^- Pulled: (.+)$/m)?.[1];
-  const pr = content.match(/^- PR\/MR: #(\d+)(?: — (.+))?$/m);
-  return renderThreadArtifact(title, target, threads, {
-    timestamp,
-    number: pr ? Number.parseInt(pr[1], 10) : undefined,
-    url: pr?.[2]
-  });
-}
 // src/review/github-review-backend.ts
 function GitHubReviewBackend(vcs, number) {
   const pendingReview = async () => {
@@ -1498,9 +1448,6 @@ function GitHubReviewBackend(vcs, number) {
         id: thread.id,
         file: thread.path ?? undefined,
         line: thread.line ?? undefined,
-        rootCommentId: comment?.id,
-        commentIds: nodes.flatMap((node) => [node.id, node.databaseId?.toString()].filter((id) => Boolean(id))),
-        commentNodeIds: nodes.flatMap((node) => node.id ? [node.id] : []),
         body,
         author: comment?.author?.login,
         resolved: thread.isResolved,
@@ -1510,7 +1457,6 @@ function GitHubReviewBackend(vcs, number) {
     });
   };
   return {
-    kind: "remote",
     async stage(draft) {
       const pending = await pendingReview();
       if (!pending) {
@@ -1568,33 +1514,6 @@ function GitHubReviewBackend(vcs, number) {
         await ghChecked(args);
       }
     },
-    async readDraft() {
-      const pending = await pendingReview();
-      if (!pending)
-        return { comments: [], body: "" };
-      const review = await ghChecked(["api", `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}`]);
-      const comments = await ghChecked([
-        "api",
-        `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}/comments`
-      ]);
-      let reviewData;
-      let commentData;
-      try {
-        reviewData = JSON.parse(review.stdout);
-        commentData = JSON.parse(comments.stdout);
-      } catch {
-        throw new Error("Cannot parse the pending GitHub review as JSON.");
-      }
-      return {
-        body: reviewData.body ?? "",
-        comments: commentData.map((comment) => ({
-          file: comment.path,
-          line: comment.line ?? comment.original_line ?? undefined,
-          side: comment.side ?? undefined,
-          body: comment.body
-        }))
-      };
-    },
     listThreads,
     async reply(input) {
       const threads = await listThreads();
@@ -1611,32 +1530,14 @@ function GitHubReviewBackend(vcs, number) {
           `body=${input.body}`
         ]);
       }
-      if (input.resolve)
-        await this.setResolved?.(input.threadId, true);
-    },
-    async setResolved(threadId, resolved) {
-      await ghChecked([
-        "api",
-        "graphql",
-        "-f",
-        `query=${resolved ? GITHUB_RESOLVE_MUTATION : GITHUB_UNRESOLVE_MUTATION}`,
-        "-f",
-        `threadId=${threadId}`
-      ]);
-    },
-    async deleteThread(threadId) {
-      const thread = (await listThreads()).find((candidate) => candidate.id === threadId);
-      const commentNodeIds = thread?.commentNodeIds ?? (thread?.rootCommentId ? [thread.rootCommentId] : []);
-      if (!commentNodeIds.length)
-        throw new Error(`Cannot delete GitHub thread ${threadId}: comment node IDs are missing.`);
-      for (const commentId of commentNodeIds) {
+      if (input.resolve) {
         await ghChecked([
           "api",
           "graphql",
           "-f",
-          `query=${GITHUB_DELETE_COMMENT_MUTATION}`,
+          `query=${GITHUB_RESOLVE_MUTATION}`,
           "-f",
-          `commentId=${commentId}`
+          `threadId=${input.threadId}`
         ]);
       }
     },
@@ -1655,13 +1556,11 @@ function GitHubReviewBackend(vcs, number) {
 function githubReviewSubmissionEndpoint(owner, repo, id, pendingReviewId) {
   return pendingReviewId ? `/repos/${owner}/${repo}/pulls/${id}/reviews/${pendingReviewId}/events` : `/repos/${owner}/${repo}/pulls/${id}/reviews`;
 }
-var GITHUB_THREADS_QUERY = `query($owner:String!,$repo:String!,$number:Int!,$after:String){repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewThreads(first:100,after:$after){nodes{id,isResolved,path,line,comments(first:100){nodes{id,databaseId,body,author{login}}}}pageInfo{hasNextPage,endCursor}}}}}`;
+var GITHUB_THREADS_QUERY = `query($owner:String!,$repo:String!,$number:Int!,$after:String){repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewThreads(first:100,after:$after){nodes{id,isResolved,path,line,comments(first:100){nodes{body,author{login}}}}pageInfo{hasNextPage,endCursor}}}}}`;
 var GITHUB_ADD_THREAD_MUTATION = `mutation($reviewId:ID!,$body:String!,$path:String!,$line:Int!,$side:DiffSide!){addPullRequestReviewThread(input:{pullRequestReviewId:$reviewId,body:$body,path:$path,line:$line,side:$side}){thread{id}}}`;
 var GITHUB_ADD_FILE_THREAD_MUTATION = `mutation($reviewId:ID!,$body:String!,$path:String!){addPullRequestReviewThread(input:{pullRequestReviewId:$reviewId,body:$body,path:$path,subjectType:FILE}){thread{id}}}`;
 var GITHUB_REPLY_MUTATION = `mutation($threadId:ID!,$body:String!){addPullRequestReviewThreadReply(input:{pullRequestReviewThreadId:$threadId,body:$body}){comment{id}}}`;
 var GITHUB_RESOLVE_MUTATION = `mutation($threadId:ID!){resolveReviewThread(input:{threadId:$threadId}){thread{isResolved}}}`;
-var GITHUB_UNRESOLVE_MUTATION = `mutation($threadId:ID!){unresolveReviewThread(input:{threadId:$threadId}){thread{isResolved}}}`;
-var GITHUB_DELETE_COMMENT_MUTATION = `mutation($commentId:ID!){deletePullRequestReviewComment(input:{id:$commentId}){clientMutationId}}`;
 
 // src/review/gitlab-review-backend.ts
 function GitLabReviewBackend(vcs, number) {
@@ -1698,7 +1597,6 @@ function GitLabReviewBackend(vcs, number) {
     });
   };
   return {
-    kind: "remote",
     async stage(draft) {
       const endpoint = `${mergeRequestEndpoint()}/draft_notes`;
       if (draft.body.trim()) {
@@ -1727,36 +1625,6 @@ function GitLabReviewBackend(vcs, number) {
         });
       }
     },
-    async readDraft() {
-      const result = await glabChecked(["api", `${mergeRequestEndpoint()}/draft_notes`]);
-      let notes;
-      try {
-        notes = JSON.parse(result.stdout);
-      } catch {
-        throw new Error("Cannot parse GitLab draft notes as JSON.");
-      }
-      const comments = [];
-      const body = [];
-      for (const note of notes) {
-        if (!note.note)
-          continue;
-        const file = note.position?.new_path ?? note.position?.old_path;
-        const line = note.position?.new_line ?? note.position?.old_line;
-        if (file && line) {
-          comments.push({
-            file,
-            line,
-            side: note.position?.new_line ? "RIGHT" : "LEFT",
-            body: note.note
-          });
-        } else {
-          body.push(note.note);
-        }
-      }
-      return { comments, body: body.join(`
-
-`) };
-    },
     listThreads,
     async reply(input) {
       const endpoint = `${mergeRequestEndpoint()}/discussions/${encodeURIComponent(input.threadId)}`;
@@ -1768,15 +1636,7 @@ function GitLabReviewBackend(vcs, number) {
         });
       }
       if (input.resolve)
-        await this.setResolved?.(input.threadId, true);
-    },
-    async setResolved(threadId, resolved) {
-      const endpoint = `${mergeRequestEndpoint()}/discussions/${encodeURIComponent(threadId)}`;
-      await glabChecked(["api", "--method", "PUT", `${endpoint}?resolved=${resolved}`]);
-    },
-    async deleteThread(threadId) {
-      const endpoint = `${mergeRequestEndpoint()}/discussions/${encodeURIComponent(threadId)}`;
-      await glabChecked(["api", "--method", "DELETE", endpoint]);
+        await glabChecked(["api", "--method", "PUT", `${endpoint}?resolved=true`]);
     },
     async publish(event) {
       assertReviewEventSupported(vcs.provider, event);
@@ -1816,12 +1676,105 @@ function hasGitlabDraftNotes(input) {
   }
 }
 
-// src/review/local-review-backend.ts
-import { readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+// src/review/review-backend.ts
+function createRemoteReviewBackend(vcs, number) {
+  if (vcs.provider === "github")
+    return GitHubReviewBackend(vcs, number);
+  if (vcs.provider === "gitlab")
+    return GitLabReviewBackend(vcs, number);
+  throw new Error("A remote review backend requires a GitHub or GitLab repository.");
+}
+// src/review/local-reviews.ts
+import { mkdir as mkdir4, readdir as readdir2, readFile as readFile6, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+
+// src/store.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir as mkdir3, readlink, realpath as realpath2, 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 resolve2 } from "node:path";
+var STORE_LINK = ".diffpi";
+var LEGACY_STORE_LINK = join8(".pi", "diffpi");
+async function computeProjectSlug(cwd) {
+  return projectSlug(await inspectGitRepository(cwd));
+}
+function storeGlobalRoot(homeDir = homedir4()) {
+  return join8(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir4()) {
+  const repository = await inspectGitRepository(cwd);
+  const root = repository.root;
+  const slug = projectSlug(repository);
+  const dest = join8(storeGlobalRoot(homeDir), slug);
+  const link = join8(root, STORE_LINK);
+  await mkdir3(dest, { recursive: true });
+  try {
+    await assertStoreLink(link, dest);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+    await symlink(dest, link);
+  }
+  await removeLegacyStoreLink(join8(root, LEGACY_STORE_LINK), dest);
+  return { slug, root, dest, link, linked: true };
+}
+async function storeDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  return store.dest;
+}
+async function plansDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join8(store.link, "plan");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function reviewsDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join8(store.link, "review");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function 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(isAbsolute2(target) ? target : resolve2(dirname4(path), target));
+}
+async function canonicalPath2(path) {
+  try {
+    return await realpath2(path);
+  } catch {
+    return resolve2(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/extensions/tuicrx.ts
-import { readFile as readFile5, realpath as realpath2 } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
+import { readFile as readFile5, realpath as realpath3 } from "node:fs/promises";
+import { resolve as resolve3 } from "node:path";
 async function tuicrAvailable() {
   return Boolean(await findExecutable("tuicr"));
 }
@@ -1897,7 +1850,7 @@ async function resolvePrSession(cwd, owner, repo, number) {
   });
 }
 async function findMatchingSession(sessions, cwd, branch) {
-  const repository = await canonicalPath2(await gitToplevel(cwd));
+  const repository = await canonicalPath3(await gitToplevel(cwd));
   for (const session of sessions) {
     if (session.kind !== "local")
       continue;
@@ -1905,7 +1858,7 @@ async function findMatchingSession(sessions, cwd, branch) {
       const data = await readSession(session.path);
       if (data.branch_name !== branch || !data.repo_path)
         continue;
-      if (await canonicalPath2(data.repo_path) === repository)
+      if (await canonicalPath3(data.repo_path) === repository)
         return session;
     } catch {}
   }
@@ -1919,53 +1872,33 @@ async function readSession(path) {
     throw new Error(`Cannot parse tuicr session JSON: ${path}`);
   }
 }
-function toFindings(session, options = {}) {
-  const comments = [];
-  const include = (comment) => (!options.agentOnly || commentAuthor(comment)?.startsWith("Agent: ")) && (!options.excludeLocalResponses || !isLocalResponse(comment.content));
-  const publishableBody = (comment) => {
+function toLocalReviewThreads(session) {
+  const threads = [];
+  const add = (comment, location = {}) => {
     const author = commentAuthor(comment);
-    const route = author?.match(/^Agent:\s*(.+)$/)?.[1];
-    return route ? withRemoteProvenance(comment.content, route) : comment.content;
+    threads.push({
+      id: comment.id ?? `local-${threads.length + 1}`,
+      ...location,
+      body: comment.content,
+      ...author ? { author } : {},
+      resolved: false,
+      question: /\?\s*$/.test(comment.content.trim())
+    });
   };
-  const bodyParts = (session.review_comments ?? []).flatMap((comment) => include(comment) ? [publishableBody(comment)] : []);
+  for (const comment of session.review_comments ?? [])
+    add(comment);
   for (const [file, entry] of Object.entries(session.files ?? {})) {
-    for (const fileComment of entry.file_comments ?? []) {
-      if (!include(fileComment))
-        continue;
-      const comment = {
-        file,
-        body: fileComment.content,
-        ...fileComment.id ? { sourceCommentId: String(fileComment.id) } : {}
-      };
-      const author = commentAuthor(fileComment);
-      if (author)
-        comment.author = author;
-      comments.push(comment);
-    }
+    for (const comment of entry.file_comments ?? [])
+      add(comment, { file });
     for (const [lineKey, lineComments] of Object.entries(entry.line_comments ?? {})) {
       const line = Number.parseInt(lineKey, 10);
       if (!Number.isFinite(line))
         continue;
-      for (const lineComment of lineComments) {
-        if (!include(lineComment))
-          continue;
-        const comment = {
-          file,
-          line,
-          side: lineComment.side === "old" ? "LEFT" : "RIGHT",
-          body: lineComment.content,
-          ...lineComment.id ? { sourceCommentId: String(lineComment.id) } : {}
-        };
-        const author = commentAuthor(lineComment);
-        if (author)
-          comment.author = author;
-        comments.push(comment);
-      }
+      for (const comment of lineComments)
+        add(comment, { file, line });
     }
   }
-  return { comments, body: bodyParts.join(`
-
-`) };
+  return threads;
 }
 async function requireTuicr() {
   if (!await tuicrAvailable())
@@ -1974,207 +1907,70 @@ async function requireTuicr() {
 function commentAuthor(comment) {
   return comment.username ?? comment.author;
 }
-async function canonicalPath2(path) {
+async function canonicalPath3(path) {
   try {
-    return await realpath2(path);
+    return await realpath3(path);
   } catch {
-    return resolve2(path);
+    return resolve3(path);
   }
 }
 
-// src/review/local-review-backend.ts
-function LocalReviewBackend(options) {
-  return {
-    kind: "local",
-    async stage(draft) {
-      for (const comment of draft.comments) {
-        await addComment(options.session, comment.body, {
-          targetFile: comment.file,
-          line: comment.line,
-          side: comment.side === "LEFT" ? "old" : "new",
-          username: options.author
-        });
-      }
-      if (draft.body.trim())
-        await addComment(options.session, draft.body, { username: options.author });
-    },
-    async readDraft() {
-      return toFindings(await readSession(options.session), { excludeLocalResponses: true });
-    },
-    async listThreads() {
-      try {
-        return parseThreadArtifact(await readFile6(options.artifactPath, "utf8"));
-      } catch (error) {
-        if (error.code === "ENOENT")
-          return [];
-        throw error;
-      }
-    },
-    async reply(input) {
-      const content = await readFile6(options.artifactPath, "utf8");
-      await writeFile3(options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question, input.resolve), "utf8");
-    },
-    async publish() {
-      throw new Error("Promote a local draft through a remote review backend before publishing it.");
-    }
+// src/review/local-reviews.ts
+async function captureLocalReview(input) {
+  const id = reviewSlug(input.branch) || "local-review";
+  const dir = join9(await reviewsDir(input.cwd, input.homeDir), id);
+  await mkdir4(dir, { recursive: true });
+  const revision = await nextRevision(dir);
+  const output = await readFile6(input.session.path, "utf8");
+  const comments = toLocalReviewThreads(await readSession(input.session.path));
+  const dump = {
+    schemaVersion: 1,
+    id,
+    revision,
+    branch: input.branch,
+    base: input.base,
+    createdAt: (input.now ?? (() => new Date))().toISOString(),
+    diff: input.diff,
+    comments,
+    tuicr: { slug: input.session.slug, output }
   };
-}
-
-// src/review/review-backend.ts
-function createRemoteReviewBackend(vcs, number) {
-  if (vcs.provider === "github")
-    return GitHubReviewBackend(vcs, number);
-  if (vcs.provider === "gitlab")
-    return GitLabReviewBackend(vcs, number);
-  throw new Error("A remote review backend requires a GitHub or GitLab repository.");
-}
-function createLocalReviewBackend(options) {
-  return LocalReviewBackend(options);
-}
-// src/review/review-state.ts
-import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile7, rename, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-import { z as z4 } from "zod";
-
-// src/store.ts
-import { createHash } from "node:crypto";
-import { lstat, mkdir as mkdir3, readlink, realpath as realpath3, symlink, unlink } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join8, resolve as resolve3 } from "node:path";
-var STORE_LINK = ".diffpi";
-var LEGACY_STORE_LINK = join8(".pi", "diffpi");
-async function computeProjectSlug(cwd) {
-  return projectSlug(await inspectGitRepository(cwd));
-}
-function storeGlobalRoot(homeDir = homedir4()) {
-  return join8(homeDir, ".difflab", "diffpi", "projects");
-}
-async function ensureStore(cwd, homeDir = homedir4()) {
-  const repository = await inspectGitRepository(cwd);
-  const root = repository.root;
-  const slug = projectSlug(repository);
-  const dest = join8(storeGlobalRoot(homeDir), slug);
-  const link = join8(root, STORE_LINK);
-  await mkdir3(dest, { recursive: true });
+  const path = join9(dir, `${revision}.json`);
+  await writeFile3(path, `${JSON.stringify(dump, null, 2)}
+`, { encoding: "utf8", flag: "wx" });
+  await unlink2(input.session.path);
+  return { path, dump };
+}
+async function readLocalReview(cwd, branch, revision, homeDir) {
+  const id = reviewSlug(branch) || "local-review";
+  const dir = join9(await reviewsDir(cwd, homeDir), id);
+  const selected = revision ?? await latestRevision(dir);
+  if (!selected)
+    return;
   try {
-    await assertStoreLink(link, dest);
+    return JSON.parse(await readFile6(join9(dir, `${selected}.json`), "utf8"));
   } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-    await symlink(dest, link);
-  }
-  await removeLegacyStoreLink(join8(root, LEGACY_STORE_LINK), dest);
-  return { slug, root, dest, link, linked: true };
-}
-async function storeDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  return store.dest;
-}
-async function plansDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "plan");
-  await mkdir3(dir, { recursive: true });
-  return dir;
-}
-async function reviewsDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "review");
-  await mkdir3(dir, { recursive: true });
-  return dir;
-}
-async function sessionsDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "sessions");
-  await mkdir3(dir, { recursive: true });
-  return dir;
-}
-async function assertStoreLink(path, dest) {
-  const entry = await lstat(path);
-  if (!entry.isSymbolicLink())
-    throw new Error(`${path} exists and is not a symlink.`);
-  const target = await symlinkTarget(path);
-  if (target !== await canonicalPath3(dest))
-    throw new Error(`${path} points to ${target}, not ${dest}.`);
-}
-async function removeLegacyStoreLink(path, dest) {
-  try {
-    const entry = await lstat(path);
-    if (!entry.isSymbolicLink())
+    if (error.code === "ENOENT")
       return;
-    const target = await symlinkTarget(path);
-    if (target === await canonicalPath3(dest))
-      await unlink(path);
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-  }
-}
-async function symlinkTarget(path) {
-  const target = await readlink(path);
-  return canonicalPath3(isAbsolute2(target) ? target : resolve3(dirname4(path), target));
-}
-async function canonicalPath3(path) {
-  try {
-    return await realpath3(path);
-  } catch {
-    return resolve3(path);
+    throw error;
   }
 }
-function projectSlug(repository) {
-  const readable = repository.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed";
-  const digest = createHash("sha256").update(repository.identity).digest("hex").slice(0, 12);
-  return `${readable}-${digest}`;
-}
-
-// src/review/review-state.ts
-var reviewPublicationStateSchema = z4.object({
-  target: z4.string().optional(),
-  bodies: z4.array(z4.string()).default([]),
-  comments: z4.array(z4.string()).default([]),
-  stagedComments: z4.array(z4.string()).default([]),
-  replies: z4.array(z4.string()).default([]),
-  overlayPath: z4.string().optional()
-});
-function reviewBodyFingerprint(body) {
-  return digest(body);
-}
-function reviewCommentFingerprint(comment) {
-  return digest([comment.file, String(comment.line), comment.side ?? "RIGHT", comment.body].join("\x00"));
-}
-function reviewReplyFingerprint(threadId, body) {
-  return digest(`${threadId}\x00${body}`);
+async function nextRevision(dir) {
+  return await latestRevision(dir) + 1;
 }
-function unpublishedReviewComments(comments, knownFingerprints) {
-  return comments.filter((comment) => !knownFingerprints.has(reviewCommentFingerprint(comment)));
-}
-async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
-  const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
-  const path = join9(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+async function latestRevision(dir) {
   try {
-    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile7(path, "utf8")));
-    return { path, state: { ...parsed, target } };
+    return (await readdir2(dir)).reduce((latest, name) => {
+      const match = name.match(/^(\d+)\.json$/);
+      return match ? Math.max(latest, Number(match[1])) : latest;
+    }, 0);
   } catch (error) {
-    if (error.code === "ENOENT") {
-      return { path, state: { target, bodies: [], comments: [], stagedComments: [], replies: [] } };
-    }
-    if (error instanceof SyntaxError || error instanceof z4.ZodError) {
-      throw new Error(`Cannot parse review publication state: ${path}`);
-    }
+    if (error.code === "ENOENT")
+      return 0;
     throw error;
   }
 }
-async function saveReviewPublicationState(path, state) {
-  const temp = `${path}.${process.pid}.tmp`;
-  await writeFile4(temp, `${JSON.stringify(state, null, 2)}
-`, "utf8");
-  await rename(temp, path);
-}
-function digest(value) {
-  return createHash2("sha256").update(value).digest("hex");
-}
 // src/mcp.ts
-import { mkdir as mkdir4, readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { dirname as dirname5, join as join10 } from "node:path";
 var mcp = {
@@ -2192,8 +1988,8 @@ 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 writeFile5(path, `${JSON.stringify(next, null, 2)}
+      await mkdir5(dirname5(path), { recursive: true });
+      await writeFile4(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -2222,7 +2018,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;
@@ -2237,7 +2033,7 @@ 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";
 async function discoverAgentModes(options) {
@@ -2436,7 +2232,7 @@ async function loadAgentModes(directory, source, modes, diagnostics, skillName)
   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);
     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;
@@ -2492,7 +2288,7 @@ function isModeBaseline(value) {
   return (model === undefined || typeof model.provider === "string" && typeof model.id === "string") && candidate.thinkingLevel !== undefined && THINKING_LEVELS.has(candidate.thinkingLevel) && Array.isArray(candidate.tools) && candidate.tools.every((tool) => typeof tool === "string");
 }
 // src/pi.ts
-import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
 import { dirname as dirname6, join as join12 } from "node:path";
 var pi = {
@@ -2511,8 +2307,8 @@ async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(),
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
-    await mkdir5(dirname6(path), { recursive: true });
-    await writeFile6(path, content, "utf8");
+    await mkdir6(dirname6(path), { recursive: true });
+    await writeFile5(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
@@ -2548,8 +2344,8 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const next = update(current);
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
-    await mkdir5(dirname6(path), { recursive: true });
-    await writeFile6(path, `${JSON.stringify(next, null, 2)}
+    await mkdir6(dirname6(path), { recursive: true });
+    await writeFile5(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -2581,271 +2377,93 @@ function parseJsonObject(content, path) {
   } catch {}
   throw new Error(`Expected valid JSON object in ${path}.`);
 }
-// src/extensions/subagentx.ts
-import { z as z5 } from "zod";
-var escalationSchema = z5.object({
-  correlation: z5.object({
-    workflow: z5.string().min(1),
-    executionId: z5.string().min(1).optional(),
-    unitId: z5.string().min(1).optional(),
-    parentUnitId: z5.string().min(1).optional(),
-    metadata: z5.record(z5.string(), z5.string()).optional()
-  }).strict(),
-  blocker: z5.string().min(1),
-  attempts: z5.array(z5.string()),
-  evidence: z5.array(z5.string()),
-  needsUserDecision: z5.boolean()
-}).strict();
-var ESCALATION_OPEN = "<diffpi-subagent-escalation>";
-var ESCALATION_CLOSE = "</diffpi-subagent-escalation>";
-function renderSubagentEscalation(value) {
-  return `${ESCALATION_OPEN}${JSON.stringify(escalationSchema.parse(value))}${ESCALATION_CLOSE}`;
-}
-
-// 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";
-import { z as z6 } from "zod";
-
-// src/log.ts
-import { randomUUID } from "node:crypto";
-import { appendFile, readFile as readFile10 } from "node:fs/promises";
-async function appendLogEntry(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/store.ts
+import { mkdir as mkdir8, readdir as readdir3, readFile as readFile11, realpath as realpath4, 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/plan/log.ts
-async function appendPlanLog(logPath, event) {
-  return appendLogEntry(logPath, event);
+// src/extensions/fsx.ts
+import { mkdir as mkdir7, rename, rm, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname7, join as join13 } from "node:path";
+async function atomicWrite(path, content) {
+  const temp = join13(dirname7(path), `.${basename5(path)}.${crypto.randomUUID()}.tmp`);
+  await writeFile6(temp, content, { encoding: "utf8", mode: 384, flag: "wx" });
+  await rename(temp, path);
 }
-
-// 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");
+async function withDirectoryLock(lockDir, operation, options = {}) {
   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 });
+      await mkdir7(lockDir);
       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));
+      if (Date.now() - started >= waitMs)
+        throw new Error(`Timed out waiting to ${options.operation ?? "acquire lock"}: ${lockDir}`);
+      await sleep(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 });
+    await rm(lockDir, { recursive: true, force: true });
   }
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
-// src/plan/annotations.ts
-var commentSchema = z6.object({
-  id: z6.string(),
-  content: z6.string(),
-  path: z6.string().optional(),
-  start_line: z6.number().int().optional(),
-  line: z6.number().int().optional(),
-  end_line: z6.number().int().optional()
-}).loose();
-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((error) => {
-      if (error.code === "ENOENT")
-        return;
-      throw error;
-    });
-    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 };
+// src/log.ts
+import { randomUUID } from "node:crypto";
+import { appendFile, readFile as readFile9 } from "node:fs/promises";
+async function appendLogEntry(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 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" });
+
+// src/templates.ts
+import { readFile as readFile10 } from "node:fs/promises";
+import { homedir as homedir8 } from "node:os";
+import { join as join14, normalize } from "node:path";
+async function loadTemplate(name, options = {}) {
+  const relative = templateRelativePath(name);
+  const userPath = join14(options.homeDir ?? homedir8(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join14(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 annotationStatePath(record) {
-  return join14(record.dir, "annotations.json");
+function renderTemplate(content, variables) {
+  return content.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (match, key) => variables[key] ?? match);
 }
-async function readAnnotationState(record) {
-  const source = await readFile12(annotationStatePath(record), "utf8");
-  let value;
-  try {
-    value = JSON.parse(source);
-  } catch {
-    throw new Error(`Malformed annotation state: ${annotationStatePath(record)}.`);
-  }
-  if (value.schemaVersion !== 1 || typeof value.sessionSlug !== "string" || !Array.isArray(value.appliedCommentIds)) {
-    throw new Error(`Malformed annotation state: ${annotationStatePath(record)}.`);
+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 value;
-}
-function normalizeComment(value, index, lines, applied) {
-  const parsed = commentSchema.safeParse(value);
-  if (!parsed.success)
-    throw new Error(`Malformed tuicr comment at index ${index}.`);
-  const raw = parsed.data;
-  const line = raw.start_line ?? raw.line;
-  const endLine = raw.end_line ?? line;
-  const targetPath = raw.path;
-  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)
-  };
+  return normalized.endsWith(".md") ? normalized : `${normalized}.md`;
 }
-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 };
+async function readOptionalFile(path) {
+  try {
+    return await readFile10(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
   }
-  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);
-}
-
-// 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 and keep plan tools as the source of truth for eligibility, ownership, status, gates, and commits.",
-    "Use SubagentWorkflow for deterministic multi-task coordination: pipeline dependent work, parallelize only tasks with non-overlapping declared file scopes, and use structured schemas for worker outcomes.",
-    "The extension cannot launch workflow children over RPC, so the active orchestrator must invoke SubagentWorkflow itself.",
-    "Persist every transition, progress event, issue, and deviation. Do not edit PLAN.md directly. Delegated implementation workers never commit or restructure the plan.",
-    "For commit-per-phase execution, commit after local gates, push immediately, record pending CI on the completed phase, and launch a bounded background Worker to call plan_watch_ci for the exact SHA while the next phase executes. Collect that monitor before the next push and collect all monitors before plan completion; failed or timed-out CI blocks execution."
-  ].join(" ");
 }
 
 // src/plan/markdown.ts
@@ -7485,25 +7103,6 @@ function looksLikeAValue(value) {
 function isUint8Array2(value) {
   return Boolean(value && typeof value === "object" && "byteLength" in value && "byteOffset" in value);
 }
-// src/plan/ids.ts
-var STABLE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-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 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;
@@ -7551,8 +7150,6 @@ function validatePlanDocument(plan, options = {}) {
     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) {
@@ -7894,6 +7491,19 @@ function parseCsv(value) {
     return [];
   return value.split(",").map((item) => item.trim()).filter(Boolean);
 }
+function assertStableId(value, label) {
+  if (!zx.id.safeParse(value).success)
+    throw new Error(`${label} must be a lowercase stable slug, not a path: ${value}`);
+}
+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);
+  }
+}
 function cleanPlaceholder(value) {
   return value.replace(/<!--[^]*?-->/g, "").trim();
 }
@@ -7925,46 +7535,6 @@ 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 join17, 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 join16, normalize } from "node:path";
-async function loadTemplate(name, options = {}) {
-  const relative = templateRelativePath(name);
-  const userPath = join16(options.homeDir ?? homedir8(), ".difflab", "diffpi", "templates", relative);
-  const bundledPath = join16(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);
@@ -7972,7 +7542,7 @@ function planRecordName(shortSlug, date = new Date) {
 }
 async function resolvePlan(cwd, query, filters = {}, options = {}) {
   const root = await plansDir(cwd, options.homeDir);
-  const entries = await readdir2(root, { withFileTypes: true });
+  const entries = await readdir3(root, { withFileTypes: true });
   const normalizedQuery = query ? normalizeQuery(query) : undefined;
   const records = [];
   for (const entry of entries) {
@@ -7980,7 +7550,7 @@ async function resolvePlan(cwd, query, filters = {}, options = {}) {
       continue;
     if (normalizedQuery && entry.name !== normalizedQuery && stripDate(entry.name) !== normalizedQuery)
       continue;
-    const dir = join17(root, entry.name);
+    const dir = join16(root, entry.name);
     await assertContained(root, dir);
     try {
       const record = await readRecord(dir);
@@ -8006,10 +7576,10 @@ function createPlanStore(options = {}) {
     async init(input) {
       const root = await plansDir(input.cwd, options.homeDir);
       const id = planRecordName(input.shortSlug, now());
-      const dir = join17(root, id);
+      const dir = join16(root, id);
       await assertContained(root, dirname8(dir));
       try {
-        await mkdir7(dir);
+        await mkdir8(dir);
       } catch (error) {
         if (error.code === "EEXIST")
           throw new Error(`Plan ${id} already exists.`);
@@ -8026,25 +7596,19 @@ function createPlanStore(options = {}) {
           branch: input.branch,
           title: input.title?.trim() || titleFromSlug(input.shortSlug),
           intent: input.intent?.trim() || "<!-- Describe the intended outcome. -->",
+          issue_id: input.issueId?.trim() || "<!-- Add issue tracker ID. -->",
+          issue_url: input.issueUrl?.trim() || "<!-- Add issue tracker URL. -->",
           created_at: timestamp,
           updated_at: timestamp
         });
-        const document = parsePlanDocument(source, join17(dir, "PLAN.md"));
-        await atomicWrite(join17(dir, "PLAN.md"), source);
-        await ensureImplementationFiles(dir, document, options);
-        await atomicWrite(join17(dir, "logs.txt"), "");
-        await appendPlanLog(join17(dir, "logs.txt"), {
-          planRevision: document.revision,
-          kind: "created",
-          actor: "diffpi",
-          message: `Created plan ${id}.`
-        });
+        const document = parsePlanDocument(source, join16(dir, "PLAN.md"));
+        await atomicWrite(join16(dir, "PLAN.md"), source);
         return {
           id,
           dir,
-          planPath: join17(dir, "PLAN.md"),
-          logPath: join17(dir, "logs.txt"),
-          implementationDir: join17(dir, "implementation"),
+          planPath: join16(dir, "PLAN.md"),
+          logPath: join16(dir, "logs.txt"),
+          implementationDir: join16(dir, "implementation"),
           document,
           source
         };
@@ -8064,7 +7628,7 @@ function createPlanStore(options = {}) {
     },
     async mutate(cwd, query, operation, update) {
       const initial = await this.read(cwd, query);
-      return withPlanLock(initial.dir, async () => {
+      return withDirectoryLock(join16(initial.dir, ".lock"), async () => {
         const current = await readRecord(initial.dir);
         const next = await update(structuredClone(current.document));
         if (next.id !== current.id)
@@ -8078,41 +7642,41 @@ function createPlanStore(options = {}) {
         parsePlanDocument(source, current.planPath);
         await atomicWrite(current.planPath, source);
         await ensureImplementationFiles(current.dir, document, options);
-        return { ...current, document, source, implementationDir: join17(current.dir, "implementation") };
+        return { ...current, document, source, implementationDir: join16(current.dir, "implementation") };
       }, { operation });
     },
     async log(cwd, query, event) {
       const record = await this.read(cwd, query);
-      return withPlanLock(record.dir, () => appendPlanLog(record.logPath, event), { operation: "append log" });
+      return appendLogEntry(record.logPath, event);
     }
   };
 }
 async function readRecord(dir) {
-  const planPath = join17(dir, "PLAN.md");
-  const logPath = join17(dir, "logs.txt");
-  const source = await readFile14(planPath, "utf8");
+  const planPath = join16(dir, "PLAN.md");
+  const logPath = join16(dir, "logs.txt");
+  const source = await readFile11(planPath, "utf8");
   const document = parsePlanDocument(source, planPath);
   return {
     id: basename6(dir),
     dir,
     planPath,
     logPath,
-    implementationDir: join17(dir, "implementation"),
+    implementationDir: join16(dir, "implementation"),
     document,
     source
   };
 }
 async function ensureImplementationFiles(dir, document, options) {
-  const implementationDir = join17(dir, "implementation");
-  await mkdir7(implementationDir, { recursive: true });
+  const implementationDir = join16(dir, "implementation");
+  await mkdir8(implementationDir, { recursive: true });
   const template = await loadTemplate("plan/implementation", {
     homeDir: options.homeDir,
     bundledDir: options.bundledTemplatesDir
   });
   for (const phase of document.phases) {
-    const path = join17(implementationDir, `phase-${phase.id}.md`);
+    const path = join16(implementationDir, `phase-${phase.id}.md`);
     try {
-      await readFile14(path, "utf8");
+      await readFile11(path, "utf8");
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -8126,25 +7690,6 @@ async function ensureImplementationFiles(dir, document, options) {
     }
   }
 }
-async function atomicWrite(path, content) {
-  const temp = join17(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;
@@ -8162,7 +7707,8 @@ function normalizeSlug(value) {
     throw new Error(`Invalid plan slug: ${value}.`);
   }
   const slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  assertStableId(slug, "plan slug");
+  if (!zx.id.safeParse(slug).success)
+    throw new Error(`Invalid plan slug: ${value}.`);
   return slug;
 }
 function normalizeQuery(value) {
@@ -8177,345 +7723,11 @@ function stripDate(value) {
 function titleFromSlug(value) {
   return normalizeSlug(value).replace(/^(?:[a-z]+-\d+-)/, "").split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
 }
-
-// src/plan/controller.ts
-function createPlanController(options = {}) {
-  const store = createPlanStore(options);
-  const controller = {
-    context: store.context,
-    create: store.init,
-    read: store.read,
-    update: store.mutate,
-    appendLog: store.log,
-    updateStatus: (cwd, query, input) => updateStatus(store, cwd, query, input),
-    updateCi: (cwd, query, input) => updateCi(store, cwd, query, input),
-    retryCi: (cwd, query, input) => retryCi(store, cwd, query, input),
-    assertPhasePushEligible,
-    validate: validatePlanDocument,
-    countDesignWords,
-    annotate: annotatePlan,
-    annotations: readPlanAnnotations,
-    acknowledgeAnnotations: acknowledgePlanAnnotations,
-    executionPacket: createExecutionPacket,
-    executionPrompt: renderExecutionPrompt,
-    renderEscalation: renderSubagentEscalation,
-    assertStableId
-  };
-  return controller;
-}
-async function updateStatus(store, cwd, query, input) {
-  let escalation;
-  const record = await store.mutate(cwd, query, "update status", (plan) => {
-    if (input.target.type === "plan") {
-      if (plan.status !== input.expectedStatus)
-        throw new Error(`Expected plan status ${input.expectedStatus}, found ${plan.status}.`);
-      assertPlanTransition(plan.status, input.status);
-      if (input.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 ((input.status === "blocked" || input.status === "completed") && plan.status === "in_progress")
-        assertExecutionOwner(plan, input.executionId);
-      if (input.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.");
-      if (input.status === "completed" && plan.execution?.policy === "commit-per-phase") {
-        const unsettled = plan.phases.filter((phase) => phase.status === "completed" && (!phase.commit?.pushedAt || !["passed", "skipped"].includes(phase.commit.ci?.status ?? "pending")));
-        if (unsettled.length)
-          throw new Error(`CI must settle successfully for phases: ${unsettled.map((phase) => phase.id).join(", ")}.`);
-      }
-      return {
-        ...heartbeat(plan),
-        status: input.status,
-        execution: input.status === "completed" || input.status === "blocked" ? plan.execution && { ...plan.execution, active: false, heartbeatAt: new Date().toISOString() } : plan.execution
-      };
-    }
-    if (!input.target.id)
-      throw new Error("Target ID is required.");
-    const phase = input.target.type === "phase" ? getPhase(plan, input.target.id) : findTaskPhase(plan, input.target.id);
-    if (input.target.type === "phase") {
-      if (phase.status !== input.expectedStatus)
-        throw new Error(`Expected phase status ${input.expectedStatus}, found ${phase.status}.`);
-      if (phase.status === "completed")
-        throw new Error(`Completed phase ${phase.id} cannot transition again.`);
-      assertExecutionOwner(plan, input.executionId);
-      assertPhaseTransition(phase.status, input.status);
-      if (input.status === "in_progress" || input.status === "completed")
-        assertPhaseDependenciesSatisfied(plan, phase);
-      if (input.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")
-          assertPhasePushEligible(plan, phase.id, input.executionId);
-        if (plan.execution?.policy === "commit-per-phase" && !input.commit)
-          throw new Error("Commit-per-phase execution requires commit metadata before phase completion.");
-        if (plan.execution?.policy === "commit-per-phase" && (!input.commit?.pushedAt || input.commit.ci?.status !== "pending"))
-          throw new Error("Commit-per-phase execution requires a pushed commit with pending CI monitoring.");
-        if (plan.execution?.policy === "no-commit" && input.commit)
-          throw new Error("No-commit execution cannot record a phase commit.");
-      }
-      const updated = {
-        ...phase,
-        status: input.status,
-        revision: phase.revision + 1,
-        commit: input.commit ?? phase.commit,
-        blocker: input.blockedReason ? blocker(input) : phase.blocker
-      };
-      if (input.status === "blocked" && input.blockedReason)
-        escalation = escalationFor(plan, updated.id, undefined, input);
-      const phases = plan.phases.map((item) => {
-        if (item.id === updated.id)
-          return updated;
-        if (input.status === "completed" && plan.execution?.policy === "commit-per-phase" && input.commit && item.status !== "completed" && item.status !== "skipped" && item.gate.status === "passed")
-          return { ...item, gate: { ...item.gate, status: "stale" } };
-        return item;
-      });
-      return { ...heartbeat(plan), phases };
-    }
-    const task = getTask(phase, input.target.id);
-    if (task.status !== input.expectedStatus)
-      throw new Error(`Expected task status ${input.expectedStatus}, found ${task.status}.`);
-    assertExecutionOwner(plan, input.executionId);
-    assertTaskTransition(task, input.status, input.executionId, input.actor);
-    if (input.status === "in_progress" || input.status === "completed") {
-      if (phase.status !== "in_progress")
-        throw new Error(`Phase ${phase.id} is not in progress.`);
-      assertTaskDependenciesSatisfied(plan, task);
-    }
-    const updatedTask = {
-      ...task,
-      status: input.status,
-      revision: task.revision + 1,
-      owner: input.status === "in_progress" ? input.actor : task.owner,
-      executionId: input.status === "in_progress" ? input.executionId : task.executionId,
-      blocker: input.blockedReason ? blocker(input) : task.blocker
-    };
-    if (input.status === "blocked" && input.blockedReason)
-      escalation = escalationFor(plan, phase.id, task.id, input);
-    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(cwd, record.id, {
-    planRevision: record.document.revision,
-    kind: input.status === "blocked" ? "blocker" : "status",
-    actor: input.actor,
-    message: input.message,
-    executionId: input.executionId,
-    phaseId: input.target.type === "phase" ? input.target.id : escalation?.correlation.parentUnitId ?? escalation?.correlation.unitId,
-    taskId: input.target.type === "task" ? input.target.id : undefined,
-    evidence: input.evidence
-  });
-  return { record, escalation };
-}
-async function updateCi(store, cwd, query, input) {
-  const record = await store.mutate(cwd, query, "update CI status", (plan) => {
-    assertExecutionOwner(plan, input.executionId);
-    if (plan.execution?.policy !== "commit-per-phase")
-      throw new Error("CI status applies only to commit-per-phase execution.");
-    const phase = getPhase(plan, input.phaseId);
-    if (phase.status !== "completed")
-      throw new Error(`Phase ${phase.id} must be completed before CI can settle.`);
-    if (!phase.commit || phase.commit.sha !== input.sha)
-      throw new Error(`Phase ${phase.id} is not committed at ${input.sha}.`);
-    const current = phase.commit.ci?.status;
-    if (current !== "pending")
-      throw new Error(`CI for phase ${phase.id} is already ${current ?? "untracked"}.`);
-    const timestamp = new Date().toISOString();
-    const updated = {
-      ...phase,
-      revision: phase.revision + 1,
-      commit: {
-        ...phase.commit,
-        ci: {
-          ...phase.commit.ci,
-          status: input.status,
-          startedAt: phase.commit.ci?.startedAt ?? timestamp,
-          completedAt: timestamp,
-          detail: input.detail
-        }
-      }
-    };
-    return {
-      ...heartbeat(plan),
-      phases: plan.phases.map((item) => item.id === updated.id ? updated : item)
-    };
-  });
-  await store.log(cwd, record.id, {
-    planRevision: record.document.revision,
-    kind: "gate",
-    actor: input.actor,
-    message: `CI ${input.status} for ${input.phaseId}: ${input.detail}`,
-    executionId: input.executionId,
-    phaseId: input.phaseId,
-    evidence: [input.sha]
-  });
-  return record;
-}
-async function retryCi(store, cwd, query, input) {
-  let previousDetail;
-  const record = await store.mutate(cwd, query, "retry CI", (plan) => {
-    assertExecutionOwner(plan, input.executionId);
-    if (plan.execution?.policy !== "commit-per-phase")
-      throw new Error("CI retry applies only to commit-per-phase execution.");
-    const phase = getPhase(plan, input.phaseId);
-    if (phase.status !== "completed")
-      throw new Error(`Phase ${phase.id} must be completed before CI can retry.`);
-    if (!phase.commit || phase.commit.sha !== input.sha)
-      throw new Error(`Phase ${phase.id} is not committed at ${input.sha}.`);
-    if (phase.commit.ci?.status !== "failed")
-      throw new Error(`CI for phase ${phase.id} cannot retry from ${phase.commit.ci?.status ?? "untracked"}.`);
-    previousDetail = phase.commit.ci.detail;
-    const updated = {
-      ...phase,
-      revision: phase.revision + 1,
-      commit: {
-        ...phase.commit,
-        ci: { status: "pending", startedAt: new Date().toISOString() }
-      }
-    };
-    return {
-      ...heartbeat(plan),
-      phases: plan.phases.map((item) => item.id === updated.id ? updated : item)
-    };
-  });
-  await store.log(cwd, record.id, {
-    planRevision: record.document.revision,
-    kind: "gate",
-    actor: input.actor,
-    message: `Retrying CI for ${input.phaseId}: ${input.reason}`,
-    executionId: input.executionId,
-    phaseId: input.phaseId,
-    evidence: [input.sha],
-    data: { previousStatus: "failed", previousDetail }
-  });
-  return record;
-}
-function assertPhasePushEligible(plan, phaseId, executionId) {
-  assertExecutionOwner(plan, executionId);
-  if (plan.execution?.policy !== "commit-per-phase")
-    return;
-  const phaseIndex = plan.phases.findIndex((phase) => phase.id === phaseId);
-  if (phaseIndex < 0)
-    throw new Error(`Unknown phase: ${phaseId}.`);
-  const unsettled = plan.phases.slice(0, phaseIndex).filter((phase) => {
-    if (phase.status === "skipped")
-      return false;
-    return phase.status !== "completed" || !phase.commit?.pushedAt || !["passed", "skipped"].includes(phase.commit.ci?.status ?? "pending");
-  });
-  if (unsettled.length)
-    throw new Error(`Prior phase CI must settle successfully before another push: ${unsettled.map((phase) => phase.id).join(", ")}.`);
-}
-function assertPhaseDependenciesSatisfied(plan, phase) {
-  const unsettled = phase.dependencies.map((id) => getPhase(plan, id)).filter((dependency) => !dependencySatisfied(dependency.status));
-  if (unsettled.length)
-    throw new Error(`Phase ${phase.id} has incomplete dependencies: ${unsettled.map((dependency) => `${dependency.id} (${dependency.status})`).join(", ")}.`);
-}
-function assertTaskDependenciesSatisfied(plan, task) {
-  const tasks = plan.phases.flatMap((phase) => phase.tasks);
-  const unsettled = task.dependencies.map((id) => {
-    const dependency = tasks.find((candidate) => candidate.id === id);
-    if (!dependency)
-      throw new Error(`Unknown task dependency: ${id}.`);
-    return dependency;
-  }).filter((dependency) => !dependencySatisfied(dependency.status));
-  if (unsettled.length)
-    throw new Error(`Task ${task.id} has incomplete dependencies: ${unsettled.map((dependency) => `${dependency.id} (${dependency.status})`).join(", ")}.`);
-}
-function dependencySatisfied(status) {
-  return status === "completed" || status === "skipped";
-}
-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 assertPlanTransition(from, to) {
-  if (from !== to && !PLAN_TRANSITIONS[from].includes(to))
-    throw new Error(`Invalid plan status transition: ${from} -> ${to}.`);
-}
-function assertPhaseTransition(from, to) {
-  if (from !== to && !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 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(input) {
-  return {
-    reason: input.blockedReason,
-    attempts: input.attempts,
-    evidence: input.evidence,
-    needsUserDecision: input.needsUserDecision
-  };
-}
-function escalationFor(plan, phaseId, taskId, input) {
-  return {
-    correlation: {
-      workflow: "plan",
-      executionId: input.executionId,
-      unitId: taskId ?? phaseId,
-      parentUnitId: taskId ? phaseId : undefined,
-      metadata: { planId: plan.id }
-    },
-    blocker: input.blockedReason,
-    attempts: input.attempts ?? [],
-    evidence: input.evidence ?? [],
-    needsUserDecision: input.needsUserDecision ?? false
-  };
-}
-function heartbeat(plan) {
-  return plan.execution?.active ? { ...plan, execution: { ...plan.execution, heartbeatAt: new Date().toISOString() } } : plan;
-}
 // 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 { readdir as readdir4, readFile as readFile12 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
-import { basename as basename7, join as join18 } from "node:path";
+import { basename as basename7, join as join17 } from "node:path";
 var MISE_DEPENDENCIES = [
   { name: "node", tool: "node", spec: "node@22", minimumVersion: "22.19.0" },
   { name: "zellij", tool: "zellij", spec: "zellij@latest", minimumVersion: undefined },
@@ -8554,7 +7766,7 @@ var FORGE_DEPENDENCIES = {
 };
 async function ensureMise(options = {}) {
   const homeDir = options.homeDir ?? homedir9();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join18(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");
@@ -8603,9 +7815,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(join18(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(join18(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);
@@ -8616,11 +7828,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 readdir4(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(join18(bundledAgentsDir, entry.name), "utf8");
+    const source = await readFile12(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));
@@ -8629,7 +7841,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join18(options.homeDir ?? homedir9(), ".agents", "skills");
+  const sharedSkillsDir = join17(options.homeDir ?? homedir9(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -8825,7 +8037,7 @@ function reportProgress(options, message) {
   options.onProgress?.(message);
 }
 async function packageVersion2() {
-  const source = await readFile15(join18(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
+  const source = await readFile12(join17(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
   let value;
   try {
     value = JSON.parse(source);
@@ -8850,13 +8062,13 @@ export {
   addComment,
   assertGitHubMergeReady,
   assertReviewEventSupported,
+  captureLocalReview,
   checkConventionalSubject,
   computeProjectSlug,
   createForge,
   createForgeBackend,
-  createLocalReviewBackend,
   createModeController,
-  createPlanController,
+  createPlanStore,
   createRemoteReviewBackend,
   createVcsBackend,
   dedupeFindings,
@@ -8887,45 +8099,36 @@ export {
   launch,
   listSessions,
   loadDiffpiConfig,
-  loadReviewPublicationState,
   loadTemplate,
   localReviewAuthor,
   mcp,
   mise,
+  openFileAdjacent,
   openInNewTab,
   parseGitlabDiffRefs,
   parseRemote,
-  parseThreadArtifact,
   pi,
   plansDir,
+  readLocalReview,
   readSession,
   renderReviewDoc,
   renderTemplate,
-  renderThreadArtifact,
   resolveAgentMode,
   resolveAgentModelPreferences,
   resolvePrSession,
   resolveReviewSession,
   resolveSession,
-  reviewBodyFingerprint,
-  reviewCommentFingerprint,
   reviewRecordName,
-  reviewReplyFingerprint,
   reviewSlug,
   reviewsDir,
   runMiseGates,
-  saveReviewPublicationState,
-  sessionsDir,
   setupPi,
   severitySchema,
   storeDir,
   storeGlobalRoot,
   templateRelativePath,
-  toFindings,
   toReviewComments,
   tuicrAvailable,
-  unpublishedReviewComments,
-  upsertThreadReply,
   withRemoteProvenance,
   yymmdd,
   zedKeymapPath,