opencode-forgekeeper 2.1.1 → 2.2.1

package/dist/index.js

@@ -189,14 +189,182 @@ class ForgeError extends Error {
 var query = (text) => text;
 var typed = (transport) => async (host, query2, variables) => await transport(host, query2, variables);
 
-// packages/forgekeeper/src/gitlab-feedback.ts
+// packages/forgekeeper/src/github-feedback.ts
 var PAGE_SIZE = 100;
 var MAX_COMMENT_PAGES = 20;
+var MAX_FETCH_REQUESTS = 200;
+var author = "author { __typename login ... on User { id } ... on Bot { id } ... on Mannequin { id } }";
+var page = "pageInfo { hasPreviousPage startCursor }";
+var INLINE_FIELDS = `id url state createdAt publishedAt lastEditedAt isMinimized ${author}`;
+var listQuery = (field, connection) => query(`query($owner: String!, $repo: String!, $number: Int!, $before: String) {
+  viewer { id }
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      ${field}(last: ${PAGE_SIZE}, before: $before) { ${page} nodes { ${connection} } }
+    }
+  }
+}`);
+var ISSUE_COMMENTS_QUERY = listQuery("comments", `id url createdAt publishedAt lastEditedAt isMinimized ${author}`);
+var REVIEWS_QUERY = listQuery("reviews", `id url state body submittedAt lastEditedAt isMinimized ${author}`);
+var THREADS_QUERY = listQuery("reviewThreads", `id isResolved comments(last: ${PAGE_SIZE}) { ${page} nodes { ${INLINE_FIELDS} } }`);
+var THREAD_COMMENTS_QUERY = query(`query($id: ID!, $before: String) {
+  node(id: $id) {
+    ... on PullRequestReviewThread {
+      comments(last: ${PAGE_SIZE}, before: $before) { ${page} nodes { ${INLINE_FIELDS} } }
+    }
+  }
+}`);
+var REVIEW_STATES = new Set(["COMMENTED", "CHANGES_REQUESTED", "APPROVED"]);
+var time = (...values) => {
+  const value = values.find((candidate) => candidate);
+  return value ? Date.parse(value) : NaN;
+};
+var activity = (lastEditedAt, postedAt) => {
+  const edited = lastEditedAt ? Date.parse(lastEditedAt) : NaN;
+  return Number.isFinite(edited) ? Math.max(edited, postedAt) : postedAt;
+};
+function build({ node, postedAt, editedAt, resolved }) {
+  if (node.isMinimized || !node.author?.id || !Number.isFinite(postedAt) || !Number.isFinite(editedAt))
+    return;
+  const { __typename, login } = node.author;
+  return {
+    id: node.id,
+    order: postedAt,
+    url: node.url ?? "",
+    editedAt,
+    resolved,
+    bot: __typename === "Bot" || login.endsWith("[bot]"),
+    authorID: node.author.id,
+    username: login
+  };
+}
+function toIssueComment(node) {
+  const postedAt = time(node.publishedAt, node.createdAt);
+  return build({
+    node,
+    postedAt,
+    editedAt: activity(node.lastEditedAt, postedAt),
+    resolved: false
+  });
+}
+function toReview(node) {
+  if (!REVIEW_STATES.has(node.state) || !node.body.trim())
+    return;
+  const postedAt = time(node.submittedAt);
+  return build({
+    node,
+    postedAt,
+    editedAt: activity(node.lastEditedAt, postedAt),
+    resolved: false
+  });
+}
+function toInlineComment(node, resolved) {
+  if (node.state === "PENDING")
+    return;
+  const postedAt = time(node.publishedAt, node.createdAt);
+  return build({
+    node,
+    postedAt,
+    editedAt: activity(node.lastEditedAt, postedAt),
+    resolved
+  });
+}
+var commentWindow = { pages: MAX_COMMENT_PAGES, completeAtLimit: true };
+var allThreads = { pages: MAX_FETCH_REQUESTS, completeAtLimit: false };
+async function readList(graphql, host, base, text, field, limit = commentWindow) {
+  const pages = [];
+  let viewer;
+  let before;
+  const result = (complete) => ({
+    items: pages.toReversed().flat(),
+    viewer,
+    complete
+  });
+  for (let count = 0;count < limit.pages; count++) {
+    const variables = before ? { ...base, before } : base;
+    const data = await graphql(host, text, variables);
+    viewer ??= data.viewer?.id ?? undefined;
+    const connection = data.repository?.pullRequest?.[field];
+    if (!connection)
+      return count === 0 ? { viewer, complete: false } : result(false);
+    pages.push(connection.nodes);
+    if (!connection.pageInfo.hasPreviousPage)
+      return result(true);
+    before = connection.pageInfo.startCursor ?? undefined;
+    if (!before)
+      return result(false);
+  }
+  return result(limit.completeAtLimit);
+}
+async function readOlderComments(graphql, host, thread) {
+  if (!thread.comments)
+    return { comments: [], complete: false };
+  const pages = [];
+  let before = thread.comments?.pageInfo.hasPreviousPage ? thread.comments.pageInfo.startCursor ?? undefined : undefined;
+  if (thread.comments?.pageInfo.hasPreviousPage && !before)
+    return { comments: [], complete: false };
+  for (let count = 1;before && count < MAX_COMMENT_PAGES; count++) {
+    const data = await graphql(host, THREAD_COMMENTS_QUERY, { id: thread.id, before });
+    const connection = data.node?.comments;
+    if (!connection)
+      return { comments: pages.toReversed().flat(), complete: false };
+    pages.push(connection.nodes);
+    before = connection.pageInfo.hasPreviousPage ? connection.pageInfo.startCursor ?? undefined : undefined;
+    if (connection.pageInfo.hasPreviousPage && !before)
+      return { comments: pages.toReversed().flat(), complete: false };
+  }
+  return { comments: pages.toReversed().flat(), complete: true };
+}
+async function fetchComments(transport, host, project, number) {
+  let requests = 0;
+  const graphql = typed(async (...args) => {
+    if (requests++ >= MAX_FETCH_REQUESTS)
+      return {};
+    return transport(...args);
+  });
+  const [owner, repo] = project.split("/");
+  const base = { owner, repo, number: Number(number) };
+  const [conversation, reviews, threads] = await Promise.all([
+    readList(graphql, host, base, ISSUE_COMMENTS_QUERY, "comments"),
+    readList(graphql, host, base, REVIEWS_QUERY, "reviews"),
+    readList(graphql, host, base, THREADS_QUERY, "reviewThreads", allThreads)
+  ]);
+  if (!conversation.items || !reviews.items || !threads.items)
+    return;
+  const viewerID = conversation.viewer ?? reviews.viewer ?? threads.viewer;
+  let threadsComplete = threads.complete;
+  const inline = [];
+  for (const thread of threads.items) {
+    const older = await readOlderComments(graphql, host, thread);
+    threadsComplete &&= older.complete;
+    for (const node of [...older.comments, ...thread.comments?.nodes ?? []]) {
+      const comment = toInlineComment(node, thread.isResolved);
+      if (comment)
+        inline.push(comment);
+    }
+    inline.sort((a, b) => b.order - a.order);
+    inline.splice(PAGE_SIZE * MAX_COMMENT_PAGES);
+  }
+  const comments = [
+    ...conversation.items.map(toIssueComment),
+    ...reviews.items.map(toReview),
+    ...inline.sort((a, b) => a.order - b.order).slice(-PAGE_SIZE * MAX_COMMENT_PAGES)
+  ].flatMap((comment) => comment ?? []);
+  return {
+    complete: conversation.complete && reviews.complete && threadsComplete && viewerID !== undefined,
+    viewerID,
+    comments: comments.sort((a, b) => a.order - b.order)
+  };
+}
+
+// packages/forgekeeper/src/gitlab-feedback.ts
+var PAGE_SIZE2 = 100;
+var MAX_COMMENT_PAGES2 = 20;
 var COMMENTS_QUERY = query(`query($project: ID!, $iid: String!, $before: String) {
   currentUser { id }
   project(fullPath: $project) {
     mergeRequest(iid: $iid) {
-      notes(last: ${PAGE_SIZE}, before: $before, filter: ONLY_COMMENTS) {
+      notes(last: ${PAGE_SIZE2}, before: $before, filter: ONLY_COMMENTS) {
         pageInfo { hasPreviousPage startCursor }
         nodes {
           id url createdAt updatedAt lastEditedAt system
@@ -225,7 +393,7 @@ function toComment(node) {
     username: node.author.username
   };
 }
-async function fetchComments(transport, host, project, iid) {
+async function fetchComments2(transport, host, project, iid) {
   const graphql = typed(transport);
   const pages = [];
   let viewerID;
@@ -235,7 +403,7 @@ async function fetchComments(transport, host, project, iid) {
     viewerID,
     comments: pages.toReversed().flat()
   });
-  for (let page = 0;page < MAX_COMMENT_PAGES; page++) {
+  for (let page2 = 0;page2 < MAX_COMMENT_PAGES2; page2++) {
     const variables = { project, iid };
     if (before)
       variables.before = before;
@@ -243,7 +411,7 @@ async function fetchComments(transport, host, project, iid) {
     viewerID ??= data.currentUser?.id ?? undefined;
     const connection = data.project?.mergeRequest?.notes;
     if (!connection)
-      return page === 0 ? undefined : snapshot(false);
+      return page2 === 0 ? undefined : snapshot(false);
     pages.push(connection.nodes.flatMap((node) => toComment(node) ?? []));
     if (!connection.pageInfo.hasPreviousPage)
       return snapshot(true);
@@ -256,7 +424,7 @@ async function fetchComments(transport, host, project, iid) {
 
 // packages/forgekeeper/src/gitlab.ts
 var DISCUSSIONS = "pageInfo { hasNextPage endCursor } nodes { resolvable resolved }";
-var PAGE_SIZE2 = 100;
+var PAGE_SIZE3 = 100;
 var MAX_DISCUSSION_PAGES = 50;
 var MERGE_REQUEST_FIELDS = `
   iid title webUrl state draft conflicts approved detailedMergeStatus diffHeadSha updatedAt targetBranch
@@ -265,7 +433,7 @@ var MERGE_REQUEST_FIELDS = `
   targetProject { fullPath }
   headPipeline { status path detailedStatus { label } }
   reviewers(first: 100) { nodes { type username bot mergeRequestInteraction { reviewState approved } } }
-  discussions(first: ${PAGE_SIZE2}) { ${DISCUSSIONS} }
+  discussions(first: ${PAGE_SIZE3}) { ${DISCUSSIONS} }
 `;
 function mergeRequestsQuery(projectCount) {
   const variables = Array.from({ length: projectCount }, (_, index) => `$p${index}: ID!`).join(", ");
@@ -300,7 +468,7 @@ var SOURCE_BRANCH_QUERY = query(`query($project: ID!, $iid: String!) {
 }`);
 var DISCUSSIONS_QUERY = query(`query($project: ID!, $iid: String!, $after: String) {
   project(fullPath: $project) {
-    mergeRequest(iid: $iid) { discussions(first: ${PAGE_SIZE2}, after: $after) { ${DISCUSSIONS} } }
+    mergeRequest(iid: $iid) { discussions(first: ${PAGE_SIZE3}, after: $after) { ${DISCUSSIONS} } }
   }
 }`);
 function classifyError(message, code) {
@@ -339,7 +507,7 @@ function glabGraphQL(run, cwd) {
     return body.data;
   };
 }
-var countUnresolved = (page) => page.nodes.filter((discussion) => discussion.resolvable && !discussion.resolved).length;
+var countUnresolved = (page2) => page2.nodes.filter((discussion) => discussion.resolvable && !discussion.resolved).length;
 var gitlabTraits = {
   kind: "gitlab",
   noun: "MR",
@@ -374,7 +542,7 @@ var gitlabTraits = {
   feedback: {
     async fetch(run, directory, request) {
       const ref = gitlabTraits.parseUrl(request.url);
-      return ref ? fetchComments(glabGraphQL(run, directory), ref.host, ref.project, ref.iid) : undefined;
+      return ref ? fetchComments2(glabGraphQL(run, directory), ref.host, ref.project, ref.iid) : undefined;
     }
   }
 };
@@ -446,22 +614,22 @@ class GitLabForge {
   }
   async unresolvedThreads(host, node) {
     let count = countUnresolved(node.discussions);
-    let page = node.discussions.pageInfo;
+    let page2 = node.discussions.pageInfo;
     let pages = 1;
-    while (page.hasNextPage && page.endCursor && pages < MAX_DISCUSSION_PAGES) {
+    while (page2.hasNextPage && page2.endCursor && pages < MAX_DISCUSSION_PAGES) {
       const data = await this.graphql(host, DISCUSSIONS_QUERY, {
         project: node.targetProject.fullPath,
         iid: node.iid,
-        after: page.endCursor
+        after: page2.endCursor
       });
       const next = data.project?.mergeRequest?.discussions;
       if (!next)
         break;
       count += countUnresolved(next);
-      page = next.pageInfo;
+      page2 = next.pageInfo;
       pages++;
     }
-    return { count, complete: !page.hasNextPage };
+    return { count, complete: !page2.hasNextPage };
   }
   async normalize(host, node) {
     const threads = await this.unresolvedThreads(host, node);
@@ -500,10 +668,12 @@ class GitLabForge {
 }
 
 // packages/forgekeeper/src/github.ts
+var COPILOT_AUTHOR = "copilot-pull-request-reviewer[bot]";
 var fields = `number title url state isDraft mergeable reviewDecision headRefOid headRefName
   headRepository { nameWithOwner } baseRepository { nameWithOwner } baseRefName updatedAt
   reviewThreads(first:100) { nodes { isResolved } pageInfo { hasNextPage endCursor } }
-  reviewRequests(first:100) { nodes { requestedReviewer { ... on User { login } ... on Team { name } } } pageInfo { hasNextPage } }
+  reviewRequests(first:100) { nodes { requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Team { name } } } pageInfo { hasNextPage endCursor } }
+  copilotReviews: reviews(last:1, author:"${COPILOT_AUTHOR}", states:[COMMENTED,CHANGES_REQUESTED,APPROVED,DISMISSED]) { nodes { id state comments { totalCount } } }
   commits(last:1) { nodes { commit { statusCheckRollup { contexts(first:100) {
     nodes { __typename ... on CheckRun { status conclusion detailsUrl } ... on StatusContext { state targetUrl } }
     pageInfo { hasNextPage endCursor }
@@ -561,22 +731,31 @@ var CONCLUSIONS = [
 ];
 var STATES = ["SUCCESS", "FAILURE", "ERROR", "PENDING", "EXPECTED"];
 function checks(nodes, complete, url) {
+  const count = (value) => `${value} check${value === 1 ? "" : "s"}`;
   const failed = nodes.filter((node) => FAILED.includes(node.conclusion ?? node.state ?? "")).length;
   const pending = nodes.filter((node) => node.status ? node.status !== "COMPLETED" : ["PENDING", "EXPECTED"].includes(node.state ?? "")).length;
   const unknown = nodes.some((node) => node.status === "COMPLETED" ? !CONCLUSIONS.includes(node.conclusion ?? "") : !node.status && !STATES.includes(node.state ?? ""));
   if (failed)
     return {
       status: "FAILED",
-      label: `${failed} failed${pending ? `, ${pending} pending` : ""}${complete ? "" : " (partial)"}`,
+      label: `${count(failed)} failed${pending ? `, ${count(pending)} pending` : ""}${complete ? "" : " (partial)"}`,
       url
     };
   if (pending || !complete || unknown)
     return {
       status: "PENDING",
-      label: `${pending ? `${pending} pending` : "unknown"}${complete ? "" : " (partial)"}`,
+      label: `${pending ? `${count(pending)} pending` : "unknown"}${complete ? "" : " (partial)"}`,
       url
     };
-  return { status: "SUCCESS", label: `${nodes.length} passed or skipped`, url };
+  const label = [
+    ["SUCCESS", "passed"],
+    ["SKIPPED", "skipped"],
+    ["NEUTRAL", "neutral"]
+  ].flatMap(([result, text]) => {
+    const total = nodes.filter((node) => (node.conclusion ?? node.state) === result).length;
+    return total ? [`${count(total)} ${text}`] : [];
+  }).join(", ");
+  return { status: "SUCCESS", label: label || "0 checks", url };
 }
 function parseGitHubUrl(url, pattern) {
   const ref = parseWebUrl("github", url, pattern);
@@ -597,8 +776,43 @@ var githubTraits = {
   indicators: (request) => request.reviewDecision === "CHANGES_REQUESTED" ? [{ text: "changes requested", tone: "warning", essential: true }] : [],
   details: (request) => [
     `Review decision: ${request.reviewDecision ? humanize(request.reviewDecision) : "not reported"}`
-  ]
+  ],
+  automatedReview: {
+    name: "GitHub Copilot",
+    status: (request) => copilotStatus(request.copilotReview)
+  },
+  feedback: {
+    async fetch(run, directory, request) {
+      const ref = githubTraits.parseUrl(request.url);
+      return ref ? fetchComments(ghGraphQL(run, directory), ref.host, ref.project, ref.iid) : undefined;
+    }
+  }
 };
+function copilotStatus(review) {
+  if (!review)
+    return;
+  const feedback = review.comments > 0 && !review.dismissed;
+  const label = review.dismissed ? "dismissed" : feedback ? "commented" : "no comments";
+  const completed = review.reviewID ? { id: review.reviewID, feedback, label } : undefined;
+  if (review.requested)
+    return { state: "running", label: "reviewing", completed };
+  if (!completed)
+    return;
+  return { state: feedback ? "feedback" : "settled", label, completed };
+}
+var isCopilotReviewer = (login) => /^copilot-pull-request-reviewer(\[bot\])?$/i.test(login ?? "");
+function copilotReview(node) {
+  const requested = node.reviewRequests.nodes.some((request) => isCopilotReviewer(request.requestedReviewer?.login));
+  const latest = node.copilotReviews?.nodes?.find((review) => review);
+  if (!requested && !latest)
+    return;
+  return {
+    requested,
+    reviewID: latest?.id,
+    comments: latest?.comments.totalCount ?? 0,
+    ...latest?.state === "DISMISSED" ? { dismissed: true } : {}
+  };
+}
 
 class GitHubForge {
   traits = githubTraits;
@@ -649,7 +863,7 @@ class GitHubForge {
       const [owner, repo] = target.path.split("/");
       let after;
       let complete = false;
-      for (let page = 0;page < MAX_PAGES; page++) {
+      for (let page2 = 0;page2 < MAX_PAGES; page2++) {
         const data = await this.graphql(target.host, query(`query($owner:String!,$repo:String!,$branch:String!${after ? ",$after:String!" : ""}) {
           repository(owner:$owner,name:$repo) { pullRequests(first:100,states:OPEN,headRefName:$branch${after ? ",after:$after" : ""}) {
             nodes { ${fields} } pageInfo { hasNextPage endCursor }
@@ -679,21 +893,21 @@ class GitHubForge {
   async threads(host, node) {
     const [owner, repo] = node.baseRepository.nameWithOwner.split("/");
     const threads = [...node.reviewThreads.nodes];
-    let page = node.reviewThreads.pageInfo;
-    for (let count = 1;page?.hasNextPage && page.endCursor && count < MAX_PAGES; count++) {
+    let page2 = node.reviewThreads.pageInfo;
+    for (let count = 1;page2?.hasNextPage && page2.endCursor && count < MAX_PAGES; count++) {
       const data = await this.graphql(host, query(`query($owner:String!,$repo:String!,$number:Int!,$after:String!) {
         repository(owner:$owner,name:$repo) { pullRequest(number:$number) {
           reviewThreads(first:100,after:$after) { nodes { isResolved } pageInfo { hasNextPage endCursor } }
-        } } }`), { owner, repo, number: node.number, after: page.endCursor });
+        } } }`), { owner, repo, number: node.number, after: page2.endCursor });
       const next = data.repository?.pullRequest?.reviewThreads;
       if (!next)
         break;
       threads.push(...next.nodes);
-      page = next.pageInfo;
+      page2 = next.pageInfo;
     }
     return {
       unresolved: threads.filter((thread) => !thread.isResolved).length,
-      complete: !page?.hasNextPage
+      complete: !page2?.hasNextPage
     };
   }
   async contexts(host, node) {
@@ -714,7 +928,33 @@ class GitHubForge {
     }
     return { nodes: contexts, complete: !cursor?.hasNextPage };
   }
+  async reviewers(host, node) {
+    const nodes = [...node.reviewRequests.nodes];
+    let reviewerPage = node.reviewRequests.pageInfo;
+    for (let count = 1;reviewerPage?.hasNextPage && count < MAX_PAGES; count++) {
+      if (!reviewerPage.endCursor)
+        throw new ForgeError("request", "GitHub reviewer pagination cursor missing");
+      const [owner, repo] = node.baseRepository.nameWithOwner.split("/");
+      const data = await this.graphql(host, query(`query($owner:String!,$repo:String!,$number:Int!,$after:String!) {
+            repository(owner:$owner,name:$repo) { pullRequest(number:$number) {
+              reviewRequests(first:100,after:$after) {
+                nodes { requestedReviewer { __typename ... on User { login } ... on Bot { login } ... on Team { name } } }
+                pageInfo { hasNextPage endCursor }
+              }
+            } }
+          }`), { owner, repo, number: node.number, after: reviewerPage.endCursor });
+      const next = data.repository?.pullRequest?.reviewRequests;
+      if (!next)
+        throw new ForgeError("request", "GitHub reviewers unavailable");
+      nodes.push(...next.nodes);
+      reviewerPage = next.pageInfo;
+    }
+    if (reviewerPage?.hasNextPage)
+      throw new ForgeError("request", "GitHub reviewers exceeded the pagination limit");
+    return { nodes, pageInfo: reviewerPage };
+  }
   async normalize(host, node) {
+    const reviewers = await this.reviewers(host, node);
     const [threads, contexts] = [await this.threads(host, node), await this.contexts(host, node)];
     return {
       forge: "github",
@@ -727,11 +967,14 @@ class GitHubForge {
       conflictsKnown: node.mergeable !== "UNKNOWN",
       approved: node.reviewDecision === "APPROVED",
       reviewDecision: node.reviewDecision ?? undefined,
-      awaitingReviewers: node.reviewRequests.nodes.flatMap((request) => {
+      copilotReview: copilotReview({ ...node, reviewRequests: reviewers }),
+      awaitingReviewers: reviewers.nodes.flatMap((request) => {
         const reviewer = request.requestedReviewer;
+        if (reviewer?.__typename === "Bot")
+          return [];
         return reviewer?.login ? [reviewer.login] : reviewer?.name ? [reviewer.name] : [];
       }),
-      reviewersComplete: !node.reviewRequests.pageInfo?.hasNextPage,
+      reviewersComplete: !reviewers.pageInfo?.hasNextPage,
       targetProject: node.baseRepository.nameWithOwner,
       targetBranch: node.baseRefName,
       headSha: node.headRefOid,
@@ -1023,11 +1266,33 @@ function automatedReview(request) {
   return reviewer && status2 ? { name: reviewer.name, ...status2 } : undefined;
 }
 var isReviewRunning = (lookup) => requests(lookup).some((request) => automatedReview(request)?.state === "running");
+function hasFeedback(review) {
+  if (!review)
+    return false;
+  if (review.completed)
+    return review.completed.feedback;
+  return review.state === "feedback";
+}
 function finishedReviews(previous, next) {
-  const running = new Set(requests(previous).filter((request) => automatedReview(request)?.state === "running").map((request) => request.url));
-  return requests(next).filter((request) => running.has(request.url) && automatedReview(request)?.state === "feedback");
+  const before = new Map(requests(previous).map((request) => [request.url, request]));
+  return requests(next).filter((request) => {
+    const review = automatedReview(request);
+    if (!hasFeedback(review))
+      return false;
+    const earlier = before.get(request.url);
+    if (!earlier)
+      return false;
+    const was = automatedReview(earlier);
+    if (review?.completed)
+      return review.completed.id !== was?.completed?.id;
+    return was?.state === "running";
+  });
 }
 var reviewer = (request) => automatedReview(request)?.name ?? "The automated reviewer";
+function outcomeLabel(request) {
+  const review = automatedReview(request);
+  return review?.completed?.label ?? review?.label ?? "";
+}
 var shared = (requests2, value, fallback) => {
   const values = new Set(requests2.map(value));
   return values.size === 1 ? [...values][0] : fallback;
@@ -1035,7 +1300,7 @@ var shared = (requests2, value, fallback) => {
 var reviewers = (requests2) => shared(requests2, reviewer, "Automated reviewers");
 var nouns = (requests2) => shared(requests2, (request) => `${traitsOf(request).noun}s`, "PRs/MRs");
 function reviewOutcome(request) {
-  const label = automatedReview(request)?.label ?? "";
+  const label = outcomeLabel(request);
   return label.charAt(0).toUpperCase() + label.slice(1);
 }
 function reviewTitle(requests2) {
@@ -1044,7 +1309,7 @@ function reviewTitle(requests2) {
   return `${reviewers(requests2)} finished reviewing ${requests2.length} ${nouns(requests2)}`;
 }
 function reviewMessage(requests2) {
-  const state = (request) => `the state "${automatedReview(request)?.label ?? ""}"`;
+  const state = (request) => `the state "${outcomeLabel(request)}"`;
   if (requests2.length === 1) {
     const [request] = requests2;
     const name2 = reviewer(request);
@@ -1062,7 +1327,7 @@ function reviewMessage(requests2) {
 `);
 }
 function reviewToast(requests2) {
-  const outcome = requests2.length === 1 ? reviewOutcome(requests2[0]) : requests2.map((request) => `${reference(request)}: ${automatedReview(request)?.label ?? ""}`).join(", ");
+  const outcome = requests2.length === 1 ? reviewOutcome(requests2[0]) : requests2.map((request) => `${reference(request)}: ${outcomeLabel(request)}`).join(", ");
   return { title: reviewTitle(requests2), message: `${outcome}. Sent to the agent.` };
 }
 var RETRY_DELAY = 10 * 60000;
@@ -1073,7 +1338,23 @@ function createAutomatedReviewWatcher(options) {
   const now = options.now ?? Date.now;
   const known = new Map;
   const sending = new Set;
+  const histories = new Map;
   const write = (sessionID, url, delivery) => options.write?.(sessionID, url, delivery);
+  async function observeCompletion(sessionID, request) {
+    const completed = automatedReview(request)?.completed;
+    if (!completed)
+      return;
+    const key2 = notificationKey(sessionID, request);
+    const history = histories.get(key2) ?? await options.readHistory?.(sessionID, request.url);
+    const alreadyObserved = history?.observed.includes(completed.id) === true;
+    const current = history ?? { observed: [], delivered: [] };
+    histories.set(key2, current);
+    if (!alreadyObserved) {
+      current.observed.push(completed.id);
+      options.writeHistory?.(sessionID, request.url, current);
+    }
+    return { alreadyObserved, newFeedback: !!history && !alreadyObserved && completed.feedback };
+  }
   return {
     async observe(sessionID, previous, next) {
       const pending = known.get(sessionID) ?? { ...await options.read?.(sessionID) };
@@ -1082,7 +1363,8 @@ function createAutomatedReviewWatcher(options) {
       const targets = requests(next).filter((request) => isOpen(request) && options.isTarget(sessionID, request.url));
       for (const [key2, entry] of Object.entries(pending)) {
         const request = targets.find((target2) => target2.url === entry.url);
-        if (request && automatedReview(request)?.state === "feedback" && at - entry.since < PENDING_RETENTION)
+        const completed = request && automatedReview(request)?.completed;
+        if (request && hasFeedback(automatedReview(request)) && at - entry.since < PENDING_RETENTION && (!entry.reviewID || completed?.id === entry.reviewID))
           continue;
         if (sending.has(key2))
           continue;
@@ -1090,6 +1372,16 @@ function createAutomatedReviewWatcher(options) {
         write(sessionID, entry.url);
       }
       const finished = finishedReviews(previous, next).filter((request) => isOpen(request) && options.isTarget(sessionID, request.url));
+      for (const request of targets) {
+        const observation = await observeCompletion(sessionID, request);
+        if (!observation)
+          continue;
+        const index = finished.findIndex((item) => item.url === request.url);
+        if (observation.alreadyObserved && index >= 0)
+          finished.splice(index, 1);
+        if (observation.newFeedback && index < 0)
+          finished.push(request);
+      }
       const due = targets.filter((request) => (pending[notificationKey(sessionID, request)]?.retryAt ?? Infinity) <= at);
       const batch = [
         ...new Map([...finished, ...due].map((request) => [request.url, request])).values()
@@ -1102,6 +1394,12 @@ function createAutomatedReviewWatcher(options) {
       try {
         await options.send(sessionID, batch);
         batch.forEach((request, index) => {
+          const history = histories.get(keys[index]);
+          const completed = automatedReview(request)?.completed;
+          if (history && completed && !history.delivered.includes(completed.id)) {
+            history.delivered.push(completed.id);
+            options.writeHistory?.(sessionID, request.url, history);
+          }
           delete pending[keys[index]];
           write(sessionID, request.url);
         });
@@ -1109,7 +1407,14 @@ function createAutomatedReviewWatcher(options) {
         const retryAt = now() + RETRY_DELAY;
         batch.forEach((request, index) => {
           const key2 = keys[index];
-          pending[key2] = { sessionID, url: request.url, since: pending[key2]?.since ?? at, retryAt };
+          const reviewID = automatedReview(request)?.completed?.id;
+          pending[key2] = {
+            sessionID,
+            url: request.url,
+            since: pending[key2]?.since ?? at,
+            retryAt,
+            ...reviewID ? { reviewID } : {}
+          };
           write(sessionID, request.url, pending[key2]);
         });
         options.onSendError?.(error, sessionID, batch);
@@ -1119,7 +1424,13 @@ function createAutomatedReviewWatcher(options) {
       }
     },
     hasPending: (sessionID) => Object.keys(known.get(sessionID) ?? {}).length > 0,
-    forget: (sessionID) => void known.delete(sessionID)
+    forget(sessionID) {
+      known.delete(sessionID);
+      for (const key2 of histories.keys()) {
+        if (key2.startsWith(`${sessionID} `))
+          histories.delete(key2);
+      }
+    }
   };
 }
 
@@ -1136,11 +1447,17 @@ function applyFeedback(record, change, now) {
   for (const id of change.announced ?? [])
     if (!announced.includes(id))
       announced.push(id);
-  return { baseline: record?.baseline ?? change.baseline ?? 0, announced, seenAt: now };
+  const baselineIDs = record?.baselineIDs ?? change.baselineIDs;
+  return {
+    baseline: record?.baseline ?? change.baseline ?? 0,
+    ...baselineIDs ? { baselineIDs } : {},
+    announced,
+    seenAt: now
+  };
 }
 var isExpired = (record, now) => now - record.seenAt > RECORD_RETENTION;
 var baselineOf = (snapshot2) => snapshot2.comments.reduce((highest, comment) => Math.max(highest, comment.order), 0);
-var isNew = (comment, seen) => comment.order > seen.baseline && !seen.announced.has(comment.id);
+var isNew = (comment, seen) => (comment.order > seen.baseline || comment.order === seen.baseline && seen.baselineIDs !== undefined && !seen.baselineIDs.includes(comment.id)) && !seen.announced.has(comment.id);
 var humanFeedback = (snapshot2) => snapshot2.comments.filter((comment) => !comment.bot && comment.authorID !== snapshot2.viewerID && !comment.resolved);
 function eligibleFeedback(snapshot2, seen, now) {
   const human = humanFeedback(snapshot2);
@@ -1188,13 +1505,19 @@ function createFeedbackWatcher(options) {
     const mine = local.get(key2);
     if (!shared2 && !mine)
       return;
+    const latest = (mine?.baseline ?? -1) >= (shared2?.baseline ?? -1) ? mine : shared2;
     return {
       baseline: Math.max(shared2?.baseline ?? 0, mine?.baseline ?? 0),
+      baselineIDs: latest?.baselineIDs,
       announced: new Set([...shared2?.announced ?? [], ...mine?.announced ?? []])
     };
   };
   const remember = (key2, change, at) => {
-    const mine = local.get(key2) ?? { baseline: change.baseline ?? 0, announced: new Set };
+    const mine = local.get(key2) ?? {
+      baseline: change.baseline ?? 0,
+      baselineIDs: change.baselineIDs,
+      announced: new Set
+    };
     for (const id of change.announced ?? [])
       mine.announced.add(id);
     local.set(key2, mine);
@@ -1207,8 +1530,11 @@ function createFeedbackWatcher(options) {
     const stored = await options.record(key2);
     const at = now();
     const previous = seen(key2, stored);
-    if (!previous)
-      return remember(key2, { baseline: baselineOf(snapshot2) }, at);
+    if (!previous) {
+      const baseline = baselineOf(snapshot2);
+      const baselineIDs = snapshot2.comments.filter((comment) => comment.order === baseline).map((comment) => comment.id);
+      return remember(key2, { baseline, baselineIDs }, at);
+    }
     if (at < (retryAt.get(key2) ?? 0))
       return;
     const comments = eligibleFeedback(snapshot2, previous, at).filter((comment) => !reserved.has(`${key2} ${comment.id}`));
@@ -1845,6 +2171,7 @@ var FEEDBACK_PREFIX = "status/feedback/";
 var pendingPrefix = (sessionID) => `${PENDING_PREFIX}${encodeURIComponent(sessionID)}/`;
 var pendingKey = (sessionID, url) => `${pendingPrefix(sessionID)}${encodeURIComponent(url)}`;
 var feedbackRecordKey = (key2) => `${FEEDBACK_PREFIX}${encodeURIComponent(key2)}`;
+var reviewHistoryKey = (sessionID, url) => `status/reviews/${encodeURIComponent(sessionID)}/${encodeURIComponent(url)}`;
 function userTitle(title, prefix) {
   if (!title || !prefix)
     return title;
@@ -1868,9 +2195,9 @@ async function setupStatus(ctx, settings, deps, host) {
     const entries = [];
     let after;
     do {
-      const page = await ctx.storage.scan({ prefix, ...after ? { after } : {} });
-      entries.push(...page.entries);
-      after = page.next;
+      const page2 = await ctx.storage.scan({ prefix, ...after ? { after } : {} });
+      entries.push(...page2.entries);
+      after = page2.next;
     } while (after);
     return entries;
   }
@@ -1926,6 +2253,11 @@ async function setupStatus(ctx, settings, deps, host) {
   const automated = settings.notifyAutomatedReviews ? createAutomatedReviewWatcher({
     isTarget,
     now: deps.now,
+    readHistory: async (sessionID, url) => await ctx.storage.get(reviewHistoryKey(sessionID, url)),
+    writeHistory: (sessionID, url, history) => {
+      const snapshot2 = { observed: [...history.observed], delivered: [...history.delivered] };
+      write(() => ctx.storage.set(reviewHistoryKey(sessionID, url), snapshot2));
+    },
     async read(sessionID) {
       const deliveries = {};
       for (const { value } of await scanAll(pendingPrefix(sessionID))) {