@sentry/junior-github 0.111.0 → 0.113.0

package/dist/index.js

@@ -166,6 +166,28 @@ function githubConversationIds(body) {
   }
   return [...ids];
 }
+function githubLinkedIssues(body, repositoryFullName) {
+  if (!body) return [];
+  const references = /* @__PURE__ */ new Map();
+  const add = (linkedRepository, rawNumber) => {
+    const number = Number.parseInt(rawNumber, 10);
+    if (!Number.isInteger(number) || number <= 0) return;
+    const normalizedRepository = linkedRepository.toLowerCase();
+    references.set(`${normalizedRepository}#${number}`, {
+      number,
+      repositoryFullName: linkedRepository
+    });
+  };
+  for (const match of body.matchAll(/\b([\w.-]+\/[\w.-]+)#(\d+)\b/g)) {
+    add(match[1] ?? "", match[2] ?? "");
+  }
+  for (const match of body.matchAll(/(?:^|[^\w/])#(\d+)\b/g)) {
+    add(repositoryFullName, match[1] ?? "");
+  }
+  return [...references.values()].sort(
+    (left, right) => left.repositoryFullName.localeCompare(right.repositoryFullName) || left.number - right.number
+  );
+}
 function appendGitHubFooter(body, conversationId, dashboardUrl) {
   const footer = githubConversationFooter(conversationId, dashboardUrl);
   const normalizedBody = body.trimEnd();
@@ -1096,12 +1118,19 @@ function createGitHubTools(ctx) {
 import { createHmac, timingSafeEqual } from "crypto";
 
 // src/issue-outcomes/store.ts
-import { and, eq, lte } from "drizzle-orm";
+import { and, eq, lte, sql as sql2 } from "drizzle-orm";
 import { z as z6 } from "zod";
 
 // src/db/schema.ts
 import { sql } from "drizzle-orm";
-import { index, integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import {
+  index,
+  integer,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp
+} from "drizzle-orm/pg-core";
 import { z as z5 } from "zod";
 var githubPullRequestStateSchema = z5.enum([
   "closed_unmerged",
@@ -1128,6 +1157,7 @@ var juniorGitHubIssues = pgTable(
     number: integer("number").notNull(),
     state: text("state").$type().notNull(),
     stateReason: text("state_reason").$type(),
+    conversationIds: text("conversation_ids").array().notNull().default(sql`ARRAY[]::text[]`),
     openedAt: timestamp("opened_at", { withTimezone: true }).notNull(),
     closedAt: timestamp("closed_at", { withTimezone: true }),
     updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
@@ -1160,6 +1190,25 @@ var juniorGitHubPullRequests = pgTable(
     index("junior_github_pull_requests_open_idx").on(table.pullRequestId).where(sql`${table.state} = 'open'`)
   ]
 );
+var juniorGitHubPullRequestIssues = pgTable(
+  "junior_github_pull_request_issues",
+  {
+    pullRequestId: text("pull_request_id").notNull().references(() => juniorGitHubPullRequests.pullRequestId, {
+      onDelete: "cascade"
+    }),
+    issueRepositoryFullName: text("issue_repository_full_name").notNull(),
+    issueNumber: integer("issue_number").notNull()
+  },
+  (table) => [
+    primaryKey({
+      columns: [
+        table.pullRequestId,
+        table.issueRepositoryFullName,
+        table.issueNumber
+      ]
+    })
+  ]
+);
 
 // src/issue-outcomes/store.ts
 var githubIssueOutcomeInputSchema = z6.object({
@@ -1174,6 +1223,10 @@ var githubIssueOutcomeInputSchema = z6.object({
   stateReason: githubIssueStateReasonSchema.optional(),
   updatedAt: z6.date()
 }).strict();
+var githubIssueConversationsInputSchema = z6.object({
+  conversationIds: z6.array(z6.string().min(1)).min(1),
+  issueId: z6.string().min(1)
+}).strict();
 function projectionValues(input) {
   return {
     closedAt: input.closedAt ?? null,
@@ -1204,9 +1257,27 @@ async function recordGitHubIssueOutcome(db, input) {
     where: lte(juniorGitHubIssues.updatedAt, outcome.updatedAt)
   });
 }
+async function recordGitHubIssueConversations(db, input) {
+  const association = githubIssueConversationsInputSchema.parse(input);
+  const conversationIds = sql2.join(
+    association.conversationIds.map((id) => sql2`${id}`),
+    sql2`, `
+  );
+  const updated = await db.update(juniorGitHubIssues).set({
+    conversationIds: sql2`ARRAY(
+        SELECT DISTINCT value
+        FROM unnest(
+          ${juniorGitHubIssues.conversationIds}
+          || ARRAY[${conversationIds}]::text[]
+        ) AS value
+        ORDER BY value
+      )`
+  }).where(eq(juniorGitHubIssues.issueId, association.issueId)).returning({ issueId: juniorGitHubIssues.issueId });
+  return updated.length > 0;
+}
 
 // src/pull-request-outcomes/store.ts
-import { and as and2, eq as eq2, lte as lte2, sql as sql2 } from "drizzle-orm";
+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(),
@@ -1225,6 +1296,15 @@ var githubPullRequestConversationsInputSchema = z7.object({
   conversationIds: z7.array(z7.string().min(1)).min(1),
   pullRequestId: z7.string().min(1)
 }).strict();
+var githubPullRequestLinkedIssuesInputSchema = z7.object({
+  linkedIssues: z7.array(
+    z7.object({
+      number: z7.number().int().positive(),
+      repositoryFullName: z7.string().min(1)
+    }).strict()
+  ).min(1),
+  pullRequestId: z7.string().min(1)
+}).strict();
 function projectionValues2(input) {
   return {
     closedAt: input.closedAt ?? null,
@@ -1269,12 +1349,12 @@ async function recordGitHubPullRequestOutcome(db, input) {
 }
 async function recordGitHubPullRequestConversations(db, input) {
   const association = githubPullRequestConversationsInputSchema.parse(input);
-  const conversationIds = sql2.join(
-    association.conversationIds.map((id) => sql2`${id}`),
-    sql2`, `
+  const conversationIds = sql3.join(
+    association.conversationIds.map((id) => sql3`${id}`),
+    sql3`, `
   );
   const updated = await db.update(juniorGitHubPullRequests).set({
-    conversationIds: sql2`ARRAY(
+    conversationIds: sql3`ARRAY(
         SELECT DISTINCT value
         FROM unnest(
           ${juniorGitHubPullRequests.conversationIds}
@@ -1287,6 +1367,30 @@ async function recordGitHubPullRequestConversations(db, input) {
   ).returning({ pullRequestId: juniorGitHubPullRequests.pullRequestId });
   return updated.length > 0;
 }
+async function recordGitHubPullRequestLinkedIssues(db, input) {
+  const association = githubPullRequestLinkedIssuesInputSchema.parse(input);
+  const inserted = await Promise.all(
+    association.linkedIssues.map(
+      (issue) => db.insert(juniorGitHubPullRequestIssues).select(
+        db.select({
+          pullRequestId: juniorGitHubPullRequests.pullRequestId,
+          issueRepositoryFullName: sql3`lower(${issue.repositoryFullName})`.as(
+            "issue_repository_full_name"
+          ),
+          issueNumber: sql3`${issue.number}`.as("issue_number")
+        }).from(juniorGitHubPullRequests).where(
+          eq2(
+            juniorGitHubPullRequests.pullRequestId,
+            association.pullRequestId
+          )
+        )
+      ).onConflictDoNothing().returning({
+        issueNumber: juniorGitHubPullRequestIssues.issueNumber
+      })
+    )
+  );
+  return inserted.some((rows) => rows.length > 0);
+}
 
 // src/webhooks/issue-outcome.ts
 import { z as z8 } from "zod";
@@ -1404,6 +1508,45 @@ 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()
+  }).strict(),
+  sender: z8.object({ login: z8.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()
+  }).passthrough(),
+  sender: z8.object({ login: z8.string().min(1) }).passthrough().optional()
+}).passthrough().transform(
+  (provider) => canonicalIssueConversationSchema.parse({
+    issue: {
+      body: provider.issue.body,
+      id: provider.issue.id,
+      user: { login: provider.issue.user.login }
+    },
+    ...provider.sender ? { sender: { login: provider.sender.login } } : {}
+  })
+);
+function normalizeGitHubIssueConversations(args) {
+  const parsed = issueConversationSchema.safeParse(args.body);
+  const botLogin = botLoginFromEmail(args.botEmail)?.toLowerCase();
+  if (!parsed.success || !botLogin) return void 0;
+  const authorLogin = parsed.data.issue.user.login.trim().toLowerCase();
+  if (authorLogin !== botLogin) return void 0;
+  const senderLogin = parsed.data.sender?.login.trim().toLowerCase();
+  if (senderLogin && senderLogin !== botLogin) return void 0;
+  const conversationIds = githubConversationIds(parsed.data.issue.body);
+  return conversationIds.length > 0 ? {
+    conversationIds,
+    issueId: String(parsed.data.issue.id)
+  } : void 0;
+}
 
 // src/webhooks/pull-request-outcome.ts
 import { z as z9 } from "zod";
@@ -1469,6 +1612,7 @@ var canonicalPullRequestConversationSchema = z9.object({
     id: z9.number().int().positive(),
     user: z9.object({ login: z9.string().min(1) }).strict()
   }).strict(),
+  repository: z9.object({ full_name: z9.string().min(1) }).strict(),
   sender: z9.object({ login: z9.string().min(1) }).strict()
 }).strict();
 var pullRequestConversationSchema = z9.object({
@@ -1477,6 +1621,7 @@ var pullRequestConversationSchema = z9.object({
     id: z9.number().int().positive(),
     user: z9.object({ login: z9.string().min(1) }).passthrough()
   }).passthrough(),
+  repository: z9.object({ full_name: z9.string().min(1) }).passthrough(),
   sender: z9.object({ login: z9.string().min(1) }).passthrough()
 }).passthrough().transform(
   (provider) => canonicalPullRequestConversationSchema.parse({
@@ -1485,6 +1630,7 @@ var pullRequestConversationSchema = z9.object({
       id: provider.pull_request.id,
       user: { login: provider.pull_request.user.login }
     },
+    repository: { full_name: provider.repository.full_name },
     sender: { login: provider.sender.login }
   })
 );
@@ -1548,6 +1694,22 @@ function normalizeGitHubPullRequestConversations(args) {
     pullRequestId: String(parsed.data.pull_request.id)
   } : void 0;
 }
+function normalizeGitHubPullRequestLinkedIssues(args) {
+  const parsed = pullRequestConversationSchema.safeParse(args.body);
+  const botLogin = botLoginFromEmail(args.botEmail)?.toLowerCase();
+  if (!parsed.success || !botLogin) return void 0;
+  if (parsed.data.pull_request.user.login.trim().toLowerCase() !== botLogin || parsed.data.sender.login.trim().toLowerCase() !== botLogin) {
+    return void 0;
+  }
+  const linkedIssues = githubLinkedIssues(
+    parsed.data.pull_request.body,
+    parsed.data.repository.full_name
+  );
+  return linkedIssues.length > 0 ? {
+    linkedIssues,
+    pullRequestId: String(parsed.data.pull_request.id)
+  } : void 0;
+}
 
 // src/webhooks/handler.ts
 function verifyGitHubSignature(body, signature, secret) {
@@ -1584,7 +1746,9 @@ function createGitHubWebhookRoute(args) {
       const botEmail = args.botEmail();
       const pullRequestOutcome = eventName === "pull_request" ? normalizeGitHubPullRequestOutcome({ body, botEmail }) : void 0;
       const issueOutcome = eventName === "issues" ? normalizeGitHubIssueOutcome({ body, botEmail }) : void 0;
+      const issueConversations = eventName === "issues" ? normalizeGitHubIssueConversations({ body, botEmail }) : void 0;
       const pullRequestConversations = eventName === "pull_request" ? normalizeGitHubPullRequestConversations({ body, botEmail }) : void 0;
+      const pullRequestLinkedIssues = eventName === "pull_request" ? normalizeGitHubPullRequestLinkedIssues({ body, botEmail }) : void 0;
       if (pullRequestOutcome) {
         const recordedOutcome = await recordGitHubPullRequestOutcome(
           args.db,
@@ -1616,10 +1780,15 @@ function createGitHubWebhookRoute(args) {
       if (issueOutcome) {
         await recordGitHubIssueOutcome(args.db, issueOutcome);
       }
+      const recordedIssueConversations = issueConversations ? await recordGitHubIssueConversations(args.db, issueConversations) : false;
       const recordedPullRequestConversations = pullRequestConversations ? await recordGitHubPullRequestConversations(
         args.db,
         pullRequestConversations
       ) : false;
+      const recordedPullRequestLinkedIssues = pullRequestLinkedIssues ? await recordGitHubPullRequestLinkedIssues(
+        args.db,
+        pullRequestLinkedIssues
+      ) : false;
       const resourceEvents = normalizeGitHubResourceEvents({
         body,
         deliveryId,
@@ -1628,7 +1797,7 @@ function createGitHubWebhookRoute(args) {
       for (const event of resourceEvents) {
         await args.resourceEvents.publish(event);
       }
-      if (!pullRequestOutcome && !issueOutcome && !recordedPullRequestConversations && resourceEvents.length === 0) {
+      if (!pullRequestOutcome && !issueOutcome && !recordedIssueConversations && !recordedPullRequestConversations && !recordedPullRequestLinkedIssues && resourceEvents.length === 0) {
         return new Response("Ignored", { status: 202 });
       }
       return new Response("Accepted", { status: 202 });
@@ -1637,37 +1806,344 @@ function createGitHubWebhookRoute(args) {
 }
 
 // src/outcomes/report.ts
-import { sql as sql3 } from "drizzle-orm";
+import { sql as sql5 } from "drizzle-orm";
+import { z as z11 } from "zod";
+
+// src/outcomes/cost.ts
+import { sql as sql4 } from "drizzle-orm";
 import { z as z10 } from "zod";
 var DAY_MS = 24 * 60 * 60 * 1e3;
-var WINDOWS = [7, 30, 90];
-var pullRequestStatsSchema = z10.object({
-  closed: z10.number().int().nonnegative(),
-  compositionUnknown: z10.number().int().nonnegative(),
-  created: z10.number().int().nonnegative(),
+var costWindowSchema = z10.object({
   days: z10.number().int().positive(),
-  juniorOnly: z10.number().int().nonnegative(),
-  medianMergeTimeMs: z10.number().nonnegative().nullable(),
-  merged: z10.number().int().nonnegative(),
-  mixed: z10.number().int().nonnegative()
+  issueCostUsd: z10.number().nonnegative().nullable(),
+  medianIssueCostUsd: z10.number().nonnegative().nullable(),
+  medianPullRequestCostUsd: z10.number().nonnegative().nullable(),
+  pullRequestCostUsd: z10.number().nonnegative().nullable()
+}).strict().transform((row) => ({
+  days: row.days,
+  issueCostUsd: row.issueCostUsd ?? void 0,
+  medianIssueCostUsd: row.medianIssueCostUsd ?? void 0,
+  medianPullRequestCostUsd: row.medianPullRequestCostUsd ?? void 0,
+  pullRequestCostUsd: row.pullRequestCostUsd ?? void 0
+}));
+var repositoryCostSchema = z10.object({
+  issueCostUsd: z10.number().nonnegative().nullable(),
+  pullRequestCostUsd: z10.number().nonnegative().nullable(),
+  repository: z10.string().min(1)
+}).strict().transform((row) => ({
+  issueCostUsd: row.issueCostUsd ?? void 0,
+  pullRequestCostUsd: row.pullRequestCostUsd ?? void 0,
+  repository: row.repository
+}));
+function queryRows(result) {
+  if (typeof result !== "object" || result === null || !("rows" in result) || !Array.isArray(result.rows)) {
+    throw new TypeError("GitHub cost query did not return rows");
+  }
+  return result.rows;
+}
+async function hasConversationUsageTable(db) {
+  const result = await db.execute(sql4`
+    SELECT to_regclass('public.junior_conversations') IS NOT NULL AS "present"
+  `);
+  const row = queryRows(result)[0];
+  return typeof row === "object" && row !== null && "present" in row && row.present === true;
+}
+function emptyCostWindows(windows) {
+  return windows.map((days) => ({
+    days,
+    issueCostUsd: 0,
+    medianIssueCostUsd: void 0,
+    medianPullRequestCostUsd: void 0,
+    pullRequestCostUsd: 0
+  }));
+}
+function conversationTreeCostExpr() {
+  return sql4`
+    coalesce((
+      SELECT sum(
+        CASE
+          WHEN conversations.usage_json->'cost'->>'total' IS NOT NULL
+            THEN (conversations.usage_json->'cost'->>'total')::double precision
+          WHEN coalesce(
+            conversations.usage_json->'cost'->>'input',
+            conversations.usage_json->'cost'->>'output',
+            conversations.usage_json->'cost'->>'cacheRead',
+            conversations.usage_json->'cost'->>'cacheWrite'
+          ) IS NOT NULL
+            THEN coalesce((conversations.usage_json->'cost'->>'input')::double precision, 0)
+              + coalesce((conversations.usage_json->'cost'->>'output')::double precision, 0)
+              + coalesce((conversations.usage_json->'cost'->>'cacheRead')::double precision, 0)
+              + coalesce((conversations.usage_json->'cost'->>'cacheWrite')::double precision, 0)
+          ELSE 0
+        END
+      )
+      FROM junior_conversations AS conversations
+      WHERE conversations.root_conversation_id IN (
+        SELECT coalesce(roots.root_conversation_id, roots.conversation_id)
+        FROM junior_conversations AS roots
+        WHERE roots.conversation_id = ANY (conversation_ids.ids)
+      )
+    ), 0::double precision)
+  `;
+}
+function pullRequestConversationIdsExpr() {
+  const pullRequests = juniorGitHubPullRequests;
+  const issues = juniorGitHubIssues;
+  return sql4`
+    ARRAY(
+      SELECT DISTINCT unnest(
+        ${pullRequests.conversationIds}
+        || coalesce((
+          SELECT array_agg(DISTINCT issue_conversation_id)
+          FROM ${juniorGitHubPullRequestIssues} AS issue_links
+          INNER JOIN ${issues} AS linked_issues
+            ON lower(linked_issues.repository_full_name) =
+              issue_links.issue_repository_full_name
+            AND linked_issues.number = issue_links.issue_number
+          CROSS JOIN LATERAL unnest(linked_issues.conversation_ids)
+            AS issue_conversation_id
+          WHERE issue_links.pull_request_id = ${pullRequests.pullRequestId}
+        ), ARRAY[]::text[])
+      )
+    )
+  `;
+}
+function issueConversationIdsExpr() {
+  const pullRequests = juniorGitHubPullRequests;
+  const issues = juniorGitHubIssues;
+  return sql4`
+    ARRAY(
+      SELECT DISTINCT unnest(
+        ${issues.conversationIds}
+        || coalesce((
+          SELECT array_agg(DISTINCT pr_conversation_id)
+          FROM ${juniorGitHubPullRequestIssues} AS issue_links
+          INNER JOIN ${pullRequests} AS linked_prs
+            ON linked_prs.pull_request_id = issue_links.pull_request_id
+          CROSS JOIN LATERAL unnest(linked_prs.conversation_ids)
+            AS pr_conversation_id
+          WHERE issue_links.issue_repository_full_name =
+            lower(${issues.repositoryFullName})
+            AND issue_links.issue_number = ${issues.number}
+        ), ARRAY[]::text[])
+      )
+    )
+  `;
+}
+async function aggregateGitHubCostWindows(args) {
+  if (!await hasConversationUsageTable(args.db)) {
+    return emptyCostWindows(args.windows);
+  }
+  const starts = args.windows.map(
+    (days) => [days, new Date(args.nowMs - days * DAY_MS)]
+  );
+  const oldestStart = starts.at(-1)[1];
+  const pullRequests = juniorGitHubPullRequests;
+  const issues = juniorGitHubIssues;
+  const windowValues = sql4.join(
+    starts.map(
+      ([days, start]) => sql4`(${days}::integer, ${start}::timestamptz)`
+    ),
+    sql4`, `
+  );
+  const conversationTreeCost = conversationTreeCostExpr();
+  const pullRequestConversationIds = pullRequestConversationIdsExpr();
+  const issueConversationIds = issueConversationIdsExpr();
+  const result = await args.db.execute(sql4`
+    WITH windows(days, start_at) AS (
+      VALUES ${windowValues}
+    ), pull_request_entities AS (
+      SELECT
+        ${pullRequests.openedAt} AS opened_at,
+        conversation_ids.ids AS ids,
+        ${conversationTreeCost} AS cost_usd
+      FROM ${pullRequests}
+      CROSS JOIN LATERAL (
+        SELECT ${pullRequestConversationIds} AS ids
+      ) AS conversation_ids
+      WHERE ${pullRequests.openedAt} >= ${oldestStart}
+    ), issue_entities AS (
+      SELECT
+        ${issues.openedAt} AS opened_at,
+        conversation_ids.ids AS ids,
+        ${conversationTreeCost} AS cost_usd
+      FROM ${issues}
+      CROSS JOIN LATERAL (
+        SELECT ${issueConversationIds} AS ids
+      ) AS conversation_ids
+      WHERE ${issues.openedAt} >= ${oldestStart}
+    ), pull_request_window AS (
+      SELECT
+        windows.days AS days,
+        coalesce((
+          SELECT ${conversationTreeCost}
+          FROM (
+            SELECT ARRAY(
+              SELECT DISTINCT unnest(pull_request_entities.ids)
+              FROM pull_request_entities
+              WHERE pull_request_entities.opened_at >= windows.start_at
+            ) AS ids
+          ) AS conversation_ids
+        ), 0)::double precision AS pull_request_cost_usd,
+        (
+          percentile_cont(0.5) WITHIN GROUP (
+            ORDER BY pull_request_entities.cost_usd
+          ) FILTER (
+            WHERE pull_request_entities.opened_at >= windows.start_at
+              AND pull_request_entities.cost_usd > 0
+          )
+        )::double precision AS median_pull_request_cost_usd
+      FROM windows
+      LEFT JOIN pull_request_entities ON true
+      GROUP BY windows.days, windows.start_at
+    ), issue_window AS (
+      SELECT
+        windows.days AS days,
+        coalesce((
+          SELECT ${conversationTreeCost}
+          FROM (
+            SELECT ARRAY(
+              SELECT DISTINCT unnest(issue_entities.ids)
+              FROM issue_entities
+              WHERE issue_entities.opened_at >= windows.start_at
+            ) AS ids
+          ) AS conversation_ids
+        ), 0)::double precision AS issue_cost_usd,
+        (
+          percentile_cont(0.5) WITHIN GROUP (
+            ORDER BY issue_entities.cost_usd
+          ) FILTER (
+            WHERE issue_entities.opened_at >= windows.start_at
+              AND issue_entities.cost_usd > 0
+          )
+        )::double precision AS median_issue_cost_usd
+      FROM windows
+      LEFT JOIN issue_entities ON true
+      GROUP BY windows.days, windows.start_at
+    )
+    SELECT
+      pull_request_window.days AS "days",
+      pull_request_window.pull_request_cost_usd AS "pullRequestCostUsd",
+      pull_request_window.median_pull_request_cost_usd
+        AS "medianPullRequestCostUsd",
+      issue_window.issue_cost_usd AS "issueCostUsd",
+      issue_window.median_issue_cost_usd AS "medianIssueCostUsd"
+    FROM pull_request_window
+    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));
+}
+async function aggregateGitHubRepositoryCosts(args) {
+  if (!await hasConversationUsageTable(args.db)) {
+    return [];
+  }
+  const start = new Date(args.nowMs - 30 * DAY_MS);
+  const pullRequests = juniorGitHubPullRequests;
+  const issues = juniorGitHubIssues;
+  const conversationTreeCost = conversationTreeCostExpr();
+  const pullRequestConversationIds = pullRequestConversationIdsExpr();
+  const issueConversationIds = issueConversationIdsExpr();
+  const result = await args.db.execute(sql4`
+    WITH pull_request_entities AS (
+      SELECT
+        ${pullRequests.repositoryFullName} AS repository,
+        conversation_ids.ids AS ids
+      FROM ${pullRequests}
+      CROSS JOIN LATERAL (
+        SELECT ${pullRequestConversationIds} AS ids
+      ) AS conversation_ids
+      WHERE ${pullRequests.openedAt} >= ${start}
+    ), issue_entities AS (
+      SELECT
+        ${issues.repositoryFullName} AS repository,
+        conversation_ids.ids AS ids
+      FROM ${issues}
+      CROSS JOIN LATERAL (
+        SELECT ${issueConversationIds} AS ids
+      ) AS conversation_ids
+      WHERE ${issues.openedAt} >= ${start}
+    ), repositories AS (
+      SELECT repository FROM pull_request_entities
+      UNION
+      SELECT repository FROM issue_entities
+    ), pull_request_totals AS (
+      SELECT
+        repositories.repository AS repository,
+        coalesce((
+          SELECT ${conversationTreeCost}
+          FROM (
+            SELECT ARRAY(
+              SELECT DISTINCT unnest(pull_request_entities.ids)
+              FROM pull_request_entities
+              WHERE pull_request_entities.repository = repositories.repository
+            ) AS ids
+          ) AS conversation_ids
+        ), 0)::double precision AS pull_request_cost_usd
+      FROM repositories
+    ), issue_totals AS (
+      SELECT
+        repositories.repository AS repository,
+        coalesce((
+          SELECT ${conversationTreeCost}
+          FROM (
+            SELECT ARRAY(
+              SELECT DISTINCT unnest(issue_entities.ids)
+              FROM issue_entities
+              WHERE issue_entities.repository = repositories.repository
+            ) AS ids
+          ) AS conversation_ids
+        ), 0)::double precision AS issue_cost_usd
+      FROM repositories
+    )
+    SELECT
+      repositories.repository AS "repository",
+      coalesce(pull_request_totals.pull_request_cost_usd, 0)::double precision
+        AS "pullRequestCostUsd",
+      coalesce(issue_totals.issue_cost_usd, 0)::double precision
+        AS "issueCostUsd"
+    FROM repositories
+    LEFT JOIN pull_request_totals
+      ON pull_request_totals.repository = repositories.repository
+    LEFT JOIN issue_totals
+      ON issue_totals.repository = repositories.repository
+    ORDER BY "pullRequestCostUsd" DESC, "issueCostUsd" DESC, "repository" ASC
+  `);
+  return z10.array(repositoryCostSchema).parse(queryRows(result));
+}
+function formatCostUsd(value) {
+  if (value === void 0) return "\u2014";
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency: "USD",
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).format(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()
 }).strict().transform((row) => {
   const terminal = row.merged + row.closed;
-  const classified = row.juniorOnly + row.mixed;
   return {
     ...row,
     medianMergeTimeMs: row.medianMergeTimeMs ?? void 0,
-    mergeRate: terminal > 0 ? row.merged / terminal : void 0,
-    juniorOnlyRate: classified > 0 ? row.juniorOnly / classified : void 0
+    mergeRate: terminal > 0 ? row.merged / terminal : void 0
   };
 });
-var pullRequestRepositoryStatsSchema = z10.object({
-  closed: z10.number().int().nonnegative(),
-  compositionUnknown: z10.number().int().nonnegative(),
-  created: z10.number().int().nonnegative(),
-  juniorOnly: z10.number().int().nonnegative(),
-  merged: z10.number().int().nonnegative(),
-  mixed: z10.number().int().nonnegative(),
-  repository: z10.string().min(1)
+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)
 }).strict().transform((row) => {
   const terminal = row.merged + row.closed;
   return {
@@ -1675,41 +2151,35 @@ var pullRequestRepositoryStatsSchema = z10.object({
     mergeRate: terminal > 0 ? row.merged / terminal : void 0
   };
 });
-var issueStatsSchema = z10.object({
-  closedCompleted: z10.number().int().nonnegative(),
-  closedDuplicate: z10.number().int().nonnegative(),
-  closedNotPlanned: z10.number().int().nonnegative(),
-  closedUnknown: z10.number().int().nonnegative(),
-  created: z10.number().int().nonnegative(),
-  days: z10.number().int().positive(),
-  medianCloseTimeMs: z10.number().nonnegative().nullable()
+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()
 }).strict().transform((row) => ({
   ...row,
   medianCloseTimeMs: row.medianCloseTimeMs ?? void 0
 }));
-var pullRequestDaySchema = z10.object({
-  closed: z10.number().int().nonnegative(),
-  created: z10.number().int().nonnegative(),
-  date: z10.string().date(),
-  merged: z10.number().int().nonnegative()
+var pullRequestDaySchema = z11.object({
+  created: z11.number().int().nonnegative(),
+  date: z11.string().date()
 }).strict();
-var issueDaySchema = z10.object({
-  closedCompleted: z10.number().int().nonnegative(),
-  closedDuplicate: z10.number().int().nonnegative(),
-  closedNotPlanned: z10.number().int().nonnegative(),
-  closedUnknown: z10.number().int().nonnegative(),
-  created: z10.number().int().nonnegative(),
-  date: z10.string().date()
+var issueDaySchema = z11.object({
+  created: z11.number().int().nonnegative(),
+  date: z11.string().date()
 }).strict();
-var issueRepositoryStatsSchema = z10.object({
-  closedCompleted: z10.number().int().nonnegative(),
-  closedDuplicate: z10.number().int().nonnegative(),
-  closedNotPlanned: z10.number().int().nonnegative(),
-  closedUnknown: z10.number().int().nonnegative(),
-  created: z10.number().int().nonnegative(),
-  repository: z10.string().min(1)
+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)
 }).strict();
-function queryRows(result) {
+function queryRows2(result) {
   if (typeof result !== "object" || result === null || !("rows" in result) || !Array.isArray(result.rows)) {
     throw new TypeError("GitHub outcome query did not return rows");
   }
@@ -1717,11 +2187,11 @@ function queryRows(result) {
 }
 async function aggregatePullRequestWindows(args) {
   const starts = WINDOWS.map(
-    (days) => [days, new Date(args.nowMs - days * DAY_MS)]
+    (days) => [days, new Date(args.nowMs - days * DAY_MS2)]
   );
   const oldestStart = starts.at(-1)[1];
   const table = juniorGitHubPullRequests;
-  const result = await args.db.execute(sql3`
+  const result = await args.db.execute(sql5`
     WITH windows(days, start_at) AS (
       VALUES
         (${starts[0][0]}::integer, ${starts[0][1]}::timestamptz),
@@ -1731,7 +2201,6 @@ async function aggregatePullRequestWindows(args) {
       SELECT
         ${table.pullRequestId},
         ${table.state},
-        ${table.commitComposition},
         ${table.openedAt},
         ${table.mergedAt},
         ${table.closedAt}
@@ -1755,24 +2224,6 @@ async function aggregatePullRequestWindows(args) {
           WHERE recent_pull_requests.state = 'closed_unmerged'
             AND recent_pull_requests.closed_at >= windows.start_at
         )::integer AS "closed",
-      count(recent_pull_requests.pull_request_id)
-        FILTER (
-          WHERE recent_pull_requests.state = 'merged'
-            AND recent_pull_requests.merged_at >= windows.start_at
-            AND recent_pull_requests.commit_composition = 'junior_only'
-        )::integer AS "juniorOnly",
-      count(recent_pull_requests.pull_request_id)
-        FILTER (
-          WHERE recent_pull_requests.state = 'merged'
-            AND recent_pull_requests.merged_at >= windows.start_at
-            AND recent_pull_requests.commit_composition = 'mixed'
-        )::integer AS "mixed",
-      count(recent_pull_requests.pull_request_id)
-        FILTER (
-          WHERE recent_pull_requests.state = 'merged'
-            AND recent_pull_requests.merged_at >= windows.start_at
-            AND recent_pull_requests.commit_composition IS NULL
-        )::integer AS "compositionUnknown",
       (
         percentile_cont(0.5) WITHIN GROUP (
           ORDER BY extract(
@@ -1790,61 +2241,40 @@ async function aggregatePullRequestWindows(args) {
     GROUP BY windows.days
     ORDER BY windows.days
   `);
-  return z10.array(pullRequestStatsSchema).parse(queryRows(result));
+  return z11.array(pullRequestStatsSchema).parse(queryRows2(result));
 }
 async function aggregatePullRequestDays(args) {
   const end = new Date(args.nowMs);
-  const start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1) - 1) * DAY_MS);
+  const start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1) - 1) * DAY_MS2);
   const table = juniorGitHubPullRequests;
-  const result = await args.db.execute(sql3`
+  const result = await args.db.execute(sql5`
     WITH days AS (
       SELECT generate_series(
         date_trunc('day', ${start}::timestamptz AT TIME ZONE 'UTC'),
         date_trunc('day', ${end}::timestamptz AT TIME ZONE 'UTC'),
         interval '1 day'
       ) AS day
-    ), events AS (
+    ), daily AS (
       SELECT
         date_trunc('day', ${table.openedAt} AT TIME ZONE 'UTC') AS day,
-        'created' AS kind
+        count(*)::integer AS created
       FROM ${table}
       WHERE ${table.openedAt} >= ${start}
-      UNION ALL
-      SELECT
-        date_trunc('day', ${table.mergedAt} AT TIME ZONE 'UTC') AS day,
-        'merged' AS kind
-      FROM ${table}
-      WHERE ${table.state} = 'merged' AND ${table.mergedAt} >= ${start}
-      UNION ALL
-      SELECT
-        date_trunc('day', ${table.closedAt} AT TIME ZONE 'UTC') AS day,
-        'closed' AS kind
-      FROM ${table}
-      WHERE ${table.state} = 'closed_unmerged' AND ${table.closedAt} >= ${start}
-    ), daily AS (
-      SELECT
-        events.day,
-        count(*) FILTER (WHERE events.kind = 'created')::integer AS created,
-        count(*) FILTER (WHERE events.kind = 'merged')::integer AS merged,
-        count(*) FILTER (WHERE events.kind = 'closed')::integer AS closed
-      FROM events
-      GROUP BY events.day
+      GROUP BY date_trunc('day', ${table.openedAt} AT TIME ZONE 'UTC')
     )
     SELECT
       to_char(days.day, 'YYYY-MM-DD') AS "date",
-      coalesce(daily.created, 0)::integer AS "created",
-      coalesce(daily.merged, 0)::integer AS "merged",
-      coalesce(daily.closed, 0)::integer AS "closed"
+      coalesce(daily.created, 0)::integer AS "created"
     FROM days
     LEFT JOIN daily ON daily.day = days.day
     ORDER BY days.day
   `);
-  return z10.array(pullRequestDaySchema).parse(queryRows(result));
+  return z11.array(pullRequestDaySchema).parse(queryRows2(result));
 }
 async function aggregatePullRequestRepositories(args) {
-  const start = new Date(args.nowMs - 30 * DAY_MS);
+  const start = new Date(args.nowMs - 30 * DAY_MS2);
   const table = juniorGitHubPullRequests;
-  const result = await args.db.execute(sql3`
+  const result = await args.db.execute(sql5`
     SELECT
       ${table.repositoryFullName} AS "repository",
       count(*) FILTER (WHERE ${table.openedAt} >= ${start})::integer
@@ -1860,17 +2290,7 @@ async function aggregatePullRequestRepositories(args) {
         WHERE ${table.state} = 'merged'
           AND ${table.mergedAt} >= ${start}
           AND ${table.commitComposition} = 'junior_only'
-      )::integer AS "juniorOnly",
-      count(*) FILTER (
-        WHERE ${table.state} = 'merged'
-          AND ${table.mergedAt} >= ${start}
-          AND ${table.commitComposition} = 'mixed'
-      )::integer AS "mixed",
-      count(*) FILTER (
-        WHERE ${table.state} = 'merged'
-          AND ${table.mergedAt} >= ${start}
-          AND ${table.commitComposition} IS NULL
-      )::integer AS "compositionUnknown"
+      )::integer AS "juniorOnly"
     FROM ${table}
     WHERE ${table.openedAt} >= ${start}
       OR ${table.mergedAt} >= ${start}
@@ -1879,15 +2299,15 @@ async function aggregatePullRequestRepositories(args) {
     ORDER BY "merged" DESC, "created" DESC, "repository" ASC
     LIMIT 25
   `);
-  return z10.array(pullRequestRepositoryStatsSchema).parse(queryRows(result));
+  return z11.array(pullRequestRepositoryStatsSchema).parse(queryRows2(result));
 }
 async function aggregateIssueWindows(args) {
   const starts = WINDOWS.map(
-    (days) => [days, new Date(args.nowMs - days * DAY_MS)]
+    (days) => [days, new Date(args.nowMs - days * DAY_MS2)]
   );
   const oldestStart = starts.at(-1)[1];
   const table = juniorGitHubIssues;
-  const result = await args.db.execute(sql3`
+  const result = await args.db.execute(sql5`
     WITH windows(days, start_at) AS (
       VALUES
         (${starts[0][0]}::integer, ${starts[0][1]}::timestamptz),
@@ -1948,63 +2368,40 @@ async function aggregateIssueWindows(args) {
     GROUP BY windows.days
     ORDER BY windows.days
   `);
-  return z10.array(issueStatsSchema).parse(queryRows(result));
+  return z11.array(issueStatsSchema).parse(queryRows2(result));
 }
 async function aggregateIssueDays(args) {
   const end = new Date(args.nowMs);
-  const start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1) - 1) * DAY_MS);
+  const start = startOfUtcDay(args.nowMs - (WINDOWS.at(-1) - 1) * DAY_MS2);
   const table = juniorGitHubIssues;
-  const result = await args.db.execute(sql3`
+  const result = await args.db.execute(sql5`
     WITH days AS (
       SELECT generate_series(
         date_trunc('day', ${start}::timestamptz AT TIME ZONE 'UTC'),
         date_trunc('day', ${end}::timestamptz AT TIME ZONE 'UTC'),
         interval '1 day'
       ) AS day
-    ), events AS (
+    ), daily AS (
       SELECT
         date_trunc('day', ${table.openedAt} AT TIME ZONE 'UTC') AS day,
-        'created' AS kind
+        count(*)::integer AS created
       FROM ${table}
       WHERE ${table.openedAt} >= ${start}
-      UNION ALL
-      SELECT
-        date_trunc('day', ${table.closedAt} AT TIME ZONE 'UTC') AS day,
-        coalesce(${table.stateReason}, 'unknown') AS kind
-      FROM ${table}
-      WHERE ${table.state} = 'closed' AND ${table.closedAt} >= ${start}
-    ), daily AS (
-      SELECT
-        events.day,
-        count(*) FILTER (WHERE events.kind = 'created')::integer AS created,
-        count(*) FILTER (WHERE events.kind = 'completed')::integer
-          AS closed_completed,
-        count(*) FILTER (WHERE events.kind = 'duplicate')::integer
-          AS closed_duplicate,
-        count(*) FILTER (WHERE events.kind = 'not_planned')::integer
-          AS closed_not_planned,
-        count(*) FILTER (WHERE events.kind = 'unknown')::integer
-          AS closed_unknown
-      FROM events
-      GROUP BY events.day
+      GROUP BY date_trunc('day', ${table.openedAt} AT TIME ZONE 'UTC')
     )
     SELECT
       to_char(days.day, 'YYYY-MM-DD') AS "date",
-      coalesce(daily.created, 0)::integer AS "created",
-      coalesce(daily.closed_completed, 0)::integer AS "closedCompleted",
-      coalesce(daily.closed_duplicate, 0)::integer AS "closedDuplicate",
-      coalesce(daily.closed_not_planned, 0)::integer AS "closedNotPlanned",
-      coalesce(daily.closed_unknown, 0)::integer AS "closedUnknown"
+      coalesce(daily.created, 0)::integer AS "created"
     FROM days
     LEFT JOIN daily ON daily.day = days.day
     ORDER BY days.day
   `);
-  return z10.array(issueDaySchema).parse(queryRows(result));
+  return z11.array(issueDaySchema).parse(queryRows2(result));
 }
 async function aggregateIssueRepositories(args) {
-  const start = new Date(args.nowMs - 30 * DAY_MS);
+  const start = new Date(args.nowMs - 30 * DAY_MS2);
   const table = juniorGitHubIssues;
-  const result = await args.db.execute(sql3`
+  const result = await args.db.execute(sql5`
     SELECT
       ${table.repositoryFullName} AS "repository",
       count(*) FILTER (WHERE ${table.openedAt} >= ${start})::integer
@@ -2036,7 +2433,7 @@ async function aggregateIssueRepositories(args) {
     ORDER BY "created" DESC, "closedCompleted" DESC, "repository" ASC
     LIMIT 25
   `);
-  return z10.array(issueRepositoryStatsSchema).parse(queryRows(result));
+  return z11.array(issueRepositoryStatsSchema).parse(queryRows2(result));
 }
 function formatPercent(value) {
   return value === void 0 ? "\u2014" : `${Math.round(value * 100)}%`;
@@ -2048,9 +2445,6 @@ function formatDuration(value) {
   if (hours < 24) return `${Math.round(hours * 10) / 10}h`;
   return `${Math.round(hours / 24 * 10) / 10}d`;
 }
-function formatCommitComposition(stats) {
-  return `${stats.juniorOnly} Junior-only \xB7 ${stats.mixed} mixed \xB7 ${stats.compositionUnknown} unknown`;
-}
 function startOfUtcDay(timestampMs) {
   const date = new Date(timestampMs);
   date.setUTCHours(0, 0, 0, 0);
@@ -2063,83 +2457,83 @@ async function buildGitHubOutcomeReport(args) {
     repositories,
     issueWindows,
     issueDays,
-    issueRepositories
+    issueRepositories,
+    costWindows,
+    repositoryCosts
   ] = await Promise.all([
     aggregatePullRequestWindows(args),
     aggregatePullRequestDays(args),
     aggregatePullRequestRepositories(args),
     aggregateIssueWindows(args),
     aggregateIssueDays(args),
-    aggregateIssueRepositories(args)
+    aggregateIssueRepositories(args),
+    aggregateGitHubCostWindows({ ...args, windows: WINDOWS }),
+    aggregateGitHubRepositoryCosts(args)
   ]);
   const thirtyDays = windows.find((window) => window.days === 30);
   const issueThirtyDays = issueWindows.find((window) => window.days === 30);
+  const costThirtyDays = costWindows.find((window) => window.days === 30);
+  const repositoryCostByName = new Map(
+    repositoryCosts.map((row) => [row.repository, row])
+  );
   return {
     generatedAt: new Date(args.nowMs).toISOString(),
-    title: "GitHub work delivered",
+    title: "GitHub activity",
     metrics: [
       {
-        label: "Junior-only merge rate \xB7 30d",
-        value: formatPercent(thirtyDays.juniorOnlyRate)
-      },
-      {
-        label: "PR merge rate \xB7 30d",
+        label: "PR closure merge rate \xB7 30d",
         value: formatPercent(thirtyDays.mergeRate)
       },
       {
-        label: "median PR merge time \xB7 30d",
+        label: "Median PR merge time \xB7 merged in 30d",
         value: formatDuration(thirtyDays.medianMergeTimeMs)
       },
       {
-        label: "median issue close time \xB7 30d",
+        label: "Median issue close time \xB7 closed in 30d",
         value: formatDuration(issueThirtyDays.medianCloseTimeMs)
+      },
+      {
+        label: "PR cost \xB7 opened in 30d",
+        value: formatCostUsd(costThirtyDays.pullRequestCostUsd)
+      },
+      {
+        label: "Median PR cost \xB7 opened in 30d",
+        value: formatCostUsd(costThirtyDays.medianPullRequestCostUsd)
+      },
+      {
+        label: "Issue cost \xB7 opened in 30d",
+        value: formatCostUsd(costThirtyDays.issueCostUsd)
+      },
+      {
+        label: "Median issue cost \xB7 opened in 30d",
+        value: formatCostUsd(costThirtyDays.medianIssueCostUsd)
       }
     ],
     widgets: [
       {
-        id: "pull-request-outcomes",
+        id: "pull-requests-created",
         type: "bar_chart",
-        title: "Pull request outcomes",
-        description: "Daily outcomes",
+        title: "Pull requests created",
+        description: "Junior-owned pull requests opened per day",
         timeRangeDays: [...WINDOWS],
-        series: [
-          { key: "created", label: "Created" },
-          { key: "merged", label: "Merged", tone: "good" },
-          { key: "closed", label: "Closed unmerged", tone: "danger" }
-        ],
+        series: [{ key: "created", label: "Created" }],
         categories: pullRequestDays.map((stats) => ({
           id: stats.date,
           label: stats.date,
-          values: {
-            created: stats.created,
-            merged: stats.merged,
-            closed: stats.closed
-          }
+          values: { created: stats.created }
         }))
       },
       {
-        id: "issue-outcomes",
+        id: "issues-created",
         type: "bar_chart",
-        title: "Issue outcomes",
-        description: "Daily outcomes",
+        title: "Issues created",
+        description: "Junior-owned issues opened per day",
         timeRangeDays: [...WINDOWS],
-        series: [
-          { key: "created", label: "Created" },
-          { key: "completed", label: "Completed", tone: "good" },
-          { key: "duplicate", label: "Duplicate", tone: "warning" },
-          { key: "notPlanned", label: "Not planned", tone: "danger" },
-          { key: "unknown", label: "Unknown" }
-        ],
+        series: [{ key: "created", label: "Created" }],
         categories: issueDays.map((stats) => ({
           id: stats.date,
           label: stats.date,
-          values: {
-            created: stats.created,
-            completed: stats.closedCompleted,
-            duplicate: stats.closedDuplicate,
-            notPlanned: stats.closedNotPlanned,
-            unknown: stats.closedUnknown
-          }
+          values: { created: stats.created }
         }))
       }
     ],
@@ -2150,10 +2544,11 @@ async function buildGitHubOutcomeReport(args) {
         fields: [
           { key: "repository", label: "Repository" },
           { key: "created", label: "Created" },
+          { key: "juniorOnly", label: "Junior-only merges" },
           { key: "merged", label: "Merged" },
           { key: "closed", label: "Closed unmerged" },
-          { key: "commitComposition", label: "Merged commit composition" },
-          { key: "mergeRate", label: "Merge rate" }
+          { key: "mergeRate", label: "Closure merge rate" },
+          { key: "cost", label: "Cost" }
         ],
         records: repositories.map(({ repository, ...stats }) => ({
           id: repository,
@@ -2162,8 +2557,11 @@ async function buildGitHubOutcomeReport(args) {
             created: String(stats.created),
             merged: String(stats.merged),
             closed: String(stats.closed),
-            commitComposition: formatCommitComposition(stats),
-            mergeRate: formatPercent(stats.mergeRate)
+            juniorOnly: String(stats.juniorOnly),
+            mergeRate: formatPercent(stats.mergeRate),
+            cost: formatCostUsd(
+              repositoryCostByName.get(repository)?.pullRequestCostUsd ?? 0
+            )
           }
         }))
       },
@@ -2176,7 +2574,8 @@ async function buildGitHubOutcomeReport(args) {
           { key: "completed", label: "Completed" },
           { key: "duplicate", label: "Duplicate" },
           { key: "notPlanned", label: "Not planned" },
-          { key: "unknown", label: "Unknown reason" }
+          { key: "unknown", label: "Unknown reason" },
+          { key: "cost", label: "Cost" }
         ],
         records: issueRepositories.map(({ repository, ...stats }) => ({
           id: repository,
@@ -2186,7 +2585,10 @@ async function buildGitHubOutcomeReport(args) {
             completed: String(stats.closedCompleted),
             duplicate: String(stats.closedDuplicate),
             notPlanned: String(stats.closedNotPlanned),
-            unknown: String(stats.closedUnknown)
+            unknown: String(stats.closedUnknown),
+            cost: formatCostUsd(
+              repositoryCostByName.get(repository)?.issueCostUsd ?? 0
+            )
           }
         }))
       }
@@ -2195,18 +2597,18 @@ async function buildGitHubOutcomeReport(args) {
 }
 
 // src/pull-request-outcomes/commit-composition.ts
-import { z as z11 } from "zod";
-var canonicalCommitSchema = z11.object({
-  authorEmail: z11.string().nullable(),
-  authorLogin: z11.string().nullable()
+import { z as z12 } from "zod";
+var canonicalCommitSchema = z12.object({
+  authorEmail: z12.string().nullable(),
+  authorLogin: z12.string().nullable()
 }).strict();
-var providerCommitSchema = z11.object({
-  author: z11.object({ login: z11.string() }).passthrough().nullable(),
-  commit: z11.object({
-    author: z11.object({ email: z11.string() }).passthrough().nullable()
+var providerCommitSchema = z12.object({
+  author: z12.object({ login: z12.string() }).passthrough().nullable(),
+  commit: z12.object({
+    author: z12.object({ email: z12.string() }).passthrough().nullable()
   }).passthrough()
 }).passthrough();
-var commitPageSchema = z11.array(providerCommitSchema).transform(
+var commitPageSchema = z12.array(providerCommitSchema).transform(
   (commits) => commits.map(
     (commit) => canonicalCommitSchema.parse({
       authorEmail: commit.commit.author?.email ?? null,