@difflab/pi 0.5.0-rc.202609231305.97666c2 → 0.5.0

package/dist/index.js

@@ -1301,6 +1301,9 @@ function yymmdd(date = new Date) {
 function reviewRecordName(target, date = new Date) {
   return `${yymmdd(date)}-${reviewSlug(target) || "uncommitted"}`;
 }
+function isLocalResponse(body) {
+  return /^<!-- diffpi(?:-local-response:[A-Za-z0-9_-]+)? -->\n/m.test(body);
+}
 function dedupeFindings(findings) {
   const rank = { BLOCKING: 3, CONSIDER: 2, NOTE: 1 };
   const byKey = new Map;
@@ -1346,6 +1349,18 @@ function renderCommentBody(finding) {
   return `${prefix}${finding.body}${reference}`;
 }
 // src/review/review-markdown.ts
+import { z as z4 } from "zod";
+var reviewThreadRecordSchema = z4.object({
+  id: z4.string().min(1),
+  file: z4.string().nullable().optional().transform((value) => value ?? undefined),
+  line: z4.number().int().positive().nullable().optional().transform((value) => value ?? undefined),
+  body: z4.string(),
+  author: z4.string().optional(),
+  resolved: z4.boolean(),
+  addressed: z4.boolean().optional(),
+  question: z4.boolean(),
+  replies: z4.array(z4.string()).optional()
+});
 function renderReviewDoc(input) {
   const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
   const lines = [`# Review: ${input.title}`, "", "## Metadata"];
@@ -1387,6 +1402,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 = z4.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 () => {
@@ -1448,6 +1545,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,
@@ -1457,6 +1557,7 @@ function GitHubReviewBackend(vcs, number) {
     });
   };
   return {
+    kind: "remote",
     async stage(draft) {
       const pending = await pendingReview();
       if (!pending) {
@@ -1514,6 +1615,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();
@@ -1530,14 +1658,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}`
         ]);
       }
     },
@@ -1556,11 +1702,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) {
@@ -1597,6 +1745,7 @@ function GitLabReviewBackend(vcs, number) {
     });
   };
   return {
+    kind: "remote",
     async stage(draft) {
       const endpoint = `${mergeRequestEndpoint()}/draft_notes`;
       if (draft.body.trim()) {
@@ -1625,6 +1774,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)}`;
@@ -1636,7 +1815,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);
@@ -1676,105 +1863,12 @@ 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 mkdir4, readdir as readdir2, readFile as readFile6, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-
-// src/store.ts
-import { createHash } from "node:crypto";
-import { lstat, mkdir as mkdir3, readlink, realpath as realpath2, symlink, unlink } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname4, isAbsolute as isAbsolute2, join as join8, resolve as resolve2 } from "node:path";
-var STORE_LINK = ".diffpi";
-var LEGACY_STORE_LINK = join8(".pi", "diffpi");
-async function computeProjectSlug(cwd) {
-  return projectSlug(await inspectGitRepository(cwd));
-}
-function storeGlobalRoot(homeDir = homedir4()) {
-  return join8(homeDir, ".difflab", "diffpi", "projects");
-}
-async function ensureStore(cwd, homeDir = homedir4()) {
-  const repository = await inspectGitRepository(cwd);
-  const root = repository.root;
-  const slug = projectSlug(repository);
-  const dest = join8(storeGlobalRoot(homeDir), slug);
-  const link = join8(root, STORE_LINK);
-  await mkdir3(dest, { recursive: true });
-  try {
-    await assertStoreLink(link, dest);
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-    await symlink(dest, link);
-  }
-  await removeLegacyStoreLink(join8(root, LEGACY_STORE_LINK), dest);
-  return { slug, root, dest, link, linked: true };
-}
-async function storeDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  return store.dest;
-}
-async function plansDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "plan");
-  await mkdir3(dir, { recursive: true });
-  return dir;
-}
-async function reviewsDir(cwd, homeDir = homedir4()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join8(store.link, "review");
-  await mkdir3(dir, { recursive: true });
-  return dir;
-}
-async function assertStoreLink(path, dest) {
-  const entry = await lstat(path);
-  if (!entry.isSymbolicLink())
-    throw new Error(`${path} exists and is not a symlink.`);
-  const target = await symlinkTarget(path);
-  if (target !== await canonicalPath2(dest))
-    throw new Error(`${path} points to ${target}, not ${dest}.`);
-}
-async function removeLegacyStoreLink(path, dest) {
-  try {
-    const entry = await lstat(path);
-    if (!entry.isSymbolicLink())
-      return;
-    const target = await symlinkTarget(path);
-    if (target === await canonicalPath2(dest))
-      await unlink(path);
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      throw error;
-  }
-}
-async function symlinkTarget(path) {
-  const target = await readlink(path);
-  return canonicalPath2(isAbsolute2(target) ? target : resolve2(dirname4(path), target));
-}
-async function canonicalPath2(path) {
-  try {
-    return await realpath2(path);
-  } catch {
-    return resolve2(path);
-  }
-}
-function projectSlug(repository) {
-  const readable = repository.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed";
-  const digest = createHash("sha256").update(repository.identity).digest("hex").slice(0, 12);
-  return `${readable}-${digest}`;
-}
+// src/review/local-review-backend.ts
+import { readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
 
 // src/extensions/tuicrx.ts
-import { readFile as readFile5, realpath as realpath3 } from "node:fs/promises";
-import { resolve as resolve3 } from "node:path";
+import { readFile as readFile5, realpath as realpath2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
 async function tuicrAvailable() {
   return Boolean(await findExecutable("tuicr"));
 }
@@ -1850,7 +1944,7 @@ async function resolvePrSession(cwd, owner, repo, number) {
   });
 }
 async function findMatchingSession(sessions, cwd, branch) {
-  const repository = await canonicalPath3(await gitToplevel(cwd));
+  const repository = await canonicalPath2(await gitToplevel(cwd));
   for (const session of sessions) {
     if (session.kind !== "local")
       continue;
@@ -1858,7 +1952,7 @@ async function findMatchingSession(sessions, cwd, branch) {
       const data = await readSession(session.path);
       if (data.branch_name !== branch || !data.repo_path)
         continue;
-      if (await canonicalPath3(data.repo_path) === repository)
+      if (await canonicalPath2(data.repo_path) === repository)
         return session;
     } catch {}
   }
@@ -1872,33 +1966,53 @@ async function readSession(path) {
     throw new Error(`Cannot parse tuicr session JSON: ${path}`);
   }
 }
