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

package/dist/tools/index.js

@@ -1069,6 +1069,18 @@ async function reviewsDir(cwd, homeDir = homedir2()) {
   await mkdir2(dir, { recursive: true });
   return dir;
 }
+async function completedReviewsDir(cwd, homeDir = homedir2()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join6(store.link, "reviews");
+  await mkdir2(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir2()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join6(store.link, "sessions");
+  await mkdir2(dir, { recursive: true });
+  return dir;
+}
 async function assertStoreLink(path, dest) {
   const entry = await lstat(path);
   if (!entry.isSymbolicLink())
@@ -7891,10 +7903,10 @@ function result2(text, details = {}) {
 
 // src/tools/review.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir8, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir7, readdir as readdir2, readFile as readFile11, rename as rename3, stat, unlink as unlink2, writeFile as writeFile7 } from "node:fs/promises";
 import { join as join16 } from "node:path";
 import { defineTool as defineTool6 } from "@earendil-works/pi-coding-agent";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 
 // src/review/types.ts
 import { z as z8 } from "zod";
@@ -7919,6 +7931,21 @@ 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;
@@ -7964,6 +7991,18 @@ function renderCommentBody(finding) {
   return `${prefix}${finding.body}${reference}`;
 }
 // src/review/review-markdown.ts
+import { z as z9 } from "zod";
+var reviewThreadRecordSchema = z9.object({
+  id: z9.string().min(1),
+  file: z9.string().nullable().optional().transform((value) => value ?? undefined),
+  line: z9.number().int().positive().nullable().optional().transform((value) => value ?? undefined),
+  body: z9.string(),
+  author: z9.string().optional(),
+  resolved: z9.boolean(),
+  addressed: z9.boolean().optional(),
+  question: z9.boolean(),
+  replies: z9.array(z9.string()).optional()
+});
 function renderReviewDoc(input) {
   const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
   const lines = [`# Review: ${input.title}`, "", "## Metadata"];
@@ -8005,6 +8044,88 @@ 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 = z9.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 () => {
@@ -8066,6 +8187,9 @@ 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,
@@ -8075,6 +8199,7 @@ function GitHubReviewBackend(vcs, number) {
     });
   };
   return {
+    kind: "remote",
     async stage(draft) {
       const pending = await pendingReview();
       if (!pending) {
@@ -8132,6 +8257,33 @@ 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();
@@ -8148,14 +8300,32 @@ function GitHubReviewBackend(vcs, number) {
           `body=${input.body}`
         ]);
       }
-      if (input.resolve) {
+      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) {
         await ghChecked([
           "api",
           "graphql",
           "-f",
-          `query=${GITHUB_RESOLVE_MUTATION}`,
+          `query=${GITHUB_DELETE_COMMENT_MUTATION}`,
           "-f",
-          `threadId=${input.threadId}`
+          `commentId=${commentId}`
         ]);
       }
     },
@@ -8174,11 +8344,13 @@ 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{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{id,databaseId,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) {
@@ -8215,6 +8387,7 @@ function GitLabReviewBackend(vcs, number) {
     });
   };
   return {
+    kind: "remote",
     async stage(draft) {
       const endpoint = `${mergeRequestEndpoint()}/draft_notes`;
       if (draft.body.trim()) {
@@ -8243,6 +8416,36 @@ 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)}`;
@@ -8254,7 +8457,15 @@ function GitLabReviewBackend(vcs, number) {
         });
       }
       if (input.resolve)
-        await glabChecked(["api", "--method", "PUT", `${endpoint}?resolved=true`]);
+        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]);
     },
     async publish(event) {
       assertReviewEventSupported(vcs.provider, event);
@@ -8294,17 +8505,8 @@ function hasGitlabDraftNotes(input) {
   }
 }
 
-// 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 readdir2, readFile as readFile9, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+// src/review/local-review-backend.ts
+import { readFile as readFile9, writeFile as writeFile5 } from "node:fs/promises";
 
 // src/extensions/tuicrx.ts
 import { readFile as readFile8, realpath as realpath4 } from "node:fs/promises";
@@ -8375,6 +8577,11 @@ 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);
@@ -8409,6 +8616,8 @@ 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}`,
@@ -8434,6 +8643,54 @@ 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.");
@@ -8449,83 +8706,167 @@ async function canonicalPath3(path) {
   }
 }
 
-// src/review/local-reviews.ts
-async function captureLocalReview(input) {
-  const id = reviewSlug(input.branch) || "local-review";
-  const dir = join15(await reviewsDir(input.cwd, input.homeDir), id);
-  await mkdir7(dir, { recursive: true });
-  const revision = await nextRevision(dir);
-  const output = await readFile9(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/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 readFile9(options.artifactPath, "utf8"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          return [];
+        throw error;
+      }
+    },
+    async reply(input) {
+      const content = await readFile9(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.");
+    }
   };
-  const path = join15(dir, `${revision}.json`);
-  await writeFile5(path, `${JSON.stringify(dump, null, 2)}
-`, { encoding: "utf8", flag: "wx" });
-  await unlink2(input.session.path);
-  return { path, dump };
 }
-async function nextRevision(dir) {
-  return await latestRevision(dir) + 1;
+
+// 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.");
 }
-async function latestRevision(dir) {
+function createLocalReviewBackend(options) {
+  return LocalReviewBackend(options);
+}
+// src/review/review-state.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile10, rename as rename2, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join15 } from "node:path";
+import { z as z10 } from "zod";
+var reviewPublicationStateSchema = z10.object({
+  target: z10.string().optional(),
+  bodies: z10.array(z10.string()).default([]),
+  comments: z10.array(z10.string()).default([]),
+  stagedComments: z10.array(z10.string()).default([]),
+  replies: z10.array(z10.string()).default([]),
+  overlayPath: z10.string().optional()
+});
+function reviewBodyFingerprint(body) {
+  return digest(body);
+}
+function reviewCommentFingerprint(comment) {
+  return digest([comment.file, String(comment.line), comment.side ?? "RIGHT", comment.body].join("\x00"));
+}
+function reviewReplyFingerprint(threadId, body) {
+  return digest(`${threadId}\x00${body}`);
+}
+function unpublishedReviewComments(comments, knownFingerprints) {
+  return comments.filter((comment) => !knownFingerprints.has(reviewCommentFingerprint(comment)));
+}
+async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
+  const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
+  const path = join15(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
   try {
-    return (await readdir2(dir)).reduce((latest, name) => {
-      const match = name.match(/^(\d+)\.json$/);
-      return match ? Math.max(latest, Number(match[1])) : latest;
-    }, 0);
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile10(path, "utf8")));
+    return { path, state: { ...parsed, target } };
   } catch (error) {
-    if (error.code === "ENOENT")
-      return 0;
+    if (error.code === "ENOENT") {
+      return { path, state: { target, bodies: [], comments: [], stagedComments: [], replies: [] } };
+    }
+    if (error instanceof SyntaxError || error instanceof z10.ZodError) {
+      throw new Error(`Cannot parse review publication state: ${path}`);
+    }
     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 = z9.object({
-  cwd: z9.string().optional(),
-  target: z9.string().optional(),
-  workingTree: z9.boolean().optional()
+var contextSchema = z11.object({
+  cwd: z11.string().optional(),
+  target: z11.string().optional(),
+  workingTree: z11.boolean().optional()
 });
-var localSchema = contextSchema.extend({ local: z9.boolean().optional() });
+var localSchema = contextSchema.extend({ local: z11.boolean().optional() });
 var openSchema = localSchema.extend({
-  title: z9.string().optional(),
-  intent: z9.string().optional(),
-  issueUrl: z9.string().url().optional(),
-  base: z9.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: z9.array(z9.string()).optional(),
-  notVerified: z9.array(z9.string()).optional(),
-  title: z9.string().optional()
+  overallIssues: z11.array(z11.string()).optional(),
+  notVerified: z11.array(z11.string()).optional(),
+  title: z11.string().optional()
 });
 var addCommentSchema = localSchema.extend({
-  body: z9.string().min(1),
-  file: z9.string().min(1),
-  line: z9.number().int().positive(),
-  side: z9.enum(["LEFT", "RIGHT"]).optional()
+  body: 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: z9.string().min(1),
-  body: z9.string().min(1),
-  question: z9.boolean().optional(),
-  resolve: z9.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: z9.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
+  status: z11.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
 });
 var completeSchema = localSchema.extend({
-  action: z9.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 run("git", ["-C", cwd, "diff", "HEAD"], { capture: "unbounded" });
   if (tracked.code !== 0)
@@ -8721,7 +9062,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 writeFile6(artifact, renderReviewDoc({
+        await writeFile7(artifact, renderReviewDoc({
           title: params.title ?? review.pr?.title ?? review.vcs.branch,
           number: useLocalBackend ? undefined : review.pr?.number,
           url: useLocalBackend ? undefined : review.pr?.url,
@@ -8744,21 +9085,17 @@ ${openMessage}`, {
               count: findings.length
             });
           }
-          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) });
+          const backend = createLocalReviewBackend({
+            session: session.path,
+            artifactPath: artifact,
+            author: localReviewAuthor(model)
+          });
+          await backend.stage({ comments, body });
           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 = comments.length > 0 || body.trim().length > 0;
+        const hasDraft = hasReviewDraft(comments, body);
         if (hasDraft) {
           await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments, body });
         }
@@ -8794,12 +9131,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.");
-          await addComment(session.path, comment.body, {
-            targetFile: comment.file,
-            line: comment.line,
-            side: comment.side === "LEFT" ? "old" : "new",
-            username: localReviewAuthor(model)
+          const backend = createLocalReviewBackend({
+            session: session.path,
+            artifactPath: "",
+            author: localReviewAuthor(model)
           });
+          await backend.stage({ comments: [comment], body: "" });
           return result3(`Comment added to tuicr session ${session.slug}.`, { session, comment });
         }
         if (!review.pr)
@@ -8811,70 +9148,88 @@ ${openMessage}`, {
     defineTool6({
       name: "review_comments",
       label: "review comments",
-      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."],
+      description: "Pull review threads or local tuicr comments and write a target-named artifact.",
+      promptSnippet: "Call review_comments before addressing findings",
+      promptGuidelines: ["Pass local=true to prepare the local reply overlay."],
       parameters: parameters2(localSchema),
-      executionMode: "parallel",
+      executionMode: "sequential",
       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);
-        if (!review.pr || !review.forge)
+        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 {
           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.", { 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: parameters2(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 });
+`) || "No comments.", { artifact, threads });
       }
     }),
     defineTool6({
       name: "review_respond",
       label: "review respond",
-      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."],
+      description: "Post local question replies to tuicr and record their publish overlay, or reply to remote threads.",
+      promptSnippet: "Call review_respond after addressing a comment",
+      promptGuidelines: ["Question replies remain unresolved."],
       parameters: parameters2(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 (!existsSync2(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 resolve = params.question ? false : params.resolve ?? false;
-        await createRemoteReviewBackend(review.vcs, review.pr.number).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({
           threadId: params.threadId,
-          body: withRemoteProvenance(params.body, modelRoute(ctx)),
+          body: withRemoteProvenance(params.body, model),
           resolve,
-          question: params.question
+          question
         });
         return result3(`Replied to ${params.threadId}${resolve ? " and resolved it" : " and left it open"}.`, {
           pr: review.pr,
@@ -8885,40 +9240,51 @@ ${openMessage}`, {
     defineTool6({
       name: "review_publish",
       label: "review publish",
-      description: "Publish pending remote review comments and status.",
+      description: "Publish pending remote draft PR/MR review comments and status, or promote a local tuicr draft before publishing.",
       promptSnippet: "Call review_publish to make remote review work public",
-      promptGuidelines: ["Local reviews use revision dumps and are never published remotely."],
+      promptGuidelines: ["Statuses are COMMENT, APPROVE, REQUEST_CHANGES, or CLOSE."],
       parameters: parameters2(publishSchema),
       executionMode: "sequential",
-      async execute(_id, input) {
+      async execute(_id, input, _signal, _onUpdate, ctx) {
         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);
+        return publishResolvedReview(review, params, modelRoute(ctx));
       }
     }),
     defineTool6({
       name: "review_complete",
       label: "review complete",
-      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."],
+      description: "Approve, reject, or abandon a remote review, or archive a local review artifact.",
+      promptSnippet: "Call review_complete to finish a review without merging it.",
+      promptGuidelines: ["A local completion archives the Diffpi artifact and deletes the matching tuicr session."],
       parameters: parameters2(completeSchema),
       executionMode: "sequential",
-      async execute(_id, input) {
+      async execute(_id, input, _signal, _onUpdate, ctx) {
         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 (!existsSync2(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 });
+        return publishResolvedReview(review, { ...params, status }, modelRoute(ctx));
       }
     }),
     defineTool6({
@@ -8927,10 +9293,10 @@ ${openMessage}`, {
       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: parameters2(contextSchema.extend({ subject: z9.string().optional() })),
+      parameters: parameters2(contextSchema.extend({ subject: z11.string().optional() })),
       executionMode: "sequential",
       async execute(_id, input) {
-        const params = contextSchema.extend({ subject: z9.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.");
@@ -8963,8 +9329,32 @@ ${openMessage}`, {
     })
   ];
 }
+async function syncLocalThreadArtifact(path, title, sessionSlug, threads) {
+  let previous = [];
+  try {
+    previous = parseThreadArtifact(await readFile11(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 parameters2(schema) {
-  return z9.toJSONSchema(schema, { io: "input" });
+  return z11.toJSONSchema(schema, { io: "input" });
 }
 function resolveWorkingDirectory(params) {
   return params.cwd ?? process.cwd();
@@ -8980,17 +9370,159 @@ 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) {
+async function publishResolvedReview(review, params, model) {
   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 createRemoteReviewBackend(review.vcs, review.pr.number).publish(event);
+  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);
+  }
   if (status === "CLOSE")
     await review.forge.closePr(review.pr.number);
   const finalPr = await review.forge.viewPr(String(review.pr.number));
-  return result3(`Published #${review.pr.number} (${status}).`, { pr: finalPr ?? review.pr, status });
+  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;
 }
 async function resolveReviewContext(cwd, target) {
   const vcs = await detectVcs(cwd);
@@ -9031,6 +9563,10 @@ 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";
@@ -9047,9 +9583,60 @@ async function headSha(cwd) {
 }
 async function newReviewArtifactPath(cwd, target) {
   const dir = await reviewsDir(cwd);
-  await mkdir8(dir, { recursive: true });
+  await mkdir7(dir, { recursive: true });
   return uniqueRecordPath(dir, reviewRecordName(target));
 }
+async function localThreadArtifactPath(cwd, sessionSlug) {
+  const dir = await reviewsDir(cwd);
+  return join16(dir, `${reviewSlug(sessionSlug) || "local-review"}.md`);
+}
+async function readThreadArtifact(path) {
+  try {
+    return parseThreadArtifact(await readFile11(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 = join16(dir, name);
+        const info = await stat(path);
+        return { path, name, content: await readFile11(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 readdir2(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());
 }
@@ -9060,28 +9647,39 @@ function uniqueRecordPath(dir, base) {
     path = join16(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 z11 } from "zod";
+import { z as z13 } from "zod";
 
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter2 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir4, readFile as readFile12 } from "node:fs/promises";
+import { readdir as readdir4, readFile as readFile14 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
 import { basename as basename6, join as join20 } from "node:path";
 
 // src/config.ts
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 import { homedir as homedir5 } from "node:os";
 import { join as join17 } from "node:path";
 
 // src/fsx.ts
-import { readdir as readdir3, readFile as readFile10 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile12 } from "node:fs/promises";
 async function readTextIfExists(path) {
   try {
-    return await readFile10(path, "utf8");
+    return await readFile12(path, "utf8");
   } catch (error) {
     if (isMissingPath(error))
       return;
@@ -9094,11 +9692,11 @@ function isMissingPath(error) {
 
 // src/config.ts
 var modelReferenceSchema = zx.text;
-var agentConfigSchema = z10.object({
-  models: z10.array(modelReferenceSchema).optional()
+var agentConfigSchema = z12.object({
+  models: z12.array(modelReferenceSchema).optional()
 }).strict();
-var diffpiConfigSchema = z10.object({
-  agents: z10.record(z10.string(), agentConfigSchema).optional()
+var diffpiConfigSchema = z12.object({
+  agents: z12.record(z12.string(), agentConfigSchema).optional()
 }).strict();
 function diffpiConfigPaths(homeDir = homedir5()) {
   const directory = join17(homeDir, ".difflab", "diffpi");
@@ -9160,7 +9758,7 @@ function normalizeModelReference(value) {
 }
 
 // src/mcp.ts
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
 import { dirname as dirname8, join as join18 } from "node:path";
 var mcp = {
@@ -9178,8 +9776,8 @@ var mcp = {
     const next = { ...current, mcpServers: nextServers };
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
-      await mkdir9(dirname8(path), { recursive: true });
-      await writeFile7(path, `${JSON.stringify(next, null, 2)}
+      await mkdir8(dirname8(path), { recursive: true });
+      await writeFile8(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -9208,7 +9806,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile11(path, "utf8");
+    return await readFile13(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -9220,7 +9818,7 @@ function isRecord(value) {
 }
 
 // src/pi.ts
-import { mkdir as mkdir10, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir9, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
 import { dirname as dirname9, join as join19 } from "node:path";
 var pi = {
@@ -9239,8 +9837,8 @@ async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(),
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
-    await mkdir10(dirname9(path), { recursive: true });
-    await writeFile8(path, content, "utf8");
+    await mkdir9(dirname9(path), { recursive: true });
+    await writeFile9(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
@@ -9276,8 +9874,8 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const next = update(current);
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
-    await mkdir10(dirname9(path), { recursive: true });
-    await writeFile8(path, `${JSON.stringify(next, null, 2)}
+    await mkdir9(dirname9(path), { recursive: true });
+    await writeFile9(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -9415,7 +10013,7 @@ async function ensurePiAgents(options = {}) {
   const actions = [];
   for (const entry of entries) {
     const id = basename6(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile12(join20(bundledAgentsDir, entry.name), "utf8");
+    const source = await readFile14(join20(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));
@@ -9620,7 +10218,7 @@ function reportProgress(options, message) {
   options.onProgress?.(message);
 }
 async function packageVersion2() {
-  const source = await readFile12(join20(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
+  const source = await readFile14(join20(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
   let value;
   try {
     value = JSON.parse(source);
@@ -9636,13 +10234,13 @@ function getRecord(value) {
 }
 
 // src/tools/setup.ts
-var setupParametersSchema = z11.object({
-  issueTracker: z11.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
-  forges: z11.array(z11.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
-  forge: z11.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
-  bindZedKey: z11.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
+var setupParametersSchema = z13.object({
+  issueTracker: z13.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
+  forges: z13.array(z13.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
+  forge: z13.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
+  bindZedKey: z13.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
 });
-var setupParameters = z11.toJSONSchema(setupParametersSchema, { io: "input" });
+var setupParameters = z13.toJSONSchema(setupParametersSchema, { io: "input" });
 var diffpiSetupTool = defineTool7({
   name: "diffpi_setup",
   label: "diffpi setup",
@@ -9715,11 +10313,11 @@ ${lines.join(`
 
 // src/tools/templates.ts
 import { defineTool as defineTool8 } from "@earendil-works/pi-coding-agent";
-import { z as z12 } from "zod";
-var templateSchema = z12.object({
-  name: z12.string().min(1),
-  variables: z12.record(z12.string(), z12.string()).optional(),
-  homeDir: z12.string().optional()
+import { z as z14 } from "zod";
+var templateSchema = z14.object({
+  name: z14.string().min(1),
+  variables: z14.record(z14.string(), z14.string()).optional(),
+  homeDir: z14.string().optional()
 });
 var diffpiTemplateTool = defineTool8({
   name: "diffpi_template",
@@ -9727,7 +10325,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: z12.toJSONSchema(templateSchema, { io: "input" }),
+  parameters: z14.toJSONSchema(templateSchema, { io: "input" }),
   executionMode: "parallel",
   async execute(_id, input) {
     const params = templateSchema.parse(input);