paperclip-github-plugin 0.5.3 → 0.6.0

package/dist/worker.js

@@ -561,6 +561,12 @@ function parseRepositoryReference(repositoryInput) {
   }
 }
 
+// src/kpi-contract.ts
+var GITHUB_SYNC_PLUGIN_ID = "paperclip-github-plugin";
+var COMPANY_METRIC_WEBHOOK_ENDPOINT_KEY = "record-company-metric-event";
+var COMPANY_METRIC_WEBHOOK_PATH = `/api/plugins/${GITHUB_SYNC_PLUGIN_ID}/webhooks/${COMPANY_METRIC_WEBHOOK_ENDPOINT_KEY}`;
+var COMPANY_METRIC_WEBHOOK_AUTH_HEADER = "authorization";
+
 // src/paperclip-health.ts
 function normalizeOptionalString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
@@ -604,6 +610,10 @@ var IMPORT_REGISTRY_SCOPE = {
   scopeKind: "instance",
   stateKey: "paperclip-github-plugin-import-registry"
 };
+var COMPANY_KPI_SCOPE = {
+  scopeKind: "instance",
+  stateKey: "paperclip-github-plugin-company-kpis"
+};
 var DEFAULT_SCHEDULE_FREQUENCY_MINUTES = 15;
 var DEFAULT_IMPORTED_ISSUE_STATUS = "backlog";
 var DEFAULT_IGNORED_GITHUB_ISSUE_USERNAMES = ["renovate"];
@@ -629,6 +639,11 @@ var SYNC_PROGRESS_PERSIST_INTERVAL_MS = 250;
 var MAX_SYNC_FAILURE_LOG_ENTRIES = 25;
 var GITHUB_SECONDARY_RATE_LIMIT_FALLBACK_MS = 6e4;
 var IMPORTED_ISSUE_WAKEUP_CONCURRENCY = 4;
+var COMPANY_KPI_CHART_WINDOW_DAYS = 14;
+var COMPANY_KPI_COMPARISON_WINDOW_DAYS = 30;
+var MAX_COMPANY_BACKLOG_SNAPSHOTS = 180;
+var MAX_COMPANY_ACTIVITY_ROLLUPS = 365;
+var MAX_COMPANY_METRIC_EVENT_KEYS = 2e3;
 var MISSING_GITHUB_TOKEN_SYNC_MESSAGE = "Configure a GitHub token before running sync.";
 var MISSING_GITHUB_TOKEN_SYNC_ACTION = 'Open settings and save a GitHub token secret, or create $PAPERCLIP_HOME/plugins/github-sync/config.json (or ~/.paperclip/plugins/github-sync/config.json when PAPERCLIP_HOME is unset) with a "githubToken" value, and then run sync again.';
 var MISSING_MAPPING_SYNC_MESSAGE = "Save at least one mapping with a created Paperclip project before running sync.";
@@ -646,6 +661,7 @@ var AI_AUTHORED_MARKDOWN_FOOTER_PATTERN = /\n\n---\n###### ✨ This (?:comment|i
 var HIDDEN_GITHUB_IMPORT_MARKER_PREFIX = "<!-- paperclip-github-plugin-imported-from: ";
 var HIDDEN_GITHUB_IMPORT_MARKER_SUFFIX = " -->";
 var EMPTY_GITHUB_ISSUE_DESCRIPTION_PLACEHOLDER = "_No description provided on GitHub._";
+var pluginRuntimeContext = null;
 function normalizeCompanyId(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
@@ -2528,6 +2544,144 @@ async function buildToolbarSyncState(ctx, input) {
     savedMappingCount
   };
 }
