paperclip-github-plugin 0.5.2 → 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,10 @@ 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
+    );
     if (!mappingId || Number.isNaN(githubIssueId) || !paperclipIssueId || !importedAt) {
       return null;
     }
@@ -3734,7 +4222,9 @@ function normalizeImportRegistry(value) {
       ...repositoryUrl ? { repositoryUrl } : {},
       ...paperclipProjectId ? { paperclipProjectId } : {},
       ...companyId ? { companyId } : {},
-      ...lastSeenCommentCount !== void 0 ? { lastSeenCommentCount } : {}
+      ...lastSeenCommentCount !== void 0 ? { lastSeenCommentCount } : {},
+      ...lastSeenGitHubState ? { lastSeenGitHubState } : {},
+      ...linkedPullRequestCommentCounts.length > 0 ? { linkedPullRequestCommentCounts } : {}
     };
   }).filter((entry) => entry !== null);
 }
@@ -3780,6 +4270,8 @@ function buildImportedIssueRecord(mapping, issue, paperclipIssueId, importedAt)
     paperclipIssueId,
     importedAt,
     lastSeenCommentCount: issue.commentsCount,
+    lastSeenGitHubState: issue.state,
+    linkedPullRequestCommentCounts: [],
     repositoryUrl: getNormalizedMappingRepositoryUrl(mapping),
     paperclipProjectId: mapping.paperclipProjectId,
     companyId: mapping.companyId