-function toLocalReviewThreads(session) {
-  const threads = [];
-  const add = (comment, location = {}) => {
+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);
-    threads.push({
-      id: comment.id ?? `local-${threads.length + 1}`,
-      ...location,
-      body: comment.content,
-      ...author ? { author } : {},
-      resolved: false,
-      question: /\?\s*$/.test(comment.content.trim())
-    });
+    const route = author?.match(/^Agent:\s*(.+)$/)?.[1];
+    return route ? withRemoteProvenance(comment.content, route) : comment.content;
   };
-  for (const comment of session.review_comments ?? [])
-    add(comment);
+  const bodyParts = (session.review_comments ?? []).flatMap((comment) => include(comment) ? [publishableBody(comment)] : []);
   for (const [file, entry] of Object.entries(session.files ?? {})) {
-    for (const comment of entry.file_comments ?? [])
-      add(comment, { file });
+    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 comment of lineComments)
-        add(comment, { file, line });
+      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 threads;
+  return { comments, body: bodyParts.join(`
+
+`) };
 }
 async function requireTuicr() {
   if (!await tuicrAvailable())
@@ -1907,70 +2021,207 @@ async function requireTuicr() {
 function commentAuthor(comment) {
   return comment.username ?? comment.author;
 }
-async function canonicalPath3(path) {
+async function canonicalPath2(path) {
   try {
-    return await realpath3(path);
+    return await realpath2(path);
   } catch {
-    return resolve3(path);
+    return resolve2(path);
   }
 }
 
-// src/review/local-reviews.ts
-async function captureLocalReview(input) {
-  const id = reviewSlug(input.branch) || "local-review";
-  const dir = join9(await reviewsDir(input.cwd, input.homeDir), id);
-  await mkdir4(dir, { recursive: true });
-  const revision = await nextRevision(dir);
-  const output = await readFile6(input.session.path, "utf8");
-  const comments = toLocalReviewThreads(await readSession(input.session.path));
-  const dump = {
-    schemaVersion: 1,
-    id,
-    revision,
-    branch: input.branch,
-    base: input.base,
-    createdAt: (input.now ?? (() => new Date))().toISOString(),
-    diff: input.diff,
-    comments,
-    tuicr: { slug: input.session.slug, output }
+// src/review/local-review-backend.ts
+function LocalReviewBackend(options) {
+  return {
+    kind: "local",
+    async stage(draft) {
+      for (const comment of draft.comments) {
+        await addComment(options.session, comment.body, {
+          targetFile: comment.file,
+          line: comment.line,
+          side: comment.side === "LEFT" ? "old" : "new",
+          username: options.author
+        });
+      }
+      if (draft.body.trim())
+        await addComment(options.session, draft.body, { username: options.author });
+    },
+    async readDraft() {
+      return toFindings(await readSession(options.session), { excludeLocalResponses: true });
+    },
+    async listThreads() {
+      try {
+        return parseThreadArtifact(await readFile6(options.artifactPath, "utf8"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          return [];
+        throw error;
+      }
+    },
+    async reply(input) {
+      const content = await readFile6(options.artifactPath, "utf8");
+      await writeFile3(options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question, input.resolve), "utf8");
+    },
+    async publish() {
+      throw new Error("Promote a local draft through a remote review backend before publishing it.");
+    }
   };
-  const path = join9(dir, `${revision}.json`);
-  await writeFile3(path, `${JSON.stringify(dump, null, 2)}
-`, { encoding: "utf8", flag: "wx" });
-  await unlink2(input.session.path);
-  return { path, dump };
-}
-async function readLocalReview(cwd, branch, revision, homeDir) {
-  const id = reviewSlug(branch) || "local-review";
-  const dir = join9(await reviewsDir(cwd, homeDir), id);
-  const selected = revision ?? await latestRevision(dir);
-  if (!selected)
-    return;
+}
+
+// src/review/review-backend.ts
+function createRemoteReviewBackend(vcs, number) {
+  if (vcs.provider === "github")
+    return GitHubReviewBackend(vcs, number);
+  if (vcs.provider === "gitlab")
+    return GitLabReviewBackend(vcs, number);
+  throw new Error("A remote review backend requires a GitHub or GitLab repository.");
+}
+function createLocalReviewBackend(options) {
+  return LocalReviewBackend(options);
+}
+// src/review/review-state.ts
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile7, rename, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+import { z as z5 } from "zod";
+
+// src/store.ts
+import { createHash } from "node:crypto";
+import { lstat, mkdir as mkdir3, readlink, realpath as realpath3, symlink, unlink } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname4, isAbsolute as isAbsolute2, join as join8, resolve as resolve3 } from "node:path";
+var STORE_LINK = ".diffpi";
+var LEGACY_STORE_LINK = join8(".pi", "diffpi");
+async function computeProjectSlug(cwd) {
+  return projectSlug(await inspectGitRepository(cwd));
+}
+function storeGlobalRoot(homeDir = homedir4()) {
+  return join8(homeDir, ".difflab", "diffpi", "projects");
+}
+async function ensureStore(cwd, homeDir = homedir4()) {
+  const repository = await inspectGitRepository(cwd);
+  const root = repository.root;
+  const slug = projectSlug(repository);
+  const dest = join8(storeGlobalRoot(homeDir), slug);
+  const link = join8(root, STORE_LINK);
+  await mkdir3(dest, { recursive: true });
   try {
-    return JSON.parse(await readFile6(join9(dir, `${selected}.json`), "utf8"));
+    await assertStoreLink(link, dest);
   } catch (error) {
-    if (error.code === "ENOENT")
+    if (error.code !== "ENOENT")
+      throw error;
+    await symlink(dest, link);
+  }
+  await removeLegacyStoreLink(join8(root, LEGACY_STORE_LINK), dest);
+  return { slug, root, dest, link, linked: true };
+}
+async function storeDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  return store.dest;
+}
+async function plansDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join8(store.link, "plan");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function reviewsDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join8(store.link, "review");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir4()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join8(store.link, "sessions");
+  await mkdir3(dir, { recursive: true });
+  return dir;
+}
+async function assertStoreLink(path, dest) {
+  const entry = await lstat(path);
+  if (!entry.isSymbolicLink())
+    throw new Error(`${path} exists and is not a symlink.`);
+  const target = await symlinkTarget(path);
+  if (target !== await canonicalPath3(dest))
+    throw new Error(`${path} points to ${target}, not ${dest}.`);
+}
+async function removeLegacyStoreLink(path, dest) {
+  try {
+    const entry = await lstat(path);
+    if (!entry.isSymbolicLink())
       return;
-    throw error;
+    const target = await symlinkTarget(path);
+    if (target === await canonicalPath3(dest))
+      await unlink(path);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
   }
 }
-async function nextRevision(dir) {
-  return await latestRevision(dir) + 1;
+async function symlinkTarget(path) {
+  const target = await readlink(path);
+  return canonicalPath3(isAbsolute2(target) ? target : resolve3(dirname4(path), target));
 }
-async function latestRevision(dir) {
+async function canonicalPath3(path) {
   try {
-    return (await readdir2(dir)).reduce((latest, name) => {
-      const match = name.match(/^(\d+)\.json$/);
-      return match ? Math.max(latest, Number(match[1])) : latest;
-    }, 0);
+    return await realpath3(path);
+  } catch {
+    return resolve3(path);
+  }
+}
+function projectSlug(repository) {
+  const readable = repository.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "unnamed";
+  const digest = createHash("sha256").update(repository.identity).digest("hex").slice(0, 12);
+  return `${readable}-${digest}`;
+}
+
+// src/review/review-state.ts
+var reviewPublicationStateSchema = z5.object({
+  target: z5.string().optional(),
+  bodies: z5.array(z5.string()).default([]),
+  comments: z5.array(z5.string()).default([]),
+  stagedComments: z5.array(z5.string()).default([]),
+  replies: z5.array(z5.string()).default([]),
+  overlayPath: z5.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 = join9(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
+  try {
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile7(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 z5.ZodError) {
+      throw new Error(`Cannot parse review publication state: ${path}`);
+    }
     throw error;
   }
 }
+async function saveReviewPublicationState(path, state) {
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile4(temp, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  await rename(temp, path);
+}
+function digest(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
 // src/mcp.ts
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir4, readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
 import { dirname as dirname5, join as join10 } from "node:path";
 var mcp = {
@@ -1988,8 +2239,8 @@ var mcp = {
     const next = { ...current, mcpServers: nextServers };
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
-      await mkdir5(dirname5(path), { recursive: true });
-      await writeFile4(path, `${JSON.stringify(next, null, 2)}
+      await mkdir4(dirname5(path), { recursive: true });
+      await writeFile5(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -2018,7 +2269,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile7(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -2033,7 +2284,7 @@ import {
   getAgentDir,
   parseFrontmatter as parseFrontmatter2
 } from "@earendil-works/pi-coding-agent";
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
 import { basename as basename4, extname, join as join11 } from "node:path";
 async function discoverAgentModes(options) {
@@ -2232,7 +2483,7 @@ async function loadAgentModes(directory, source, modes, diagnostics, skillName)
   for (const entry of entries.filter((item) => item.isFile() && item.name.endsWith(".md")).sort((a, b) => a.name.localeCompare(b.name))) {
     const path = join11(directory, entry.name);
     try {
-      const content = await readFile8(path, "utf8");
+      const content = await readFile9(path, "utf8");
       const { frontmatter, body } = parseFrontmatter2(content.startsWith("\uFEFF") ? content.slice(1) : content);
       if (frontmatter.enabled === false || frontmatter.inline === false)
         continue;
@@ -2288,7 +2539,7 @@ function isModeBaseline(value) {
   return (model === undefined || typeof model.provider === "string" && typeof model.id === "string") && candidate.thinkingLevel !== undefined && THINKING_LEVELS.has(candidate.thinkingLevel) && Array.isArray(candidate.tools) && candidate.tools.every((tool) => typeof tool === "string");
 }
 // src/pi.ts
-import { mkdir as mkdir6, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir5, writeFile as writeFile6 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
 import { dirname as dirname6, join as join12 } from "node:path";
 var pi = {
@@ -2307,8 +2558,8 @@ async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(),
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
-    await mkdir6(dirname6(path), { recursive: true });
-    await writeFile5(path, content, "utf8");
+    await mkdir5(dirname6(path), { recursive: true });
+    await writeFile6(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
@@ -2344,8 +2595,8 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const next = update(current);
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
-    await mkdir6(dirname6(path), { recursive: true });
-    await writeFile5(path, `${JSON.stringify(next, null, 2)}
+    await mkdir5(dirname6(path), { recursive: true });
+    await writeFile6(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -2378,16 +2629,16 @@ function parseJsonObject(content, path) {
   throw new Error(`Expected valid JSON object in ${path}.`);
 }
 // src/plan/store.ts
-import { mkdir as mkdir8, readdir as readdir3, readFile as readFile11, realpath as realpath4, rm as rm2 } from "node:fs/promises";
+import { mkdir as mkdir7, readdir as readdir2, readFile as readFile12, realpath as realpath4, rm as rm2 } from "node:fs/promises";
 import { basename as basename6, dirname as dirname8, join as join16, resolve as resolve4, sep } from "node:path";
 
 // src/extensions/fsx.ts
-import { mkdir as mkdir7, rename, rm, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir6, rename as rename2, rm, writeFile as writeFile7 } from "node:fs/promises";
 import { basename as basename5, dirname as dirname7, join as join13 } from "node:path";
 async function atomicWrite(path, content) {
   const temp = join13(dirname7(path), `.${basename5(path)}.${crypto.randomUUID()}.tmp`);
-  await writeFile6(temp, content, { encoding: "utf8", mode: 384, flag: "wx" });
-  await rename(temp, path);
+  await writeFile7(temp, content, { encoding: "utf8", mode: 384, flag: "wx" });
+  await rename2(temp, path);
 }
 async function withDirectoryLock(lockDir, operation, options = {}) {
   const waitMs = options.waitMs ?? 5000;
@@ -2395,7 +2646,7 @@ async function withDirectoryLock(lockDir, operation, options = {}) {
   const started = Date.now();
   while (true) {
     try {
-      await mkdir7(lockDir);
+      await mkdir6(lockDir);
       break;
     } catch (error) {
       if (error.code !== "EEXIST")
@@ -2417,7 +2668,7 @@ function sleep(ms) {
 
 // src/log.ts
 import { randomUUID } from "node:crypto";
-import { appendFile, readFile as readFile9 } from "node:fs/promises";
+import { appendFile, readFile as readFile10 } from "node:fs/promises";
 async function appendLogEntry(logPath, event) {
   const entry = {
     ...event,
@@ -2431,7 +2682,7 @@ async function appendLogEntry(logPath, event) {
 }
 
 // src/templates.ts
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
 import { join as join14, normalize } from "node:path";
 async function loadTemplate(name, options = {}) {
@@ -2458,7 +2709,7 @@ function templateRelativePath(name) {
 }
 async function readOptionalFile(path) {
   try {
-    return await readFile10(path, "utf8");
+    return await readFile11(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -7542,7 +7793,7 @@ function planRecordName(shortSlug, date = new Date) {
 }
 async function resolvePlan(cwd, query, filters = {}, options = {}) {
   const root = await plansDir(cwd, options.homeDir);
-  const entries = await readdir3(root, { withFileTypes: true });
+  const entries = await readdir2(root, { withFileTypes: true });
   const normalizedQuery = query ? normalizeQuery(query) : undefined;
   const records = [];
   for (const entry of entries) {
@@ -7579,7 +7830,7 @@ function createPlanStore(options = {}) {
       const dir = join16(root, id);
       await assertContained(root, dirname8(dir));
       try {
-        await mkdir8(dir);
+        await mkdir7(dir);
       } catch (error) {
         if (error.code === "EEXIST")
           throw new Error(`Plan ${id} already exists.`);
@@ -7654,7 +7905,7 @@ function createPlanStore(options = {}) {
 async function readRecord(dir) {
   const planPath = join16(dir, "PLAN.md");
   const logPath = join16(dir, "logs.txt");
-  const source = await readFile11(planPath, "utf8");
+  const source = await readFile12(planPath, "utf8");
   const document = parsePlanDocument(source, planPath);
   return {
     id: basename6(dir),
@@ -7668,7 +7919,7 @@ async function readRecord(dir) {
 }
 async function ensureImplementationFiles(dir, document, options) {
   const implementationDir = join16(dir, "implementation");
-  await mkdir8(implementationDir, { recursive: true });
+  await mkdir7(implementationDir, { recursive: true });
   const template = await loadTemplate("plan/implementation", {
     homeDir: options.homeDir,
     bundledDir: options.bundledTemplatesDir
@@ -7676,7 +7927,7 @@ async function ensureImplementationFiles(dir, document, options) {
   for (const phase of document.phases) {
     const path = join16(implementationDir, `phase-${phase.id}.md`);
     try {
-      await readFile11(path, "utf8");
+      await readFile12(path, "utf8");
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -7725,7 +7976,7 @@ function titleFromSlug(value) {
 }
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter3 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir4, readFile as readFile12 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile13 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
 import { basename as basename7, join as join17 } from "node:path";
 var MISE_DEPENDENCIES = [
@@ -7828,11 +8079,11 @@ async function ensurePiAgents(options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
   const bundledAgentsDir = options.bundledAgentsDir ?? BUNDLED_AGENTS_DIR2;
   const userConfig = await loadDiffpiConfig({ homeDir: options.homeDir });
-  const entries = (await readdir4(bundledAgentsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
+  const entries = (await readdir3(bundledAgentsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
   const actions = [];
   for (const entry of entries) {
     const id = basename7(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile12(join17(bundledAgentsDir, entry.name), "utf8");
+    const source = await readFile13(join17(bundledAgentsDir, entry.name), "utf8");
     const content = materializeAgentModels(source, id, userConfig.config, options.availableModels);
     const result = await pi.agentEnsure(entry.name, content, agentDir, options.dryRun);
     actions.push(getConfigSetupAction(`pi agent ${id}`, result));
@@ -8037,7 +8288,7 @@ function reportProgress(options, message) {
   options.onProgress?.(message);
 }
 async function packageVersion2() {
-  const source = await readFile12(join17(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
+  const source = await readFile13(join17(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
   let value;
   try {
     value = JSON.parse(source);
@@ -8062,11 +8313,11 @@ export {
   addComment,
   assertGitHubMergeReady,
   assertReviewEventSupported,
-  captureLocalReview,
   checkConventionalSubject,
   computeProjectSlug,
   createForge,
   createForgeBackend,
+  createLocalReviewBackend,
   createModeController,
   createPlanStore,
   createRemoteReviewBackend,
@@ -8099,6 +8350,7 @@ export {
   launch,
   listSessions,
   loadDiffpiConfig,
+  loadReviewPublicationState,
   loadTemplate,
   localReviewAuthor,
   mcp,
@@ -8107,28 +8359,37 @@ export {
   openInNewTab,
   parseGitlabDiffRefs,
   parseRemote,
+  parseThreadArtifact,
   pi,
   plansDir,
-  readLocalReview,
   readSession,
   renderReviewDoc,
   renderTemplate,
+  renderThreadArtifact,
   resolveAgentMode,
   resolveAgentModelPreferences,
   resolvePrSession,
   resolveReviewSession,
   resolveSession,
+  reviewBodyFingerprint,
+  reviewCommentFingerprint,
   reviewRecordName,
+  reviewReplyFingerprint,
   reviewSlug,
   reviewsDir,
   runMiseGates,
+  saveReviewPublicationState,
+  sessionsDir,
   setupPi,
   severitySchema,
   storeDir,
   storeGlobalRoot,
   templateRelativePath,
+  toFindings,
   toReviewComments,
   tuicrAvailable,
+  unpublishedReviewComments,
+  upsertThreadReply,
   withRemoteProvenance,
   yymmdd,
   zedKeymapPath,