opencode-forgekeeper 2.1.0 → 2.2.0

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 }
@@ -597,8 +767,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 +854,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 +884,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 +919,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 +958,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 +1257,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 +1291,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 +1300,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 +1318,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 +1329,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 +1354,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 +1363,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 +1385,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 +1398,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 +1415,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 +1438,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 +1496,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 +1521,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}`));
@@ -1255,6 +1572,175 @@ function createFeedbackWatcher(options) {
   };
 }
 
+// packages/forgekeeper/src/store.ts
+class TargetLookupError extends Error {
+  cause;
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : String(cause));
+    this.cause = cause;
+  }
+}
+function createStatusStore(options) {
+  const now = options.now ?? Date.now;
+  const setTimer = options.setTimer ?? ((callback, delay) => setTimeout(callback, delay));
+  const clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
+  const interval = options.interval ?? 120000;
+  const maxBackoff = options.maxBackoff ?? 900000;
+  const minEventInterval = options.minEventInterval ?? 15000;
+  const entries = new Map;
+  let disposed = false;
+  let revision = now() * 1000;
+  const entry = (key2) => {
+    let value = entries.get(key2);
+    if (!value) {
+      value = { snapshot: { loading: false }, refs: 0, failures: 0 };
+      entries.set(key2, value);
+    }
+    return value;
+  };
+  const update = (key2, value, patch) => {
+    value.snapshot = { ...value.snapshot, ...patch, revision: ++revision };
+    if (!disposed)
+      options.onChange(key2);
+  };
+  const cancelTimer = (value) => {
+    if (value.timer === undefined)
+      return;
+    clearTimer(value.timer);
+    value.timer = undefined;
+  };
+  const baseInterval = (value) => options.active?.(value.snapshot.lookup) ? options.activeInterval ?? interval : interval;
+  const pollDelay = (value) => Math.min(baseInterval(value) * 2 ** value.failures, maxBackoff);
+  const lastAttempt = (value) => Math.max(value.snapshot.fetchedAt ?? -Infinity, value.snapshot.error?.at ?? -Infinity);
+  const schedule = (key2, value, delay = pollDelay(value)) => {
+    cancelTimer(value);
+    if (disposed || value.refs === 0)
+      return;
+    const lookup = value.snapshot.lookup;
+    if (!value.snapshot.error && (lookup?.kind !== "found" || lookup.requests.length === 0))
+      return;
+    value.timer = setTimer(() => {
+      value.timer = undefined;
+      refresh(key2);
+    }, delay);
+  };
+  function refresh(key2) {
+    if (disposed)
+      return Promise.resolve({ loading: false });
+    const value = entry(key2);
+    if (value.inflight)
+      return value.inflight;
+    value.stale = false;
+    update(key2, value, { loading: true });
+    value.inflight = options.load(key2).then((lookup) => {
+      if (disposed || value.invalidated)
+        return;
+      const previous = value.snapshot.lookup;
+      value.failures = 0;
+      update(key2, value, {
+        lookup,
+        fetchedAt: now(),
+        error: undefined,
+        targeted: lookup.explicitTarget === true ? true : undefined,
+        loading: false
+      });
+      try {
+        if (!disposed)
+          options.onLoad?.(key2, previous, lookup);
+      } catch (error) {
+        try {
+          options.onLoadError?.(error);
+        } catch {}
+      }
+    }, (error) => {
+      if (disposed || value.invalidated)
+        return;
+      value.failures++;
+      const target2 = error instanceof TargetLookupError;
+      const cause = target2 ? error.cause : error;
+      update(key2, value, {
+        loading: false,
+        error: {
+          kind: cause instanceof ForgeError ? cause.kind : "request",
+          message: cause instanceof Error ? cause.message : String(cause),
+          at: now()
+        },
+        ...target2 ? { targeted: true } : {}
+      });
+    }).then(() => {
+      value.inflight = undefined;
+      if (value.invalidated && !disposed) {
+        value.invalidated = false;
+        return refresh(key2);
+      }
+      schedule(key2, value);
+      return value.snapshot;
+    });
+    return value.inflight;
+  }
+  return {
+    get(key2) {
+      return entries.get(key2)?.snapshot ?? { loading: false };
+    },
+    acquire(key2) {
+      const value = entry(key2);
+      value.refs++;
+      if (value.refs === 1 && !value.inflight) {
+        const remaining = lastAttempt(value) + pollDelay(value) - now();
+        if (value.stale || remaining <= 0)
+          refresh(key2);
+        else
+          schedule(key2, value, remaining);
+      }
+      let released = false;
+      return () => {
+        if (released)
+          return;
+        released = true;
+        value.refs--;
+        if (value.refs === 0)
+          cancelTimer(value);
+      };
+    },
+    refresh,
+    keys() {
+      return [...entries.keys()];
+    },
+    notify(key2) {
+      const value = entries.get(key2);
+      if (!value || value.refs === 0 || value.inflight)
+        return;
+      const last = Math.max(value.snapshot.fetchedAt ?? 0, value.snapshot.error?.at ?? 0);
+      if (now() - last < minEventInterval)
+        return;
+      refresh(key2);
+    },
+    invalidate(key2) {
+      const value = entries.get(key2);
+      if (!value)
+        return;
+      if (value.inflight)
+        value.invalidated = true;
+      else if (value.refs > 0)
+        refresh(key2);
+      else
+        value.stale = true;
+    },
+    setTargeted(key2, targeted) {
+      const value = entries.get(key2);
+      if (!value || disposed || value.snapshot.targeted === true === targeted)
+        return;
+      update(key2, value, { targeted: targeted ? true : undefined });
+    },
+    dispose() {
+      disposed = true;
+      for (const value of entries.values())
+        cancelTimer(value);
+      entries.clear();
+    }
+  };
+}
+
 // packages/forgekeeper/src/target.ts
 var MAX_TARGETS = 50;
 var PREFIX_REFERENCES = 4;
@@ -1466,11 +1952,12 @@ async function locateTargets(forges, directory, targets, previous) {
     });
   });
   if (error !== undefined && !outcomes.some((outcome) => ("request" in outcome)))
-    throw error;
+    throw new TargetLookupError(error);
   if (found.length === 0)
     return {
       kind: "none",
-      reason: requests2.length === 1 ? failed[0].reason : "No session target PR/MR could be resolved"
+      reason: requests2.length === 1 ? failed[0].reason : "No session target PR/MR could be resolved",
+      explicitTarget: true
     };
   return {
     kind: "found",
@@ -1516,154 +2003,6 @@ async function locate(forges, hints) {
   };
 }
 
-// packages/forgekeeper/src/store.ts
-function createStatusStore(options) {
-  const now = options.now ?? Date.now;
-  const setTimer = options.setTimer ?? ((callback, delay) => setTimeout(callback, delay));
-  const clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
-  const interval = options.interval ?? 120000;
-  const maxBackoff = options.maxBackoff ?? 900000;
-  const minEventInterval = options.minEventInterval ?? 15000;
-  const entries = new Map;
-  let disposed = false;
-  let revision = now() * 1000;
-  const entry = (key2) => {
-    let value = entries.get(key2);
-    if (!value) {
-      value = { snapshot: { loading: false }, refs: 0, failures: 0 };
-      entries.set(key2, value);
-    }
-    return value;
-  };
-  const update = (key2, value, patch) => {
-    value.snapshot = { ...value.snapshot, ...patch, revision: ++revision };
-    if (!disposed)
-      options.onChange(key2);
-  };
-  const cancelTimer = (value) => {
-    if (value.timer === undefined)
-      return;
-    clearTimer(value.timer);
-    value.timer = undefined;
-  };
-  const baseInterval = (value) => options.active?.(value.snapshot.lookup) ? options.activeInterval ?? interval : interval;
-  const pollDelay = (value) => Math.min(baseInterval(value) * 2 ** value.failures, maxBackoff);
-  const lastAttempt = (value) => Math.max(value.snapshot.fetchedAt ?? -Infinity, value.snapshot.error?.at ?? -Infinity);
-  const schedule = (key2, value, delay = pollDelay(value)) => {
-    cancelTimer(value);
-    if (disposed || value.refs === 0)
-      return;
-    const lookup = value.snapshot.lookup;
-    if (!value.snapshot.error && (lookup?.kind !== "found" || lookup.requests.length === 0))
-      return;
-    value.timer = setTimer(() => {
-      value.timer = undefined;
-      refresh(key2);
-    }, delay);
-  };
-  function refresh(key2) {
-    if (disposed)
-      return Promise.resolve({ loading: false });
-    const value = entry(key2);
-    if (value.inflight)
-      return value.inflight;
-    value.stale = false;
-    update(key2, value, { loading: true });
-    value.inflight = options.load(key2).then((lookup) => {
-      if (disposed || value.invalidated)
-        return;
-      const previous = value.snapshot.lookup;
-      value.failures = 0;
-      update(key2, value, { lookup, fetchedAt: now(), error: undefined, loading: false });
-      try {
-        if (!disposed)
-          options.onLoad?.(key2, previous, lookup);
-      } catch (error) {
-        try {
-          options.onLoadError?.(error);
-        } catch {}
-      }
-    }, (error) => {
-      if (disposed || value.invalidated)
-        return;
-      value.failures++;
-      const known = error instanceof ForgeError;
-      update(key2, value, {
-        loading: false,
-        error: {
-          kind: known ? error.kind : "request",
-          message: error instanceof Error ? error.message : String(error),
-          at: now()
-        }
-      });
-    }).then(() => {
-      value.inflight = undefined;
-      if (value.invalidated && !disposed) {
-        value.invalidated = false;
-        return refresh(key2);
-      }
-      schedule(key2, value);
-      return value.snapshot;
-    });
-    return value.inflight;
-  }
-  return {
-    get(key2) {
-      return entries.get(key2)?.snapshot ?? { loading: false };
-    },
-    acquire(key2) {
-      const value = entry(key2);
-      value.refs++;
-      if (value.refs === 1 && !value.inflight) {
-        const remaining = lastAttempt(value) + pollDelay(value) - now();
-        if (value.stale || remaining <= 0)
-          refresh(key2);
-        else
-          schedule(key2, value, remaining);
-      }
-      let released = false;
-      return () => {
-        if (released)
-          return;
-        released = true;
-        value.refs--;
-        if (value.refs === 0)
-          cancelTimer(value);
-      };
-    },
-    refresh,
-    keys() {
-      return [...entries.keys()];
-    },
-    notify(key2) {
-      const value = entries.get(key2);
-      if (!value || value.refs === 0 || value.inflight)
-        return;
-      const last = Math.max(value.snapshot.fetchedAt ?? 0, value.snapshot.error?.at ?? 0);
-      if (now() - last < minEventInterval)
-        return;
-      refresh(key2);
-    },
-    invalidate(key2) {
-      const value = entries.get(key2);
-      if (!value)
-        return;
-      if (value.inflight)
-        value.invalidated = true;
-      else if (value.refs > 0)
-        refresh(key2);
-      else
-        value.stale = true;
-    },
-    dispose() {
-      disposed = true;
-      for (const value of entries.values())
-        cancelTimer(value);
-      entries.clear();
-    }
-  };
-}
-
 // packages/forgekeeper/src/status-service.ts
 function createStatusService(options) {
   const now = options.now ?? Date.now;
@@ -1791,6 +2130,7 @@ function createStatusService(options) {
       if (!disposed && !holds.has(key2) && liveLeases(key2).length > 0)
         store.refresh(key2);
     },
+    setTargeted: (key2, targeted) => store.setTargeted(key2, targeted),
     notify: (key2) => store.notify(key2),
     keys: () => store.keys(),
     polling: (key2) => holds.has(key2),
@@ -1822,6 +2162,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;
@@ -1845,9 +2186,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;
   }
@@ -1903,6 +2244,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))) {
@@ -1995,7 +2341,11 @@ async function setupStatus(ctx, settings, deps, host) {
   });
   return {
     service,
-    targetsChanged: (sessionID) => service.invalidate(sessionID),
+    targetsChanged(sessionID, targets) {
+      const classified = classifyTargets(targetOutput(targets)) ?? [];
+      service.setTargeted(sessionID, classified.some((target2) => target2.kind === "merge-request"));
+      service.invalidate(sessionID);
+    },
     async titleChanged(sessionID) {
       if (!service.keys().includes(sessionID))
         return;
@@ -2243,7 +2593,7 @@ async function setupServer(ctx, lookups, status2) {
             targets: result.targets,
             ...state.prefix ? { prefix: state.prefix } : {}
           });
-          watcher?.targetsChanged(sessionID);
+          watcher?.targetsChanged(sessionID, result.targets);
           await rpc.events.emit("targetChanged", { sessionID, ...targetOutput(result.targets) });
           await update(sessionID);
         });