@@ -3789,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;
@@ -4612,7 +5105,7 @@ function buildSyncFallbackExecutionStatePatch(params) {
   return void 0;
 }
 function describeGitHubStatusTransitionReason(params) {
-  const { snapshot, previousCommentCount, hasTrustedNewComment, maintainerAuthoredImportedIssue } = params;
+  const { snapshot, hasTrustedNewComment, maintainerAuthoredImportedIssue } = params;
   if (snapshot.state === "closed") {
     switch (snapshot.stateReason) {
       case "duplicate":
@@ -4623,8 +5116,7 @@ function describeGitHubStatusTransitionReason(params) {
         return "the GitHub issue was closed as completed work";
     }
   }
-  const baselineCommentCount = previousCommentCount ?? snapshot.commentCount;
-  if (snapshot.commentCount > baselineCommentCount && hasTrustedNewComment) {
+  if (hasTrustedNewComment) {
     return "a new GitHub comment from the issue author or a repository maintainer was added";
   }
   if (snapshot.linkedPullRequests.length === 0) {
@@ -4675,13 +5167,11 @@ function buildPaperclipIssueStatusTransitionComment(params) {
     nextStatus,
     repository,
     snapshot,
-    previousCommentCount,
     hasTrustedNewComment,
     maintainerAuthoredImportedIssue
   } = params;
   const reason = describeGitHubStatusTransitionReason({
     snapshot,
-    previousCommentCount,
     hasTrustedNewComment,
     maintainerAuthoredImportedIssue
   });
@@ -4700,7 +5190,6 @@ function resolvePaperclipIssueStatus(params) {
   const {
     currentStatus,
     snapshot,
-    previousCommentCount,
     hasTrustedNewComment,
     wasImportedThisRun,
     defaultImportedStatus,
@@ -4713,8 +5202,7 @@ function resolvePaperclipIssueStatus(params) {
   if (currentStatus === "backlog" && !wasImportedThisRun) {
     return "backlog";
   }
-  const baselineCommentCount = previousCommentCount ?? snapshot.commentCount;
-  if (snapshot.commentCount > baselineCommentCount && hasTrustedNewComment) {
+  if (hasTrustedNewComment) {
     return hasExecutorHandoffTarget ? "in_progress" : "todo";
   }
   if (snapshot.linkedPullRequests.length > 0) {
@@ -5214,54 +5702,203 @@ async function listNewGitHubIssueCommentsSinceCount(octokit, repository, issueNu
   }
   return comments;
 }
+async function listNewGitHubPullRequestReviewCommentsSinceCount(octokit, repository, pullRequestNumber, previousCommentCount, currentCommentCount) {
+  const normalizedPreviousCommentCount = Math.max(0, Math.floor(previousCommentCount));
+  const normalizedCurrentCommentCount = Math.max(0, Math.floor(currentCommentCount));
+  if (normalizedCurrentCommentCount <= normalizedPreviousCommentCount) {
+    return [];
+  }
+  const newCommentCount = normalizedCurrentCommentCount - normalizedPreviousCommentCount;
+  const comments = [];
+  const perPage = 100;
+  let page = Math.floor(normalizedPreviousCommentCount / perPage) + 1;
+  let remainingOffset = normalizedPreviousCommentCount % perPage;
+  while (comments.length < newCommentCount) {
+    const response = await octokit.rest.pulls.listReviewComments({
+      owner: repository.owner,
+      repo: repository.repo,
+      pull_number: pullRequestNumber,
+      page,
+      per_page: perPage,
+      headers: {
+        accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": GITHUB_API_VERSION
+      }
+    });
+    if (response.data.length === 0) {
+      break;
+    }
+    for (const comment of response.data.slice(remainingOffset)) {
+      comments.push({
+        id: comment.id,
+        body: typeof comment.body === "string" ? stripNullBytes(comment.body) : "",
+        url: comment.html_url ?? void 0,
+        authorLogin: normalizeGitHubUserLogin(comment.user?.login),
+        ...normalizeGitHubLowercaseString(comment.author_association) ? { authorAssociation: normalizeGitHubLowercaseString(comment.author_association) } : {},
+        createdAt: comment.created_at ?? void 0,
+        updatedAt: comment.updated_at ?? void 0
+      });
+      if (comments.length >= newCommentCount) {
+        break;
+      }
+    }
+    if (response.data.length < perPage) {
+      break;
+    }
+    page += 1;
+    remainingOffset = 0;
+  }
+  return comments;
+}
+async function hasTrustedGitHubCommentRecords(params) {
+  const originalPosterLogin = normalizeGitHubUserLogin(params.originalPosterLogin);
+  const unseenAuthors = /* @__PURE__ */ new Set();
+  for (const comment of params.comments) {
+    const authorLogin = normalizeGitHubUserLogin(comment.authorLogin);
+    if (!authorLogin) {
+      continue;
+    }
+    if (originalPosterLogin && authorLogin === originalPosterLogin) {
+      return true;
+    }
+    const trustedAuthorStatus = cacheGitHubRepositoryTrustedAuthorStatusFromAssociation(
+      params.repository,
+      authorLogin,
+      comment.authorAssociation,
+      params.maintainerCache
+    );
+    if (trustedAuthorStatus === true) {
+      return true;
+    }
+    if (trustedAuthorStatus === false) {
+      continue;
+    }
+    unseenAuthors.add(authorLogin);
+  }
+  for (const authorLogin of unseenAuthors) {
+    if (await isGitHubUserRepositoryMaintainer(
+      params.octokit,
+      params.repository,
+      authorLogin,
+      params.maintainerCache
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
 async function hasTrustedNewGitHubIssueComment(params) {
   const normalizedPreviousCommentCount = typeof params.previousCommentCount === "number" && params.previousCommentCount >= 0 ? Math.floor(params.previousCommentCount) : params.currentCommentCount;
   const normalizedCurrentCommentCount = Math.max(0, Math.floor(params.currentCommentCount));
   if (normalizedCurrentCommentCount <= normalizedPreviousCommentCount) {
     return false;
   }
-  const newComments = await listNewGitHubIssueCommentsSinceCount(
-    params.octokit,
-    params.repository,
-    params.githubIssue.number,
-    normalizedPreviousCommentCount,
-    normalizedCurrentCommentCount
-  );
-  if (newComments.length === 0) {
+  const newComments = await listNewGitHubIssueCommentsSinceCount(
+    params.octokit,
+    params.repository,
+    params.githubIssue.number,
+    normalizedPreviousCommentCount,
+    normalizedCurrentCommentCount
+  );
+  if (newComments.length === 0) {
+    return false;
+  }
+  return hasTrustedGitHubCommentRecords({
+    octokit: params.octokit,
+    repository: params.repository,
+    comments: newComments,
+    originalPosterLogin: params.githubIssue.authorLogin,
+    maintainerCache: params.maintainerCache
+  });
+}
+async function getGitHubPullRequestCommentCountRecord(octokit, repository, pullRequestNumber, cache) {
+  const pullRequestReference = {
+    number: pullRequestNumber,
+    repositoryUrl: repository.url
+  };
+  const cacheKey = buildGitHubPullRequestReferenceKey(pullRequestReference);
+  const cachedRecord = cache.get(cacheKey);
+  if (cachedRecord) {
+    return cachedRecord;
+  }
+  const response = await octokit.rest.pulls.get({
+    owner: repository.owner,
+    repo: repository.repo,
+    pull_number: pullRequestNumber,
+    headers: {
+      "X-GitHub-Api-Version": GITHUB_API_VERSION
+    }
+  });
+  const record = {
+    ...pullRequestReference,
+    topLevelCommentCount: typeof response.data.comments === "number" && response.data.comments >= 0 ? Math.floor(response.data.comments) : 0,
+    reviewCommentCount: typeof response.data.review_comments === "number" && response.data.review_comments >= 0 ? Math.floor(response.data.review_comments) : 0
+  };
+  cache.set(cacheKey, record);
+  return record;
+}
+async function listGitHubPullRequestCommentCountRecords(octokit, linkedPullRequests, cache) {
+  const commentCounts = [];
+  for (const pullRequest of linkedPullRequests) {
+    commentCounts.push(
+      await getGitHubPullRequestCommentCountRecord(
+        octokit,
+        requireRepositoryReference(pullRequest.repositoryUrl),
+        pullRequest.number,
+        cache
+      )
+    );
+  }
+  return normalizeGitHubPullRequestCommentCountRecords(commentCounts);
+}
+async function hasTrustedNewLinkedPullRequestComments(params) {
+  if ((params.currentCommentCounts?.length ?? 0) === 0 || (params.previousCommentCounts?.length ?? 0) === 0) {
     return false;
   }
-  const originalPosterLogin = normalizeGitHubUserLogin(params.githubIssue.authorLogin);
-  const unseenAuthors = /* @__PURE__ */ new Set();
-  for (const comment of newComments) {
-    const authorLogin = normalizeGitHubUserLogin(comment.authorLogin);
-    if (!authorLogin) {
+  const previousCommentCountsByKey = new Map(
+    (params.previousCommentCounts ?? []).map((record) => [buildGitHubPullRequestReferenceKey(record), record])
+  );
+  for (const currentCommentCount of params.currentCommentCounts) {
+    const previousCommentCount = previousCommentCountsByKey.get(buildGitHubPullRequestReferenceKey(currentCommentCount));
+    if (!previousCommentCount) {
       continue;
     }
-    if (originalPosterLogin && authorLogin === originalPosterLogin) {
-      return true;
-    }
-    const trustedAuthorStatus = cacheGitHubRepositoryTrustedAuthorStatusFromAssociation(
-      params.repository,
-      authorLogin,
-      comment.authorAssociation,
-      params.maintainerCache
-    );
-    if (trustedAuthorStatus === true) {
-      return true;
-    }
-    if (trustedAuthorStatus === false) {
-      continue;
+    const pullRequestRepository = requireRepositoryReference(currentCommentCount.repositoryUrl);
+    if (currentCommentCount.topLevelCommentCount > previousCommentCount.topLevelCommentCount) {
+      const newTopLevelComments = await listNewGitHubIssueCommentsSinceCount(
+        params.octokit,
+        pullRequestRepository,
+        currentCommentCount.number,
+        previousCommentCount.topLevelCommentCount,
+        currentCommentCount.topLevelCommentCount
+      );
+      if (await hasTrustedGitHubCommentRecords({
+        octokit: params.octokit,
+        repository: pullRequestRepository,
+        comments: newTopLevelComments,
+        originalPosterLogin: params.githubIssue.authorLogin,
+        maintainerCache: params.maintainerCache
+      })) {
+        return true;
+      }
     }
-    unseenAuthors.add(authorLogin);
-  }
-  for (const authorLogin of unseenAuthors) {
-    if (await isGitHubUserRepositoryMaintainer(
-      params.octokit,
-      params.repository,
-      authorLogin,
-      params.maintainerCache
-    )) {
-      return true;
+    if (currentCommentCount.reviewCommentCount > previousCommentCount.reviewCommentCount) {
+      const newReviewComments = await listNewGitHubPullRequestReviewCommentsSinceCount(
+        params.octokit,
+        pullRequestRepository,
+        currentCommentCount.number,
+        previousCommentCount.reviewCommentCount,
+        currentCommentCount.reviewCommentCount
+      );
+      if (await hasTrustedGitHubCommentRecords({
+        octokit: params.octokit,
+        repository: pullRequestRepository,
+        comments: newReviewComments,
+        originalPosterLogin: params.githubIssue.authorLogin,
+        maintainerCache: params.maintainerCache
+      })) {
+        return true;
+      }
     }
   }
   return false;
@@ -5346,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, "\\$&");
 }
@@ -5375,6 +6030,41 @@ function normalizeLinkedPullRequestNumbers(values) {
 function buildGitHubPullRequestReferenceKey(pullRequest) {
   return `${getNormalizedMappingRepositoryUrl({ repositoryUrl: pullRequest.repositoryUrl }).toLowerCase()}#${Math.max(1, Math.floor(pullRequest.number))}`;
 }
+function normalizeGitHubPullRequestCommentCountRecords(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const recordsByKey = /* @__PURE__ */ new Map();
+  for (const entry of value) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const record = entry;
+    const pullRequestNumber = typeof record.number === "number" && Number.isInteger(record.number) && record.number > 0 ? Math.floor(record.number) : void 0;
+    const repositoryUrl = typeof record.repositoryUrl === "string" && record.repositoryUrl.trim() ? getNormalizedMappingRepositoryUrl({
+      repositoryUrl: record.repositoryUrl
+    }) : void 0;
+    const topLevelCommentCount = typeof record.topLevelCommentCount === "number" && record.topLevelCommentCount >= 0 ? Math.floor(record.topLevelCommentCount) : void 0;
+    const reviewCommentCount = typeof record.reviewCommentCount === "number" && record.reviewCommentCount >= 0 ? Math.floor(record.reviewCommentCount) : void 0;
+    if (pullRequestNumber === void 0 || !repositoryUrl || topLevelCommentCount === void 0 || reviewCommentCount === void 0) {
+      continue;
+    }
+    const normalizedRecord = {
+      number: pullRequestNumber,
+      repositoryUrl,
+      topLevelCommentCount,
+      reviewCommentCount
+    };
+    recordsByKey.set(buildGitHubPullRequestReferenceKey(normalizedRecord), normalizedRecord);
+  }
+  return [...recordsByKey.values()].sort((left, right) => {
+    const repositoryComparison = left.repositoryUrl.toLowerCase().localeCompare(right.repositoryUrl.toLowerCase());
+    if (repositoryComparison !== 0) {
+      return repositoryComparison;
+    }
+    return left.number - right.number;
+  });
+}
 function normalizeLinkedPullRequestReferences(values, fallbackRepositoryUrl) {
   const references = [];
   const seenKeys = /* @__PURE__ */ new Set();
@@ -5953,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") {
@@ -6024,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();
 }
@@ -7158,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,
@@ -7172,6 +7856,7 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
   let completedIssueCount = 0;
   const totalIssueCount = importedIssues.length;
   const queuedIssueWakeups = [];
+  const pullRequestCommentCountCache = /* @__PURE__ */ new Map();
   for (const importedIssue of importedIssues) {
     if (assertNotCancelled) {
       await assertNotCancelled();
@@ -7238,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",
@@ -7277,9 +7963,18 @@ 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 hasNewComments = snapshot.commentCount > (previousCommentCount ?? snapshot.commentCount);
-      const hasTrustedNewComment = paperclipIssue.status === "backlog" || !hasNewComments ? false : await hasTrustedNewGitHubIssueComment({
+      const hasNewIssueComments = snapshot.commentCount > (previousCommentCount ?? snapshot.commentCount);
+      const hasTrustedNewIssueComment = paperclipIssue.status === "backlog" || !hasNewIssueComments ? false : await hasTrustedNewGitHubIssueComment({
         octokit,
         repository,
         githubIssue,
@@ -7287,6 +7982,28 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         currentCommentCount: snapshot.commentCount,
         maintainerCache: repositoryMaintainerCache
       });
+      let currentLinkedPullRequestCommentCounts = snapshot.linkedPullRequests.length === 0 ? [] : importedIssue.linkedPullRequestCommentCounts ?? [];
+      if (snapshot.linkedPullRequests.length > 0) {
+        try {
+          currentLinkedPullRequestCommentCounts = await listGitHubPullRequestCommentCountRecords(
+            octokit,
+            snapshot.linkedPullRequests,
+            pullRequestCommentCountCache
+          );
+        } catch (error) {
+          if (isGitHubRateLimitError(error)) {
+            throw error;
+          }
+        }
+      }
+      const hasTrustedNewLinkedPullRequestComment = paperclipIssue.status === "backlog" || currentLinkedPullRequestCommentCounts.length === 0 ? false : await hasTrustedNewLinkedPullRequestComments({
+        octokit,
+        githubIssue,
+        previousCommentCounts: importedIssue.linkedPullRequestCommentCounts,
+        currentCommentCounts: currentLinkedPullRequestCommentCounts,
+        maintainerCache: repositoryMaintainerCache
+      });
+      const hasTrustedNewComment = hasTrustedNewIssueComment || hasTrustedNewLinkedPullRequestComment;
       const wasImportedThisRun = createdIssueIds.has(importedIssue.githubIssueId);
       const maintainerAuthoredImportedIssue = wasImportedThisRun && advancedSettings.defaultStatus !== "todo" && snapshot.state === "open" && snapshot.linkedPullRequests.length === 0 ? await isMaintainerAuthoredGitHubIssue({
         octokit,
@@ -7302,7 +8019,6 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
       const nextStatus = resolvePaperclipIssueStatus({
         currentStatus: paperclipIssue.status,
         snapshot,
-        previousCommentCount,
         hasTrustedNewComment,
         wasImportedThisRun,
         defaultImportedStatus: advancedSettings.defaultStatus,
@@ -7320,6 +8036,8 @@ 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) {
           updateSyncFailureContext(syncFailureContext, {
@@ -7353,7 +8071,6 @@ async function synchronizePaperclipIssueStatuses(ctx, octokit, repository, mappi
         nextStatus,
         repository,
         snapshot,
-        previousCommentCount,
         hasTrustedNewComment,
         maintainerAuthoredImportedIssue
       });
@@ -7621,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) {
@@ -10576,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);
@@ -10660,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) {
@@ -10712,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();
@@ -10811,6 +11838,7 @@ async function performSync(ctx, trigger, options = {}) {
         continue;
       }
     }
+    recordCompanyBacklogSnapshotsFromPlans(repositoryPlans);
     if (repositoryPlans.length > 0) {
       const firstPlan = repositoryPlans[0];
       currentProgress = {
@@ -10997,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 = {
@@ -11100,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 = {}) {
@@ -11481,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)}.`,
         {
@@ -11978,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);
@@ -12012,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);
@@ -12337,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;