@sentry/junior-github 0.199.0 → 0.201.0

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 {
@@ -1001,7 +1002,9 @@ var createPullRequestToolInputSchema = z4.object({
   title: z4.string().describe("Pull request title."),
   head: z4.string().describe("Head branch or owner:branch ref."),
   base: z4.string().describe("Base branch."),
-  body: z4.string().describe("Pull request body. The runtime appends the conversation footer.").optional(),
+  body: z4.string().describe(
+    "Pull request body. The runtime appends the conversation footer."
+  ).optional(),
   draft: z4.boolean().describe("Whether to open the pull request as a draft.").optional()
 }).strict();
 var createPullRequestStateSchema = Type2.Union([
@@ -1252,6 +1255,7 @@ function createGitHubPullRequestTool(ctx, subscriptionConfig) {
       readOnlyHint: false
     },
     description: "Create a GitHub pull request with a runtime-owned conversation footer. Use this instead of shelling out to gh pr create when creating pull requests.",
+    exposure: "direct",
     inputSchema: createPullRequestToolInputSchema,
     outputSchema: gitHubPullRequestOutputSchema,
     async execute(input, options) {
@@ -1994,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,
@@ -2019,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());
@@ -2042,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;
@@ -2058,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,
@@ -2066,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 {
@@ -2108,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."
         );
       }
@@ -2164,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;
@@ -2191,6 +2372,129 @@ function createGitHubResolvePullRequestReviewThreadTool(ctx, botEmail) {
   });
 }
 
+// src/tools/submit-pull-request-review.ts
+import {
+  definePluginTool as definePluginTool12,
+  PluginToolInputError as PluginToolInputError13,
+  pluginToolOutputSchema as pluginToolOutputSchema12
+} from "@sentry/junior-plugin-api";
+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 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 outputSchema10 = pluginToolOutputSchema12.extend({
+  target: z12.literal("submitPullRequestReview"),
+  repo: z12.string(),
+  number: z12.number(),
+  reviewId: z12.number(),
+  state: z12.string(),
+  url: z12.string()
+});
+function parseRepo12(value) {
+  const parts = value.split("/").map((part) => part.trim());
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new PluginToolInputError13('repo must use "owner/name" format');
+  }
+  return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
+}
+async function readJson9(response) {
+  const text2 = await response.text();
+  if (!text2) return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function githubError3(body) {
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    const message = body.message;
+    if (typeof message === "string" && message.trim()) return message.trim();
+  }
+  if (typeof body === "string" && body.trim()) return body.trim();
+  return "GitHub request failed";
+}
+function throwReviewError(status, body) {
+  const message = `GitHub pull request review failed with HTTP ${status}: ${githubError3(body)}`;
+  if (status === 404 || status === 422) {
+    throw new PluginToolInputError13(message);
+  }
+  throw new Error(message);
+}
+function createGitHubSubmitPullRequestReviewTool(egress) {
+  return definePluginTool12({
+    annotations: {
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: true,
+      readOnlyHint: false
+    },
+    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: inputSchema10,
+    outputSchema: outputSchema10,
+    async execute(review) {
+      const repo = parseRepo12(review.repo);
+      const comments = review.comments?.map((comment) => ({
+        path: comment.path,
+        body: comment.body,
+        line: comment.line,
+        side: comment.side,
+        ...comment.startLine !== void 0 ? { start_line: comment.startLine } : void 0,
+        ...comment.startSide !== void 0 ? { start_side: comment.startSide } : void 0
+      }));
+      const response = await egress.fetch({
+        provider: "github",
+        operation: "github.pull.review.create",
+        request: new Request(
+          `https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}/pulls/${review.number}/reviews`,
+          {
+            method: "POST",
+            headers: {
+              Accept: "application/vnd.github+json",
+              "Content-Type": "application/json",
+              "X-GitHub-Api-Version": "2022-11-28"
+            },
+            body: JSON.stringify({
+              body: review.body,
+              event: review.event,
+              ...comments ? { comments } : void 0
+            })
+          }
+        )
+      });
+      const parsed = await readJson9(response);
+      if (!response.ok) {
+        throwReviewError(response.status, parsed);
+      }
+      const providerResult = z12.object({ id: z12.number(), html_url: z12.string(), state: z12.string() }).parse(parsed);
+      return {
+        target: "submitPullRequestReview",
+        repo: repo.ref,
+        number: review.number,
+        reviewId: providerResult.id,
+        state: providerResult.state,
+        url: providerResult.html_url
+      };
+    }
+  });
+}
+
 // src/tools.ts
 function createGitHubTools(ctx, botEmail, pullRequestSubscription) {
   return {
@@ -2205,8 +2509,15 @@ function createGitHubTools(ctx, botEmail, pullRequestSubscription) {
     getRelease: createGitHubGetReleaseTool(ctx),
     getRepository: createGitHubGetRepositoryTool(ctx),
     resolvePullRequestReviewThread: createGitHubResolvePullRequestReviewThreadTool(ctx, botEmail),
+    submitPullRequestReview: createGitHubSubmitPullRequestReviewTool(
+      ctx.egress
+    ),
     updateIssue: createGitHubUpdateIssueTool(ctx),
-    updatePullRequest: createGitHubUpdatePullRequestTool(ctx)
+    updatePullRequest: createGitHubUpdatePullRequestTool(ctx),
+    updatePullRequestFeedback: createGitHubUpdatePullRequestFeedbackTool(
+      ctx,
+      botEmail
+    )
   };
 }
 
@@ -2215,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 z12 } from "zod";
+import { z as z14 } from "zod";
 
 // src/db/schema.ts
 import { sql } from "drizzle-orm";
