@sentry/junior-github 0.117.0 → 0.118.0

package/dist/index.js

@@ -1,7 +1,8 @@
 import {
+  gitHubDeploymentSourceSubscribable,
   gitHubPullRequestSubscribable,
   normalizeGitHubResourceEvents
-} from "./chunk-JDNXIBCQ.js";
+} from "./chunk-EPYBKNXS.js";
 
 // src/plugin.ts
 import {
@@ -274,6 +275,7 @@ var createIssueStateSchema = Type.Union([
   Type.Object(
     {
       createdAtMs: Type.Number(),
+      input: Type.Optional(createIssueInputSchema),
       number: Type.Number(),
       status: Type.Literal("completed"),
       url: Type.String()
@@ -283,6 +285,7 @@ var createIssueStateSchema = Type.Union([
   Type.Object(
     {
       createdAtMs: Type.Number(),
+      input: Type.Optional(createIssueInputSchema),
       status: Type.Literal("pending")
     },
     { additionalProperties: false }
@@ -434,6 +437,16 @@ async function createGitHubIssue(ctx, request) {
     url: issue.html_url
   };
 }
+async function annotateIssue(ctx, input, result) {
+  const repo = parseRepo(input.repo);
+  await ctx.annotations?.upsert({
+    kind: "resource_link",
+    key: `${repo.owner.toLowerCase()}/${repo.name.toLowerCase()}#${result.number}`,
+    label: `${repo.owner}/${repo.name}#${result.number}`,
+    url: result.url,
+    status: "open"
+  });
+}
 function createGitHubIssueTool(ctx) {
   return definePluginTool({
     description: "Create a GitHub issue with a runtime-owned Junior conversation footer. Use this instead of shelling out to gh issue create when creating issues.",
@@ -453,10 +466,13 @@ function createGitHubIssueTool(ctx) {
         async () => {
           const state = createIssueState(await ctx.state.get(key));
           if (state?.status === "completed") {
-            return gitHubIssueToolResult({
+            const completedInput = state.input ?? parsedInput;
+            const completedResult = {
               number: state.number,
               url: state.url
-            });
+            };
+            await annotateIssue(ctx, completedInput, completedResult);
+            return gitHubIssueToolResult(completedResult);
           }
           if (state?.status === "pending") {
             throw new Error(
@@ -470,7 +486,8 @@ function createGitHubIssueTool(ctx) {
           );
           const pendingState = {
             status: "pending",
-            createdAtMs: Date.now()
+            createdAtMs: Date.now(),
+            input: parsedInput
           };
           await ctx.state.set(
             key,
@@ -492,6 +509,7 @@ function createGitHubIssueTool(ctx) {
                 { cause: error }
               );
             }
+            await annotateIssue(ctx, parsedInput, result);
             return gitHubIssueToolResult(result);
           } catch (error) {
             if (isEgressAuthRequired(error) || isDefinitiveGitHubIssueCreateRejection(error)) {
@@ -505,20 +523,216 @@ function createGitHubIssueTool(ctx) {
   });
 }
 
-// src/tools/create-pull-request.ts
+// src/tools/get-deployment.ts
 import {
   definePluginTool as definePluginTool2,
-  EgressAuthRequired as EgressAuthRequired2,
   PluginToolInputError as PluginToolInputError3,
-  pluginToolResultSchema as pluginToolResultSchema2
+  pluginToolResultSchema as pluginToolResultSchema2,
+  subscribableResourceSchema
+} from "@sentry/junior-plugin-api";
+import { z as z2 } from "zod";
+var commitShaSchema = z2.string().regex(/^[0-9a-f]{40}$/i);
+var inputSchema = z2.object({
+  repo: z2.string().describe('Repository in "owner/name" format.'),
+  commitSha: commitShaSchema.describe(
+    "Full 40-character Git commit SHA recorded by the deployment."
+  ),
+  environment: z2.string().trim().min(1).describe('GitHub deployment environment, such as "Production".')
+}).strict();
+var statusSchema = z2.object({
+  createdAt: z2.string(),
+  creator: z2.string().nullable(),
+  description: z2.string().nullable(),
+  environmentUrl: z2.string().nullable(),
+  id: z2.number(),
+  logUrl: z2.string().nullable(),
+  state: z2.string()
+}).strict();
+var deploymentSchema = z2.object({
+  createdAt: z2.string(),
+  creator: z2.string().nullable(),
+  description: z2.string().nullable(),
+  environment: z2.string(),
+  id: z2.number(),
+  latestStatus: statusSchema.nullable(),
+  ref: z2.string(),
+  sha: commitShaSchema,
+  updatedAt: z2.string(),
+  url: z2.string()
+}).strict();
+var deploymentSourceSchema = z2.object({
+  commitSha: commitShaSchema,
+  deployment: deploymentSchema.nullable(),
+  environment: z2.string(),
+  repo: z2.string(),
+  subscribable: subscribableResourceSchema.optional()
+}).strict();
+var outputSchema = pluginToolResultSchema2.extend({
+  data: deploymentSourceSchema,
+  ok: z2.literal(true),
+  status: z2.literal("success"),
+  target: z2.literal("getDeployment"),
+  ...deploymentSourceSchema.shape
+}).strict();
+var providerCreatorSchema = z2.object({ login: z2.string() }).passthrough().nullable();
+var providerDeploymentSchema = z2.object({
+  created_at: z2.string(),
+  creator: providerCreatorSchema,
+  description: z2.string().nullable(),
+  environment: z2.string(),
+  id: z2.number(),
+  ref: z2.string(),
+  sha: commitShaSchema,
+  updated_at: z2.string()
+}).passthrough();
+var providerStatusSchema = z2.object({
+  created_at: z2.string(),
+  creator: providerCreatorSchema,
+  description: z2.string().nullable().optional(),
+  environment_url: z2.string().nullable().optional(),
+  id: z2.number(),
+  log_url: z2.string().nullable().optional(),
+  state: z2.string()
+}).passthrough();
+function parseRepo2(value) {
+  const parts = value.split("/").map((part) => part.trim());
+  if (parts.length !== 2 || !parts[0] || !parts[1]) {
+    throw new PluginToolInputError3('repo must use "owner/name" format');
+  }
+  return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
+}
+async function readJson(response) {
+  const text2 = await response.text();
+  if (!text2) return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function throwLookupError(target, status, body) {
+  const message = `GitHub ${target} lookup failed with HTTP ${status}`;
+  const hasValidationErrors = body !== null && typeof body === "object" && !Array.isArray(body) && Array.isArray(body.errors) && body.errors.length > 0;
+  if (target === "deployment" && (status === 404 || status === 422 && hasValidationErrors)) {
+    throw new PluginToolInputError3(message);
+  }
+  throw new Error(message);
+}
+function repositoryUrl(repo, path) {
+  return `https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}/${path}`;
+}
+function createGitHubGetDeploymentTool(ctx) {
+  return definePluginTool2({
+    description: "Get the latest GitHub deployment and status for an exact repository, environment, and full commit SHA. The result remains subscribable when no deployment exists yet, so use it before waiting for a deployment outcome.",
+    inputSchema,
+    outputSchema,
+    async execute(input) {
+      const repo = parseRepo2(input.repo);
+      const commitSha = input.commitSha.toLowerCase();
+      const deploymentsUrl = new URL(repositoryUrl(repo, "deployments"));
+      deploymentsUrl.searchParams.set("sha", commitSha);
+      deploymentsUrl.searchParams.set("environment", input.environment);
+      deploymentsUrl.searchParams.set("per_page", "1");
+      const deploymentsResponse = await ctx.egress.fetch({
+        provider: "github",
+        operation: "github.deployment.list",
+        request: new Request(deploymentsUrl, {
+          headers: {
+            Accept: "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28"
+          }
+        })
+      });
+      const deploymentsBody = await readJson(deploymentsResponse);
+      if (!deploymentsResponse.ok) {
+        throwLookupError(
+          "deployment",
+          deploymentsResponse.status,
+          deploymentsBody
+        );
+      }
+      const providerDeployment = z2.array(providerDeploymentSchema).parse(deploymentsBody)[0];
+      let deployment = null;
+      if (providerDeployment) {
+        const statusesResponse = await ctx.egress.fetch({
+          provider: "github",
+          operation: "github.deployment-status.list",
+          request: new Request(
+            `${repositoryUrl(repo, `deployments/${providerDeployment.id}/statuses`)}?per_page=1`,
+            {
+              headers: {
+                Accept: "application/vnd.github+json",
+                "X-GitHub-Api-Version": "2022-11-28"
+              }
+            }
+          )
+        });
+        const statusesBody = await readJson(statusesResponse);
+        if (!statusesResponse.ok) {
+          throwLookupError(
+            "deployment status",
+            statusesResponse.status,
+            statusesBody
+          );
+        }
+        const providerStatus = z2.array(providerStatusSchema).parse(statusesBody)[0];
+        deployment = {
+          createdAt: providerDeployment.created_at,
+          creator: providerDeployment.creator?.login ?? null,
+          description: providerDeployment.description,
+          environment: providerDeployment.environment,
+          id: providerDeployment.id,
+          latestStatus: providerStatus ? {
+            createdAt: providerStatus.created_at,
+            creator: providerStatus.creator?.login ?? null,
+            description: providerStatus.description ?? null,
+            environmentUrl: providerStatus.environment_url ?? null,
+            id: providerStatus.id,
+            logUrl: providerStatus.log_url ?? null,
+            state: providerStatus.state
+          } : null,
+          ref: providerDeployment.ref,
+          sha: providerDeployment.sha.toLowerCase(),
+          updatedAt: providerDeployment.updated_at,
+          url: `https://github.com/${repo.ref}/deployments`
+        };
+      }
+      const subscribable = gitHubDeploymentSourceSubscribable({
+        commitSha,
+        environment: input.environment,
+        repo: repo.ref
+      });
+      const data = {
+        commitSha,
+        deployment,
+        environment: input.environment,
+        repo: repo.ref,
+        ...subscribable ? { subscribable } : {}
+      };
+      return {
+        data,
+        ok: true,
+        status: "success",
+        target: "getDeployment",
+        ...data
+      };
+    }
+  });
+}
+
+// src/tools/create-pull-request.ts
+import {
+  definePluginTool as definePluginTool3,
+  EgressAuthRequired as EgressAuthRequired2,
+  PluginToolInputError as PluginToolInputError4,
+  pluginToolResultSchema as pluginToolResultSchema3
 } from "@sentry/junior-plugin-api";
 import { Type as Type2 } from "@sinclair/typebox";
 import { Value as Value2 } from "@sinclair/typebox/value";
-import { z as z2 } from "zod";
-import { subscribableResourceSchema } from "@sentry/junior-plugin-api";
+import { z as z3 } from "zod";
+import { subscribableResourceSchema as subscribableResourceSchema2 } from "@sentry/junior-plugin-api";
 var GITHUB_PULL_REQUEST_CREATE_IDEMPOTENCY_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var GITHUB_PULL_REQUEST_CREATE_LOCK_TTL_MS = 6e4;
-var RESOURCE_LINK_LABEL_MAX_LENGTH = 256;
 var GitHubPullRequestCreateRejectedError = class extends Error {
   status;
   constructor(message, status) {
@@ -554,13 +768,13 @@ var createPullRequestInputSchema = Type2.Object(
   },
   { additionalProperties: false }
 );
-var createPullRequestToolInputSchema = z2.object({
-  repo: z2.string().describe('Repository in "owner/name" format.'),
-  title: z2.string().describe("Pull request title."),
-  head: z2.string().describe("Head branch or owner:branch ref."),
-  base: z2.string().describe("Base branch."),
-  body: z2.string().describe("Pull request body. Junior appends the conversation footer.").optional(),
-  draft: z2.boolean().describe("Whether to open the pull request as a draft.").optional()
+var createPullRequestToolInputSchema = z3.object({
+  repo: z3.string().describe('Repository in "owner/name" format.'),
+  title: z3.string().describe("Pull request title."),
+  head: z3.string().describe("Head branch or owner:branch ref."),
+  base: z3.string().describe("Base branch."),
+  body: z3.string().describe("Pull request body. Junior appends the conversation footer.").optional(),
+  draft: z3.boolean().describe("Whether to open the pull request as a draft.").optional()
 }).strict();
 var createPullRequestStateSchema = Type2.Union([
   Type2.Object(
@@ -582,40 +796,40 @@ var createPullRequestStateSchema = Type2.Union([
     { additionalProperties: false }
   )
 ]);
-var gitHubPullRequestDataSchema = z2.object({
-  number: z2.number(),
-  url: z2.string(),
-  subscribable: subscribableResourceSchema.optional()
+var gitHubPullRequestDataSchema = z3.object({
+  number: z3.number(),
+  url: z3.string(),
+  subscribable: subscribableResourceSchema2.optional()
 });
-var gitHubPullRequestOutputSchema = pluginToolResultSchema2.extend({
-  ok: z2.literal(true),
-  status: z2.literal("success"),
-  target: z2.literal("createPullRequest"),
+var gitHubPullRequestOutputSchema = pluginToolResultSchema3.extend({
+  ok: z3.literal(true),
+  status: z3.literal("success"),
+  target: z3.literal("createPullRequest"),
   data: gitHubPullRequestDataSchema,
-  number: z2.number(),
-  url: z2.string(),
-  subscribable: subscribableResourceSchema.optional()
+  number: z3.number(),
+  url: z3.string(),
+  subscribable: subscribableResourceSchema2.optional()
 });
 function parseCreatePullRequestInput(input) {
   try {
     return Value2.Parse(createPullRequestInputSchema, input);
   } catch (error) {
-    throw new PluginToolInputError3("Invalid GitHub createPullRequest input.", {
+    throw new PluginToolInputError4("Invalid GitHub createPullRequest input.", {
       cause: error
     });
   }
 }
 function nonEmptyString3(value, name) {
   if (!value?.trim()) {
-    throw new PluginToolInputError3(`${name} is required`);
+    throw new PluginToolInputError4(`${name} is required`);
   }
   return value.trim();
 }
-function parseRepo2(value) {
+function parseRepo3(value) {
   const repo = nonEmptyString3(value, "repo");
   const parts = repo.split("/");
   if (parts.length !== 2 || !parts[0]?.trim() || !parts[1]?.trim()) {
-    throw new PluginToolInputError3('repo must use "owner/name" format');
+    throw new PluginToolInputError4('repo must use "owner/name" format');
   }
   return {
     owner: parts[0].trim(),
@@ -685,7 +899,7 @@ function isDefinitiveGitHubPullRequestCreateRejection(error) {
   return [400, 401, 404, 410, 422].includes(error.status);
 }
 function createGitHubPullRequestRequest(conversationId, input, actor, dashboardUrl) {
-  const repo = parseRepo2(input.repo);
+  const repo = parseRepo3(input.repo);
   const payload = {
     title: nonEmptyString3(input.title, "title"),
     head: nonEmptyString3(input.head, "head"),
@@ -744,7 +958,7 @@ async function createGitHubPullRequest(ctx, request) {
   };
 }
 function gitHubPullRequestToolResult(input, result) {
-  const repo = parseRepo2(input.repo);
+  const repo = parseRepo3(input.repo);
   const subscribable = gitHubPullRequestSubscribable({
     number: result.number,
     repo: `${repo.owner}/${repo.name}`
@@ -752,15 +966,11 @@ function gitHubPullRequestToolResult(input, result) {
   return { ...result, ...subscribable ? { subscribable } : {} };
 }
 async function annotatePullRequest(ctx, input, result) {
-  const repo = parseRepo2(input.repo);
-  const label = `${repo.owner}/${repo.name} #${result.number}: ${nonEmptyString3(input.title, "title")}`.slice(
-    0,
-    RESOURCE_LINK_LABEL_MAX_LENGTH
-  );
+  const repo = parseRepo3(input.repo);
   await ctx.annotations?.upsert({
     kind: "resource_link",
     key: `${repo.owner.toLowerCase()}/${repo.name.toLowerCase()}#${result.number}`,
-    label,
+    label: `${repo.owner}/${repo.name}#${result.number}`,
     url: result.url,
     status: input.draft ? "draft" : "open"
   });
@@ -776,7 +986,7 @@ function gitHubPullRequestStructuredResult(input, result) {
   };
 }
 function createGitHubPullRequestTool(ctx) {
-  return definePluginTool2({
+  return definePluginTool3({
     description: "Create a GitHub pull request with a runtime-owned Junior conversation footer. Use this instead of shelling out to gh pr create when creating pull requests.",
     inputSchema: createPullRequestToolInputSchema,
     outputSchema: gitHubPullRequestOutputSchema,
@@ -857,42 +1067,42 @@ function createGitHubPullRequestTool(ctx) {
 
 // src/tools/get-pull-request.ts
 import {
-  definePluginTool as definePluginTool3,
-  PluginToolInputError as PluginToolInputError4,
-  pluginToolResultSchema as pluginToolResultSchema3
+  definePluginTool as definePluginTool4,
+  PluginToolInputError as PluginToolInputError5,
+  pluginToolResultSchema as pluginToolResultSchema4
 } from "@sentry/junior-plugin-api";
-import { z as z3 } from "zod";
-import { subscribableResourceSchema as subscribableResourceSchema2 } from "@sentry/junior-plugin-api";
-var inputSchema = z3.object({
-  repo: z3.string().describe('Repository in "owner/name" format.'),
-  number: z3.number().int().positive().describe("Pull request number.")
+import { z as z4 } from "zod";
+import { subscribableResourceSchema as subscribableResourceSchema3 } from "@sentry/junior-plugin-api";
+var inputSchema2 = z4.object({
+  repo: z4.string().describe('Repository in "owner/name" format.'),
+  number: z4.number().int().positive().describe("Pull request number.")
 }).strict();
-var pullRequestSchema = z3.object({
-  base: z3.string(),
-  draft: z3.boolean(),
-  head: z3.string(),
-  merged: z3.boolean(),
-  number: z3.number(),
-  state: z3.string(),
-  subscribable: subscribableResourceSchema2.optional(),
-  title: z3.string(),
-  url: z3.string()
+var pullRequestSchema = z4.object({
+  base: z4.string(),
+  draft: z4.boolean(),
+  head: z4.string(),
+  merged: z4.boolean(),
+  number: z4.number(),
+  state: z4.string(),
+  subscribable: subscribableResourceSchema3.optional(),
+  title: z4.string(),
+  url: z4.string()
 });
-var outputSchema = pluginToolResultSchema3.extend({
-  ok: z3.literal(true),
-  status: z3.literal("success"),
-  target: z3.literal("getPullRequest"),
+var outputSchema2 = pluginToolResultSchema4.extend({
+  ok: z4.literal(true),
+  status: z4.literal("success"),
+  target: z4.literal("getPullRequest"),
   data: pullRequestSchema,
   ...pullRequestSchema.shape
 });
-function parseRepo3(value) {
+function parseRepo4(value) {
   const parts = value.split("/").map((part) => part.trim());
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new PluginToolInputError4('repo must use "owner/name" format');
+    throw new PluginToolInputError5('repo must use "owner/name" format');
   }
   return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
 }
-async function readJson(response) {
+async function readJson2(response) {
   const text2 = await response.text();
   if (!text2) return void 0;
   try {
@@ -902,12 +1112,12 @@ async function readJson(response) {
   }
 }
 function createGitHubGetPullRequestTool(ctx) {
-  return definePluginTool3({
+  return definePluginTool4({
     description: "Get a GitHub pull request. Use this when an existing PR may need resource-event monitoring; the result includes a subscribable hint when GitHub webhooks are configured.",
-    inputSchema,
-    outputSchema,
+    inputSchema: inputSchema2,
+    outputSchema: outputSchema2,
     async execute(input) {
-      const repo = parseRepo3(input.repo);
+      const repo = parseRepo4(input.repo);
       const response = await ctx.egress.fetch({
         provider: "github",
         operation: "github.pull.get",
@@ -921,20 +1131,20 @@ function createGitHubGetPullRequestTool(ctx) {
           }
         )
       });
-      const parsed = await readJson(response);
+      const parsed = await readJson2(response);
       if (!response.ok)
         throw new Error(
           `GitHub pull request lookup failed with HTTP ${response.status}`
         );
-      const providerResult = z3.object({
-        base: z3.object({ ref: z3.string() }),
-        draft: z3.boolean(),
-        head: z3.object({ ref: z3.string() }),
-        html_url: z3.string(),
-        merged: z3.boolean().optional().default(false),
-        number: z3.number(),
-        state: z3.string(),
-        title: z3.string()
+      const providerResult = z4.object({
+        base: z4.object({ ref: z4.string() }),
+        draft: z4.boolean(),
+        head: z4.object({ ref: z4.string() }),
+        html_url: z4.string(),
+        merged: z4.boolean().optional().default(false),
+        number: z4.number(),
+        state: z4.string(),
+        title: z4.string()
       }).parse(parsed);
       const subscribable = gitHubPullRequestSubscribable({
         number: providerResult.number,
@@ -964,56 +1174,56 @@ function createGitHubGetPullRequestTool(ctx) {
 
 // src/tools/update-pull-request.ts
 import {
-  definePluginTool as definePluginTool4,
-  PluginToolInputError as PluginToolInputError5,
-  pluginToolResultSchema as pluginToolResultSchema4
+  definePluginTool as definePluginTool5,
+  PluginToolInputError as PluginToolInputError6,
+  pluginToolResultSchema as pluginToolResultSchema5
 } from "@sentry/junior-plugin-api";
-import { z as z4 } from "zod";
-import { subscribableResourceSchema as subscribableResourceSchema3 } from "@sentry/junior-plugin-api";
-var inputSchema2 = z4.object({
-  repo: z4.string().describe('Repository in "owner/name" format.'),
-  number: z4.number().int().positive().describe("Pull request number."),
-  title: z4.string().trim().min(1).optional().describe("Replacement pull request title."),
-  body: z4.string().optional().describe(
+import { z as z5 } from "zod";
+import { subscribableResourceSchema as subscribableResourceSchema4 } from "@sentry/junior-plugin-api";
+var inputSchema3 = z5.object({
+  repo: z5.string().describe('Repository in "owner/name" format.'),
+  number: z5.number().int().positive().describe("Pull request number."),
+  title: z5.string().trim().min(1).optional().describe("Replacement pull request title."),
+  body: z5.string().optional().describe(
     "Replacement pull request body. Junior appends requester attribution and the conversation footer."
   ),
-  base: z4.string().trim().min(1).optional().describe("Replacement base branch."),
-  state: z4.enum(["open", "closed"]).optional().describe("Replacement pull request state.")
+  base: z5.string().trim().min(1).optional().describe("Replacement base branch."),
+  state: z5.enum(["open", "closed"]).optional().describe("Replacement pull request state.")
 }).strict().refine(
   ({ title, body, base, state }) => title !== void 0 || body !== void 0 || base !== void 0 || state !== void 0,
   { message: "At least one pull request field must be provided." }
 );
-var pullRequestSchema2 = z4.object({
-  base: z4.string(),
-  body: z4.string().nullable(),
-  draft: z4.boolean(),
-  number: z4.number(),
-  state: z4.string(),
-  subscribable: subscribableResourceSchema3.optional(),
-  title: z4.string(),
-  url: z4.string()
+var pullRequestSchema2 = z5.object({
+  base: z5.string(),
+  body: z5.string().nullable(),
+  draft: z5.boolean(),
+  number: z5.number(),
+  state: z5.string(),
+  subscribable: subscribableResourceSchema4.optional(),
+  title: z5.string(),
+  url: z5.string()
 });
-var outputSchema2 = pluginToolResultSchema4.extend({
-  ok: z4.literal(true),
-  status: z4.literal("success"),
-  target: z4.literal("updatePullRequest"),
+var outputSchema3 = pluginToolResultSchema5.extend({
+  ok: z5.literal(true),
+  status: z5.literal("success"),
+  target: z5.literal("updatePullRequest"),
   data: pullRequestSchema2,
   ...pullRequestSchema2.shape
 });
 function nonEmptyString4(value, name) {
   if (!value?.trim()) {
-    throw new PluginToolInputError5(`${name} is required`);
+    throw new PluginToolInputError6(`${name} is required`);
   }
   return value.trim();
 }
-function parseRepo4(value) {
+function parseRepo5(value) {
   const parts = value.split("/").map((part) => part.trim());
   if (parts.length !== 2 || !parts[0] || !parts[1]) {
-    throw new PluginToolInputError5('repo must use "owner/name" format');
+    throw new PluginToolInputError6('repo must use "owner/name" format');
   }
   return { owner: parts[0], name: parts[1], ref: `${parts[0]}/${parts[1]}` };
 }
-async function readJson2(response) {
+async function readJson3(response) {
   const text2 = await response.text();
   if (!text2) return void 0;
   try {
@@ -1031,20 +1241,20 @@ function githubApiErrorMessage3(payload) {
   return "GitHub request failed";
 }
 function createGitHubUpdatePullRequestTool(ctx) {
-  return definePluginTool4({
+  return definePluginTool5({
     description: "Update an existing GitHub pull request's title, body, base branch, or open/closed state. Use this instead of raw GitHub API calls when changing PR metadata.",
-    inputSchema: inputSchema2,
-    outputSchema: outputSchema2,
+    inputSchema: inputSchema3,
+    outputSchema: outputSchema3,
     async execute(input) {
-      const parsedInput = inputSchema2.safeParse(input);
+      const parsedInput = inputSchema3.safeParse(input);
       if (!parsedInput.success) {
-        throw new PluginToolInputError5(
+        throw new PluginToolInputError6(
           "Invalid GitHub updatePullRequest input.",
           { cause: parsedInput.error }
         );
       }
       const update = parsedInput.data;
-      const repo = parseRepo4(update.repo);
+      const repo = parseRepo5(update.repo);
       const payload = {
         ...update.title !== void 0 ? { title: update.title } : {},
         ...update.body !== void 0 ? {
@@ -1073,20 +1283,20 @@ function createGitHubUpdatePullRequestTool(ctx) {
           }
         )
       });
-      const parsed = await readJson2(response);
+      const parsed = await readJson3(response);
       if (!response.ok) {
         throw new Error(
           `GitHub pull request update failed with HTTP ${response.status}: ${githubApiErrorMessage3(parsed)}`
         );
       }
-      const providerResult = z4.object({
-        base: z4.object({ ref: z4.string() }),
-        body: z4.string().nullable().optional().default(null),
-        draft: z4.boolean(),
-        html_url: z4.string(),
-        number: z4.number(),
-        state: z4.string(),
-        title: z4.string()
+      const providerResult = z5.object({
+        base: z5.object({ ref: z5.string() }),
+        body: z5.string().nullable().optional().default(null),
+        draft: z5.boolean(),
+        html_url: z5.string(),
+        number: z5.number(),
+        state: z5.string(),
+        title: z5.string()
       }).parse(parsed);
       const subscribable = gitHubPullRequestSubscribable({
         number: providerResult.number,
@@ -1118,6 +1328,7 @@ function createGitHubTools(ctx) {
   return {
     createIssue: createGitHubIssueTool(ctx),
     createPullRequest: createGitHubPullRequestTool(ctx),
+    getDeployment: createGitHubGetDeploymentTool(ctx),
     getPullRequest: createGitHubGetPullRequestTool(ctx),
     updatePullRequest: createGitHubUpdatePullRequestTool(ctx)
   };
@@ -1128,7 +1339,7 @@ import { createHmac, timingSafeEqual } from "crypto";
 
 // src/issue-outcomes/store.ts
 import { and, eq, lte, sql as sql2 } from "drizzle-orm";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/db/schema.ts
 import { sql } from "drizzle-orm";
@@ -1140,18 +1351,18 @@ import {
   text,
   timestamp
 } from "drizzle-orm/pg-core";
-import { z as z5 } from "zod";
-var githubPullRequestStateSchema = z5.enum([
+import { z as z6 } from "zod";
+var githubPullRequestStateSchema = z6.enum([
   "closed_unmerged",
   "merged",
   "open"
 ]);
-var githubPullRequestCommitCompositionSchema = z5.enum([
+var githubPullRequestCommitCompositionSchema = z6.enum([
   "junior_only",
   "mixed"
 ]);
-var githubIssueStateSchema = z5.enum(["closed", "open"]);
-var githubIssueStateReasonSchema = z5.enum([
+var githubIssueStateSchema = z6.enum(["closed", "open"]);
+var githubIssueStateReasonSchema = z6.enum([
   "completed",
   "duplicate",
   "not_planned",
@@ -1220,21 +1431,21 @@ var juniorGitHubPullRequestIssues = pgTable(
 );
 
 // src/issue-outcomes/store.ts
-var githubIssueOutcomeInputSchema = z6.object({
-  candidateOwned: z6.boolean(),
-  closedAt: z6.date().optional(),
-  issueId: z6.string().min(1),
-  number: z6.number().int().positive(),
-  openedAt: z6.date(),
-  repositoryFullName: z6.string().min(1),
-  repositoryId: z6.string().min(1),
+var githubIssueOutcomeInputSchema = z7.object({
+  candidateOwned: z7.boolean(),
+  closedAt: z7.date().optional(),
+  issueId: z7.string().min(1),
+  number: z7.number().int().positive(),
+  openedAt: z7.date(),
+  repositoryFullName: z7.string().min(1),
+  repositoryId: z7.string().min(1),
   state: githubIssueStateSchema,
   stateReason: githubIssueStateReasonSchema.optional(),
-  updatedAt: z6.date()
+  updatedAt: z7.date()
 }).strict();
-var githubIssueConversationsInputSchema = z6.object({
-  conversationIds: z6.array(z6.string().min(1)).min(1),
-  issueId: z6.string().min(1)
+var githubIssueConversationsInputSchema = z7.object({
+  conversationIds: z7.array(z7.string().min(1)).min(1),
+  issueId: z7.string().min(1)
 }).strict();
 function projectionValues(input) {
   return {
@@ -1287,32 +1498,32 @@ async function recordGitHubIssueConversations(db, input) {
 
 // src/pull-request-outcomes/store.ts
 import { and as and2, eq as eq2, lte as lte2, sql as sql3 } from "drizzle-orm";
-import { z as z7 } from "zod";
-var githubPullRequestOutcomeInputSchema = z7.object({
-  candidateOwned: z7.boolean(),
-  closedAt: z7.date().optional(),
+import { z as z8 } from "zod";
+var githubPullRequestOutcomeInputSchema = z8.object({
+  candidateOwned: z8.boolean(),
+  closedAt: z8.date().optional(),
   commitComposition: githubPullRequestCommitCompositionSchema.optional(),
-  mergedAt: z7.date().optional(),
-  number: z7.number().int().positive(),
-  openedAt: z7.date(),
-  pullRequestId: z7.string().min(1),
-  repositoryFullName: z7.string().min(1),
-  repositoryId: z7.string().min(1),
+  mergedAt: z8.date().optional(),
+  number: z8.number().int().positive(),
+  openedAt: z8.date(),
+  pullRequestId: z8.string().min(1),
+  repositoryFullName: z8.string().min(1),
+  repositoryId: z8.string().min(1),
   state: githubPullRequestStateSchema,
-  updatedAt: z7.date()
+  updatedAt: z8.date()
 }).strict();
-var githubPullRequestConversationsInputSchema = z7.object({
-  conversationIds: z7.array(z7.string().min(1)).min(1),
-  pullRequestId: z7.string().min(1)
+var githubPullRequestConversationsInputSchema = z8.object({
+  conversationIds: z8.array(z8.string().min(1)).min(1),
+  pullRequestId: z8.string().min(1)
 }).strict();
-var githubPullRequestLinkedIssuesInputSchema = z7.object({
-  linkedIssues: z7.array(
-    z7.object({
-      number: z7.number().int().positive(),
-      repositoryFullName: z7.string().min(1)
+var githubPullRequestLinkedIssuesInputSchema = z8.object({
+  linkedIssues: z8.array(
+    z8.object({
+      number: z8.number().int().positive(),
+      repositoryFullName: z8.string().min(1)
     }).strict()
   ).min(1),
-  pullRequestId: z7.string().min(1)
+  pullRequestId: z8.string().min(1)
 }).strict();
 function projectionValues2(input) {
   return {
@@ -1402,7 +1613,7 @@ async function recordGitHubPullRequestLinkedIssues(db, input) {
 }
 
 // src/webhooks/issue-outcome.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/webhooks/ownership.ts
 var GITHUB_NOREPLY_DOMAIN = "users.noreply.github.com";
@@ -1419,38 +1630,38 @@ function botLoginFromEmail(value) {
 }
 
 // src/webhooks/issue-outcome.ts
-var canonicalIssueOutcomeSchema = z8.object({
-  action: z8.enum(["opened", "closed", "reopened"]),
-  issue: z8.object({
-    body: z8.string().nullable().optional(),
-    closed_at: z8.string().nullable().optional(),
-    created_at: z8.string(),
-    id: z8.number().int().positive(),
-    number: z8.number().int().positive(),
+var canonicalIssueOutcomeSchema = z9.object({
+  action: z9.enum(["opened", "closed", "reopened"]),
+  issue: z9.object({
+    body: z9.string().nullable().optional(),
+    closed_at: z9.string().nullable().optional(),
+    created_at: z9.string(),
+    id: z9.number().int().positive(),
+    number: z9.number().int().positive(),
     state_reason: githubIssueStateReasonSchema.nullable().optional(),
-    updated_at: z8.string(),
-    user: z8.object({ login: z8.string().min(1) }).strict()
+    updated_at: z9.string(),
+    user: z9.object({ login: z9.string().min(1) }).strict()
   }).strict(),
-  repository: z8.object({
-    full_name: z8.string().min(1),
-    id: z8.number().int().positive()
+  repository: z9.object({
+    full_name: z9.string().min(1),
+    id: z9.number().int().positive()
   }).strict()
 }).strict();
-var issueOutcomeSchema = z8.object({
-  action: z8.enum(["opened", "closed", "reopened"]),
-  issue: z8.object({
-    body: z8.string().nullable().optional(),
-    closed_at: z8.string().nullable().optional(),
-    created_at: z8.string(),
-    id: z8.number().int().positive(),
-    number: z8.number().int().positive(),
+var issueOutcomeSchema = z9.object({
+  action: z9.enum(["opened", "closed", "reopened"]),
+  issue: z9.object({
+    body: z9.string().nullable().optional(),
+    closed_at: z9.string().nullable().optional(),
+    created_at: z9.string(),
+    id: z9.number().int().positive(),
+    number: z9.number().int().positive(),
     state_reason: githubIssueStateReasonSchema.nullable().optional(),
-    updated_at: z8.string(),
-    user: z8.object({ login: z8.string().min(1) }).passthrough()
+    updated_at: z9.string(),
+    user: z9.object({ login: z9.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z8.object({
-    full_name: z8.string().min(1),
-    id: z8.number().int().positive()
+  repository: z9.object({
+    full_name: z9.string().min(1),
+    id: z9.number().int().positive()
   }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalIssueOutcomeSchema.parse({
@@ -1471,7 +1682,7 @@ var issueOutcomeSchema = z8.object({
     }
   })
 );
-var issueLifecycleActionSchema = z8.object({ action: z8.string() }).passthrough();
+var issueLifecycleActionSchema = z9.object({ action: z9.string() }).passthrough();
 function timestamp2(value) {
   if (!value) return void 0;
   const parsed = new Date(value);
@@ -1517,21 +1728,21 @@ function normalizeGitHubIssueOutcome(args) {
     updatedAt
   };
 }
-var canonicalIssueConversationSchema = z8.object({
-  issue: z8.object({
-    body: z8.string().nullable().optional(),
-    id: z8.number().int().positive(),
-    user: z8.object({ login: z8.string().min(1) }).strict()
+var canonicalIssueConversationSchema = z9.object({
+  issue: z9.object({
+    body: z9.string().nullable().optional(),
+    id: z9.number().int().positive(),
+    user: z9.object({ login: z9.string().min(1) }).strict()
   }).strict(),
-  sender: z8.object({ login: z8.string().min(1) }).strict().optional()
+  sender: z9.object({ login: z9.string().min(1) }).strict().optional()
 }).strict();
-var issueConversationSchema = z8.object({
-  issue: z8.object({
-    body: z8.string().nullable().optional(),
-    id: z8.number().int().positive(),
-    user: z8.object({ login: z8.string().min(1) }).passthrough()
+var issueConversationSchema = z9.object({
+  issue: z9.object({
+    body: z9.string().nullable().optional(),
+    id: z9.number().int().positive(),
+    user: z9.object({ login: z9.string().min(1) }).passthrough()
   }).passthrough(),
-  sender: z8.object({ login: z8.string().min(1) }).passthrough().optional()
+  sender: z9.object({ login: z9.string().min(1) }).passthrough().optional()
 }).passthrough().transform(
   (provider) => canonicalIssueConversationSchema.parse({
     issue: {
@@ -1558,41 +1769,41 @@ function normalizeGitHubIssueConversations(args) {
 }
 
 // src/webhooks/pull-request-outcome.ts
-import { z as z9 } from "zod";
-var canonicalPullRequestOutcomeSchema = z9.object({
-  action: z9.enum(["opened", "closed", "reopened"]),
-  pull_request: z9.object({
-    body: z9.string().nullable().optional(),
-    closed_at: z9.string().nullable().optional(),
-    created_at: z9.string(),
-    id: z9.number().int().positive(),
-    merged: z9.boolean(),
-    merged_at: z9.string().nullable().optional(),
-    number: z9.number().int().positive(),
-    updated_at: z9.string(),
-    user: z9.object({ login: z9.string().min(1) }).strict()
+import { z as z10 } from "zod";
+var canonicalPullRequestOutcomeSchema = z10.object({
+  action: z10.enum(["opened", "closed", "reopened"]),
+  pull_request: z10.object({
+    body: z10.string().nullable().optional(),
+    closed_at: z10.string().nullable().optional(),
+    created_at: z10.string(),
+    id: z10.number().int().positive(),
+    merged: z10.boolean(),
+    merged_at: z10.string().nullable().optional(),
+    number: z10.number().int().positive(),
+    updated_at: z10.string(),
+    user: z10.object({ login: z10.string().min(1) }).strict()
   }).strict(),
-  repository: z9.object({
-    full_name: z9.string().min(1),
-    id: z9.number().int().positive()
+  repository: z10.object({
+    full_name: z10.string().min(1),
+    id: z10.number().int().positive()
   }).strict()
 }).strict();
-var pullRequestOutcomeSchema = z9.object({
-  action: z9.enum(["opened", "closed", "reopened"]),
-  pull_request: z9.object({
-    body: z9.string().nullable().optional(),
-    closed_at: z9.string().nullable().optional(),
-    created_at: z9.string(),
-    id: z9.number().int().positive(),
-    merged: z9.boolean(),
-    merged_at: z9.string().nullable().optional(),
-    number: z9.number().int().positive(),
-    updated_at: z9.string(),
-    user: z9.object({ login: z9.string().min(1) }).passthrough()
+var pullRequestOutcomeSchema = z10.object({
+  action: z10.enum(["opened", "closed", "reopened"]),
+  pull_request: z10.object({
+    body: z10.string().nullable().optional(),
+    closed_at: z10.string().nullable().optional(),
+    created_at: z10.string(),
+    id: z10.number().int().positive(),
+    merged: z10.boolean(),
+    merged_at: z10.string().nullable().optional(),
+    number: z10.number().int().positive(),
+    updated_at: z10.string(),
+    user: z10.object({ login: z10.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z9.object({
-    full_name: z9.string().min(1),
-    id: z9.number().int().positive()
+  repository: z10.object({
+    full_name: z10.string().min(1),
+    id: z10.number().int().positive()
   }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalPullRequestOutcomeSchema.parse({
@@ -1614,24 +1825,24 @@ var pullRequestOutcomeSchema = z9.object({
     }
   })
 );
-var pullRequestLifecycleActionSchema = z9.object({ action: z9.string() }).passthrough();
-var canonicalPullRequestConversationSchema = z9.object({
-  pull_request: z9.object({
-    body: z9.string().nullable().optional(),
-    id: z9.number().int().positive(),
-    user: z9.object({ login: z9.string().min(1) }).strict()
+var pullRequestLifecycleActionSchema = z10.object({ action: z10.string() }).passthrough();
+var canonicalPullRequestConversationSchema = z10.object({
+  pull_request: z10.object({
+    body: z10.string().nullable().optional(),
+    id: z10.number().int().positive(),
+    user: z10.object({ login: z10.string().min(1) }).strict()
   }).strict(),
-  repository: z9.object({ full_name: z9.string().min(1) }).strict(),
-  sender: z9.object({ login: z9.string().min(1) }).strict()
+  repository: z10.object({ full_name: z10.string().min(1) }).strict(),
+  sender: z10.object({ login: z10.string().min(1) }).strict()
 }).strict();
-var pullRequestConversationSchema = z9.object({
-  pull_request: z9.object({
-    body: z9.string().nullable().optional(),
-    id: z9.number().int().positive(),
-    user: z9.object({ login: z9.string().min(1) }).passthrough()
+var pullRequestConversationSchema = z10.object({
+  pull_request: z10.object({
+    body: z10.string().nullable().optional(),
+    id: z10.number().int().positive(),
+    user: z10.object({ login: z10.string().min(1) }).passthrough()
   }).passthrough(),
-  repository: z9.object({ full_name: z9.string().min(1) }).passthrough(),
-  sender: z9.object({ login: z9.string().min(1) }).passthrough()
+  repository: z10.object({ full_name: z10.string().min(1) }).passthrough(),
+  sender: z10.object({ login: z10.string().min(1) }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalPullRequestConversationSchema.parse({
     pull_request: {
@@ -1816,18 +2027,18 @@ function createGitHubWebhookRoute(args) {
 
 // src/outcomes/report.ts
 import { sql as sql5 } from "drizzle-orm";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/outcomes/cost.ts
 import { sql as sql4 } from "drizzle-orm";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var DAY_MS = 24 * 60 * 60 * 1e3;
-var costWindowSchema = z10.object({
-  days: z10.number().int().positive(),
-  issueCostUsd: z10.number().nonnegative().nullable(),
-  medianIssueCostUsd: z10.number().nonnegative().nullable(),
-  medianPullRequestCostUsd: z10.number().nonnegative().nullable(),
-  pullRequestCostUsd: z10.number().nonnegative().nullable()
+var costWindowSchema = z11.object({
+  days: z11.number().int().positive(),
+  issueCostUsd: z11.number().nonnegative().nullable(),
+  medianIssueCostUsd: z11.number().nonnegative().nullable(),
+  medianPullRequestCostUsd: z11.number().nonnegative().nullable(),
+  pullRequestCostUsd: z11.number().nonnegative().nullable()
 }).strict().transform((row) => ({
   days: row.days,
   issueCostUsd: row.issueCostUsd ?? void 0,
@@ -1835,12 +2046,12 @@ var costWindowSchema = z10.object({
   medianPullRequestCostUsd: row.medianPullRequestCostUsd ?? void 0,
   pullRequestCostUsd: row.pullRequestCostUsd ?? void 0
 }));
-var repositoryCostSchema = z10.object({
-  issueCostUsd: z10.number().nonnegative().nullable(),
-  medianIssueCostUsd: z10.number().nonnegative().nullable(),
-  medianPullRequestCostUsd: z10.number().nonnegative().nullable(),
-  pullRequestCostUsd: z10.number().nonnegative().nullable(),
-  repository: z10.string().min(1)
+var repositoryCostSchema = z11.object({
+  issueCostUsd: z11.number().nonnegative().nullable(),
+  medianIssueCostUsd: z11.number().nonnegative().nullable(),
+  medianPullRequestCostUsd: z11.number().nonnegative().nullable(),
+  pullRequestCostUsd: z11.number().nonnegative().nullable(),
+  repository: z11.string().min(1)
 }).strict().transform((row) => ({
   issueCostUsd: row.issueCostUsd ?? void 0,
   medianIssueCostUsd: row.medianIssueCostUsd ?? void 0,
@@ -2045,7 +2256,7 @@ async function aggregateGitHubCostWindows(args) {
     INNER JOIN issue_window ON issue_window.days = pull_request_window.days
     ORDER BY pull_request_window.days
   `);
-  return z10.array(costWindowSchema).parse(queryRows(result));
+  return z11.array(costWindowSchema).parse(queryRows(result));
 }
 async function aggregateGitHubRepositoryCosts(args) {
   if (!await hasConversationUsageTable(args.db)) {
@@ -2143,7 +2354,7 @@ async function aggregateGitHubRepositoryCosts(args) {
       ON issue_totals.repository = repositories.repository
     ORDER BY "repository" ASC
   `);
-  return z10.array(repositoryCostSchema).parse(queryRows(result));
+  return z11.array(repositoryCostSchema).parse(queryRows(result));
 }
 function formatCostUsd(value) {
   if (value === void 0) return "\u2014";
@@ -2158,12 +2369,12 @@ function formatCostUsd(value) {
 // src/outcomes/report.ts
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 var WINDOWS = [7, 30, 90];
-var pullRequestStatsSchema = z11.object({
-  closed: z11.number().int().nonnegative(),
-  created: z11.number().int().nonnegative(),
-  days: z11.number().int().positive(),
-  medianMergeTimeMs: z11.number().nonnegative().nullable(),
-  merged: z11.number().int().nonnegative()
+var pullRequestStatsSchema = z12.object({
+  closed: z12.number().int().nonnegative(),
+  created: z12.number().int().nonnegative(),
+  days: z12.number().int().positive(),
+  medianMergeTimeMs: z12.number().nonnegative().nullable(),
+  merged: z12.number().int().nonnegative()
 }).strict().transform((row) => {
   const terminal = row.merged + row.closed;
   return {
@@ -2172,12 +2383,12 @@ var pullRequestStatsSchema = z11.object({
     mergeRate: terminal > 0 ? row.merged / terminal : void 0
   };
 });
-var pullRequestRepositoryStatsSchema = z11.object({
-  closed: z11.number().int().nonnegative(),
-  created: z11.number().int().nonnegative(),
-  juniorOnly: z11.number().int().nonnegative(),
-  merged: z11.number().int().nonnegative(),
-  repository: z11.string().min(1)
+var pullRequestRepositoryStatsSchema = z12.object({
+  closed: z12.number().int().nonnegative(),
+  created: z12.number().int().nonnegative(),
+  juniorOnly: z12.number().int().nonnegative(),
+  merged: z12.number().int().nonnegative(),
+  repository: z12.string().min(1)
 }).strict().transform((row) => {
   const terminal = row.merged + row.closed;
   return {
@@ -2185,33 +2396,33 @@ var pullRequestRepositoryStatsSchema = z11.object({
     mergeRate: terminal > 0 ? row.merged / terminal : void 0
   };
 });
-var issueStatsSchema = z11.object({
-  closedCompleted: z11.number().int().nonnegative(),
-  closedDuplicate: z11.number().int().nonnegative(),
-  closedNotPlanned: z11.number().int().nonnegative(),
-  closedUnknown: z11.number().int().nonnegative(),
-  created: z11.number().int().nonnegative(),
-  days: z11.number().int().positive(),
-  medianCloseTimeMs: z11.number().nonnegative().nullable()
+var issueStatsSchema = z12.object({
+  closedCompleted: z12.number().int().nonnegative(),
+  closedDuplicate: z12.number().int().nonnegative(),
+  closedNotPlanned: z12.number().int().nonnegative(),
+  closedUnknown: z12.number().int().nonnegative(),
+  created: z12.number().int().nonnegative(),
+  days: z12.number().int().positive(),
+  medianCloseTimeMs: z12.number().nonnegative().nullable()
 }).strict().transform((row) => ({
   ...row,
   medianCloseTimeMs: row.medianCloseTimeMs ?? void 0
 }));
-var pullRequestDaySchema = z11.object({
-  created: z11.number().int().nonnegative(),
-  date: z11.string().date()
+var pullRequestDaySchema = z12.object({
+  created: z12.number().int().nonnegative(),
+  date: z12.string().date()
 }).strict();
-var issueDaySchema = z11.object({
-  created: z11.number().int().nonnegative(),
-  date: z11.string().date()
+var issueDaySchema = z12.object({
+  created: z12.number().int().nonnegative(),
+  date: z12.string().date()
 }).strict();
-var issueRepositoryStatsSchema = z11.object({
-  closedCompleted: z11.number().int().nonnegative(),
-  closedDuplicate: z11.number().int().nonnegative(),
-  closedNotPlanned: z11.number().int().nonnegative(),
-  closedUnknown: z11.number().int().nonnegative(),
-  created: z11.number().int().nonnegative(),
-  repository: z11.string().min(1)
+var issueRepositoryStatsSchema = z12.object({
+  closedCompleted: z12.number().int().nonnegative(),
+  closedDuplicate: z12.number().int().nonnegative(),
+  closedNotPlanned: z12.number().int().nonnegative(),
+  closedUnknown: z12.number().int().nonnegative(),
+  created: z12.number().int().nonnegative(),
+  repository: z12.string().min(1)
 }).strict();
 function queryRows2(result) {
   if (typeof result !== "object" || result === null || !("rows" in result) || !Array.isArray(result.rows)) {
@@ -2275,7 +2486,7 @@ async function aggregatePullRequestWindows(args) {
     GROUP BY windows.days
     ORDER BY windows.days
   `);
-  return z11.array(pullRequestStatsSchema).parse(queryRows2(result));
+  return z12.array(pullRequestStatsSchema).parse(queryRows2(result));
 }
 async function aggregatePullRequestDays(args) {
   const end = new Date(args.nowMs);
@@ -2303,7 +2514,7 @@ async function aggregatePullRequestDays(args) {
     LEFT JOIN daily ON daily.day = days.day
     ORDER BY days.day
   `);
-  return z11.array(pullRequestDaySchema).parse(queryRows2(result));
+  return z12.array(pullRequestDaySchema).parse(queryRows2(result));
 }
 async function aggregatePullRequestRepositories(args) {
   const start = new Date(args.nowMs - 30 * DAY_MS2);
@@ -2333,7 +2544,7 @@ async function aggregatePullRequestRepositories(args) {
     ORDER BY "merged" DESC, "created" DESC, "repository" ASC
     LIMIT 25
   `);
-  return z11.array(pullRequestRepositoryStatsSchema).parse(queryRows2(result));
+  return z12.array(pullRequestRepositoryStatsSchema).parse(queryRows2(result));
 }
 async function aggregateIssueWindows(args) {
   const starts = WINDOWS.map(
@@ -2402,7 +2613,7 @@ async function aggregateIssueWindows(args) {
     GROUP BY windows.days
     ORDER BY windows.days
   `);
-  return z11.array(issueStatsSchema).parse(queryRows2(result));
+  return z12.array(issueStatsSchema).parse(queryRows2(result));
 }
 async function aggregateIssueDays(args) {
   const end = new Date(args.nowMs);
@@ -2430,7 +2641,7 @@ async function aggregateIssueDays(args) {
     LEFT JOIN daily ON daily.day = days.day
     ORDER BY days.day
   `);
-  return z11.array(issueDaySchema).parse(queryRows2(result));
+  return z12.array(issueDaySchema).parse(queryRows2(result));
 }
 async function aggregateIssueRepositories(args) {
   const start = new Date(args.nowMs - 30 * DAY_MS2);
@@ -2467,7 +2678,7 @@ async function aggregateIssueRepositories(args) {
     ORDER BY "created" DESC, "closedCompleted" DESC, "repository" ASC
     LIMIT 25
   `);
-  return z11.array(issueRepositoryStatsSchema).parse(queryRows2(result));
+  return z12.array(issueRepositoryStatsSchema).parse(queryRows2(result));
 }
 function formatPercent(value) {
   return value === void 0 ? "\u2014" : `${Math.round(value * 100)}%`;
@@ -2631,18 +2842,18 @@ async function buildGitHubOutcomeReport(args) {
 }
 
 // src/pull-request-outcomes/commit-composition.ts
-import { z as z12 } from "zod";
-var canonicalCommitSchema = z12.object({
-  authorEmail: z12.string().nullable(),
-  authorLogin: z12.string().nullable()
+import { z as z13 } from "zod";
+var canonicalCommitSchema = z13.object({
+  authorEmail: z13.string().nullable(),
+  authorLogin: z13.string().nullable()
 }).strict();
-var providerCommitSchema = z12.object({
-  author: z12.object({ login: z12.string() }).passthrough().nullable(),
-  commit: z12.object({
-    author: z12.object({ email: z12.string() }).passthrough().nullable()
+var providerCommitSchema = z13.object({
+  author: z13.object({ login: z13.string() }).passthrough().nullable(),
+  commit: z13.object({
+    author: z13.object({ email: z13.string() }).passthrough().nullable()
   }).passthrough()
 }).passthrough();
-var commitPageSchema = z12.array(providerCommitSchema).transform(
+var commitPageSchema = z13.array(providerCommitSchema).transform(
   (commits) => commits.map(
     (commit) => canonicalCommitSchema.parse({
       authorEmail: commit.commit.author?.email ?? null,
@@ -3843,7 +4054,7 @@ function githubPlugin(options = {}) {
     manifest: {
       name: "github",
       displayName: "GitHub",
-      description: "GitHub issue, pull request, and repository workflows via GitHub App",
+      description: "GitHub deployment, issue, pull request, and repository workflows via GitHub App",
       configKeys: ["org", "repo"],
       domains: ["api.github.com", "github.com", "uploads.github.com"],
       envVars: {