@difflab/pi 0.5.0 → 0.6.0

package/dist/extensions/index.js

@@ -16642,8 +16642,14 @@ async function rpc(events, method, payload, timeout = 5000) {
 // src/workflow.ts
 import { readFile as readFile3 } from "node:fs/promises";
 import { join as join6 } from "node:path";
-async function loadPlanWorkflow(name, args) {
-  const workflowDir = join6(resolveBundledWorkflowsDir(), "plan");
+function loadPlanWorkflow(name, args) {
+  return loadWorkflow("plan", name, args);
+}
+function loadReviewWorkflow(name, args) {
+  return loadWorkflow("review", name, args);
+}
+async function loadWorkflow(scope, name, args) {
+  const workflowDir = join6(resolveBundledWorkflowsDir(), scope);
   const content = await readFile3(join6(workflowDir, `${name}.md`), "utf8");
   return [`Workflow directory: ${workflowDir}`, content.trim(), `Arguments:
 ${JSON.stringify(args, null, 2)}`].join(`
@@ -16854,46 +16860,172 @@ function registerReloadCommand(pi) {
 }
 
 // src/commands/review.ts
-var REVIEWER_VERBS = new Set(["address", "auto", "launch"]);
 function registerReviewCommand(pi, modes) {
   pi.registerCommand("review", {
-    description: "Code review: auto, new, edit, address, publish, complete, merge (add --local or --bg)",
-    handler: async (args, ctx) => handleReviewCommand(args, ctx, pi, modes)
+    description: "Code review: auto, new, edit, address, publish, complete, merge, help",
+    handler: async (args, ctx) => runReviewCommand(args, { pi, ctx, modes })
   });
 }
-async function handleReviewCommand(args, ctx, pi, modes) {
-  const background = hasFlag2(args, "--bg");
-  const invocation = withoutFlag(args, "--bg") || "help";
-  const verb = reviewVerb(invocation);
-  if (background) {
-    await launchBackgroundAgent(pi.events, {
-      name: `Review ${verb}`,
-      agent: "orchestrator",
-      cwd: ctx.cwd,
-      prompt: reviewPrompt(invocation, "orchestrator")
-    });
-    return;
+async function runReviewCommand(raw, runtime) {
+  try {
+    const reviewCommand = createReviewCommand(runtime);
+    const parsed = await dryRun(reviewCommand, tokenizeCommandArgs(raw));
+    if (parsed._tag === "error")
+      throw new Error(parsed.error);
+  } catch (error) {
+    const help = await generateCommandHelp(createReviewCommand(runtime));
+    runtime.ctx.ui.notify(`${error instanceof Error ? error.message : String(error)}
+${help}`, "error");
   }
-  const agent = REVIEWER_VERBS.has(verb) ? "reviewer" : "orchestrator";
-  const activation = await modes.set(agent, ctx);
-  pi.sendMessage({
-    customType: "diffpi-review-command",
-    display: false,
-    content: `${reviewPrompt(invocation, agent)} ${activation.message}`
-  }, { triggerTurn: true });
-}
-function reviewVerb(invocation) {
-  return invocation.split(/\s+/).find((token) => token && !token.startsWith("-")) ?? "help";
 }
-function reviewPrompt(invocation, agent) {
-  const routing = agent === "reviewer" ? "Coordinate this auto/address workflow. For address, classify every thread and delegate bounded edits to lightweight worker agents before collecting outcomes." : "Own this lifecycle workflow. Delegate review judgment to the reviewer only if the selected workflow requires it.";
-  return `The user ran /review ${invocation}. Active inline agent: ${agent}. ${routing} Follow the review skill dispatcher. Call review_context first, then the matching review_* tools. Do not perform unrelated work.`;
+function createReviewCommand(runtime) {
+  const invokeWorkflow = createReviewWorkflowInvoker(runtime);
+  const auto = command({
+    name: "auto",
+    args: { target: targetArgument(), local: flag({ long: "local" }), background: flag({ long: "bg" }) },
+    handler: async ({ target, local, background }) => invokeWorkflow({
+      workflow: "auto",
+      arguments: { target, local, background },
+      agent: "reviewer",
+      isBackground: background
+    })
+  });
+  const create = command({
+    name: "new",
+    args: {
+      intent: option({ long: "intent", type: optional(string5), defaultValue: () => {
+        return;
+      } }),
+      base: option({ long: "base", type: optional(string5), defaultValue: () => {
+        return;
+      } }),
+      local: flag({ long: "local" }),
+      background: flag({ long: "bg" }),
+      title: restPositionals({ type: string5 })
+    },
+    handler: async ({ title, intent, base, local, background }) => invokeWorkflow({
+      workflow: "new",
+      arguments: { title: title.length ? title.join(" ") : undefined, intent, base, local, background },
+      agent: "orchestrator",
+      isBackground: background
+    })
+  });
+  const edit = command({
+    name: "edit",
+    args: { target: targetArgument(), local: flag({ long: "local" }), background: flag({ long: "bg" }) },
+    handler: async ({ target, local, background }) => invokeWorkflow({
+      workflow: "edit",
+      arguments: { target, local, background },
+      agent: "orchestrator",
+      isBackground: background
+    })
+  });
+  const address = command({
+    name: "address",
+    args: { target: targetArgument(), local: flag({ long: "local" }), background: flag({ long: "bg" }) },
+    handler: async ({ target, local, background }) => invokeWorkflow({
+      workflow: "address",
+      arguments: { target, local, background },
+      agent: "reviewer",
+      isBackground: background
+    })
+  });
+  const publish = command({
+    name: "publish",
+    args: {
+      target: targetArgument(),
+      comment: flag({ long: "comment" }),
+      approve: flag({ long: "approve" }),
+      requestChanges: flag({ long: "request-changes" }),
+      close: flag({ long: "close" }),
+      background: flag({ long: "bg" })
+    },
+    handler: async ({ target, comment, approve, requestChanges, close, background }) => invokeWorkflow({
+      workflow: "publish",
+      arguments: { target, comment, approve, requestChanges, close, background },
+      agent: "orchestrator",
+      isBackground: background
+    })
+  });
+  const complete = command({
+    name: "complete",
+    args: {
+      target: targetArgument(),
+      local: flag({ long: "local" }),
+      approve: flag({ long: "approve" }),
+      reject: flag({ long: "reject" }),
+      abandon: flag({ long: "abandon" }),
+      background: flag({ long: "bg" })
+    },
+    handler: async ({ target, local, approve, reject, abandon, background }) => invokeWorkflow({
+      workflow: "complete",
+      arguments: { target, local, approve, reject, abandon, background },
+      agent: "orchestrator",
+      isBackground: background
+    })
+  });
+  const merge = command({
+    name: "merge",
+    args: { target: targetArgument(), background: flag({ long: "bg" }) },
+    handler: async ({ target, background }) => invokeWorkflow({
+      workflow: "merge",
+      arguments: { target, background },
+      agent: "orchestrator",
+      isBackground: background
+    })
+  });
+  const help = command({
+    name: "help",
+    args: {},
+    handler: async () => invokeWorkflow({ workflow: "help", arguments: {}, agent: "orchestrator" })
+  });
+  return subcommands({
+    name: "review",
+    cmds: {
+      auto,
+      new: create,
+      edit,
+      address,
+      publish,
+      complete,
+      merge,
+      help,
+      open: create,
+      create,
+      draft: create,
+      launch: auto,
+      ready: publish,
+      close: complete,
+      land: merge
+    }
+  });
 }
-function hasFlag2(input, flag) {
-  return input.split(/\s+/).includes(flag);
+function createReviewWorkflowInvoker(runtime) {
+  return async function invokeWorkflow(invocation) {
+    const { workflow, arguments: args, agent, isBackground = false } = invocation;
+    const prompt = await loadReviewWorkflow(workflow, args);
+    if (isBackground) {
+      await launchBackgroundAgent(runtime.pi.events, {
+        name: `Review ${workflow}`,
+        agent: "orchestrator",
+        cwd: runtime.ctx.cwd,
+        inheritContext: true,
+        prompt
+      });
+      return;
+    }
+    const activation = await runtime.modes.set(agent, runtime.ctx);
+    runtime.pi.sendMessage({
+      customType: `diffpi-review-${workflow}-command`,
+      display: false,
+      content: `${prompt}
+
+${activation.message}`
+    }, { triggerTurn: true });
+  };
 }
-function withoutFlag(input, flag) {
-  return input.split(/\s+/).filter((token) => token && token !== flag).join(" ").trim();
+function targetArgument() {
+  return positional({ type: optional(string5), displayName: "target" });
 }
 
 // src/commands/index.ts
@@ -17774,18 +17906,6 @@ async function reviewsDir(cwd, homeDir = homedir5()) {
   await mkdir2(dir, { recursive: true });
   return dir;
 }
-async function completedReviewsDir(cwd, homeDir = homedir5()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join11(store.link, "reviews");
-  await mkdir2(dir, { recursive: true });
-  return dir;
-}
-async function sessionsDir(cwd, homeDir = homedir5()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join11(store.link, "sessions");
-  await mkdir2(dir, { recursive: true });
-  return dir;
-}
 async function assertStoreLink(path, dest) {
   const entry = await lstat(path);
   if (!entry.isSymbolicLink())
@@ -24608,10 +24728,10 @@ function result2(text, details = {}) {
 
 // src/tools/review.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { mkdir as mkdir7, readdir as readdir3, readFile as readFile14, rename as rename3, stat, unlink as unlink2, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdir as mkdir8, writeFile as writeFile6 } from "node:fs/promises";
 import { join as join21 } from "node:path";
 import { defineTool as defineTool6 } from "@earendil-works/pi-coding-agent";
-import { z as z13 } from "zod";
+import { z as z11 } from "zod";
 
 // src/review/types.ts
 import { z as z10 } from "zod";
@@ -24636,21 +24756,6 @@ function yymmdd(date = new Date) {
 function reviewRecordName(target, date = new Date) {
   return `${yymmdd(date)}-${reviewSlug(target) || "uncommitted"}`;
 }
-function localResponseMarker(threadId) {
-  return `<!-- diffpi -->`;
-}
-function isLocalResponse(body) {
-  return /^<!-- diffpi(?:-local-response:[A-Za-z0-9_-]+)? -->\n/m.test(body);
-}
-function parseReviewThreadAction(body) {
-  const match = body.match(/^\[(REOPEN|RESOLVE|DELETE)\]\s*/i);
-  if (!match)
-    return { body };
-  return {
-    action: match[1].toLowerCase(),
-    body: body.slice(match[0].length)
-  };
-}
 function dedupeFindings(findings) {
   const rank = { BLOCKING: 3, CONSIDER: 2, NOTE: 1 };
   const byKey = new Map;
@@ -24696,18 +24801,6 @@ function renderCommentBody(finding) {
   return `${prefix}${finding.body}${reference}`;
 }
 // src/review/review-markdown.ts
-import { z as z11 } from "zod";
-var reviewThreadRecordSchema = z11.object({
-  id: z11.string().min(1),
-  file: z11.string().nullable().optional().transform((value) => value ?? undefined),
-  line: z11.number().int().positive().nullable().optional().transform((value) => value ?? undefined),
-  body: z11.string(),
-  author: z11.string().optional(),
-  resolved: z11.boolean(),
-  addressed: z11.boolean().optional(),
-  question: z11.boolean(),
-  replies: z11.array(z11.string()).optional()
-});
 function renderReviewDoc(input) {
   const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
   const lines = [`# Review: ${input.title}`, "", "## Metadata"];
@@ -24749,88 +24842,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 = z11.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 () => {
@@ -24892,9 +24903,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,
@@ -24904,7 +24912,6 @@ function GitHubReviewBackend(vcs, number) {
     });
   };
   return {
-    kind: "remote",
     async stage(draft) {
       const pending = await pendingReview();
       if (!pending) {
@@ -24962,33 +24969,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();
@@ -25005,32 +24985,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}`
         ]);
       }
     },
@@ -25049,13 +25011,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) {
@@ -25092,7 +25052,6 @@ function GitLabReviewBackend(vcs, number) {
     });
   };
   return {
-    kind: "remote",
     async stage(draft) {
       const endpoint = `${mergeRequestEndpoint()}/draft_notes`;
       if (draft.body.trim()) {
@@ -25121,36 +25080,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)}`;
@@ -25162,15 +25091,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);
@@ -25210,8 +25131,17 @@ function hasGitlabDraftNotes(input) {
   }
 }
 
-// src/review/local-review-backend.ts
-import { readFile as readFile12, writeFile as writeFile5 } 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 mkdir7, readdir as readdir3, readFile as readFile12, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
+import { join as join20 } from "node:path";
 
 // src/extensions/tuicrx.ts
 import { readFile as readFile11, realpath as realpath4 } from "node:fs/promises";
@@ -25282,11 +25212,6 @@ async function resolveReviewSession(cwd, target) {
   }
   return resolveSession(cwd, target.branch);
 }
-async function resolvePublishSession(cwd, target) {
-  if (target.owner && target.repo && target.number !== undefined)
-    return resolvePrSession(cwd, target.owner, target.repo, target.number);
-  return resolveSession(cwd, target.branch);
-}
 async function resolvePrSession(cwd, owner, repo, number) {
   const coordinate = `${owner}/${repo}`.toLowerCase();
   const sessions = await listSessions(cwd);
@@ -25321,8 +25246,6 @@ async function readSession(path) {
 function toLocalReviewThreads(session) {
   const threads = [];
   const add = (comment, location = {}) => {
-    if (isLocalResponse(comment.content))
-      return;
     const author = commentAuthor(comment);
     threads.push({
       id: comment.id ?? `local-${threads.length + 1}`,
@@ -25348,54 +25271,6 @@ function toLocalReviewThreads(session) {
   }
   return threads;
 }
-function toFindings(session, options = {}) {
-  const comments = [];
-  const include = (comment) => (!options.agentOnly || commentAuthor(comment)?.startsWith("Agent: ")) && (!options.excludeLocalResponses || !isLocalResponse(comment.content));
-  const publishableBody = (comment) => {
-    const author = commentAuthor(comment);
-    const route = author?.match(/^Agent:\s*(.+)$/)?.[1];
-    return route ? withRemoteProvenance(comment.content, route) : comment.content;
-  };
-  const bodyParts = (session.review_comments ?? []).flatMap((comment) => include(comment) ? [publishableBody(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 [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);
-      }
-    }
-  }
-  return { comments, body: bodyParts.join(`
-
-`) };
-}
 async function requireTuicr() {
   if (!await tuicrAvailable())
     throw new Error("tuicr is not installed or is not available on PATH.");
@@ -25411,167 +25286,83 @@ async function canonicalPath3(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 readFile12(options.artifactPath, "utf8"));
-      } catch (error) {
-        if (error.code === "ENOENT")
-          return [];
-        throw error;
-      }
-    },
-    async reply(input) {
-      const content = await readFile12(options.artifactPath, "utf8");
-      await writeFile5(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 = join20(await reviewsDir(input.cwd, input.homeDir), id);
+  await mkdir7(dir, { recursive: true });
+  const revision = await nextRevision(dir);
+  const output = await readFile12(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 }
   };
+  const path = join20(dir, `${revision}.json`);
+  await writeFile5(path, `${JSON.stringify(dump, null, 2)}
+`, { encoding: "utf8", flag: "wx" });
+  await unlink2(input.session.path);
+  return { path, dump };
 }
-
-// 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 readFile13, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join20 } from "node:path";
-import { z as z12 } from "zod";
-var reviewPublicationStateSchema = z12.object({
-  target: z12.string().optional(),
-  bodies: z12.array(z12.string()).default([]),
-  comments: z12.array(z12.string()).default([]),
-  stagedComments: z12.array(z12.string()).default([]),
-  replies: z12.array(z12.string()).default([]),
-  overlayPath: z12.string().optional()
-});
-function reviewBodyFingerprint(body) {
-  return digest(body);
-}
-function reviewCommentFingerprint(comment) {
-  return digest([comment.file, String(comment.line), comment.side ?? "RIGHT", comment.body].join("\x00"));
-}
-function reviewReplyFingerprint(threadId, body) {
-  return digest(`${threadId}\x00${body}`);
-}
-function unpublishedReviewComments(comments, knownFingerprints) {
-  return comments.filter((comment) => !knownFingerprints.has(reviewCommentFingerprint(comment)));
+async function nextRevision(dir) {
+  return await latestRevision(dir) + 1;
 }
-async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
-  const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
-  const path = join20(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+async function latestRevision(dir) {
   try {
-    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile13(path, "utf8")));
-    return { path, state: { ...parsed, target } };
+    return (await readdir3(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 z12.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 writeFile6(temp, `${JSON.stringify(state, null, 2)}
-`, "utf8");
-  await rename2(temp, path);
-}
-function digest(value) {
-  return createHash2("sha256").update(value).digest("hex");
-}
 // src/tools/review.ts
-var contextSchema = z13.object({
-  cwd: z13.string().optional(),
-  target: z13.string().optional(),
-  workingTree: z13.boolean().optional()
+var contextSchema = z11.object({
+  cwd: z11.string().optional(),
+  target: z11.string().optional(),
+  workingTree: z11.boolean().optional()
 });
-var localSchema = contextSchema.extend({ local: z13.boolean().optional() });
+var localSchema = contextSchema.extend({ local: z11.boolean().optional() });
 var openSchema = localSchema.extend({
-  title: z13.string().optional(),
-  intent: z13.string().optional(),
-  issueUrl: z13.string().url().optional(),
-  base: z13.string().optional()
+  title: z11.string().optional(),
+  intent: z11.string().optional(),
+  issueUrl: z11.string().url().optional(),
+  base: z11.string().optional()
 });
 var submitSchema = localSchema.extend({
   findings: findingsSchema,
-  overallIssues: z13.array(z13.string()).optional(),
-  notVerified: z13.array(z13.string()).optional(),
-  title: z13.string().optional()
+  overallIssues: z11.array(z11.string()).optional(),
+  notVerified: z11.array(z11.string()).optional(),
+  title: z11.string().optional()
 });
 var addCommentSchema = localSchema.extend({
-  body: z13.string().min(1),
-  file: z13.string().min(1),
-  line: z13.number().int().positive(),
-  side: z13.enum(["LEFT", "RIGHT"]).optional()
+  body: z11.string().min(1),
+  file: z11.string().min(1),
+  line: z11.number().int().positive(),
+  side: z11.enum(["LEFT", "RIGHT"]).optional()
 });
 var respondSchema = localSchema.extend({
-  threadId: z13.string().min(1),
-  body: z13.string().min(1),
-  question: z13.boolean().optional(),
-  resolve: z13.boolean().optional()
+  threadId: z11.string().min(1),
+  body: z11.string().min(1),
+  question: z11.boolean().optional(),
+  resolve: z11.boolean().optional()
 });
 var publishSchema = localSchema.extend({
-  status: z13.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
+  status: z11.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
 });
 var completeSchema = localSchema.extend({
-  action: z13.enum(["approve", "reject", "abandon"]).optional()
+  action: z11.enum(["approve", "reject", "abandon"]).optional()
 });
-function hasReviewDraft(comments, body) {
-  return comments.length > 0 || body.trim().length > 0;
-}
-function partitionReviewComments(comments, knownFingerprints, model) {
-  const normalized = comments.map((comment) => {
-    const published = { ...comment, body: withCommentProvenance(comment, model) };
-    return { source: comment, published, fingerprint: reviewCommentFingerprint(published) };
-  });
-  return {
-    checkpointed: normalized.filter((comment) => knownFingerprints.has(comment.fingerprint)),
-    candidates: normalized.filter((comment) => !knownFingerprints.has(comment.fingerprint))
-  };
-}
-function resolveReviewThread(comment, threads) {
-  const sourceCommentId = comment.sourceCommentId;
-  if (sourceCommentId) {
-    const identified = threads.find((thread) => thread.id === sourceCommentId || thread.rootCommentId === sourceCommentId || thread.commentIds?.includes(sourceCommentId));
-    if (identified)
-      return identified;
-  }
-  const matches = threads.filter((thread) => thread.file === comment.file && (thread.line ?? undefined) === (comment.line ?? undefined));
-  if (matches.length > 1)
-    throw new Error(`Ambiguous remote review threads at ${comment.file}:${comment.line ?? "file"}: ${matches.map((thread) => thread.id).join(", ")}.`);
-  return matches[0];
-}
 async function workingTreeDiff(cwd) {
   const tracked = await run2("git", ["-C", cwd, "diff", "HEAD"], { capture: "unbounded" });
   if (tracked.code !== 0)
@@ -25767,7 +25558,7 @@ ${openMessage}`, {
         const gates = await runMiseGates(review.cwd);
         const baseRef = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "local");
         const artifact = await newReviewArtifactPath(review.cwd, params.local || params.workingTree || !review.pr ? "uncommitted" : await reviewTargetId(review));
-        await writeFile7(artifact, renderReviewDoc({
+        await writeFile6(artifact, renderReviewDoc({
           title: params.title ?? review.pr?.title ?? review.vcs.branch,
           number: useLocalBackend ? undefined : review.pr?.number,
           url: useLocalBackend ? undefined : review.pr?.url,
@@ -25790,17 +25581,21 @@ ${openMessage}`, {
               count: findings.length
             });
           }
-          const backend = createLocalReviewBackend({
-            session: session.path,
-            artifactPath: artifact,
-            author: localReviewAuthor(model)
-          });
-          await backend.stage({ comments, body });
+          for (const comment of comments) {
+            await addComment(session.path, comment.body, {
+              targetFile: comment.file,
+              line: comment.line,
+              side: comment.side === "LEFT" ? "old" : "new",
+              username: localReviewAuthor(model)
+            });
+          }
+          if (body.trim())
+            await addComment(session.path, body, { username: localReviewAuthor(model) });
           return result3(`Local review staged in tuicr: ${artifact}`, { artifact, count: findings.length, session });
         }
         if (!review.pr)
           return result3(`Review written: ${artifact}. No PR/MR matches this remote target.`, { artifact });
-        const hasDraft = hasReviewDraft(comments, body);
+        const hasDraft = comments.length > 0 || body.trim().length > 0;
         if (hasDraft) {
           await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments, body });
         }
@@ -25836,12 +25631,12 @@ ${openMessage}`, {
           const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
           if (!session)
             return result3("No matching tuicr session. Open review_new or review_launch_ui first.");
-          const backend = createLocalReviewBackend({
-            session: session.path,
-            artifactPath: "",
-            author: localReviewAuthor(model)
+          await addComment(session.path, comment.body, {
+            targetFile: comment.file,
+            line: comment.line,
+            side: comment.side === "LEFT" ? "old" : "new",
+            username: localReviewAuthor(model)
           });
-          await backend.stage({ comments: [comment], body: "" });
           return result3(`Comment added to tuicr session ${session.slug}.`, { session, comment });
         }
         if (!review.pr)
@@ -25853,88 +25648,70 @@ ${openMessage}`, {
     defineTool6({
       name: "review_comments",
       label: "review comments",
-      description: "Pull review threads or local tuicr comments and write a target-named artifact.",
-      promptSnippet: "Call review_comments before addressing findings",
-      promptGuidelines: ["Pass local=true to prepare the local reply overlay."],
+      description: "Read remote GitHub or GitLab review threads.",
+      promptSnippet: "Call review_comments before addressing remote findings",
+      promptGuidelines: ["Use review_dump for a local tuicr review."],
       parameters: parameters6(localSchema),
-      executionMode: "sequential",
+      executionMode: "parallel",
       async execute(_id, input) {
         const params = localSchema.parse(input);
+        if (params.local || params.workingTree)
+          return result3("Use review_dump for a local tuicr review.");
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
-        let threads;
-        let artifact;
-        if (params.local || params.workingTree) {
-          const session = await resolveTuicrSession(review, true);
-          if (!session)
-            return result3("No matching tuicr session found.");
-          artifact = await localThreadArtifactPath(review.cwd, session.slug);
-          threads = await syncLocalThreadArtifact(artifact, review.pr?.title ?? review.vcs.branch, session.slug, toLocalReviewThreads(await readSession(session.path)));
-        } else if (review.pr && review.forge) {
-          threads = await createRemoteReviewBackend(review.vcs, review.pr.number).listThreads();
-          const target = await reviewTargetId(review);
-          artifact = await newReviewArtifactPath(review.cwd, target);
-          await writeFile7(artifact, renderThreadArtifact(review.pr.title, target, threads, { number: review.pr.number, url: review.pr.url }), "utf8");
-        } else {
+        if (!review.pr || !review.forge)
           return result3(review.forge ? "No PR/MR matches this remote review target." : unsupportedForgeMessage());
-        }
+        const threads = await createRemoteReviewBackend(review.vcs, review.pr.number).listThreads();
         return result3(threads.map((thread) => `${thread.id} ${thread.file ?? "review"}:${thread.line ?? "-"} — ${thread.body}`).join(`
-`) || "No comments.", { artifact, threads });
+`) || "No comments.", { pr: review.pr, threads });
+      }
+    }),
+    defineTool6({
+      name: "review_dump",
+      label: "review dump",
+      description: "Save one immutable local tuicr review revision and remove its completed session.",
+      promptSnippet: "Call review_dump before applying local review feedback",
+      promptGuidelines: ["Each dump advances the local review revision."],
+      parameters: parameters6(localSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const session = await resolveTuicrSession(review, true);
+        if (!session)
+          return result3("No matching local tuicr session found.");
+        const base = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "HEAD");
+        const captured = await captureLocalReview({
+          cwd: review.cwd,
+          branch: review.vcs.branch,
+          base,
+          diff: await workingTreeDiff(review.cwd),
+          session
+        });
+        return result3(captured.dump.comments.map((thread) => `${thread.id} ${thread.file ?? "review"}:${thread.line ?? "-"} — ${thread.body}`).join(`
+`) || "No comments.", { artifact: captured.path, review: captured.dump, threads: captured.dump.comments });
       }
     }),
     defineTool6({
       name: "review_respond",
       label: "review respond",
-      description: "Post local question replies to tuicr and record their publish overlay, or reply to remote threads.",
-      promptSnippet: "Call review_respond after addressing a comment",
-      promptGuidelines: ["Question replies remain unresolved."],
+      description: "Reply directly to a remote GitHub or GitLab review thread.",
+      promptSnippet: "Call review_respond after addressing a remote comment",
+      promptGuidelines: ["Leave threads open unless the user explicitly requests resolution."],
       parameters: parameters6(respondSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = respondSchema.parse(input);
+        if (params.local)
+          return result3("Local reviews use immutable revision dumps, not thread replies.");
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
-        const model = modelRoute(ctx);
-        if (params.local) {
-          const tuicrSession = await resolveTuicrSession(review, true);
-          if (!tuicrSession)
-            return result3("No matching tuicr session. Open review_new or review_launch_ui first.");
-          const artifact = await localThreadArtifactPath(review.cwd, tuicrSession.slug);
-          if (!existsSync3(artifact))
-            return result3("No local review artifact. Run review_comments with local=true first.");
-          const threads = await readThreadArtifact(artifact);
-          const known = threads.find((thread) => thread.id === params.threadId);
-          const question = known?.question === true || params.question === true || !known && params.question === undefined;
-          const awaitUserDeletion = !question && params.resolve === true;
-          await addComment(tuicrSession.path, `${localResponseMarker(params.threadId)}
-${params.body}`, {
-            targetFile: known?.file,
-            line: known?.line,
-            side: "new",
-            username: localReviewAuthor(model)
-          });
-          await createLocalReviewBackend({
-            session: tuicrSession.path,
-            artifactPath: artifact,
-            author: localReviewAuthor(model)
-          }).reply({
-            threadId: params.threadId,
-            body: params.body,
-            resolve: false,
-            question
-          });
-          return result3(`Local ${question ? "answer" : "response"} posted to tuicr and recorded in ${artifact}${awaitUserDeletion ? "; delete the source comment in tuicr to resolve it" : ""}.`, { artifact, question, awaitUserDeletion, session: tuicrSession });
-        }
         if (!review.pr || !review.forge)
           return result3("No remote PR/MR for this reply.");
-        const remote = createRemoteReviewBackend(review.vcs, review.pr.number);
-        const remoteThreads = await remote.listThreads();
-        const known = remoteThreads.find((thread) => thread.id === params.threadId);
-        const question = known?.question === true || params.question === true || !known && params.question === undefined;
-        const resolve = question ? false : params.resolve ?? true;
-        await remote.reply({
+        const resolve = params.question ? false : params.resolve ?? false;
+        await createRemoteReviewBackend(review.vcs, review.pr.number).reply({
           threadId: params.threadId,
-          body: withRemoteProvenance(params.body, model),
+          body: withRemoteProvenance(params.body, modelRoute(ctx)),
           resolve,
-          question
+          question: params.question
         });
         return result3(`Replied to ${params.threadId}${resolve ? " and resolved it" : " and left it open"}.`, {
           pr: review.pr,
@@ -25945,51 +25722,40 @@ ${params.body}`, {
     defineTool6({
       name: "review_publish",
       label: "review publish",
-      description: "Publish pending remote draft PR/MR review comments and status, or promote a local tuicr draft before publishing.",
+      description: "Publish pending remote review comments and status.",
       promptSnippet: "Call review_publish to make remote review work public",
-      promptGuidelines: ["Statuses are COMMENT, APPROVE, REQUEST_CHANGES, or CLOSE."],
+      promptGuidelines: ["Local reviews use revision dumps and are never published remotely."],
       parameters: parameters6(publishSchema),
       executionMode: "sequential",
-      async execute(_id, input, _signal, _onUpdate, ctx) {
+      async execute(_id, input) {
         const params = publishSchema.parse(input);
+        if (params.local)
+          return result3("Local reviews use immutable revision dumps and have no publish step.");
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         if (!review.pr || !review.forge)
           return result3("No remote PR/MR to publish.");
-        return publishResolvedReview(review, params, modelRoute(ctx));
+        return publishResolvedReview(review, params);
       }
     }),
     defineTool6({
       name: "review_complete",
       label: "review complete",
-      description: "Approve, reject, or abandon a remote review, or archive a local review artifact.",
-      promptSnippet: "Call review_complete to finish a review without merging it.",
-      promptGuidelines: ["A local completion archives the Diffpi artifact and deletes the matching tuicr session."],
+      description: "Approve, reject, or abandon a remote review.",
+      promptSnippet: "Call review_complete to finish a remote review without merging it.",
+      promptGuidelines: ["Use review_dump to finish a local review revision."],
       parameters: parameters6(completeSchema),
       executionMode: "sequential",
-      async execute(_id, input, _signal, _onUpdate, ctx) {
+      async execute(_id, input) {
         const params = completeSchema.parse(input);
+        if (params.local)
+          return result3("Use review_dump to finish a local review revision.");
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
-        if (params.local) {
-          const session = await resolveTuicrSession(review, true);
-          if (!session)
-            return result3("No matching local tuicr session to close.");
-          const artifact = await localThreadArtifactPath(review.cwd, session.slug);
-          if (!existsSync3(artifact))
-            return result3("No local review artifact. Run review_comments with local=true first.");
-          const archived = await uniqueRecordPath(await completedReviewsDir(review.cwd), reviewSlug(session.slug));
-          await rename3(artifact, archived);
-          await unlink2(session.path);
-          return result3(`Archived ${archived} and deleted the tuicr session ${session.slug}.`, {
-            artifact: archived,
-            session
-          });
-        }
         if (!review.pr || !review.forge)
           return result3("No remote PR/MR to complete.");
         if (!params.action)
           return result3("Choose a complete action: approve, reject, or abandon.");
         const status = { approve: "APPROVE", reject: "REQUEST_CHANGES", abandon: "CLOSE" }[params.action];
-        return publishResolvedReview(review, { ...params, status }, modelRoute(ctx));
+        return publishResolvedReview(review, { ...params, status });
       }
     }),
     defineTool6({
@@ -25998,10 +25764,10 @@ ${params.body}`, {
       description: "Squash-merge an open, ready GitHub PR after checking its conventional subject.",
       promptSnippet: "Call review_merge after confirming the PR is open, ready, and CI is settled; approval is optional",
       promptGuidelines: ["This is intentionally GitHub-only until GitLab merge support is added."],
-      parameters: parameters6(contextSchema.extend({ subject: z13.string().optional() })),
+      parameters: parameters6(contextSchema.extend({ subject: z11.string().optional() })),
       executionMode: "sequential",
       async execute(_id, input) {
-        const params = contextSchema.extend({ subject: z13.string().optional() }).parse(input);
+        const params = contextSchema.extend({ subject: z11.string().optional() }).parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         if (review.vcs.provider !== "github" || !review.forge)
           return result3("review_merge currently supports GitHub only.");
@@ -26034,32 +25800,8 @@ ${params.body}`, {
     })
   ];
 }
-async function syncLocalThreadArtifact(path, title, sessionSlug, threads) {
-  let previous = [];
-  try {
-    previous = parseThreadArtifact(await readFile14(path, "utf8"));
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-  }
-  const previousById = new Map(previous.map((thread) => [thread.id, thread]));
-  const currentIds = new Set(threads.map((thread) => thread.id));
-  const current = threads.map((thread) => {
-    const existing = previousById.get(thread.id);
-    return {
-      ...thread,
-      resolved: false,
-      addressed: existing?.addressed ?? Boolean(existing?.reply),
-      reply: existing?.reply
-    };
-  });
-  const removed = previous.filter((thread) => !currentIds.has(thread.id)).map((thread) => ({ ...thread, resolved: true }));
-  const merged = [...current, ...removed];
-  await writeFile7(path, renderThreadArtifact(title, sessionSlug, merged), "utf8");
-  return merged;
-}
 function parameters6(schema) {
-  return z13.toJSONSchema(schema, { io: "input" });
+  return z11.toJSONSchema(schema, { io: "input" });
 }
 function resolveWorkingDirectory(params) {
   return params.cwd ?? process.cwd();
@@ -26075,159 +25817,17 @@ function modelRoute(ctx) {
     throw new Error("Cannot record review provenance because Pi did not provide an active model route.");
   return `${ctx.model.provider}/${ctx.model.id}`;
 }
-async function publishResolvedReview(review, params, model) {
+async function publishResolvedReview(review, params) {
   const status = params.status ?? "COMMENT";
   const event = status === "CLOSE" ? "COMMENT" : status;
   assertReviewEventSupported(review.vcs.provider, event);
-  const remote = createRemoteReviewBackend(review.vcs, review.pr.number);
-  const promotion = params.local ? await promoteLocalReview(review, remote, model) : undefined;
   if (status !== "CLOSE" && review.pr.isDraft)
     await review.forge.markReady(review.pr.number);
-  await remote.publish(event);
-  if (promotion) {
-    promotion.publication.state.bodies = [
-      ...new Set([...promotion.publication.state.bodies, ...promotion.bodyFingerprints])
-    ];
-    promotion.publication.state.comments = [
-      ...new Set([...promotion.publication.state.comments, ...promotion.commentFingerprints])
-    ];
-    const published = new Set(promotion.commentFingerprints);
-    promotion.publication.state.stagedComments = promotion.publication.state.stagedComments.filter((fingerprint) => !published.has(fingerprint));
-    await saveReviewPublicationState(promotion.publication.path, promotion.publication.state);
-  }
+  await createRemoteReviewBackend(review.vcs, review.pr.number).publish(event);
   if (status === "CLOSE")
     await review.forge.closePr(review.pr.number);
   const finalPr = await review.forge.viewPr(String(review.pr.number));
-  const promotedBodies = promotion?.promotedBodies ?? 0;
-  const promotedComments = promotion?.promotedComments ?? 0;
-  const promotedReplies = promotion?.promotedReplies ?? 0;
-  return result3(`Published #${review.pr.number} (${status}); promoted ${promotedBodies} review bodies, ${promotedComments} comments, and ${promotedReplies} replies.`, { pr: finalPr ?? review.pr, status, promotedBodies, promotedComments, promotedReplies });
-}
-async function promoteLocalReview(review, remote, model) {
-  const publication = await loadReviewPublicationState(review.cwd, review.vcs, review.pr.number);
-  const session = await resolvePublishSession(review.cwd, {
-    branch: review.vcs.branch,
-    owner: review.vcs.provider === "none" ? undefined : review.vcs.owner,
-    repo: review.vcs.provider === "none" ? undefined : review.vcs.repo,
-    number: review.pr?.number
-  });
-  if (!session)
-    throw new Error("No matching tuicr session to publish.");
-  const sessionIsWorkingTree = session.kind === "local";
-  const local = createLocalReviewBackend({
-    session: session.path,
-    artifactPath: "",
-    author: localReviewAuthor(model)
-  });
-  const draft = await local.readDraft();
-  const remoteDraft = await remote.readDraft();
-  const knownRootComments = new Set([
-    ...publication.state.comments,
-    ...publication.state.stagedComments,
-    ...remoteDraft.comments.map(reviewCommentFingerprint)
-  ]);
-  const { checkpointed, candidates } = partitionReviewComments(draft.comments, knownRootComments, model);
-  const remoteThreads = await remote.listThreads();
-  const threadReplies = sessionIsWorkingTree ? [] : candidates.flatMap(({ source: comment }) => {
-    const thread = resolveReviewThread(comment, remoteThreads);
-    return thread ? [{ comment, thread }] : [];
-  });
-  const unmatchedActions = sessionIsWorkingTree ? [] : candidates.map(({ source }) => source).filter((comment) => parseReviewThreadAction(comment.body).action && !threadReplies.some((reply) => reply.comment === comment));
-  if (unmatchedActions.length > 0) {
-    const locations = unmatchedActions.map(({ file, line }) => `${file}:${line ?? "?"}`).join(", ");
-    throw new Error(`Cannot apply review thread action: no matching remote thread at ${locations}.`);
-  }
-  const comments = candidates.filter(({ source }) => !threadReplies.some((reply) => reply.comment === source)).map(({ published }) => published);
-  const body = draft.body.trim();
-  const bodyFingerprints = body ? [reviewBodyFingerprint(body)] : [];
-  const commentFingerprints = [
-    ...checkpointed.map(({ fingerprint }) => fingerprint),
-    ...comments.map(reviewCommentFingerprint)
-  ];
-  const knownBodies = new Set(publication.state.bodies);
-  if (remoteDraft.body.trim())
-    knownBodies.add(reviewBodyFingerprint(remoteDraft.body));
-  const unpublishedBody = body && !knownBodies.has(reviewBodyFingerprint(body)) ? body : "";
-  const unpublished = unpublishedReviewComments(comments, knownRootComments);
-  if (unpublishedBody)
-    await remote.stage({ comments: [], body: unpublishedBody });
-  let promotedComments = 0;
-  for (const comment of unpublished) {
-    await remote.stage({ comments: [comment], body: "" });
-    publication.state.stagedComments.push(reviewCommentFingerprint(comment));
-    await saveReviewPublicationState(publication.path, publication.state);
-    promotedComments += 1;
-  }
-  const promotedReplies = await promoteLocalReplies(review, remote, publication, model, sessionIsWorkingTree) + await promoteLocationReplies(remote, publication, threadReplies, model);
-  return {
-    publication,
-    bodyFingerprints,
-    commentFingerprints,
-    promotedBodies: unpublishedBody ? 1 : 0,
-    promotedComments,
-    promotedReplies
-  };
-}
-async function promoteLocationReplies(remote, publication, replies, model) {
-  let count = 0;
-  for (const { comment, thread } of replies) {
-    const parsed = parseReviewThreadAction(comment.body);
-    const body = parsed.body.trim();
-    const action = parsed.action;
-    const fingerprint = reviewReplyFingerprint(thread.id, `${action ?? "reply"}\x00${body}`);
-    if (publication.state.replies.includes(fingerprint))
-      continue;
-    if (action === "delete") {
-      if (!remote.deleteThread)
-        throw new Error(`The review backend cannot delete thread ${thread.id}.`);
-      await remote.deleteThread(thread.id);
-      publication.state.replies.push(fingerprint);
-      await saveReviewPublicationState(publication.path, publication.state);
-      count += 1;
-      continue;
-    }
-    const remoteBody = withCommentProvenance({ ...comment, body }, model);
-    if (body && !thread.replies?.some((reply) => reply === body || reply === remoteBody)) {
-      await remote.reply({
-        threadId: thread.id,
-        body: remoteBody,
-        resolve: false
-      });
-    }
-    if (action && remote.setResolved)
-      await remote.setResolved(thread.id, action === "resolve");
-    publication.state.replies.push(fingerprint);
-    await saveReviewPublicationState(publication.path, publication.state);
-    count += 1;
-  }
-  return count;
-}
-async function promoteLocalReplies(review, remote, publication, model, workingTree) {
-  const target = workingTree ? "uncommitted" : await reviewTargetId(review);
-  const artifact = workingTree ? await latestThreadArtifact(review.cwd, review, target) : publication.state.overlayPath ?? await latestThreadArtifact(review.cwd, review, target);
-  if (!artifact)
-    return 0;
-  if (!workingTree)
-    publication.state.overlayPath = artifact;
-  let count = 0;
-  for (const thread of await readThreadArtifact(artifact)) {
-    if (!thread.reply)
-      continue;
-    const body = withRemoteProvenance(thread.reply, model);
-    const fingerprint = reviewReplyFingerprint(thread.id, body);
-    if (publication.state.replies.includes(fingerprint))
-      continue;
-    await remote.reply({
-      threadId: thread.id,
-      body,
-      resolve: !thread.question,
-      question: thread.question
-    });
-    publication.state.replies.push(fingerprint);
-    await saveReviewPublicationState(publication.path, publication.state);
-    count += 1;
-  }
-  return count;
+  return result3(`Published #${review.pr.number} (${status}).`, { pr: finalPr ?? review.pr, status });
 }
 async function resolveReviewContext(cwd, target) {
   const vcs = await detectVcs(cwd);
@@ -26268,10 +25868,6 @@ async function assertRemoteBranchReady(cwd) {
   if (head.stdout.trim() !== pushed.stdout.trim())
     throw new Error("Push the current branch before opening a remote review.");
 }
-function withCommentProvenance(comment, fallbackModel) {
-  const route = comment.author?.match(/^Agent:\s*(.+)$/)?.[1];
-  return route ? withRemoteProvenance(comment.body, route || fallbackModel) : comment.body;
-}
 async function reviewTargetId(review) {
   if (!review.pr)
     return "uncommitted";
@@ -26288,60 +25884,9 @@ async function headSha(cwd) {
 }
 async function newReviewArtifactPath(cwd, target) {
   const dir = await reviewsDir(cwd);
-  await mkdir7(dir, { recursive: true });
+  await mkdir8(dir, { recursive: true });
   return uniqueRecordPath(dir, reviewRecordName(target));
 }
-async function localThreadArtifactPath(cwd, sessionSlug) {
-  const dir = await reviewsDir(cwd);
-  return join21(dir, `${reviewSlug(sessionSlug) || "local-review"}.md`);
-}
-async function readThreadArtifact(path) {
-  try {
-    return parseThreadArtifact(await readFile14(path, "utf8"));
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      throw new Error(`Expected local reply overlay is missing: ${path}`);
-    }
-    throw error;
-  }
-}
-async function latestThreadArtifact(cwd, review, target) {
-  try {
-    return await findLatestThreadArtifact(cwd, review, target);
-  } catch (error) {
-    throw new Error(`Cannot locate the latest review thread artifact for ${target}.`, { cause: error });
-  }
-}
-async function findLatestThreadArtifact(cwd, review, target) {
-  const dir = await reviewsDir(cwd);
-  const suffix = reviewSlug(target) || "uncommitted";
-  const names = await listReviewArtifactNames(dir);
-  const candidates = await Promise.all(names.flatMap((name) => {
-    if (!name.endsWith(".md"))
-      return [];
-    return [
-      (async () => {
-        const path = join21(dir, name);
-        const info = await stat(path);
-        return { path, name, content: await readFile14(path, "utf8"), modified: info.mtimeMs };
-      })()
-    ];
-  }));
-  return candidates.filter(({ name, content }) => {
-    if (!content.startsWith("<!-- diffpi-threads:"))
-      return false;
-    if (review.pr && target !== "local" && target !== "uncommitted")
-      return content.includes(`- PR/MR: #${review.pr.number}`);
-    return artifactNameMatches(name, suffix);
-  }).sort((a, b) => b.modified - a.modified)[0]?.path;
-}
-async function listReviewArtifactNames(dir) {
-  try {
-    return await readdir3(dir);
-  } catch (error) {
-    throw new Error(`Cannot read review artifacts in ${dir}.`, { cause: error });
-  }
-}
 function deriveTitle(branch) {
   return branch.replace(/^(feature|feat|fix|bug|chore)\//, "").replace(/^eng-\d+-/i, "").replace(/[-_]+/g, " ").replace(/^\w/, (char) => char.toUpperCase());
 }
@@ -26352,30 +25897,19 @@ function uniqueRecordPath(dir, base) {
     path = join21(dir, `${base}-${count++}.md`);
   return path;
 }
-function artifactNameMatches(name, suffix) {
-  if (!name.endsWith(".md"))
-    return false;
-  const stem = name.slice(0, -3);
-  const marker = `-${suffix}`;
-  const markerIndex = stem.lastIndexOf(marker);
-  if (markerIndex < 0)
-    return false;
-  const tail = stem.slice(markerIndex + marker.length);
-  return tail === "" || /^-\d+$/.test(tail);
-}
 
 // src/tools/setup.ts
 import { defineTool as defineTool7 } from "@earendil-works/pi-coding-agent";
-import { z as z14 } from "zod";
+import { z as z12 } from "zod";
 
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter3 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir4, readFile as readFile16 } from "node:fs/promises";
+import { readdir as readdir4, readFile as readFile14 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
 import { basename as basename7, join as join24 } from "node:path";
 
 // src/mcp.ts
-import { mkdir as mkdir8, readFile as readFile15, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname9, join as join22 } from "node:path";
 var mcp = {
@@ -26393,8 +25927,8 @@ var mcp = {
     const next = { ...current, mcpServers: nextServers };
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
-      await mkdir8(dirname9(path), { recursive: true });
-      await writeFile8(path, `${JSON.stringify(next, null, 2)}
+      await mkdir9(dirname9(path), { recursive: true });
+      await writeFile7(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -26423,7 +25957,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile15(path, "utf8");
+    return await readFile13(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -26435,7 +25969,7 @@ function isRecord(value) {
 }
 
 // src/pi.ts
-import { mkdir as mkdir9, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir10, writeFile as writeFile8 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
 import { dirname as dirname10, join as join23 } from "node:path";
 var pi = {
@@ -26454,8 +25988,8 @@ async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(),
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
-    await mkdir9(dirname10(path), { recursive: true });
-    await writeFile9(path, content, "utf8");
+    await mkdir10(dirname10(path), { recursive: true });
+    await writeFile8(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
@@ -26491,8 +26025,8 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const next = update(current);
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
-    await mkdir9(dirname10(path), { recursive: true });
-    await writeFile9(path, `${JSON.stringify(next, null, 2)}
+    await mkdir10(dirname10(path), { recursive: true });
+    await writeFile8(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -26630,7 +26164,7 @@ async function ensurePiAgents(options = {}) {
   const actions = [];
   for (const entry of entries) {
     const id = basename7(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile16(join24(bundledAgentsDir, entry.name), "utf8");
+    const source = await readFile14(join24(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));
@@ -26835,7 +26369,7 @@ function reportProgress(options, message) {
   options.onProgress?.(message);
 }
 async function packageVersion2() {
-  const source = await readFile16(join24(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
+  const source = await readFile14(join24(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
   let value;
   try {
     value = JSON.parse(source);
@@ -26851,13 +26385,13 @@ function getRecord(value) {
 }
 
 // src/tools/setup.ts
-var setupParametersSchema = z14.object({
-  issueTracker: z14.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
-  forges: z14.array(z14.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
-  forge: z14.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
-  bindZedKey: z14.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
+var setupParametersSchema = z12.object({
+  issueTracker: z12.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
+  forges: z12.array(z12.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
+  forge: z12.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
+  bindZedKey: z12.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
 });
-var setupParameters = z14.toJSONSchema(setupParametersSchema, { io: "input" });
+var setupParameters = z12.toJSONSchema(setupParametersSchema, { io: "input" });
 var diffpiSetupTool = defineTool7({
   name: "diffpi_setup",
   label: "diffpi setup",
@@ -26930,11 +26464,11 @@ ${lines.join(`
 
 // src/tools/templates.ts
 import { defineTool as defineTool8 } from "@earendil-works/pi-coding-agent";
-import { z as z15 } from "zod";
-var templateSchema = z15.object({
-  name: z15.string().min(1),
-  variables: z15.record(z15.string(), z15.string()).optional(),
-  homeDir: z15.string().optional()
+import { z as z13 } from "zod";
+var templateSchema = z13.object({
+  name: z13.string().min(1),
+  variables: z13.record(z13.string(), z13.string()).optional(),
+  homeDir: z13.string().optional()
 });
 var diffpiTemplateTool = defineTool8({
   name: "diffpi_template",
@@ -26942,7 +26476,7 @@ var diffpiTemplateTool = defineTool8({
   description: "Load a bundled Diffpi template or a user override and render named variables.",
   promptSnippet: "Use diffpi_template for package workflow templates",
   promptGuidelines: ["User overrides live under ~/.difflab/diffpi/templates."],
-  parameters: z15.toJSONSchema(templateSchema, { io: "input" }),
+  parameters: z13.toJSONSchema(templateSchema, { io: "input" }),
   executionMode: "parallel",
   async execute(_id, input) {
     const params = templateSchema.parse(input);