@@ -2227,18 +2538,18 @@ import {
   text,
   timestamp
 } from "drizzle-orm/pg-core";
-import { z as z11 } from "zod";
-var githubPullRequestStateSchema = z11.enum([
+import { z as z13 } from "zod";
+var githubPullRequestStateSchema = z13.enum([
   "closed_unmerged",
   "merged",
   "open"
 ]);
-var githubPullRequestCommitCompositionSchema = z11.enum([
+var githubPullRequestCommitCompositionSchema = z13.enum([
   "junior_only",
   "mixed"
 ]);
-var githubIssueStateSchema = z11.enum(["closed", "open"]);
-var githubIssueStateReasonSchema = z11.enum([
+var githubIssueStateSchema = z13.enum(["closed", "open"]);
+var githubIssueStateReasonSchema = z13.enum([
   "completed",
   "duplicate",
   "not_planned",
@@ -2308,21 +2619,21 @@ var juniorGitHubPullRequestIssues = pgTable(
 );
 
 // src/issue-outcomes/store.ts
-var githubIssueOutcomeInputSchema = z12.object({
-  candidateOwned: z12.boolean(),
-  closedAt: z12.date().optional(),
-  issueId: z12.string().min(1),
-  number: z12.number().int().positive(),
-  openedAt: z12.date(),
-  repositoryFullName: z12.string().min(1),
-  repositoryId: z12.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: z12.date()
+  updatedAt: z14.date()
 }).strict();
-var githubIssueConversationsInputSchema = z12.object({
-  conversationIds: z12.array(z12.string().min(1)).min(1),
-  issueId: z12.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 {
@@ -2386,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 z13 } from "zod";
-var githubPullRequestOutcomeInputSchema = z13.object({
-  candidateOwned: z13.boolean(),
-  closedAt: z13.date().optional(),
+import { z as z15 } from "zod";
+var githubPullRequestOutcomeInputSchema = z15.object({
+  candidateOwned: z15.boolean(),
+  closedAt: z15.date().optional(),
   commitComposition: githubPullRequestCommitCompositionSchema.optional(),
-  mergedAt: z13.date().optional(),
-  number: z13.number().int().positive(),
-  openedAt: z13.date(),
-  pullRequestId: z13.string().min(1),
-  repositoryFullName: z13.string().min(1),
-  repositoryId: z13.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: z13.string().min(1).optional(),
-  updatedAt: z13.date()
+  title: z15.string().min(1).optional(),
+  updatedAt: z15.date()
 }).strict();
-var githubPullRequestConversationsInputSchema = z13.object({
-  conversationIds: z13.array(z13.string().min(1)).min(1),
-  pullRequestId: z13.string().min(1)
+var githubPullRequestConversationsInputSchema = z15.object({
+  conversationIds: z15.array(z15.string().min(1)).min(1),
+  pullRequestId: z15.string().min(1)
 }).strict();
-var githubPullRequestLinkedIssuesInputSchema = z13.object({
-  linkedIssues: z13.array(
-    z13.object({
-      number: z13.number().int().positive(),
-      repositoryFullName: z13.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: z13.string().min(1)
+  pullRequestId: z15.string().min(1)
 }).strict();
 function projectionValues2(input) {
   return {
@@ -2577,39 +2888,39 @@ async function recordGitHubPullRequestLinkedIssues(db, input) {
 }
 
 // src/webhooks/issue-outcome.ts
-import { z as z14 } from "zod";
-var canonicalIssueOutcomeSchema = z14.object({
-  action: z14.enum(["opened", "closed", "reopened"]),
-  issue: z14.object({
-    body: z14.string().nullable().optional(),
-    closed_at: z14.string().nullable().optional(),
-    created_at: z14.string(),
-    id: z14.number().int().positive(),
-    number: z14.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: z14.string(),
-    user: z14.object({ login: z14.string().min(1) }).strict()
+    updated_at: z16.string(),
+    user: z16.object({ login: z16.string().min(1) }).strict()
   }).strict(),
-  repository: z14.object({
-    full_name: z14.string().min(1),
-    id: z14.number().int().positive()
+  repository: z16.object({
+    full_name: z16.string().min(1),
+    id: z16.number().int().positive()
   }).strict()
 }).strict();
-var issueOutcomeSchema = z14.object({
-  action: z14.enum(["opened", "closed", "reopened"]),
-  issue: z14.object({
-    body: z14.string().nullable().optional(),
-    closed_at: z14.string().nullable().optional(),
-    created_at: z14.string(),
-    id: z14.number().int().positive(),
-    number: z14.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: z14.string(),
-    user: z14.object({ login: z14.string().min(1) }).passthrough()
+    updated_at: z16.string(),
+    user: z16.object({ login: z16.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z14.object({
-    full_name: z14.string().min(1),
-    id: z14.number().int().positive()
+  repository: z16.object({
+    full_name: z16.string().min(1),
+    id: z16.number().int().positive()
   }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalIssueOutcomeSchema.parse({
@@ -2630,7 +2941,7 @@ var issueOutcomeSchema = z14.object({
     }
   })
 );
-var issueLifecycleActionSchema = z14.object({ action: z14.string() }).passthrough();
+var issueLifecycleActionSchema = z16.object({ action: z16.string() }).passthrough();
 function timestamp2(value) {
   if (!value) return void 0;
   const parsed = new Date(value);
@@ -2676,21 +2987,21 @@ function normalizeGitHubIssueOutcome(args) {
     updatedAt
   };
 }
-var canonicalIssueConversationSchema = z14.object({
-  issue: z14.object({
-    body: z14.string().nullable().optional(),
-    id: z14.number().int().positive(),
-    user: z14.object({ login: z14.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: z14.object({ login: z14.string().min(1) }).strict().optional()
+  sender: z16.object({ login: z16.string().min(1) }).strict().optional()
 }).strict();
-var issueConversationSchema = z14.object({
-  issue: z14.object({
-    body: z14.string().nullable().optional(),
-    id: z14.number().int().positive(),
-    user: z14.object({ login: z14.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: z14.object({ login: z14.string().min(1) }).passthrough().optional()
+  sender: z16.object({ login: z16.string().min(1) }).passthrough().optional()
 }).passthrough().transform(
   (provider) => canonicalIssueConversationSchema.parse({
     issue: {
@@ -2717,43 +3028,43 @@ function normalizeGitHubIssueConversations(args) {
 }
 
 // src/webhooks/pull-request-outcome.ts
-import { z as z15 } from "zod";
-var canonicalPullRequestOutcomeSchema = z15.object({
-  action: z15.enum(["opened", "closed", "reopened"]),
-  pull_request: z15.object({
-    body: z15.string().nullable().optional(),
-    closed_at: z15.string().nullable().optional(),
-    created_at: z15.string(),
-    id: z15.number().int().positive(),
-    merged: z15.boolean(),
-    merged_at: z15.string().nullable().optional(),
-    number: z15.number().int().positive(),
-    title: z15.string().min(1).optional(),
-    updated_at: z15.string(),
-    user: z15.object({ login: z15.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: z15.object({
-    full_name: z15.string().min(1),
-    id: z15.number().int().positive()
+  repository: z17.object({
+    full_name: z17.string().min(1),
+    id: z17.number().int().positive()
   }).strict()
 }).strict();
-var pullRequestOutcomeSchema = z15.object({
-  action: z15.enum(["opened", "closed", "reopened"]),
-  pull_request: z15.object({
-    body: z15.string().nullable().optional(),
-    closed_at: z15.string().nullable().optional(),
-    created_at: z15.string(),
-    id: z15.number().int().positive(),
-    merged: z15.boolean(),
-    merged_at: z15.string().nullable().optional(),
-    number: z15.number().int().positive(),
-    title: z15.string().min(1).optional(),
-    updated_at: z15.string(),
-    user: z15.object({ login: z15.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: z15.object({
-    full_name: z15.string().min(1),
-    id: z15.number().int().positive()
+  repository: z17.object({
+    full_name: z17.string().min(1),
+    id: z17.number().int().positive()
   }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalPullRequestOutcomeSchema.parse({
@@ -2776,24 +3087,24 @@ var pullRequestOutcomeSchema = z15.object({
     }
   })
 );
-var pullRequestLifecycleActionSchema = z15.object({ action: z15.string() }).passthrough();
-var canonicalPullRequestConversationSchema = z15.object({
-  pull_request: z15.object({
-    body: z15.string().nullable().optional(),
-    id: z15.number().int().positive(),
-    user: z15.object({ login: z15.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: z15.object({ full_name: z15.string().min(1) }).strict(),
-  sender: z15.object({ login: z15.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 = z15.object({
-  pull_request: z15.object({
-    body: z15.string().nullable().optional(),
-    id: z15.number().int().positive(),
-    user: z15.object({ login: z15.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: z15.object({ full_name: z15.string().min(1) }).passthrough(),
-  sender: z15.object({ login: z15.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: {
@@ -2913,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,
@@ -3063,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);
       }
@@ -3075,18 +3415,18 @@ function createGitHubWebhookRoute(args) {
 }
 
 // src/pull-request-outcomes/commit-composition.ts
-import { z as z16 } from "zod";
-var canonicalCommitSchema = z16.object({
-  authorEmail: z16.string().nullable(),
-  authorLogin: z16.string().nullable()
+import { z as z18 } from "zod";
+var canonicalCommitSchema = z18.object({
+  authorEmail: z18.string().nullable(),
+  authorLogin: z18.string().nullable()
 }).strict();
-var providerCommitSchema = z16.object({
-  author: z16.object({ login: z16.string() }).passthrough().nullable(),
-  commit: z16.object({
-    author: z16.object({ email: z16.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 = z16.array(providerCommitSchema).transform(
+var commitPageSchema = z18.array(providerCommitSchema).transform(
   (commits) => commits.map(
     (commit) => canonicalCommitSchema.parse({
       authorEmail: commit.commit.author?.email ?? null,
@@ -3950,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}`,
@@ -3965,6 +4306,13 @@ var GITHUB_BODY_WRITES = [
     operation: "github.pull.create",
     restPath: /^\/repos\/[^/]+\/[^/]+\/pulls$/
   },
+  {
+    denialMessage: `GitHub pull request reviews must use the github_submitPullRequestReview tool. The tool posts to /repos/{owner}/{repo}/pulls/{number}/reviews. ${CREATE_TOOL_ROUTING_GUIDANCE}`,
+    graphqlField: "addPullRequestReview",
+    method: "POST",
+    operation: "github.pull.review.create",
+    restPath: /^\/repos\/[^/]+\/[^/]+\/pulls\/[^/]+\/reviews$/
+  },
   {
     denialMessage: `GitHub issue updates must use the github_updateIssue tool so Junior can own requester attribution and the conversation footer. ${CREATE_TOOL_ROUTING_GUIDANCE}`,
     graphqlField: "updateIssue",
@@ -4027,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) {
@@ -4054,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,
@@ -4087,7 +4448,7 @@ function requireRepositoryTarget(upstreamUrl) {
     return;
   }
   throw new EgressPolicyDenied2(
-    "GitHub write request does not identify a target repository."
+    "GitHub write request has no repository in its URL. Use a /repos/{owner}/{repo}/... URL or a GitHub tool for the operation."
   );
 }
 async function githubGrantForEgress(ctx) {
@@ -4154,7 +4515,7 @@ async function githubGrantForEgress(ctx) {
   if (graphqlAccess) {
     if (graphqlAccess === "write") {
       throw new EgressPolicyDenied2(
-        "GitHub GraphQL mutations are not enabled for runtime credentials."
+        "GitHub GraphQL mutations are not enabled for runtime credentials. Use the matching GitHub tool or a supported REST endpoint. For pull request reviews, use github_submitPullRequestReview. It posts to /repos/{owner}/{repo}/pulls/{number}/reviews."
       );
     }
     return grantForAccess(
@@ -4166,7 +4527,7 @@ async function githubGrantForEgress(ctx) {
   const access = HTTP_READ_METHODS.has(method) ? "read" : "write";
   if (access === "write") {
     throw new EgressPolicyDenied2(
-      "GitHub write request is not an explicitly allowed Junior operation."
+      "Junior does not support this GitHub write request. Use the matching GitHub tool or a supported REST endpoint."
     );
   }
   return grantForAccess(access, "github.api-read", "installation-read");
@@ -4205,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",
@@ -4214,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")),
@@ -4343,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")