@sentry/junior-github 0.200.0 → 0.202.0

package/dist/{chunk-6OPIFILN.js → chunk-F2PJG6AF.js}

@@ -82,6 +82,20 @@ var GITHUB_PULL_REQUEST_EVENTS = [
   "pull_request.merged",
   "pull_request.closed_unmerged"
 ];
+var GITHUB_PULL_REQUEST_EVENT_GUIDANCE = {
+  "pull_request.comment.created": 'After acting on actionable feedback, call github_updatePullRequestFeedback with the exact repo, commentId, and commentKind from Verified details, and status "addressed" or "declined".',
+  "pull_request.review_comment.created": 'After acting on actionable feedback, call github_updatePullRequestFeedback with the exact repo, commentId, and commentKind from Verified details, and status "addressed" or "declined". Then resolve the thread with github_resolvePullRequestReviewThread.'
+};
+function gitHubPullRequestEventGuidance(guidance) {
+  const merged = { ...GITHUB_PULL_REQUEST_EVENT_GUIDANCE };
+  for (const eventType of GITHUB_PULL_REQUEST_EVENTS) {
+    const extra = guidance?.[eventType]?.trim();
+    if (!extra) continue;
+    const base = merged[eventType];
+    merged[eventType] = base ? `${base} ${extra}` : extra;
+  }
+  return merged;
+}
 var GITHUB_PULL_REQUEST_SUGGESTED_EVENTS = [
   "pull_request.checks.failed",
   "pull_request.comment.created",
@@ -1374,6 +1388,7 @@ var issueCommentWebhookSchema = z2.object({
   action: z2.string(),
   comment: z2.object({
     body: z2.string(),
+    id: z2.number(),
     user: z2.object({ login: z2.string().optional() }).optional()
   }),
   issue: z2.object({
@@ -1400,7 +1415,13 @@ function normalizeIssueCommentEvents(deliveryId, body) {
     const resource = gitHubPullRequestResource(input);
     const data = pullRequestMatchData([
       pullRequestDraftData(parsed.data.issue.draft),
-      pullRequestAuthorData(parsed.data.issue.user)
+      pullRequestAuthorData(parsed.data.issue.user),
+      {
+        repo: input.repo,
+        pullRequest: input.number,
+        commentId: parsed.data.comment.id,
+        commentKind: "conversation"
+      }
     ]);
     return pullRequestTargets2(
       {
@@ -1493,6 +1514,7 @@ var pullRequestReviewCommentWebhookSchema = z2.object({
   action: z2.string(),
   comment: z2.object({
     body: z2.string(),
+    id: z2.number(),
     user: z2.object({ login: z2.string().optional() }).optional()
   }),
   pull_request: z2.object({
@@ -1521,7 +1543,13 @@ function normalizePullRequestReviewCommentEvent(deliveryId, body) {
   const data = pullRequestMatchData([
     pullRequestDraftData(parsed.data.pull_request.draft),
     pullRequestAuthorData(parsed.data.pull_request.user),
-    pullRequestHeadBranchData(parsed.data.pull_request.head?.ref)
+    pullRequestHeadBranchData(parsed.data.pull_request.head?.ref),
+    {
+      repo,
+      pullRequest: parsed.data.pull_request.number,
+      commentId: parsed.data.comment.id,
+      commentKind: "review"
+    }
   ]);
   return pullRequestTargets2(
     {
@@ -1810,6 +1838,7 @@ export {
   GITHUB_DEPLOYMENT_SUGGESTED_EVENTS,
   gitHubDeploymentSourceSubscribable,
   GITHUB_PULL_REQUEST_EVENTS,
+  gitHubPullRequestEventGuidance,
   GITHUB_PULL_REQUEST_SUGGESTED_EVENTS,
   GITHUB_PULL_REQUEST_MATCH_FIELDS,
   gitHubPullRequestSubscribable,

package/dist/index.js

@@ -23,6 +23,7 @@ import {
   credentialUnavailable,
   gitHubDeploymentSourceSubscribable,
   gitHubIssueSubscribable,
+  gitHubPullRequestEventGuidance,
   gitHubPullRequestSubscribable,
   gitHubReleaseSourceSubscribable,
   gitHubRepositorySubscribable,
@@ -42,7 +43,7 @@ import {
   readGrantPermissions,
   requireEnv,
   resolveUserAccount
-} from "./chunk-6OPIFILN.js";
+} from "./chunk-F2PJG6AF.js";
 
 // src/plugin.ts
 import {
@@ -1997,7 +1998,7 @@ function createGitHubUpdatePullRequestTool(ctx) {
   });
 }
 
-// src/tools/resolve-pull-request-review-thread.ts
+// src/tools/update-pull-request-feedback.ts
 import {
   definePluginTool as definePluginTool10,
   PluginToolInputError as PluginToolInputError11,
@@ -2022,21 +2023,33 @@ function botUserIdFromEmail(value) {
   return parseGitHubBotIdentity(value)?.userId;
 }
 
-// src/tools/resolve-pull-request-review-thread.ts
+// src/tools/update-pull-request-feedback.ts
+var STATUS_TO_REACTION_CONTENT = {
+  reviewing: "eyes",
+  addressed: "+1",
+  declined: "-1"
+};
+var FEEDBACK_REACTION_CONTENTS = new Set(
+  Object.values(STATUS_TO_REACTION_CONTENT)
+);
 var inputSchema8 = z10.object({
-  repo: z10.string().describe(
-    'Repository in "owner/name" format. Required because GraphQL has no repo path.'
+  repo: z10.string().describe('Repository in "owner/name" format.'),
+  commentKind: z10.enum(["conversation", "review"]).describe(
+    'Comment kind: "conversation" for a pull request conversation comment, "review" for an inline review comment.'
   ),
-  threadId: z10.string().trim().min(1).describe(
-    "GitHub pull request review thread node ID (the same `threadId` / `id` variable used by `gh api graphql` resolveReviewThread)."
+  commentId: z10.number().int().positive().describe(
+    "GitHub comment id (conversation comment id or inline review comment id)."
+  ),
+  status: z10.enum(["reviewing", "addressed", "declined"]).describe(
+    "Feedback status. Maps to a reaction: reviewing -> eyes, addressed -> +1, declined -> -1."
   )
 }).strict();
 var outputSchema8 = pluginToolOutputSchema10.extend({
-  target: z10.literal("resolvePullRequestReviewThread"),
+  target: z10.literal("updatePullRequestFeedback"),
   repo: z10.string(),
-  number: z10.number(),
-  threadId: z10.string(),
-  resolved: z10.boolean()
+  commentId: z10.number(),
+  status: z10.enum(["reviewing", "addressed", "declined"]),
+  reactionId: z10.number()
 });
 function parseRepo10(value) {
   const parts = value.split("/").map((part) => part.trim());
@@ -2045,6 +2058,13 @@ function parseRepo10(value) {
   }
   return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
 }
+function pullRequestCommentReactionsPath(input) {
+  const segment = input.commentKind === "conversation" ? "issues" : "pulls";
+  return `/repos/${encodeURIComponent(input.owner)}/${encodeURIComponent(input.name)}/${segment}/comments/${input.commentId}/reactions`;
+}
+function pullRequestFeedbackReactionContent(status) {
+  return STATUS_TO_REACTION_CONTENT[status];
+}
 async function readJson7(response) {
   const text2 = await response.text();
   if (!text2) return void 0;
@@ -2061,7 +2081,12 @@ function githubError(payload) {
   }
   return "GitHub request failed";
 }
-function createGitHubResolvePullRequestReviewThreadTool(ctx, botEmail) {
+var reactionSchema = z10.object({
+  id: z10.number(),
+  content: z10.string(),
+  user: z10.object({ id: z10.number() }).nullable()
+});
+function createGitHubUpdatePullRequestFeedbackTool(ctx, botEmail) {
   return definePluginTool10({
     annotations: {
       destructiveHint: true,
@@ -2069,22 +2094,175 @@ function createGitHubResolvePullRequestReviewThreadTool(ctx, botEmail) {
       openWorldHint: true,
       readOnlyHint: false
     },
-    description: "Resolve a GitHub pull request review thread. Use this instead of shelling out to `gh api graphql` for resolveReviewThread (GraphQL-only; no REST or `gh pr` equivalent). Only works on pull requests the bot authored.",
+    description: "Set Junior's status reaction on GitHub pull request feedback: reviewing (eyes), addressed (+1), or declined (-1). Use the commentId and commentKind from the resource event. Replaces only Junior's prior status reaction on that comment.",
+    exposure: "direct",
     inputSchema: inputSchema8,
     outputSchema: outputSchema8,
     async execute(input) {
       const parsedInput = inputSchema8.safeParse(input);
       if (!parsedInput.success) {
         throw new PluginToolInputError11(
-          "Invalid GitHub resolvePullRequestReviewThread input.",
+          "Invalid GitHub updatePullRequestFeedback input.",
           { cause: parsedInput.error }
         );
       }
+      const { commentId, commentKind, status } = parsedInput.data;
       const repo = parseRepo10(parsedInput.data.repo);
       const botUserId = botUserIdFromEmail(botEmail);
       if (botUserId === void 0) {
         throw new Error("GitHub App bot identity is not configured.");
       }
+      const targetContent = pullRequestFeedbackReactionContent(status);
+      const baseUrl = `https://api.github.com${pullRequestCommentReactionsPath({
+        owner: repo.owner,
+        name: repo.name,
+        commentKind,
+        commentId
+      })}`;
+      const listResponse = await ctx.egress.fetch({
+        provider: "github",
+        operation: "github.pull.comment-reaction.list",
+        request: new Request(`${baseUrl}?per_page=100`, {
+          headers: { Accept: "application/vnd.github+json" }
+        })
+      });
+      const listPayload = await readJson7(listResponse);
+      if (!listResponse.ok) {
+        throw new Error(
+          `GitHub reaction lookup failed with HTTP ${listResponse.status}: ${githubError(listPayload)}`
+        );
+      }
+      const botReactions = z10.array(reactionSchema).parse(listPayload).filter(
+        (reaction) => reaction.user?.id === botUserId && FEEDBACK_REACTION_CONTENTS.has(reaction.content)
+      );
+      const existing = botReactions.find(
+        (reaction) => reaction.content === targetContent
+      );
+      for (const stale of botReactions) {
+        if (stale.content === targetContent) continue;
+        const deleteResponse = await ctx.egress.fetch({
+          provider: "github",
+          operation: "github.pull.comment-reaction.delete",
+          request: new Request(`${baseUrl}/${stale.id}`, {
+            method: "DELETE"
+          })
+        });
+        if (!deleteResponse.ok && deleteResponse.status !== 404) {
+          const deletePayload = await readJson7(deleteResponse);
+          throw new Error(
+            `GitHub reaction removal failed with HTTP ${deleteResponse.status}: ${githubError(deletePayload)}`
+          );
+        }
+      }
+      if (existing) {
+        return {
+          target: "updatePullRequestFeedback",
+          repo: repo.ref,
+          commentId,
+          status,
+          reactionId: existing.id
+        };
+      }
+      const createResponse = await ctx.egress.fetch({
+        provider: "github",
+        operation: "github.pull.comment-reaction.create",
+        request: new Request(baseUrl, {
+          method: "POST",
+          headers: {
+            Accept: "application/vnd.github+json",
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ content: targetContent })
+        })
+      });
+      const createPayload = await readJson7(createResponse);
+      if (!createResponse.ok) {
+        throw new Error(
+          `GitHub reaction creation failed with HTTP ${createResponse.status}: ${githubError(createPayload)}`
+        );
+      }
+      const created = reactionSchema.parse(createPayload);
+      return {
+        target: "updatePullRequestFeedback",
+        repo: repo.ref,
+        commentId,
+        status,
+        reactionId: created.id
+      };
+    }
+  });
+}
+
+// src/tools/resolve-pull-request-review-thread.ts
+import {
+  definePluginTool as definePluginTool11,
+  PluginToolInputError as PluginToolInputError12,
+  pluginToolOutputSchema as pluginToolOutputSchema11
+} from "@sentry/junior-plugin-api";
+import { z as z11 } from "zod";
+var inputSchema9 = z11.object({
+  repo: z11.string().describe(
+    'Repository in "owner/name" format. Required because GraphQL has no repo path.'
+  ),
+  threadId: z11.string().trim().min(1).describe(
+    "GitHub pull request review thread node ID (the same `threadId` / `id` variable used by `gh api graphql` resolveReviewThread)."
+  )
+}).strict();
+var outputSchema9 = pluginToolOutputSchema11.extend({
+  target: z11.literal("resolvePullRequestReviewThread"),
+  repo: z11.string(),
+  number: z11.number(),
+  threadId: z11.string(),
+  resolved: z11.boolean()
+});
+function parseRepo11(value) {
+  const parts = value.split("/").map((part) => part.trim());
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new PluginToolInputError12('repo must use "owner/name" format');
+  }
+  return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
+}
+async function readJson8(response) {
+  const text2 = await response.text();
+  if (!text2) return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function githubError2(payload) {
+  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+    const message = payload.message;
+    if (typeof message === "string" && message.trim()) return message.trim();
+  }
+  return "GitHub request failed";
+}
+function createGitHubResolvePullRequestReviewThreadTool(ctx, botEmail) {
+  return definePluginTool11({
+    annotations: {
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    description: "Resolve a GitHub pull request review thread after acting on its feedback. Only works on pull requests the bot authored.",
+    exposure: "direct",
+    inputSchema: inputSchema9,
+    outputSchema: outputSchema9,
+    async execute(input) {
+      const parsedInput = inputSchema9.safeParse(input);
+      if (!parsedInput.success) {
+        throw new PluginToolInputError12(
+          "Invalid GitHub resolvePullRequestReviewThread input.",
+          { cause: parsedInput.error }
+        );
+      }
+      const repo = parseRepo11(parsedInput.data.repo);
+      const botUserId = botUserIdFromEmail(botEmail);
+      if (botUserId === void 0) {
+        throw new Error("GitHub App bot identity is not configured.");
+      }
       const query = `query ReviewThreadOwnership($threadId: ID!) {
         node(id: $threadId) {
           ... on PullRequestReviewThread {
@@ -2111,32 +2289,32 @@ function createGitHubResolvePullRequestReviewThreadTool(ctx, botEmail) {
           })
         })
       });
-      const lookupPayload = await readJson7(lookupResponse);
+      const lookupPayload = await readJson8(lookupResponse);
       if (!lookupResponse.ok) {
         throw new Error(
-          `GitHub review thread lookup failed with HTTP ${lookupResponse.status}: ${githubError(lookupPayload)}`
+          `GitHub review thread lookup failed with HTTP ${lookupResponse.status}: ${githubError2(lookupPayload)}`
         );
       }
-      const thread = z10.object({
-        data: z10.object({
-          node: z10.object({
-            id: z10.string(),
-            isResolved: z10.boolean(),
-            pullRequest: z10.object({
-              author: z10.object({ databaseId: z10.number().optional() }).nullable(),
-              number: z10.number(),
-              repository: z10.object({ nameWithOwner: z10.string() })
+      const thread = z11.object({
+        data: z11.object({
+          node: z11.object({
+            id: z11.string(),
+            isResolved: z11.boolean(),
+            pullRequest: z11.object({
+              author: z11.object({ databaseId: z11.number().optional() }).nullable(),
+              number: z11.number(),
+              repository: z11.object({ nameWithOwner: z11.string() })
             })
           }).nullable()
         })
       }).parse(lookupPayload).data.node;
       if (!thread) {
-        throw new PluginToolInputError11("GitHub review thread was not found.");
+        throw new PluginToolInputError12("GitHub review thread was not found.");
       }
       const pullRequest = thread.pullRequest;
       const ownsPullRequest = pullRequest.repository.nameWithOwner.toLowerCase() === repo.ref.toLowerCase() && pullRequest.author?.databaseId === botUserId;
       if (!ownsPullRequest) {
-        throw new PluginToolInputError11(
+        throw new PluginToolInputError12(
           "This bot can only resolve review threads on pull requests it authored."
         );
       }
@@ -2167,16 +2345,16 @@ function createGitHubResolvePullRequestReviewThreadTool(ctx, botEmail) {
           })
         })
       });
-      const resolvePayload = await readJson7(resolveResponse);
+      const resolvePayload = await readJson8(resolveResponse);
       if (!resolveResponse.ok) {
         throw new Error(
-          `GitHub review thread resolution failed with HTTP ${resolveResponse.status}: ${githubError(resolvePayload)}`
+          `GitHub review thread resolution failed with HTTP ${resolveResponse.status}: ${githubError2(resolvePayload)}`
         );
       }
-      const resolved = z10.object({
-        data: z10.object({
-          resolveReviewThread: z10.object({
-            thread: z10.object({ id: z10.string(), isResolved: z10.boolean() })
+      const resolved = z11.object({
+        data: z11.object({
+          resolveReviewThread: z11.object({
+            thread: z11.object({ id: z11.string(), isResolved: z11.boolean() })
           })
         })
       }).parse(resolvePayload).data.resolveReviewThread.thread;
@@ -2196,45 +2374,45 @@ function createGitHubResolvePullRequestReviewThreadTool(ctx, botEmail) {
 
 // src/tools/submit-pull-request-review.ts
 import {
-  definePluginTool as definePluginTool11,
-  PluginToolInputError as PluginToolInputError12,
-  pluginToolOutputSchema as pluginToolOutputSchema11
+  definePluginTool as definePluginTool12,
+  PluginToolInputError as PluginToolInputError13,
+  pluginToolOutputSchema as pluginToolOutputSchema12
 } from "@sentry/junior-plugin-api";
-import { z as z11 } from "zod";
-var reviewCommentSchema = z11.object({
-  path: z11.string().trim().min(1).describe("File path in the pull request."),
-  body: z11.string().trim().min(1).describe("Inline review comment."),
-  line: z11.number().int().positive().describe("Line in the pull request diff."),
-  side: z11.enum(["LEFT", "RIGHT"]).describe("Side of the pull request diff."),
-  startLine: z11.number().int().positive().optional().describe("First line of a multi-line comment."),
-  startSide: z11.enum(["LEFT", "RIGHT"]).optional().describe("First side of a multi-line comment.")
+import { z as z12 } from "zod";
+var reviewCommentSchema = z12.object({
+  path: z12.string().trim().min(1).describe("File path in the pull request."),
+  body: z12.string().trim().min(1).describe("Inline review comment."),
+  line: z12.number().int().positive().describe("Line in the pull request diff."),
+  side: z12.enum(["LEFT", "RIGHT"]).describe("Side of the pull request diff."),
+  startLine: z12.number().int().positive().optional().describe("First line of a multi-line comment."),
+  startSide: z12.enum(["LEFT", "RIGHT"]).optional().describe("First side of a multi-line comment.")
 }).strict().refine(
   ({ startLine, startSide }) => startLine === void 0 === (startSide === void 0),
   { message: "startLine and startSide must be provided together." }
 );
-var inputSchema9 = z11.object({
-  repo: z11.string().describe('Repository in "owner/name" format.'),
-  number: z11.number().int().positive().describe("Pull request number."),
-  event: z11.enum(["COMMENT", "REQUEST_CHANGES"]).describe("Review result. Junior cannot approve pull requests."),
-  body: z11.string().trim().min(1).describe("Review summary."),
-  comments: z11.array(reviewCommentSchema).optional().describe("Optional inline review comments.")
+var inputSchema10 = z12.object({
+  repo: z12.string().describe('Repository in "owner/name" format.'),
+  number: z12.number().int().positive().describe("Pull request number."),
+  event: z12.enum(["COMMENT", "REQUEST_CHANGES"]).describe("Review result. Junior cannot approve pull requests."),
+  body: z12.string().trim().min(1).describe("Review summary."),
+  comments: z12.array(reviewCommentSchema).optional().describe("Optional inline review comments.")
 }).strict();
-var outputSchema9 = pluginToolOutputSchema11.extend({
-  target: z11.literal("submitPullRequestReview"),
-  repo: z11.string(),
-  number: z11.number(),
-  reviewId: z11.number(),
-  state: z11.string(),
-  url: z11.string()
+var outputSchema10 = pluginToolOutputSchema12.extend({
+  target: z12.literal("submitPullRequestReview"),
+  repo: z12.string(),
+  number: z12.number(),
+  reviewId: z12.number(),
+  state: z12.string(),
+  url: z12.string()
 });
-function parseRepo11(value) {
+function parseRepo12(value) {
   const parts = value.split("/").map((part) => part.trim());
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new PluginToolInputError12('repo must use "owner/name" format');
+    throw new PluginToolInputError13('repo must use "owner/name" format');
   }
   return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
 }
-async function readJson8(response) {
+async function readJson9(response) {
   const text2 = await response.text();
   if (!text2) return void 0;
   try {
@@ -2243,7 +2421,7 @@ async function readJson8(response) {
     return text2;
   }
 }
-function githubError2(body) {
+function githubError3(body) {
   if (body && typeof body === "object" && !Array.isArray(body)) {
     const message = body.message;
     if (typeof message === "string" && message.trim()) return message.trim();
@@ -2252,14 +2430,14 @@ function githubError2(body) {
   return "GitHub request failed";
 }
 function throwReviewError(status, body) {
-  const message = `GitHub pull request review failed with HTTP ${status}: ${githubError2(body)}`;
+  const message = `GitHub pull request review failed with HTTP ${status}: ${githubError3(body)}`;
   if (status === 404 || status === 422) {
-    throw new PluginToolInputError12(message);
+    throw new PluginToolInputError13(message);
   }
   throw new Error(message);
 }
 function createGitHubSubmitPullRequestReviewTool(egress) {
-  return definePluginTool11({
+  return definePluginTool12({
     annotations: {
       destructiveHint: true,
       idempotentHint: false,
@@ -2268,10 +2446,10 @@ function createGitHubSubmitPullRequestReviewTool(egress) {
     },
     description: "Submit a GitHub pull request review as a comment or change request. Use this instead of `gh pr review`, GraphQL, or direct REST calls. Junior cannot approve pull requests.",
     exposure: "direct",
-    inputSchema: inputSchema9,
-    outputSchema: outputSchema9,
+    inputSchema: inputSchema10,
+    outputSchema: outputSchema10,
     async execute(review) {
-      const repo = parseRepo11(review.repo);
+      const repo = parseRepo12(review.repo);
       const comments = review.comments?.map((comment) => ({
         path: comment.path,
         body: comment.body,
@@ -2300,11 +2478,11 @@ function createGitHubSubmitPullRequestReviewTool(egress) {
           }
         )
       });
-      const parsed = await readJson8(response);
+      const parsed = await readJson9(response);
       if (!response.ok) {
         throwReviewError(response.status, parsed);
       }
-      const providerResult = z11.object({ id: z11.number(), html_url: z11.string(), state: z11.string() }).parse(parsed);
+      const providerResult = z12.object({ id: z12.number(), html_url: z12.string(), state: z12.string() }).parse(parsed);
       return {
         target: "submitPullRequestReview",
         repo: repo.ref,
@@ -2335,7 +2513,11 @@ function createGitHubTools(ctx, botEmail, pullRequestSubscription) {
       ctx.egress
     ),
     updateIssue: createGitHubUpdateIssueTool(ctx),
-    updatePullRequest: createGitHubUpdatePullRequestTool(ctx)
+    updatePullRequest: createGitHubUpdatePullRequestTool(ctx),
+    updatePullRequestFeedback: createGitHubUpdatePullRequestFeedbackTool(
+      ctx,
+      botEmail
+    )
   };
 }
 
@@ -2344,7 +2526,7 @@ import { createHmac, timingSafeEqual } from "crypto";
 
 // src/issue-outcomes/store.ts
 import { and, eq, lte, sql as sql2 } from "drizzle-orm";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/db/schema.ts
 import { sql } from "drizzle-orm";
@@ -2356,18 +2538,18 @@ import {
   text,
   timestamp
 } from "drizzle-orm/pg-core";
-import { z as z12 } from "zod";
-var githubPullRequestStateSchema = z12.enum([
+import { z as z13 } from "zod";
+var githubPullRequestStateSchema = z13.enum([
   "closed_unmerged",
   "merged",
   "open"
 ]);
-var githubPullRequestCommitCompositionSchema = z12.enum([
+var githubPullRequestCommitCompositionSchema = z13.enum([
   "junior_only",
   "mixed"
 ]);
-var githubIssueStateSchema = z12.enum(["closed", "open"]);
-var githubIssueStateReasonSchema = z12.enum([
+var githubIssueStateSchema = z13.enum(["closed", "open"]);
+var githubIssueStateReasonSchema = z13.enum([
   "completed",
   "duplicate",
   "not_planned",
@@ -2437,21 +2619,21 @@ var juniorGitHubPullRequestIssues = pgTable(
 );
 
 // src/issue-outcomes/store.ts
-var githubIssueOutcomeInputSchema = z13.object({
-  candidateOwned: z13.boolean(),
-  closedAt: z13.date().optional(),
-  issueId: z13.string().min(1),
-  number: z13.number().int().positive(),
-  openedAt: z13.date(),
-  repositoryFullName: z13.string().min(1),
-  repositoryId: z13.string().min(1),
+var githubIssueOutcomeInputSchema = z14.object({
+  candidateOwned: z14.boolean(),
+  closedAt: z14.date().optional(),
+  issueId: z14.string().min(1),
+  number: z14.number().int().positive(),
+  openedAt: z14.date(),
+  repositoryFullName: z14.string().min(1),
+  repositoryId: z14.string().min(1),
   state: githubIssueStateSchema,
   stateReason: githubIssueStateReasonSchema.optional(),
-  updatedAt: z13.date()
+  updatedAt: z14.date()
 }).strict();
-var githubIssueConversationsInputSchema = z13.object({
-  conversationIds: z13.array(z13.string().min(1)).min(1),
-  issueId: z13.string().min(1)
+var githubIssueConversationsInputSchema = z14.object({
+  conversationIds: z14.array(z14.string().min(1)).min(1),
+  issueId: z14.string().min(1)
 }).strict();
 function projectionValues(input) {
   return {
@@ -2515,33 +2697,33 @@ async function recordGitHubIssueConversations(db, input) {
 
 // src/pull-request-outcomes/store.ts
 import { and as and2, eq as eq2, lte as lte2, ne, sql as sql3 } from "drizzle-orm";
-import { z as z14 } from "zod";
-var githubPullRequestOutcomeInputSchema = z14.object({
-  candidateOwned: z14.boolean(),
-  closedAt: z14.date().optional(),
+import { z as z15 } from "zod";
+var githubPullRequestOutcomeInputSchema = z15.object({
+  candidateOwned: z15.boolean(),
+  closedAt: z15.date().optional(),
   commitComposition: githubPullRequestCommitCompositionSchema.optional(),
-  mergedAt: z14.date().optional(),
-  number: z14.number().int().positive(),
-  openedAt: z14.date(),
-  pullRequestId: z14.string().min(1),
-  repositoryFullName: z14.string().min(1),
-  repositoryId: z14.string().min(1),
+  mergedAt: z15.date().optional(),
+  number: z15.number().int().positive(),
+  openedAt: z15.date(),
+  pullRequestId: z15.string().min(1),
+  repositoryFullName: z15.string().min(1),
+  repositoryId: z15.string().min(1),
   state: githubPullRequestStateSchema,
-  title: z14.string().min(1).optional(),
-  updatedAt: z14.date()
+  title: z15.string().min(1).optional(),
+  updatedAt: z15.date()
 }).strict();
-var githubPullRequestConversationsInputSchema = z14.object({
-  conversationIds: z14.array(z14.string().min(1)).min(1),
-  pullRequestId: z14.string().min(1)
+var githubPullRequestConversationsInputSchema = z15.object({
+  conversationIds: z15.array(z15.string().min(1)).min(1),
+  pullRequestId: z15.string().min(1)
 }).strict();
-var githubPullRequestLinkedIssuesInputSchema = z14.object({
-  linkedIssues: z14.array(
-    z14.object({
-      number: z14.number().int().positive(),
-      repositoryFullName: z14.string().min(1)
+var githubPullRequestLinkedIssuesInputSchema = z15.object({
+  linkedIssues: z15.array(
+    z15.object({
+      number: z15.number().int().positive(),
+      repositoryFullName: z15.string().min(1)
     }).strict()
   ).min(1),
-  pullRequestId: z14.string().min(1)
+  pullRequestId: z15.string().min(1)
 }).strict();
 function projectionValues2(input) {
   return {
@@ -2706,39 +2888,39 @@ async function recordGitHubPullRequestLinkedIssues(db, input) {
 }
 
 // src/webhooks/issue-outcome.ts
-import { z as z15 } from "zod";
-var canonicalIssueOutcomeSchema = z15.object({
-  action: z15.enum(["opened", "closed", "reopened"]),
-  issue: z15.object({
-    body: z15.string().nullable().optional(),
-    closed_at: z15.string().nullable().optional(),
-    created_at: z15.string(),
-    id: z15.number().int().positive(),
-    number: z15.number().int().positive(),
+import { z as z16 } from "zod";
+var canonicalIssueOutcomeSchema = z16.object({
+  action: z16.enum(["opened", "closed", "reopened"]),
+  issue: z16.object({
+    body: z16.string().nullable().optional(),
+    closed_at: z16.string().nullable().optional(),
+    created_at: z16.string(),
+    id: z16.number().int().positive(),
+    number: z16.number().int().positive(),
     state_reason: githubIssueStateReasonSchema.nullable().optional(),
-    updated_at: z15.string(),
-    user: z15.object({ login: z15.string().min(1) }).strict()
+    updated_at: z16.string(),
+    user: z16.object({ login: z16.string().min(1) }).strict()
   }).strict(),
-  repository: z15.object({
-    full_name: z15.string().min(1),
-    id: z15.number().int().positive()
+  repository: z16.object({
+    full_name: z16.string().min(1),
+    id: z16.number().int().positive()
   }).strict()
 }).strict();
-var issueOutcomeSchema = z15.object({
-  action: z15.enum(["opened", "closed", "reopened"]),
-  issue: z15.object({
-    body: z15.string().nullable().optional(),
-    closed_at: z15.string().nullable().optional(),
-    created_at: z15.string(),
-    id: z15.number().int().positive(),
-    number: z15.number().int().positive(),
+var issueOutcomeSchema = z16.object({
+  action: z16.enum(["opened", "closed", "reopened"]),
+  issue: z16.object({
+    body: z16.string().nullable().optional(),
+    closed_at: z16.string().nullable().optional(),
+    created_at: z16.string(),
+    id: z16.number().int().positive(),
+    number: z16.number().int().positive(),
     state_reason: githubIssueStateReasonSchema.nullable().optional(),
-    updated_at: z15.string(),
-    user: z15.object({ login: z15.string().min(1) }).passthrough()
+    updated_at: z16.string(),
+    user: z16.object({ login: z16.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z15.object({
-    full_name: z15.string().min(1),
-    id: z15.number().int().positive()
+  repository: z16.object({
+    full_name: z16.string().min(1),
+    id: z16.number().int().positive()
   }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalIssueOutcomeSchema.parse({
@@ -2759,7 +2941,7 @@ var issueOutcomeSchema = z15.object({
     }
   })
 );
-var issueLifecycleActionSchema = z15.object({ action: z15.string() }).passthrough();
+var issueLifecycleActionSchema = z16.object({ action: z16.string() }).passthrough();
 function timestamp2(value) {
   if (!value) return void 0;
   const parsed = new Date(value);
@@ -2805,21 +2987,21 @@ function normalizeGitHubIssueOutcome(args) {
     updatedAt
   };
 }
-var canonicalIssueConversationSchema = z15.object({
-  issue: z15.object({
-    body: z15.string().nullable().optional(),
-    id: z15.number().int().positive(),
-    user: z15.object({ login: z15.string().min(1) }).strict()
+var canonicalIssueConversationSchema = z16.object({
+  issue: z16.object({
+    body: z16.string().nullable().optional(),
+    id: z16.number().int().positive(),
+    user: z16.object({ login: z16.string().min(1) }).strict()
   }).strict(),
-  sender: z15.object({ login: z15.string().min(1) }).strict().optional()
+  sender: z16.object({ login: z16.string().min(1) }).strict().optional()
 }).strict();
-var issueConversationSchema = z15.object({
-  issue: z15.object({
-    body: z15.string().nullable().optional(),
-    id: z15.number().int().positive(),
-    user: z15.object({ login: z15.string().min(1) }).passthrough()
+var issueConversationSchema = z16.object({
+  issue: z16.object({
+    body: z16.string().nullable().optional(),
+    id: z16.number().int().positive(),
+    user: z16.object({ login: z16.string().min(1) }).passthrough()
   }).passthrough(),
-  sender: z15.object({ login: z15.string().min(1) }).passthrough().optional()
+  sender: z16.object({ login: z16.string().min(1) }).passthrough().optional()
 }).passthrough().transform(
   (provider) => canonicalIssueConversationSchema.parse({
     issue: {
@@ -2846,43 +3028,43 @@ function normalizeGitHubIssueConversations(args) {
 }
 
 // src/webhooks/pull-request-outcome.ts
-import { z as z16 } from "zod";
-var canonicalPullRequestOutcomeSchema = z16.object({
-  action: z16.enum(["opened", "closed", "reopened"]),
-  pull_request: z16.object({
-    body: z16.string().nullable().optional(),
-    closed_at: z16.string().nullable().optional(),
-    created_at: z16.string(),
-    id: z16.number().int().positive(),
-    merged: z16.boolean(),
-    merged_at: z16.string().nullable().optional(),
-    number: z16.number().int().positive(),
-    title: z16.string().min(1).optional(),
-    updated_at: z16.string(),
-    user: z16.object({ login: z16.string().min(1) }).strict()
+import { z as z17 } from "zod";
+var canonicalPullRequestOutcomeSchema = z17.object({
+  action: z17.enum(["opened", "closed", "reopened"]),
+  pull_request: z17.object({
+    body: z17.string().nullable().optional(),
+    closed_at: z17.string().nullable().optional(),
+    created_at: z17.string(),
+    id: z17.number().int().positive(),
+    merged: z17.boolean(),
+    merged_at: z17.string().nullable().optional(),
+    number: z17.number().int().positive(),
+    title: z17.string().min(1).optional(),
+    updated_at: z17.string(),
+    user: z17.object({ login: z17.string().min(1) }).strict()
   }).strict(),
-  repository: z16.object({
-    full_name: z16.string().min(1),
-    id: z16.number().int().positive()
+  repository: z17.object({
+    full_name: z17.string().min(1),
+    id: z17.number().int().positive()
   }).strict()
 }).strict();
-var pullRequestOutcomeSchema = z16.object({
-  action: z16.enum(["opened", "closed", "reopened"]),
-  pull_request: z16.object({
-    body: z16.string().nullable().optional(),
-    closed_at: z16.string().nullable().optional(),
-    created_at: z16.string(),
-    id: z16.number().int().positive(),
-    merged: z16.boolean(),
-    merged_at: z16.string().nullable().optional(),
-    number: z16.number().int().positive(),
-    title: z16.string().min(1).optional(),
-    updated_at: z16.string(),
-    user: z16.object({ login: z16.string().min(1) }).passthrough()
+var pullRequestOutcomeSchema = z17.object({
+  action: z17.enum(["opened", "closed", "reopened"]),
+  pull_request: z17.object({
+    body: z17.string().nullable().optional(),
+    closed_at: z17.string().nullable().optional(),
+    created_at: z17.string(),
+    id: z17.number().int().positive(),
+    merged: z17.boolean(),
+    merged_at: z17.string().nullable().optional(),
+    number: z17.number().int().positive(),
+    title: z17.string().min(1).optional(),
+    updated_at: z17.string(),
+    user: z17.object({ login: z17.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z16.object({
-    full_name: z16.string().min(1),
-    id: z16.number().int().positive()
+  repository: z17.object({
+    full_name: z17.string().min(1),
+    id: z17.number().int().positive()
   }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalPullRequestOutcomeSchema.parse({
@@ -2905,24 +3087,24 @@ var pullRequestOutcomeSchema = z16.object({
     }
   })
 );
-var pullRequestLifecycleActionSchema = z16.object({ action: z16.string() }).passthrough();
-var canonicalPullRequestConversationSchema = z16.object({
-  pull_request: z16.object({
-    body: z16.string().nullable().optional(),
-    id: z16.number().int().positive(),
-    user: z16.object({ login: z16.string().min(1) }).strict()
+var pullRequestLifecycleActionSchema = z17.object({ action: z17.string() }).passthrough();
+var canonicalPullRequestConversationSchema = z17.object({
+  pull_request: z17.object({
+    body: z17.string().nullable().optional(),
+    id: z17.number().int().positive(),
+    user: z17.object({ login: z17.string().min(1) }).strict()
   }).strict(),
-  repository: z16.object({ full_name: z16.string().min(1) }).strict(),
-  sender: z16.object({ login: z16.string().min(1) }).strict()
+  repository: z17.object({ full_name: z17.string().min(1) }).strict(),
+  sender: z17.object({ login: z17.string().min(1) }).strict()
 }).strict();
-var pullRequestConversationSchema = z16.object({
-  pull_request: z16.object({
-    body: z16.string().nullable().optional(),
-    id: z16.number().int().positive(),
-    user: z16.object({ login: z16.string().min(1) }).passthrough()
+var pullRequestConversationSchema = z17.object({
+  pull_request: z17.object({
+    body: z17.string().nullable().optional(),
+    id: z17.number().int().positive(),
+    user: z17.object({ login: z17.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z16.object({ full_name: z16.string().min(1) }).passthrough(),
-  sender: z16.object({ login: z16.string().min(1) }).passthrough()
+  repository: z17.object({ full_name: z17.string().min(1) }).passthrough(),
+  sender: z17.object({ login: z17.string().min(1) }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalPullRequestConversationSchema.parse({
     pull_request: {
@@ -3042,6 +3224,20 @@ function webhookInstallationId(body) {
   }
   return parseInstallationId(installation.id);
 }
+function pullRequestFeedbackTarget(events) {
+  const event = events.find(
+    (candidate) => candidate.eventType === "pull_request.comment.created" || candidate.eventType === "pull_request.review_comment.created"
+  );
+  const data = event?.data;
+  if (!data || typeof data.repo !== "string" || typeof data.commentId !== "number" || data.commentKind !== "conversation" && data.commentKind !== "review") {
+    return void 0;
+  }
+  return {
+    commentId: data.commentId,
+    commentKind: data.commentKind,
+    repo: data.repo
+  };
+}
 function githubCodeChange(outcome, conversationIds) {
   return {
     closedAt: outcome.closedAt,
@@ -3192,6 +3388,21 @@ function createGitHubWebhookRoute(args) {
         deliveryId,
         eventName
       });
+      const feedbackTarget = pullRequestFeedbackTarget(resourceEvents);
+      const hasMatch = args.resourceEvents.hasMatch;
+      const feedbackHasMatch = feedbackTarget && hasMatch ? (await Promise.all(resourceEvents.map((event) => hasMatch(event)))).some(Boolean) : false;
+      if (feedbackTarget && feedbackHasMatch) {
+        try {
+          await args.markFeedbackReviewing(feedbackTarget);
+        } catch (error) {
+          args.log?.error("GitHub pull request feedback reaction failed", {
+            commentId: feedbackTarget.commentId,
+            deliveryId,
+            errorType: error instanceof Error ? error.name : "UnknownError",
+            repository: feedbackTarget.repo
+          });
+        }
+      }
       for (const event of resourceEvents) {
         await args.resourceEvents.publish(event);
       }
@@ -3204,18 +3415,18 @@ function createGitHubWebhookRoute(args) {
 }
 
 // src/pull-request-outcomes/commit-composition.ts
-import { z as z17 } from "zod";
-var canonicalCommitSchema = z17.object({
-  authorEmail: z17.string().nullable(),
-  authorLogin: z17.string().nullable()
+import { z as z18 } from "zod";
+var canonicalCommitSchema = z18.object({
+  authorEmail: z18.string().nullable(),
+  authorLogin: z18.string().nullable()
 }).strict();
-var providerCommitSchema = z17.object({
-  author: z17.object({ login: z17.string() }).passthrough().nullable(),
-  commit: z17.object({
-    author: z17.object({ email: z17.string() }).passthrough().nullable()
+var providerCommitSchema = z18.object({
+  author: z18.object({ login: z18.string() }).passthrough().nullable(),
+  commit: z18.object({
+    author: z18.object({ email: z18.string() }).passthrough().nullable()
   }).passthrough()
 }).passthrough();
-var commitPageSchema = z17.array(providerCommitSchema).transform(
+var commitPageSchema = z18.array(providerCommitSchema).transform(
   (commits) => commits.map(
     (commit) => canonicalCommitSchema.parse({
       authorEmail: commit.commit.author?.email ?? null,
@@ -4079,6 +4290,7 @@ function shouldInspectGitHubGraphqlResponse(ctx) {
   const contentType = ctx.response.headers.get("content-type");
   return contentType ? /\bjson\b/i.test(contentType) : false;
 }
+var PULL_REQUEST_COMMENT_REACTIONS_PATH = /^\/repos\/[^/]+\/[^/]+\/(issues|pulls)\/comments\/[^/]+\/reactions(?:\/[^/]+)?$/;
 var GITHUB_BODY_WRITES = [
   {
     denialMessage: `GitHub issue creation must use the github_createIssue tool so Junior can own idempotency and the conversation footer. ${CREATE_TOOL_ROUTING_GUIDANCE}`,
@@ -4163,6 +4375,9 @@ function githubApiWriteGrantName(method, upstreamUrl) {
   ) && !HTTP_READ_METHODS.has(method)) {
     return "installation-write";
   }
+  if ((method === "POST" || method === "DELETE") && PULL_REQUEST_COMMENT_REACTIONS_PATH.test(pathname)) {
+    return "installation-write";
+  }
   return void 0;
 }
 function reviewThreadResolveRepository(operation, method, upstreamUrl, bodyText) {
@@ -4190,6 +4405,16 @@ function isGitHubGraphqlMutation(method, upstreamUrl, bodyText, field) {
   ).test(parsed.normalized);
 }
 function applyGitHubEgressPolicy(input) {
+  const reactionWrite = isGitHubApiUrl(input.upstreamUrl) && (input.method === "POST" || input.method === "DELETE") && PULL_REQUEST_COMMENT_REACTIONS_PATH.test(
+    input.upstreamUrl.pathname.toLowerCase()
+  );
+  if (reactionWrite) {
+    const expectedOperation = input.method === "POST" ? "github.pull.comment-reaction.create" : "github.pull.comment-reaction.delete";
+    enforceEgressPolicy({
+      allowed: input.operation === expectedOperation,
+      denialMessage: "GitHub pull request feedback reactions must use the github_updatePullRequestFeedback tool."
+    });
+  }
   assertGitHubPullRequestApprovalDenied({
     ...input.bodyText !== void 0 ? { bodyText: input.bodyText } : void 0,
     method: input.method,
@@ -4341,7 +4566,9 @@ function githubPlugin(options = {}) {
           supportedEvents: [...GITHUB_PULL_REQUEST_EVENTS],
           suggestedEvents: [...GITHUB_PULL_REQUEST_SUGGESTED_EVENTS],
           matchFields: GITHUB_PULL_REQUEST_MATCH_FIELDS,
-          ...options.pullRequestEvents?.guidance ? { guidance: options.pullRequestEvents.guidance } : void 0
+          guidance: gitHubPullRequestEventGuidance(
+            options.pullRequestEvents?.guidance
+          )
         },
         {
           type: "release_source",
@@ -4350,14 +4577,20 @@ function githubPlugin(options = {}) {
         },
         {
           type: "repository",
-          supportedEvents: [...GITHUB_ISSUE_EVENTS, ...GITHUB_PULL_REQUEST_EVENTS],
+          supportedEvents: [
+            ...GITHUB_ISSUE_EVENTS,
+            ...GITHUB_PULL_REQUEST_EVENTS
+          ],
           suggestedEvents: [
             "issue.opened",
             "pull_request.opened",
             ...GITHUB_ISSUE_SUGGESTED_EVENTS,
             ...GITHUB_PULL_REQUEST_SUGGESTED_EVENTS
           ],
-          matchFields: GITHUB_PULL_REQUEST_MATCH_FIELDS
+          matchFields: GITHUB_PULL_REQUEST_MATCH_FIELDS,
+          guidance: gitHubPullRequestEventGuidance(
+            options.pullRequestEvents?.guidance
+          )
         }
       ],
       isEnabled: () => Boolean(readEnv("GITHUB_WEBHOOK_SECRET")),
@@ -4479,6 +4712,36 @@ function githubPlugin(options = {}) {
             installationId: () => readEnv(installationIdEnv),
             installationIdEnv,
             log: ctx.log,
+            markFeedbackReviewing: async ({ commentId, commentKind, repo }) => {
+              const [owner, name, ...extra] = repo.split("/");
+              if (!owner || !name || extra.length > 0) {
+                throw new Error(
+                  "GitHub pull request feedback received an invalid repository name"
+                );
+              }
+              const token = await issueInstallationToken({
+                appIdEnv,
+                privateKeyEnv,
+                installationIdEnv,
+                repositories: [name]
+              });
+              await githubRequest(
+                "https://api.github.com",
+                pullRequestCommentReactionsPath({
+                  owner,
+                  name,
+                  commentKind,
+                  commentId
+                }),
+                {
+                  body: {
+                    content: pullRequestFeedbackReactionContent("reviewing")
+                  },
+                  method: "POST",
+                  token: token.token
+                }
+              );
+            },
             privateKeyEnv,
             resourceEvents: ctx.resourceEvents,
             webhookSecret: () => readEnv("GITHUB_WEBHOOK_SECRET")

package/dist/resource-events/pull-request.d.ts

@@ -1,6 +1,8 @@
 import { type SubscribableResource } from "@sentry/junior-plugin-api";
 export declare const GITHUB_PULL_REQUEST_EVENTS: readonly ["pull_request.checks.failed", "pull_request.checks.recovered", "pull_request.comment.created", "pull_request.opened", "pull_request.ready_for_review", "pull_request.review.approved", "pull_request.review.changes_requested", "pull_request.review.commented", "pull_request.review_comment.created", "pull_request.merged", "pull_request.closed_unmerged"];
 export type GitHubPullRequestEvent = (typeof GITHUB_PULL_REQUEST_EVENTS)[number];
+/** Combine provider defaults with app guidance for pull request events. */
+export declare function gitHubPullRequestEventGuidance(guidance?: Partial<Record<GitHubPullRequestEvent, string>>): Partial<Record<GitHubPullRequestEvent, string>>;
 /** App-configured pull request resource event behavior. */
 export interface GitHubPullRequestEventOptions {
     /** App guidance applied within the matching subscription or event task instruction. */

package/dist/testing.js

@@ -1,6 +1,6 @@
 import {
   normalizeGitHubResourceEvents
-} from "./chunk-6OPIFILN.js";
+} from "./chunk-F2PJG6AF.js";
 export {
   normalizeGitHubResourceEvents
 };

package/dist/tools/update-pull-request-feedback.d.ts

@@ -0,0 +1,59 @@
+import { type PluginEgress } from "@sentry/junior-plugin-api";
+/**
+ * GitHub has reactions but no feedback state. This tool maps each state to a
+ * reaction and keeps at most one state reaction that Junior owns. It does not
+ * change reactions from other users.
+ */
+declare const STATUS_TO_REACTION_CONTENT: {
+    readonly reviewing: "eyes";
+    readonly addressed: "+1";
+    readonly declined: "-1";
+};
+type FeedbackStatus = keyof typeof STATUS_TO_REACTION_CONTENT;
+type PullRequestCommentKind = "conversation" | "review";
+/** Build the GitHub API path for one pull request comment's reactions. */
+export declare function pullRequestCommentReactionsPath(input: {
+    owner: string;
+    name: string;
+    commentKind: PullRequestCommentKind;
+    commentId: number;
+}): string;
+/** Return the GitHub reaction for one feedback state. */
+export declare function pullRequestFeedbackReactionContent(status: FeedbackStatus): (typeof STATUS_TO_REACTION_CONTENT)[FeedbackStatus];
+/**
+ * Set Junior's feedback reaction on a pull request comment. Replace only
+ * state reactions Junior previously added to the same comment.
+ */
+export declare function createGitHubUpdatePullRequestFeedbackTool(ctx: {
+    egress: PluginEgress;
+}, botEmail: string | undefined): import("@sentry/junior-plugin-api").PluginToolDefinition<{
+    repo: string;
+    commentKind: "conversation" | "review";
+    commentId: number;
+    status: "reviewing" | "addressed" | "declined";
+}, {
+    [x: string]: unknown;
+    target: "updatePullRequestFeedback";
+    repo: string;
+    commentId: number;
+    status: "reviewing" | "addressed" | "declined";
+    reactionId: number;
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    target: "updatePullRequestFeedback";
+    repo: string;
+    commentId: number;
+    status: "reviewing" | "addressed" | "declined";
+    reactionId: number;
+    truncated?: boolean | undefined;
+    continuation?: {
+        arguments: Record<string, unknown>;
+        reason?: string | undefined;
+    } | undefined;
+}>;
+export {};

package/dist/webhooks/handler.d.ts

@@ -1,6 +1,11 @@
 import type { CodeChangePublisher, PluginConversationAnnotations, PluginLogger, PluginRoute, ResourceEventPublisher } from "@sentry/junior-plugin-api";
 import type { GitHubDb } from "../db/database.js";
 import type { GitHubPullRequestCommitComposition } from "../db/schema.js";
+interface FeedbackTarget {
+    commentId: number;
+    commentKind: "conversation" | "review";
+    repo: string;
+}
 /** Create the public, signed GitHub webhook route owned by the plugin. */
 export declare function createGitHubWebhookRoute(args: {
     annotations: PluginConversationAnnotations;
@@ -15,7 +20,9 @@ export declare function createGitHubWebhookRoute(args: {
     installationId(): string | undefined;
     installationIdEnv: string;
     log?: Pick<PluginLogger, "error">;
+    markFeedbackReviewing(input: FeedbackTarget): Promise<void>;
     privateKeyEnv: string;
     resourceEvents: ResourceEventPublisher;
     webhookSecret(): string | undefined;
 }): PluginRoute;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior-github",
-  "version": "0.200.0",
+  "version": "0.202.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -31,7 +31,7 @@
     "@sinclair/typebox": "^0.34.49",
     "drizzle-orm": "^0.45.2",
     "zod": "^4.5.4",
-    "@sentry/junior-plugin-api": "0.200.0"
+    "@sentry/junior-plugin-api": "0.202.0"
   },
   "devDependencies": {
     "@oxlint/plugins": "1.79.0",

package/skills/github-code/references/api-surface.md

@@ -38,6 +38,8 @@ If the user omits `owner/repo`, run `jr-rpc config get github.repo`. Then pass `
 | Ready for review        | `gh api repos/owner/repo/pulls/NUMBER/ready_for_review --method POST`                           |
 | Request reviewers       | `gh api repos/owner/repo/pulls/NUMBER/requested_reviewers --method POST --input reviewers.json` |
 | Submit review           | `github_submitPullRequestReview`                                                                |
+| Set feedback status     | `github_updatePullRequestFeedback`                                                              |
+| Resolve review thread   | `github_resolvePullRequestReviewThread`                                                         |
 | Inline review comment   | `gh api repos/owner/repo/pulls/NUMBER/comments --method POST --input comment.json`              |
 | View PR / checks        | `gh pr view NUMBER --repo owner/repo` / `gh pr checks NUMBER --repo owner/repo`                 |
 | Diff PR                 | `gh pr diff NUMBER --repo owner/repo`                                                           |