+function shiftIsoDay(day, offsetDays) {
+  const parsed = /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`);
+  parsed.setUTCDate(parsed.getUTCDate() + offsetDays);
+  return parsed.toISOString().slice(0, 10);
+}
+function listIsoDayWindow(endDay, days) {
+  return Array.from(
+    { length: Math.max(0, days) },
+    (_, index) => shiftIsoDay(endDay, index - (days - 1))
+  );
+}
+function getBacklogValueOnOrBeforeDay(snapshots, day) {
+  let currentValue;
+  for (const snapshot of snapshots) {
+    if (snapshot.day > day) {
+      break;
+    }
+    currentValue = snapshot.openIssueCount;
+  }
+  return currentValue;
+}
+function buildBacklogHistorySeries(snapshots, endDay, days) {
+  const series = [];
+  for (const day of listIsoDayWindow(endDay, days)) {
+    const value = getBacklogValueOnOrBeforeDay(snapshots, day);
+    if (value === void 0) {
+      continue;
+    }
+    series.push({
+      day,
+      value
+    });
+  }
+  return series;
+}
+function getCompanyActivityMetricValue(rollup, metric) {
+  return metric === "githubIssuesClosedCount" ? rollup.githubIssuesClosedCount : rollup.paperclipPullRequestsCreatedCount;
+}
+function buildActivityHistorySeries(rollups, metric, endDay, days) {
+  const rollupsByDay = new Map(rollups.map((rollup) => [rollup.day, rollup]));
+  return listIsoDayWindow(endDay, days).map((day) => ({
+    day,
+    value: getCompanyActivityMetricValue(
+      rollupsByDay.get(day) ?? createEmptyCompanyActivityRollup(day, `${day}T00:00:00.000Z`),
+      metric
+    )
+  }));
+}
+function sumActivityMetricForWindow(rollups, metric, endDay, days) {
+  return buildActivityHistorySeries(rollups, metric, endDay, days).reduce((sum, point) => sum + point.value, 0);
+}
+async function buildDashboardMetricsData(ctx, input) {
+  const companyId = normalizeCompanyId(input.companyId);
+  if (!companyId) {
+    return {
+      status: "company_required",
+      historyWindowDays: COMPANY_KPI_CHART_WINDOW_DAYS,
+      comparisonWindowDays: COMPANY_KPI_COMPARISON_WINDOW_DAYS,
+      notes: {
+        backlogHistoryAvailable: false,
+        activityHistoryAvailable: false
+      }
+    };
+  }
+  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const mappings = getSyncableMappingsForScope(settings.mappings, companyId);
+  const companyKpis = normalizeCompanyKpiState(await ctx.state.get(COMPANY_KPI_SCOPE));
+  const backlogSnapshots = getCompanyBacklogSnapshots(companyKpis, companyId);
+  const activityRollups = getCompanyActivityRollups(companyKpis, companyId);
+  const latestBacklogSnapshot = backlogSnapshots.at(-1);
+  const latestActivityRollup = activityRollups.at(-1);
+  const backlogEndDay = latestBacklogSnapshot?.day;
+  const activityEndDay = latestActivityRollup?.day;
+  return {
+    status: mappings.length > 0 ? "ready" : "no_mappings",
+    companyId,
+    mappedRepositoryCount: mappings.length,
+    historyWindowDays: COMPANY_KPI_CHART_WINDOW_DAYS,
+    comparisonWindowDays: COMPANY_KPI_COMPARISON_WINDOW_DAYS,
+    backlog: {
+      ...latestBacklogSnapshot ? { lastCapturedAt: latestBacklogSnapshot.capturedAt } : {},
+      ...latestBacklogSnapshot ? { currentOpenIssueCount: latestBacklogSnapshot.openIssueCount } : {},
+      ...backlogEndDay ? {
+        comparisonOpenIssueCount: getBacklogValueOnOrBeforeDay(
+          backlogSnapshots,
+          shiftIsoDay(backlogEndDay, -(COMPANY_KPI_COMPARISON_WINDOW_DAYS - 1))
+        )
+      } : {},
+      history: backlogEndDay ? buildBacklogHistorySeries(backlogSnapshots, backlogEndDay, COMPANY_KPI_CHART_WINDOW_DAYS) : []
+    },
+    githubIssuesClosed: {
+      ...latestActivityRollup ? { lastRecordedAt: latestActivityRollup.updatedAt } : {},
+      currentPeriodCount: activityEndDay ? sumActivityMetricForWindow(
+        activityRollups,
+        "githubIssuesClosedCount",
+        activityEndDay,
+        COMPANY_KPI_COMPARISON_WINDOW_DAYS
+      ) : 0,
+      previousPeriodCount: activityEndDay ? sumActivityMetricForWindow(
+        activityRollups,
+        "githubIssuesClosedCount",
+        shiftIsoDay(activityEndDay, -COMPANY_KPI_COMPARISON_WINDOW_DAYS),
+        COMPANY_KPI_COMPARISON_WINDOW_DAYS
+      ) : 0,
+      history: activityEndDay ? buildActivityHistorySeries(
+        activityRollups,
+        "githubIssuesClosedCount",
+        activityEndDay,
+        COMPANY_KPI_CHART_WINDOW_DAYS
+      ) : []
+    },
+    paperclipPullRequestsCreated: {
+      ...latestActivityRollup ? { lastRecordedAt: latestActivityRollup.updatedAt } : {},
+      currentPeriodCount: activityEndDay ? sumActivityMetricForWindow(
+        activityRollups,
+        "paperclipPullRequestsCreatedCount",
+        activityEndDay,
+        COMPANY_KPI_COMPARISON_WINDOW_DAYS
+      ) : 0,
+      previousPeriodCount: activityEndDay ? sumActivityMetricForWindow(
+        activityRollups,
+        "paperclipPullRequestsCreatedCount",
+        shiftIsoDay(activityEndDay, -COMPANY_KPI_COMPARISON_WINDOW_DAYS),
+        COMPANY_KPI_COMPARISON_WINDOW_DAYS
+      ) : 0,
+      history: activityEndDay ? buildActivityHistorySeries(
+        activityRollups,
+        "paperclipPullRequestsCreatedCount",
+        activityEndDay,
+        COMPANY_KPI_CHART_WINDOW_DAYS
+      ) : []
+    },
+    notes: {
+      backlogHistoryAvailable: backlogSnapshots.length > 0,
+      activityHistoryAvailable: activityRollups.length > 0
+    }
+  };
+}
 async function buildIssueGitHubDetails(ctx, input) {
   const issueId = typeof input.issueId === "string" && input.issueId.trim() ? input.issueId.trim() : void 0;
   const companyId = typeof input.companyId === "string" && input.companyId.trim() ? input.companyId.trim() : void 0;
@@ -3605,6 +3759,193 @@ function normalizeSettings(value) {
     updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : void 0
   };
 }
+function getIsoDayString(value) {
+  return coerceDate(value).toISOString().slice(0, 10);
+}
+function parseDateValue(value) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    const parsed = new Date(value);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
+function normalizeIsoDayString(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return void 0;
+  }
+  return parseDateValue(value.trim())?.toISOString().slice(0, 10);
+}
+function normalizeIsoTimestampString(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return void 0;
+  }
+  return parseDateValue(value.trim())?.toISOString();
+}
+function normalizeCompanyBacklogSnapshot(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const day = normalizeIsoDayString(record.day);
+  const capturedAt = normalizeIsoTimestampString(record.capturedAt);
+  const openIssueCount = typeof record.openIssueCount === "number" && record.openIssueCount >= 0 ? Math.floor(record.openIssueCount) : NaN;
+  const repositoryCount = typeof record.repositoryCount === "number" && record.repositoryCount >= 0 ? Math.floor(record.repositoryCount) : NaN;
+  if (!day || !capturedAt || Number.isNaN(openIssueCount) || Number.isNaN(repositoryCount)) {
+    return null;
+  }
+  return {
+    day,
+    capturedAt,
+    openIssueCount,
+    repositoryCount
+  };
+}
+function normalizeCompanyBacklogSnapshots(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const snapshotsByDay = /* @__PURE__ */ new Map();
+  for (const entry of value) {
+    const snapshot = normalizeCompanyBacklogSnapshot(entry);
+    if (!snapshot) {
+      continue;
+    }
+    const existing = snapshotsByDay.get(snapshot.day);
+    if (!existing || existing.capturedAt.localeCompare(snapshot.capturedAt) <= 0) {
+      snapshotsByDay.set(snapshot.day, snapshot);
+    }
+  }
+  return [...snapshotsByDay.values()].sort((left, right) => left.day.localeCompare(right.day)).slice(-MAX_COMPANY_BACKLOG_SNAPSHOTS);
+}
+function createEmptyCompanyActivityRollup(day, updatedAt) {
+  return {
+    day,
+    updatedAt,
+    githubIssuesClosedCount: 0,
+    paperclipPullRequestsCreatedCount: 0
+  };
+}
+function normalizeCompanyActivityRollup(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const day = normalizeIsoDayString(record.day);
+  const updatedAt = normalizeIsoTimestampString(record.updatedAt);
+  const githubIssuesClosedCount = typeof record.githubIssuesClosedCount === "number" && record.githubIssuesClosedCount >= 0 ? Math.floor(record.githubIssuesClosedCount) : 0;
+  const paperclipPullRequestsCreatedCount = typeof record.paperclipPullRequestsCreatedCount === "number" && record.paperclipPullRequestsCreatedCount >= 0 ? Math.floor(record.paperclipPullRequestsCreatedCount) : 0;
+  const paperclipPullRequestsMergedCount = typeof record.paperclipPullRequestsMergedCount === "number" && record.paperclipPullRequestsMergedCount >= 0 ? Math.floor(record.paperclipPullRequestsMergedCount) : void 0;
+  if (!day || !updatedAt) {
+    return null;
+  }
+  return {
+    day,
+    updatedAt,
+    githubIssuesClosedCount,
+    paperclipPullRequestsCreatedCount,
+    ...paperclipPullRequestsMergedCount !== void 0 ? { paperclipPullRequestsMergedCount } : {}
+  };
+}
+function normalizeCompanyActivityRollups(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const rollupsByDay = /* @__PURE__ */ new Map();
+  for (const entry of value) {
+    const rollup = normalizeCompanyActivityRollup(entry);
+    if (!rollup) {
+      continue;
+    }
+    const existing = rollupsByDay.get(rollup.day);
+    if (!existing || existing.updatedAt.localeCompare(rollup.updatedAt) <= 0) {
+      rollupsByDay.set(rollup.day, rollup);
+    }
+  }
+  return [...rollupsByDay.values()].sort((left, right) => left.day.localeCompare(right.day)).slice(-MAX_COMPANY_ACTIVITY_ROLLUPS);
+}
+function normalizeCompanyMetricEventKeyRecord(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const key = typeof record.key === "string" && record.key.trim() ? record.key.trim() : "";
+  const recordedAt = typeof record.recordedAt === "string" ? coerceDate(record.recordedAt).toISOString() : void 0;
+  if (!key || !recordedAt) {
+    return null;
+  }
+  return {
+    key,
+    recordedAt
+  };
+}
+function normalizeCompanyMetricEventKeyRecords(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const entries = value.map((entry) => normalizeCompanyMetricEventKeyRecord(entry)).filter((entry) => entry !== null).sort((left, right) => left.recordedAt.localeCompare(right.recordedAt));
+  const keys = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const entry of entries) {
+    if (keys.has(entry.key)) {
+      continue;
+    }
+    keys.add(entry.key);
+    deduped.push(entry);
+  }
+  return deduped.slice(-MAX_COMPANY_METRIC_EVENT_KEYS);
+}
+function normalizeCompanyBacklogSnapshotsByCompanyId(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([companyId, snapshots]) => {
+    const normalizedCompanyId = normalizeCompanyId(companyId);
+    const normalizedSnapshots = normalizeCompanyBacklogSnapshots(snapshots);
+    return normalizedCompanyId && normalizedSnapshots.length > 0 ? [normalizedCompanyId, normalizedSnapshots] : null;
+  }).filter((entry) => entry !== null);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function normalizeCompanyActivityRollupsByCompanyId(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([companyId, rollups]) => {
+    const normalizedCompanyId = normalizeCompanyId(companyId);
+    const normalizedRollups = normalizeCompanyActivityRollups(rollups);
+    return normalizedCompanyId && normalizedRollups.length > 0 ? [normalizedCompanyId, normalizedRollups] : null;
+  }).filter((entry) => entry !== null);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function normalizeCompanyMetricEventKeysByCompanyId(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const entries = Object.entries(value).map(([companyId, records]) => {
+    const normalizedCompanyId = normalizeCompanyId(companyId);
+    const normalizedRecords = normalizeCompanyMetricEventKeyRecords(records);
+    return normalizedCompanyId && normalizedRecords.length > 0 ? [normalizedCompanyId, normalizedRecords] : null;
+  }).filter((entry) => entry !== null);
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function normalizeCompanyKpiState(value) {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  const record = value;
+  const backlogSnapshotsByCompanyId = normalizeCompanyBacklogSnapshotsByCompanyId(record.backlogSnapshotsByCompanyId);
+  const activityRollupsByCompanyId = normalizeCompanyActivityRollupsByCompanyId(record.activityRollupsByCompanyId);
+  const metricEventKeysByCompanyId = normalizeCompanyMetricEventKeysByCompanyId(record.metricEventKeysByCompanyId);
+  return {
+    ...backlogSnapshotsByCompanyId ? { backlogSnapshotsByCompanyId } : {},
+    ...activityRollupsByCompanyId ? { activityRollupsByCompanyId } : {},
+    ...metricEventKeysByCompanyId ? { metricEventKeysByCompanyId } : {}
+  };
+}
 function getScopedSyncState(settings, companyId) {
   const normalizedCompanyId = normalizeCompanyId(companyId);
   if (!normalizedCompanyId) {
@@ -3702,6 +4043,149 @@ function getSyncableMappingsForScope(mappings, companyId) {
 function hasAnyScopedValue(valueByCompanyId) {
   return Boolean(valueByCompanyId && Object.keys(valueByCompanyId).length > 0);
 }
+function getCompanyBacklogSnapshots(state, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return [];
+  }
+  return normalizeCompanyBacklogSnapshots(state.backlogSnapshotsByCompanyId?.[normalizedCompanyId]);
+}
+function getCompanyActivityRollups(state, companyId) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return [];
+  }
+  return normalizeCompanyActivityRollups(state.activityRollupsByCompanyId?.[normalizedCompanyId]);
+}
+function upsertCompanyBacklogSnapshot(state, companyId, snapshot) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId) {
+    return state;
+  }
+  const nextSnapshots = [
+    ...getCompanyBacklogSnapshots(state, normalizedCompanyId).filter((entry) => entry.day !== snapshot.day),
+    snapshot
+  ].sort((left, right) => left.day.localeCompare(right.day)).slice(-MAX_COMPANY_BACKLOG_SNAPSHOTS);
+  return {
+    ...state,
+    backlogSnapshotsByCompanyId: {
+      ...state.backlogSnapshotsByCompanyId ?? {},
+      [normalizedCompanyId]: nextSnapshots
+    }
+  };
+}
+function incrementCompanyActivityRollup(state, params) {
+  const normalizedCompanyId = normalizeCompanyId(params.companyId);
+  if (!normalizedCompanyId) {
+    return state;
+  }
+  const occurredAt = coerceDate(params.occurredAt ?? /* @__PURE__ */ new Date()).toISOString();
+  const day = getIsoDayString(occurredAt);
+  const count = Math.max(1, Math.floor(params.count ?? 1));
+  const nextRollups = [...getCompanyActivityRollups(state, normalizedCompanyId)];
+  const existingIndex = nextRollups.findIndex((entry) => entry.day === day);
+  const existing = existingIndex >= 0 ? nextRollups[existingIndex] : createEmptyCompanyActivityRollup(day, occurredAt);
+  const updated = {
+    ...existing,
+    updatedAt: occurredAt,
+    [params.metric]: existing[params.metric] + count
+  };
+  if (existingIndex >= 0) {
+    nextRollups.splice(existingIndex, 1, updated);
+  } else {
+    nextRollups.push(updated);
+  }
+  nextRollups.sort((left, right) => left.day.localeCompare(right.day));
+  return {
+    ...state,
+    activityRollupsByCompanyId: {
+      ...state.activityRollupsByCompanyId ?? {},
+      [normalizedCompanyId]: nextRollups.slice(-MAX_COMPANY_ACTIVITY_ROLLUPS)
+    }
+  };
+}
+function hasRecordedCompanyMetricEventKey(state, companyId, eventKey) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  if (!normalizedCompanyId || !eventKey.trim()) {
+    return false;
+  }
+  return (state.metricEventKeysByCompanyId?.[normalizedCompanyId] ?? []).some((entry) => entry.key === eventKey);
+}
+function rememberCompanyMetricEventKey(state, companyId, eventKey, recordedAt) {
+  const normalizedCompanyId = normalizeCompanyId(companyId);
+  const trimmedKey = eventKey.trim();
+  if (!normalizedCompanyId || !trimmedKey) {
+    return state;
+  }
+  const nextRecords = [
+    ...(state.metricEventKeysByCompanyId?.[normalizedCompanyId] ?? []).filter((entry) => entry.key !== trimmedKey),
+    {
+      key: trimmedKey,
+      recordedAt
+    }
+  ].sort((left, right) => left.recordedAt.localeCompare(right.recordedAt)).slice(-MAX_COMPANY_METRIC_EVENT_KEYS);
+  return {
+    ...state,
+    metricEventKeysByCompanyId: {
+      ...state.metricEventKeysByCompanyId ?? {},
+      [normalizedCompanyId]: nextRecords
+    }
+  };
+}
+function buildCompanyMetricEventKey(params) {
+  const pullRequestUrl = normalizeGitHubPullRequestHtmlUrl(params.pullRequestUrl);
+  if (pullRequestUrl) {
+    return `${params.metric}:${pullRequestUrl}`;
+  }
+  const repository = typeof params.repositoryUrl === "string" ? parseRepositoryReference(params.repositoryUrl) : null;
+  const pullRequestNumber = typeof params.pullRequestNumber === "number" && params.pullRequestNumber >= 1 ? Math.floor(params.pullRequestNumber) : void 0;
+  if (repository && pullRequestNumber) {
+    return `${params.metric}:${repository.url}/pull/${pullRequestNumber}`;
+  }
+  const explicitEventKey = normalizeOptionalString2(params.eventKey);
+  if (explicitEventKey) {
+    return `${params.metric}:${explicitEventKey}`;
+  }
+  return void 0;
+}
+function recordCompanyActivityMetricEvent(state, params) {
+  const normalizedCompanyId = normalizeCompanyId(params.companyId);
+  if (!normalizedCompanyId) {
+    return {
+      state,
+      recorded: false
+    };
+  }
+  const occurredAt = coerceDate(params.occurredAt ?? /* @__PURE__ */ new Date()).toISOString();
+  const eventKey = buildCompanyMetricEventKey({
+    metric: params.metric,
+    eventKey: params.eventKey,
+    repositoryUrl: params.repositoryUrl,
+    pullRequestNumber: params.pullRequestNumber,
+    pullRequestUrl: params.pullRequestUrl
+  });
+  if (eventKey && hasRecordedCompanyMetricEventKey(state, normalizedCompanyId, eventKey)) {
+    return {
+      state,
+      recorded: false,
+      eventKey
+    };
+  }
+  let nextState = incrementCompanyActivityRollup(state, {
+    companyId: normalizedCompanyId,
+    metric: params.metric,
+    count: params.count,
+    occurredAt
+  });
+  if (eventKey) {
+    nextState = rememberCompanyMetricEventKey(nextState, normalizedCompanyId, eventKey, occurredAt);
+  }
+  return {
+    state: nextState,
+    recorded: true,
+    ...eventKey ? { eventKey } : {}
+  };
+}
 function normalizeImportRegistry(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -3722,6 +4206,7 @@ function normalizeImportRegistry(value) {
     const paperclipProjectId = typeof record.paperclipProjectId === "string" && record.paperclipProjectId.trim() ? record.paperclipProjectId.trim() : void 0;
     const companyId = typeof record.companyId === "string" && record.companyId.trim() ? record.companyId.trim() : void 0;
     const lastSeenCommentCount = typeof record.lastSeenCommentCount === "number" && record.lastSeenCommentCount >= 0 ? Math.floor(record.lastSeenCommentCount) : void 0;
+    const lastSeenGitHubState = record.lastSeenGitHubState === "open" || record.lastSeenGitHubState === "closed" ? record.lastSeenGitHubState : void 0;
     const linkedPullRequestCommentCounts = normalizeGitHubPullRequestCommentCountRecords(
       record.linkedPullRequestCommentCounts
     );
@@ -3738,6 +4223,7 @@ function normalizeImportRegistry(value) {
       ...paperclipProjectId ? { paperclipProjectId } : {},
       ...companyId ? { companyId } : {},
       ...lastSeenCommentCount !== void 0 ? { lastSeenCommentCount } : {},
+      ...lastSeenGitHubState ? { lastSeenGitHubState } : {},
       ...linkedPullRequestCommentCounts.length > 0 ? { linkedPullRequestCommentCounts } : {}
     };
   }).filter((entry) => entry !== null);
@@ -3784,6 +4270,7 @@ function buildImportedIssueRecord(mapping, issue, paperclipIssueId, importedAt)
     paperclipIssueId,
     importedAt,
     lastSeenCommentCount: issue.commentsCount,
+    lastSeenGitHubState: issue.state,
     linkedPullRequestCommentCounts: [],
     repositoryUrl: getNormalizedMappingRepositoryUrl(mapping),
     paperclipProjectId: mapping.paperclipProjectId,
@@ -3794,6 +4281,7 @@ function refreshImportedIssueRecordForMapping(record, mapping, issue) {
   record.mappingId = mapping.id;
   record.githubIssueNumber = issue.number;
   record.lastSeenCommentCount ??= issue.commentsCount;
+  record.lastSeenGitHubState ??= issue.state;
   record.repositoryUrl = getNormalizedMappingRepositoryUrl(mapping);
   record.paperclipProjectId = mapping.paperclipProjectId;
   record.companyId = mapping.companyId;
@@ -5495,6 +5983,24 @@ function parseGitHubIssueHtmlUrl(value) {
 function normalizeGitHubIssueHtmlUrl(value) {
   return parseGitHubIssueHtmlUrl(value)?.issueUrl;
 }
+function normalizeGitHubPullRequestHtmlUrl(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "https:" || parsed.hostname !== "github.com") {
+      return void 0;
+    }
+    const match = parsed.pathname.match(/^\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/i);
+    if (!match) {
+      return void 0;
+    }
+    return `https://github.com/${match[1]}/${match[2]}/pull/${match[3]}`;
+  } catch {
+    return void 0;
+  }
+}
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -6137,16 +6643,7 @@ async function upsertStatusTransitionCommentAnnotation(ctx, params) {
   });
 }
 function coerceDate(value) {
-  if (value instanceof Date && !Number.isNaN(value.getTime())) {
-    return value;
-  }
-  if (typeof value === "string" || typeof value === "number") {
-    const parsed = new Date(value);
-    if (!Number.isNaN(parsed.getTime())) {
-      return parsed;
-    }
-  }
-  return /* @__PURE__ */ new Date();
+  return parseDateValue(value) ?? /* @__PURE__ */ new Date();
 }
 function parsePaperclipIssueLabel(value, expectedCompanyId) {
   if (!value || typeof value !== "object") {
@@ -6208,6 +6705,9 @@ function getPaperclipIssueEndpoint(baseUrl, issueId) {
 function getPaperclipHealthEndpoint(baseUrl) {
   return new URL("/api/health", baseUrl).toString();
 }
+function getPaperclipCurrentAgentEndpoint(baseUrl) {
+  return new URL("/api/agents/me", baseUrl).toString();
+}
 function getPaperclipAgentWakeupEndpoint(baseUrl, agentId) {
   return new URL(`/api/agents/${agentId}/wakeup`, baseUrl).toString();
 }
@@ -7342,7 +7842,7 @@ async function ensurePaperclipIssueImported(ctx, mapping, advancedSettings, issu
   }
   return createdIssue.id;
 }
-async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mapping, advancedSettings, allIssuesById, importedIssues, createdIssueIds, availableLabels, paperclipApiBaseUrl, linkedPullRequestsByIssueNumber, issueStatusSnapshotCache, pullRequestStatusCache, repositoryMaintainerCache, syncFailureContext, failures, assertNotCancelled, onProgress) {
+async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mapping, advancedSettings, allIssuesById, importedIssues, createdIssueIds, availableLabels, paperclipApiBaseUrl, linkedPullRequestsByIssueNumber, issueStatusSnapshotCache, pullRequestStatusCache, repositoryMaintainerCache, syncFailureContext, failures, assertNotCancelled, onGitHubIssueClosed, onProgress) {
   if (!mapping.companyId || !ctx.issues || typeof ctx.issues.get !== "function" || typeof ctx.issues.update !== "function") {
     return {
       updatedStatusesCount: 0,
@@ -7423,6 +7923,7 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         pullRequestStatusCache
       );
       const snapshotLinkedPullRequestNumbers = snapshot?.linkedPullRequests.map((pullRequest) => pullRequest.number) ?? [];
+      const previousGitHubState = importedIssue.lastSeenGitHubState;
       if (!doIssueNumberListsMatch(snapshotLinkedPullRequestNumbers, warmedLinkedPullRequestNumbers)) {
         updateSyncFailureContext(syncFailureContext, {
           phase: "syncing_description",
@@ -7462,6 +7963,15 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         },
         snapshot.linkedPullRequests
       );
+      if (previousGitHubState === "open" && snapshot.state === "closed" && typeof onGitHubIssueClosed === "function") {
+        await onGitHubIssueClosed({
+          companyId: mapping.companyId,
+          githubIssueId: githubIssue.id,
+          githubIssueNumber: githubIssue.number,
+          repositoryUrl: repository.url,
+          occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
       const previousCommentCount = importedIssue.lastSeenCommentCount;
       const hasNewIssueComments = snapshot.commentCount > (previousCommentCount ?? snapshot.commentCount);
       const hasTrustedNewIssueComment = paperclipIssue.status === "backlog" || !hasNewIssueComments ? false : await hasTrustedNewGitHubIssueComment({
@@ -7526,6 +8036,7 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
       const shouldWakeTransitionAssignee = paperclipIssue.status !== nextStatus && nextTransitionAssignee?.principal.kind === "agent" && isActionablePaperclipIssueStatus(nextStatus) && (nextAssigneeChanged || paperclipIssue.status !== nextStatus);
       importedIssue.githubIssueNumber = githubIssue.number;
       importedIssue.lastSeenCommentCount = snapshot.commentCount;
+      importedIssue.lastSeenGitHubState = snapshot.state;
       importedIssue.linkedPullRequestCommentCounts = currentLinkedPullRequestCommentCounts;
       if (paperclipIssue.status === nextStatus) {
         if (shouldClearTransitionAssignee) {
@@ -7827,6 +8338,259 @@ async function executeGitHubTool(fn) {
     return buildToolErrorResult(error);
   }
 }
+function normalizeCompanyActivityMetricInputValue(value) {
+  switch (value) {
+    case "pull_request_created":
+      return "paperclipPullRequestsCreatedCount";
+    default:
+      return void 0;
+  }
+}
+async function persistCompanyActivityMetricEvent(ctx, params, options = {}) {
+  const normalizedCompanyId = normalizeCompanyId(params.companyId);
+  if (!normalizedCompanyId) {
+    return {
+      recorded: false
+    };
+  }
+  const currentState = normalizeCompanyKpiState(await ctx.state.get(COMPANY_KPI_SCOPE));
+  const result = recordCompanyActivityMetricEvent(currentState, {
+    companyId: normalizedCompanyId,
+    metric: params.metric,
+    count: params.count,
+    occurredAt: params.occurredAt,
+    eventKey: params.eventKey,
+    repositoryUrl: params.repositoryUrl,
+    pullRequestNumber: params.pullRequestNumber,
+    pullRequestUrl: params.pullRequestUrl
+  });
+  if (!result.recorded) {
+    return {
+      recorded: false,
+      ...result.eventKey ? { eventKey: result.eventKey } : {}
+    };
+  }
+  try {
+    await ctx.state.set(COMPANY_KPI_SCOPE, result.state);
+  } catch (error) {
+    if (options.throwOnPersistFailure) {
+      throw error;
+    }
+    ctx.logger.warn("GitHub Sync could not persist a company activity metric event.", {
+      companyId: normalizedCompanyId,
+      metric: params.metric,
+      repositoryUrl: params.repositoryUrl,
+      pullRequestNumber: params.pullRequestNumber,
+      error: getErrorMessage(error)
+    });
+    return {
+      recorded: false,
+      ...result.eventKey ? { eventKey: result.eventKey } : {}
+    };
+  }
+  return {
+    recorded: true,
+    ...result.eventKey ? { eventKey: result.eventKey } : {}
+  };
+}
+function parseWebhookPayloadRecord(input) {
+  if (input.parsedBody && typeof input.parsedBody === "object" && !Array.isArray(input.parsedBody)) {
+    return input.parsedBody;
+  }
+  const rawBody = input.rawBody.trim();
+  if (!rawBody) {
+    throw new Error("Webhook body must be a JSON object.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawBody);
+  } catch {
+    throw new Error("Webhook body must be valid JSON.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Webhook body must be a JSON object.");
+  }
+  return parsed;
+}
+async function resolveCompanyIdForCompanyMetricEvent(ctx, params) {
+  const requestedCompanyId = normalizeCompanyId(params.companyId);
+  if (requestedCompanyId) {
+    return requestedCompanyId;
+  }
+  if (!params.repositoryUrl) {
+    return void 0;
+  }
+  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const matchingCompanyIds = [
+    ...new Set(
+      settings.mappings.filter((mapping) => getNormalizedMappingRepositoryUrl(mapping) === params.repositoryUrl).map((mapping) => normalizeCompanyId(mapping.companyId)).filter((companyId) => Boolean(companyId))
+    )
+  ];
+  return matchingCompanyIds.length === 1 ? matchingCompanyIds[0] : void 0;
+}
+function getWebhookHeaderValue(headers, name) {
+  const normalizedName = name.trim().toLowerCase();
+  for (const [headerName, headerValue] of Object.entries(headers)) {
+    if (headerName.trim().toLowerCase() !== normalizedName) {
+      continue;
+    }
+    if (typeof headerValue === "string") {
+      const trimmedValue = headerValue.trim();
+      return trimmedValue || void 0;
+    }
+    if (!Array.isArray(headerValue)) {
+      continue;
+    }
+    for (const entry of headerValue) {
+      if (typeof entry !== "string") {
+        continue;
+      }
+      const trimmedValue = entry.trim();
+      if (trimmedValue) {
+        return trimmedValue;
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeCompanyMetricWebhookBearerToken(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    return void 0;
+  }
+  const bearerMatch = trimmedValue.match(/^Bearer\s+(.+)$/i);
+  if (!bearerMatch) {
+    return void 0;
+  }
+  const token = bearerMatch[1]?.trim();
+  return token || void 0;
+}
+function normalizePaperclipCurrentAgentRecord(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const id = normalizeOptionalString2(record.id);
+  const companyId = normalizeCompanyId(record.companyId);
+  return id && companyId ? {
+    id,
+    companyId
+  } : null;
+}
+async function readCompanyMetricWebhookCurrentAgent(paperclipApiBaseUrl, bearerToken) {
+  const response = await fetchPaperclipApi(getPaperclipCurrentAgentEndpoint(paperclipApiBaseUrl), {
+    method: "GET",
+    headers: {
+      accept: "application/json",
+      authorization: `Bearer ${bearerToken}`
+    }
+  });
+  const payloadResult = await readPaperclipApiJsonResponse(response, {
+    operationLabel: "current agent"
+  });
+  if (payloadResult.failure) {
+    if (payloadResult.failure.requiresAuthentication) {
+      throw new Error("Company KPI webhook Authorization must be a valid PAPERCLIP_API_KEY bearer token.");
+    }
+    const detail = payloadResult.failure.errorMessage ? ` ${payloadResult.failure.errorMessage}` : "";
+    throw new Error(`Could not validate the KPI webhook Paperclip API key.${detail}`);
+  }
+  const agent = normalizePaperclipCurrentAgentRecord(payloadResult.data);
+  if (!agent) {
+    throw new Error("Paperclip did not return a usable current agent record while validating the KPI webhook caller.");
+  }
+  return agent;
+}
+async function assertCompanyMetricWebhookAuthenticated(ctx, input, companyId) {
+  const rawAuthorization = getWebhookHeaderValue(input.headers, COMPANY_METRIC_WEBHOOK_AUTH_HEADER);
+  const bearerToken = normalizeCompanyMetricWebhookBearerToken(rawAuthorization);
+  if (!bearerToken) {
+    throw new Error(
+      `Missing or invalid ${COMPANY_METRIC_WEBHOOK_AUTH_HEADER} header. Use Bearer <PAPERCLIP_API_KEY>.`
+    );
+  }
+  const settings = normalizeSettings(await ctx.state.get(SETTINGS_SCOPE));
+  const config = await getResolvedConfig(ctx);
+  const paperclipApiBaseUrl = getConfiguredPaperclipApiBaseUrl(settings, config, companyId);
+  if (!paperclipApiBaseUrl) {
+    throw new Error(
+      "A trusted Paperclip API origin is required to validate PAPERCLIP_API_KEY. Set PAPERCLIP_API_URL or save the Paperclip host origin before sending KPI webhook events."
+    );
+  }
+  const currentAgent = await readCompanyMetricWebhookCurrentAgent(paperclipApiBaseUrl, bearerToken);
+  if (normalizeCompanyId(currentAgent.companyId) !== companyId) {
+    throw new Error("Company KPI webhook Paperclip API key belongs to a different company.");
+  }
+}
+async function handleCompanyMetricWebhook(ctx, input) {
+  if (input.endpointKey !== COMPANY_METRIC_WEBHOOK_ENDPOINT_KEY) {
+    throw new Error(`Unsupported webhook endpoint: ${input.endpointKey}.`);
+  }
+  const payload = parseWebhookPayloadRecord(input);
+  const repositoryInput = normalizeOptionalString2(payload.repository);
+  const repository = repositoryInput ? parseRepositoryReference(repositoryInput) : null;
+  if (repositoryInput && !repository) {
+    throw new Error("repository must be owner/repo or https://github.com/owner/repo.");
+  }
+  const companyId = await resolveCompanyIdForCompanyMetricEvent(ctx, {
+    companyId: payload.companyId,
+    repositoryUrl: repository?.url
+  });
+  if (!companyId) {
+    throw new Error("companyId is required unless repository maps to exactly one company.");
+  }
+  await assertCompanyMetricWebhookAuthenticated(ctx, input, companyId);
+  const metric = normalizeCompanyActivityMetricInputValue(payload.metric);
+  if (!metric) {
+    throw new Error('metric must be "pull_request_created".');
+  }
+  const pullRequestNumber = normalizeToolPositiveInteger(payload.pullRequestNumber);
+  const pullRequestUrl = normalizeGitHubPullRequestHtmlUrl(normalizeOptionalString2(payload.pullRequestUrl));
+  const eventKey = normalizeOptionalString2(payload.eventKey);
+  const dedupeKey = buildCompanyMetricEventKey({
+    metric,
+    eventKey,
+    repositoryUrl: repository?.url,
+    pullRequestNumber,
+    pullRequestUrl
+  });
+  if (!dedupeKey) {
+    throw new Error(
+      "Company KPI webhook requires pullRequestUrl, repository plus pullRequestNumber, or eventKey so duplicate deliveries can be ignored."
+    );
+  }
+  const recordedMetric = await persistCompanyActivityMetricEvent(
+    ctx,
+    {
+      companyId,
+      metric,
+      count: normalizeToolPositiveInteger(payload.count),
+      occurredAt: normalizeOptionalString2(payload.occurredAt),
+      eventKey,
+      repositoryUrl: repository?.url,
+      pullRequestNumber,
+      pullRequestUrl
+    },
+    {
+      throwOnPersistFailure: true
+    }
+  );
+  ctx.logger.info(
+    recordedMetric.recorded ? "GitHub Sync recorded a company KPI webhook event." : "GitHub Sync ignored a duplicate company KPI webhook event.",
+    {
+      endpointKey: input.endpointKey,
+      companyId,
+      metric,
+      repositoryUrl: repository?.url,
+      pullRequestNumber,
+      pullRequestUrl,
+      requestId: input.requestId
+    }
+  );
+}
 async function createGitHubToolOctokit(ctx, companyId) {
   const token = (await resolveGithubToken(ctx, { companyId })).trim();
   if (!token) {
@@ -10782,6 +11546,8 @@ async function performSync(ctx, trigger, options = {}) {
   const config = await getResolvedConfig(ctx);
   const settings = materializeScopedSettings(baseSettings, config, targetCompanyId);
   const importRegistry = normalizeImportRegistry(await ctx.state.get(IMPORT_REGISTRY_SCOPE));
+  let companyKpiState = normalizeCompanyKpiState(await ctx.state.get(COMPANY_KPI_SCOPE));
+  let companyKpiStateDirty = false;
   const token = typeof options.resolvedToken === "string" ? options.resolvedToken : await resolveGithubToken(ctx, { companyId: targetCompanyId });
   const paperclipApiBaseUrl = getConfiguredPaperclipApiBaseUrl(baseSettings, config, targetCompanyId);
   const mappings = getSyncableMappingsForTarget(settings.mappings, options.target);
@@ -10866,6 +11632,19 @@ async function performSync(ctx, trigger, options = {}) {
     erroredIssuesCount: recoverableFailures.length,
     progress: currentProgress
   });
+  async function flushCompanyKpiState() {
+    if (!companyKpiStateDirty) {
+      return;
+    }
+    try {
+      await ctx.state.set(COMPANY_KPI_SCOPE, companyKpiState);
+      companyKpiStateDirty = false;
+    } catch (error) {
+      ctx.logger.warn("GitHub Sync could not persist company KPI state.", {
+        error: getErrorMessage(error)
+      });
+    }
+  }
   async function throwIfSyncCancelled() {
     const cancellationRequest = await getSyncCancellationRequest(ctx);
     if (!cancellationRequest) {
@@ -10918,6 +11697,48 @@ async function performSync(ctx, trigger, options = {}) {
     completedTrackedIssueKeys.add(key);
     completedTrackedIssueCount += 1;
   }
+  function recordCompanyBacklogSnapshotsFromPlans(repositoryPlans2) {
+    if (options.target?.kind === "project" || options.target?.kind === "issue") {
+      return;
+    }
+    const expectedMappingsByCompanyId = /* @__PURE__ */ new Map();
+    for (const mapping of mappings) {
+      const companyId = normalizeCompanyId(mapping.companyId);
+      if (!companyId) {
+        continue;
+      }
+      expectedMappingsByCompanyId.set(companyId, (expectedMappingsByCompanyId.get(companyId) ?? 0) + 1);
+    }
+    const planBacklogByCompanyId = /* @__PURE__ */ new Map();
+    for (const plan of repositoryPlans2) {
+      const companyId = normalizeCompanyId(plan.mapping.companyId);
+      if (!companyId) {
+        continue;
+      }
+      const current = planBacklogByCompanyId.get(companyId) ?? {
+        repositoryCount: 0,
+        openIssueCount: 0
+      };
+      current.repositoryCount += 1;
+      current.openIssueCount += plan.issues.length;
+      planBacklogByCompanyId.set(companyId, current);
+    }
+    const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const day = getIsoDayString(capturedAt);
+    for (const [companyId, expectedRepositoryCount] of expectedMappingsByCompanyId.entries()) {
+      const planned = planBacklogByCompanyId.get(companyId);
+      if (!planned || planned.repositoryCount !== expectedRepositoryCount) {
+        continue;
+      }
+      companyKpiState = upsertCompanyBacklogSnapshot(companyKpiState, companyId, {
+        day,
+        capturedAt,
+        openIssueCount: planned.openIssueCount,
+        repositoryCount: planned.repositoryCount
+      });
+      companyKpiStateDirty = true;
+    }
+  }
   const repositoryPlans = [];
   try {
     await throwIfSyncCancelled();
@@ -11017,6 +11838,7 @@ async function performSync(ctx, trigger, options = {}) {
         continue;
       }
     }
+    recordCompanyBacklogSnapshotsFromPlans(repositoryPlans);
     if (repositoryPlans.length > 0) {
       const firstPlan = repositoryPlans[0];
       currentProgress = {
@@ -11203,6 +12025,17 @@ async function performSync(ctx, trigger, options = {}) {
           failureContext,
           recoverableFailures,
           throwIfSyncCancelled,
+          async (params) => {
+            const recorded = recordCompanyActivityMetricEvent(companyKpiState, {
+              companyId: params.companyId,
+              metric: "githubIssuesClosedCount",
+              eventKey: `${params.repositoryUrl}/issues/${params.githubIssueNumber}:${coerceDate(params.occurredAt).toISOString()}`,
+              repositoryUrl: params.repositoryUrl,
+              occurredAt: params.occurredAt
+            });
+            companyKpiState = recorded.state;
+            companyKpiStateDirty = companyKpiStateDirty || recorded.recorded;
+          },
           async (progress) => {
             markTrackedIssueProcessed(mapping, progress.githubIssueId);
             currentProgress = {
@@ -11306,6 +12139,8 @@ async function performSync(ctx, trigger, options = {}) {
     await saveSettingsSyncState(ctx, currentSettings, next.syncState, targetCompanyId);
     await ctx.state.set(IMPORT_REGISTRY_SCOPE, nextRegistry);
     return materializeScopedSettings(next, config, targetCompanyId);
+  } finally {
+    await flushCompanyKpiState();
   }
 }
 async function startSync(ctx, trigger, options = {}) {
@@ -11687,6 +12522,19 @@ function registerGitHubAgentTools(ctx) {
           "X-GitHub-Api-Version": GITHUB_API_VERSION
         }
       });
+      await persistCompanyActivityMetricEvent(
+        ctx,
+        {
+          companyId: runCtx.companyId,
+          metric: "paperclipPullRequestsCreatedCount",
+          repositoryUrl: repository.url,
+          pullRequestNumber: response.data.number,
+          pullRequestUrl: response.data.html_url ?? void 0
+        },
+        {
+          throwOnPersistFailure: false
+        }
+      );
       return buildToolSuccessResult(
         `Created pull request #${response.data.number} in ${formatRepositoryLabel(repository)}.`,
         {
@@ -12184,6 +13032,7 @@ function shouldStartWorkerHost(moduleUrl, entry = process.argv[1]) {
 }
 var plugin = definePlugin({
   async setup(ctx) {
+    pluginRuntimeContext = ctx;
     ctx.data.register("settings.registration", async (input) => {
       const record = input && typeof input === "object" ? input : {};
       const requestedCompanyId = normalizeCompanyId(record.companyId);
@@ -12218,6 +13067,10 @@ var plugin = definePlugin({
         paperclipBoardAccessNeedsConfigSync: Boolean(savedBoardTokenRef && !configuredBoardTokenRef)
       };
     });
+    ctx.data.register("dashboard.metrics", async (input) => {
+      const record = input && typeof input === "object" ? input : {};
+      return buildDashboardMetricsData(ctx, record);
+    });
     ctx.data.register("sync.toolbarState", async (input) => {
       const record = input && typeof input === "object" ? input : {};
       return buildToolbarSyncState(ctx, record);
@@ -12543,6 +13396,15 @@ var plugin = definePlugin({
         await startSync(ctx, trigger, target ? { target } : {});
       }
     });
+  },
+  async onWebhook(input) {
+    if (!pluginRuntimeContext) {
+      throw new Error("GitHub Sync worker is not ready to handle webhooks yet.");
+    }
+    await handleCompanyMetricWebhook(pluginRuntimeContext, input);
+  },
+  async onShutdown() {
+    pluginRuntimeContext = null;
   }
 });
 var worker_default = plugin;