@xera-ai/core 0.9.7 → 0.10.0

package/src/bin-internal/verify-prompts.ts

@@ -14,6 +14,8 @@ const IN_SCOPE_PROMPTS = [
   'extract-areas.md',
   'similarity-match.md',
   'classify-outdated.md',
+  'map-ac-to-scenarios.md',
+  'propose-scenarios.md', // NEW v0.8.2
 ] as const;
 
 const REQUIRED_SECTION_HEADING = '## Handling untrusted input';

package/src/config/schema.ts

@@ -111,6 +111,14 @@ const RunSchema = z
   })
   .prefault({});
 
+const CoverageSchema = z
+  .object({
+    staleAfterDays: z.number().int().positive().default(30),
+    criticalAreas: z.array(z.string().regex(/^[a-z0-9-]+$/)).default([]),
+    autoSnapshotOnCoverage: z.boolean().default(true),
+  })
+  .prefault({});
+
 export const XeraConfigSchema = z
   .object({
     jira: JiraSchema,
@@ -119,6 +127,7 @@ export const XeraConfigSchema = z
     ai: AISchema,
     reporting: ReportingSchema,
     run: RunSchema.prefault({}),
+    coverage: CoverageSchema,
     adapters: z
       .array(z.enum(['web', 'http']))
       .min(1)

package/src/coverage/index.ts

@@ -0,0 +1,29 @@
+export {
+  type AreaReportRow,
+  buildCoverageReport,
+  type CoverageReport,
+  type RenderOptions,
+  renderMarkdown,
+  type TicketReportRow,
+} from './report';
+export {
+  computeAcGapScore,
+  computeAreaRisk,
+  RISK_WEIGHTS,
+} from './risk';
+export {
+  type AcStatus,
+  type AreaStatus,
+  computeAcStatus,
+  computeAreaStatus,
+  computeScenarioStatus,
+  computeTicketStatus,
+  type ScenarioStatus,
+  type TicketStatus,
+} from './status';
+export type { CoverageConfig } from './types';
+export { DEFAULT_COVERAGE_CONFIG } from './types';
+export {
+  buildWhyArea,
+  buildWhyTicket,
+} from './why';

package/src/coverage/report.ts

@@ -0,0 +1,206 @@
+import type { Snapshot } from '../graph/types';
+import { computeAcGapScore, computeAreaRisk, RISK_WEIGHTS } from './risk';
+import { type AreaStatus, computeAcStatus, computeAreaStatus, computeTicketStatus } from './status';
+import type { CoverageConfig } from './types';
+
+export interface AreaReportRow {
+  id: string;
+  status: AreaStatus;
+  risk: number;
+  breakdown: {
+    recentTickets: number;
+    recentBugs: number;
+    criticalBoost: 1 | 2;
+  };
+}
+
+export interface TicketReportRow {
+  id: string;
+  summary: string;
+  acCount: number;
+  satisfiedCount: number;
+  gapScore: number;
+  unsatisfiedAcs: Array<{ index: number; text: string }>;
+}
+
+export interface CoverageReport {
+  generatedAt: string;
+  windowDays: number;
+  areas: AreaReportRow[];
+  tickets: TicketReportRow[];
+  acBackfillNeeded: boolean;
+}
+
+const STATUS_RANK: Record<AreaStatus, number> = {
+  UNCOVERED: 0,
+  STALE: 1,
+  COVERED: 2,
+};
+
+function daysBetween(a: Date, b: Date): number {
+  return Math.abs(a.getTime() - b.getTime()) / (1000 * 60 * 60 * 24);
+}
+
+export function buildCoverageReport(
+  snap: Snapshot,
+  config: CoverageConfig,
+  now: Date,
+): CoverageReport {
+  const areas: AreaReportRow[] = Object.keys(snap.areas).map((areaId) => {
+    const status = computeAreaStatus(areaId, snap, config.staleAfterDays, now);
+    const risk = computeAreaRisk(areaId, snap, config, now);
+
+    const recentTickets = snap.edges
+      .filter((e) => e.kind === 'modifies' && e.to === areaId)
+      .map((e) => snap.tickets[e.from])
+      .filter((t): t is NonNullable<typeof t> => t !== undefined)
+      .filter((t) => daysBetween(now, new Date(t.fetchedAt)) <= config.staleAfterDays).length;
+    const pomsInArea = snap.edges
+      .filter((e) => e.kind === 'covers' && e.to === areaId)
+      .map((e) => e.from);
+    const scenariosInArea = new Set(
+      snap.edges.filter((e) => e.kind === 'uses' && pomsInArea.includes(e.to)).map((e) => e.from),
+    );
+    const recentBugs = snap.classifications
+      .filter((c) => scenariosInArea.has(c.scenarioId))
+      .filter((c) => RISK_WEIGHTS.bugClassifications.has(c.classification))
+      .filter((c) => daysBetween(now, new Date(c.ts)) <= config.staleAfterDays).length;
+    const criticalBoost: 1 | 2 = config.criticalAreas.includes(areaId) ? 2 : 1;
+
+    return {
+      id: areaId,
+      status,
+      risk,
+      breakdown: { recentTickets, recentBugs, criticalBoost },
+    };
+  });
+
+  areas.sort((a, b) => {
+    if (STATUS_RANK[a.status] !== STATUS_RANK[b.status]) {
+      return STATUS_RANK[a.status] - STATUS_RANK[b.status];
+    }
+    if (a.status === 'COVERED') return a.id.localeCompare(b.id);
+    if (b.risk !== a.risk) return b.risk - a.risk;
+    return a.id.localeCompare(b.id);
+  });
+
+  const tickets: TicketReportRow[] = Object.values(snap.tickets)
+    .filter((t) => computeTicketStatus(t.id, snap, config.staleAfterDays, now) === 'INCOMPLETE')
+    .map((t) => {
+      const acs = Object.values(snap.acNodes)
+        .filter((ac) => ac.ticketId === t.id)
+        .sort((a, b) => a.index - b.index);
+      const unsatisfiedAcs = acs
+        .filter((ac) => computeAcStatus(ac.id, snap, config.staleAfterDays, now) === 'UNSATISFIED')
+        .map((ac) => ({ index: ac.index, text: ac.text }));
+      return {
+        id: t.id,
+        summary: t.summary,
+        acCount: acs.length,
+        satisfiedCount: acs.length - unsatisfiedAcs.length,
+        gapScore: computeAcGapScore(t.id, snap, config, now),
+        unsatisfiedAcs,
+      };
+    })
+    .sort((a, b) => b.gapScore - a.gapScore || a.id.localeCompare(b.id));
+
+  return {
+    generatedAt: now.toISOString(),
+    windowDays: config.staleAfterDays,
+    areas,
+    tickets,
+    acBackfillNeeded: needsBackfill(snap),
+  };
+}
+
+function needsBackfill(snap: Snapshot): boolean {
+  for (const ticket of Object.values(snap.tickets)) {
+    const acsForTicket = Object.values(snap.acNodes).filter((ac) => ac.ticketId === ticket.id);
+    if (acsForTicket.length === 0) continue;
+    const scenariosForTicket = Object.values(snap.scenarios).filter(
+      (s) => s.ticketId === ticket.id,
+    );
+    if (scenariosForTicket.length === 0) continue;
+    const hasAnyEdge = snap.edges.some(
+      (e) => e.kind === 'satisfies' && acsForTicket.some((ac) => ac.id === e.to),
+    );
+    if (!hasAnyEdge) return true;
+  }
+  return false;
+}
+
+export interface RenderOptions {
+  includeCovered?: boolean;
+}
+
+function pad(s: string, n: number): string {
+  return s.length >= n ? s : `${s}${' '.repeat(n - s.length)}`;
+}
+
+export function renderMarkdown(report: CoverageReport, options: RenderOptions = {}): string {
+  const lines: string[] = [];
+  const dateOnly = report.generatedAt.slice(0, 10);
+  lines.push('', `Coverage report — generated ${dateOnly} · window ${report.windowDays}d`, '');
+
+  const uncovered = report.areas.filter((a) => a.status === 'UNCOVERED');
+  if (uncovered.length > 0) {
+    lines.push(
+      `UNCOVERED — ${uncovered.length} area${uncovered.length === 1 ? '' : 's'}, sorted by risk`,
+    );
+    lines.push('');
+    uncovered.forEach((a, i) => {
+      const parts: string[] = [`${a.breakdown.recentTickets} tickets`];
+      if (a.breakdown.recentBugs > 0) parts.push(`${a.breakdown.recentBugs} bugs`);
+      if (a.breakdown.criticalBoost === 2) parts.push('critical ×2');
+      lines.push(`  #${i + 1}  ${pad(a.id, 10)} risk ${a.risk}    ${parts.join(' · ')}`);
+    });
+    lines.push('');
+  }
+
+  const stale = report.areas.filter((a) => a.status === 'STALE');
+  if (stale.length > 0) {
+    lines.push(
+      `STALE — ${stale.length} area${stale.length === 1 ? '' : 's'}, has tests but no PASS in ${report.windowDays}d`,
+    );
+    lines.push('');
+    stale.forEach((a, i) => {
+      lines.push(`  #${i + 1}  ${pad(a.id, 10)} (see --why ${a.id} for details)`);
+    });
+    lines.push('');
+  }
+
+  if (report.tickets.length > 0) {
+    lines.push(
+      `AC GAPS — ${report.tickets.length} ticket${report.tickets.length === 1 ? '' : 's'} with unsatisfied acceptance criteria`,
+    );
+    lines.push('');
+    for (const t of report.tickets) {
+      lines.push(
+        `  ${t.id}  ${t.satisfiedCount}/${t.acCount} ACs covered · gap_score ${t.gapScore}`,
+      );
+      for (const ac of t.unsatisfiedAcs) {
+        lines.push(`    ✗ AC-${ac.index}  ${ac.text}`);
+      }
+      lines.push('');
+    }
+  }
+
+  const covered = report.areas.filter((a) => a.status === 'COVERED');
+  if (covered.length > 0) {
+    if (options.includeCovered) {
+      lines.push(`COVERED — ${covered.length} area${covered.length === 1 ? '' : 's'}`);
+      lines.push('');
+      covered.forEach((a, i) => {
+        lines.push(`  #${i + 1}  ${pad(a.id, 10)} ok`);
+      });
+      lines.push('');
+    } else {
+      lines.push(
+        `COVERED — ${covered.length} area${covered.length === 1 ? '' : 's'} (collapsed; show with --all)`,
+      );
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/coverage/risk.ts

@@ -0,0 +1,69 @@
+import type { Snapshot } from '../graph/types';
+import { computeAcStatus } from './status';
+import type { CoverageConfig } from './types';
+
+export const RISK_WEIGHTS = {
+  criticalBoost: 2,
+  bugClassifications: new Set<string>(['REAL_BUG', 'TEST_OUTDATED']),
+  recencyBoosts: { recent: 2.0, withinWindow: 1.0, older: 0.5 },
+  recencyThresholdDays: 7,
+} as const;
+
+function daysBetween(a: Date, b: Date): number {
+  return Math.abs(a.getTime() - b.getTime()) / (1000 * 60 * 60 * 24);
+}
+
+export function computeAreaRisk(
+  areaId: string,
+  snap: Snapshot,
+  config: CoverageConfig,
+  now: Date,
+): number {
+  const recentTickets = snap.edges
+    .filter((e) => e.kind === 'modifies' && e.to === areaId)
+    .map((e) => snap.tickets[e.from])
+    .filter((t): t is NonNullable<typeof t> => t !== undefined)
+    .filter((t) => daysBetween(now, new Date(t.fetchedAt)) <= config.staleAfterDays).length;
+
+  const pomsInArea = snap.edges
+    .filter((e) => e.kind === 'covers' && e.to === areaId)
+    .map((e) => e.from);
+  const scenariosInArea = new Set(
+    snap.edges.filter((e) => e.kind === 'uses' && pomsInArea.includes(e.to)).map((e) => e.from),
+  );
+  const recentBugs = snap.classifications
+    .filter((c) => scenariosInArea.has(c.scenarioId))
+    .filter((c) => RISK_WEIGHTS.bugClassifications.has(c.classification))
+    .filter((c) => daysBetween(now, new Date(c.ts)) <= config.staleAfterDays).length;
+
+  const criticalBoost = config.criticalAreas.includes(areaId) ? RISK_WEIGHTS.criticalBoost : 1;
+
+  return recentTickets * criticalBoost + recentBugs;
+}
+
+export function computeAcGapScore(
+  ticketId: string,
+  snap: Snapshot,
+  config: CoverageConfig,
+  now: Date,
+): number {
+  const ticket = snap.tickets[ticketId];
+  if (!ticket) return 0;
+
+  const acs = Object.values(snap.acNodes).filter((ac) => ac.ticketId === ticketId);
+  const unsatisfied = acs.filter(
+    (ac) => computeAcStatus(ac.id, snap, config.staleAfterDays, now) === 'UNSATISFIED',
+  ).length;
+  if (unsatisfied === 0) return 0;
+
+  const days = daysBetween(now, new Date(ticket.fetchedAt));
+  let boost: number;
+  if (days <= RISK_WEIGHTS.recencyThresholdDays) {
+    boost = RISK_WEIGHTS.recencyBoosts.recent;
+  } else if (days <= config.staleAfterDays) {
+    boost = RISK_WEIGHTS.recencyBoosts.withinWindow;
+  } else {
+    boost = RISK_WEIGHTS.recencyBoosts.older;
+  }
+  return unsatisfied * boost;
+}

package/src/coverage/status.ts

@@ -0,0 +1,76 @@
+import type { Snapshot } from '../graph/types';
+
+export type ScenarioStatus = 'PASSING' | 'NOT_PASSING';
+export type AreaStatus = 'UNCOVERED' | 'STALE' | 'COVERED';
+export type AcStatus = 'SATISFIED' | 'UNSATISFIED';
+export type TicketStatus = 'COMPLETE' | 'INCOMPLETE';
+
+function daysBetween(a: Date, b: Date): number {
+  return Math.abs(a.getTime() - b.getTime()) / (1000 * 60 * 60 * 24);
+}
+
+export function computeScenarioStatus(
+  scenarioId: string,
+  snap: Snapshot,
+  windowDays: number,
+  now: Date,
+): ScenarioStatus {
+  const events = snap.classifications
+    .filter((c) => c.scenarioId === scenarioId)
+    .sort((a, b) => (a.ts < b.ts ? 1 : a.ts > b.ts ? -1 : 0));
+  const latest = events[0];
+  if (!latest) return 'NOT_PASSING';
+  if (latest.classification !== 'PASS') return 'NOT_PASSING';
+  if (daysBetween(now, new Date(latest.ts)) > windowDays) return 'NOT_PASSING';
+  return 'PASSING';
+}
+
+export function computeAreaStatus(
+  areaId: string,
+  snap: Snapshot,
+  windowDays: number,
+  now: Date,
+): AreaStatus {
+  const coveringPoms = snap.edges
+    .filter((e) => e.kind === 'covers' && e.to === areaId)
+    .map((e) => e.from);
+  if (coveringPoms.length === 0) return 'UNCOVERED';
+
+  const scenariosInArea = snap.edges
+    .filter((e) => e.kind === 'uses' && coveringPoms.includes(e.to))
+    .map((e) => e.from);
+  const anyPassing = scenariosInArea.some(
+    (sid) => computeScenarioStatus(sid, snap, windowDays, now) === 'PASSING',
+  );
+  return anyPassing ? 'COVERED' : 'STALE';
+}
+
+export function computeAcStatus(
+  acId: string,
+  snap: Snapshot,
+  windowDays: number,
+  now: Date,
+): AcStatus {
+  const edges = snap.edges.filter((e) => e.kind === 'satisfies' && e.to === acId);
+  if (edges.length === 0) return 'UNSATISFIED';
+  const anyPassing = edges.some(
+    (e) => computeScenarioStatus(e.from, snap, windowDays, now) === 'PASSING',
+  );
+  return anyPassing ? 'SATISFIED' : 'UNSATISFIED';
+}
+
+export function computeTicketStatus(
+  ticketId: string,
+  snap: Snapshot,
+  windowDays: number,
+  now: Date,
+): TicketStatus {
+  const acIds = Object.values(snap.acNodes)
+    .filter((ac) => ac.ticketId === ticketId)
+    .map((ac) => ac.id);
+  if (acIds.length === 0) return 'COMPLETE';
+  const allSatisfied = acIds.every(
+    (acId) => computeAcStatus(acId, snap, windowDays, now) === 'SATISFIED',
+  );
+  return allSatisfied ? 'COMPLETE' : 'INCOMPLETE';
+}

package/src/coverage/types.ts

@@ -0,0 +1,11 @@
+export interface CoverageConfig {
+  staleAfterDays: number;
+  criticalAreas: string[];
+  autoSnapshotOnCoverage: boolean;
+}
+
+export const DEFAULT_COVERAGE_CONFIG: CoverageConfig = {
+  staleAfterDays: 30,
+  criticalAreas: [],
+  autoSnapshotOnCoverage: true,
+};

package/src/coverage/why.ts

@@ -0,0 +1,122 @@
+import type { Snapshot } from '../graph/types';
+import { computeAcGapScore, computeAreaRisk, RISK_WEIGHTS } from './risk';
+import { computeAcStatus, computeAreaStatus, computeTicketStatus } from './status';
+import type { CoverageConfig } from './types';
+
+function daysBetween(a: Date, b: Date): number {
+  return Math.abs(a.getTime() - b.getTime()) / (1000 * 60 * 60 * 24);
+}
+
+function pad(s: string, n: number): string {
+  return s.length >= n ? s : `${s}${' '.repeat(n - s.length)}`;
+}
+
+export function buildWhyArea(
+  areaId: string,
+  snap: Snapshot,
+  config: CoverageConfig,
+  now: Date,
+): string {
+  if (snap.areas[areaId] === undefined) return `Unknown area: ${areaId}\n`;
+
+  const status = computeAreaStatus(areaId, snap, config.staleAfterDays, now);
+  const isCritical = config.criticalAreas.includes(areaId);
+  const heading = isCritical ? `${status}, critical` : status;
+
+  const risk = computeAreaRisk(areaId, snap, config, now);
+  const recentTickets = snap.edges
+    .filter((e) => e.kind === 'modifies' && e.to === areaId)
+    .map((e) => snap.tickets[e.from])
+    .filter((t): t is NonNullable<typeof t> => t !== undefined)
+    .filter((t) => daysBetween(now, new Date(t.fetchedAt)) <= config.staleAfterDays);
+  const pomsInArea = snap.edges
+    .filter((e) => e.kind === 'covers' && e.to === areaId)
+    .map((e) => e.from);
+  const scenariosInArea = new Set(
+    snap.edges.filter((e) => e.kind === 'uses' && pomsInArea.includes(e.to)).map((e) => e.from),
+  );
+  const recentBugs = snap.classifications
+    .filter((c) => scenariosInArea.has(c.scenarioId))
+    .filter((c) => RISK_WEIGHTS.bugClassifications.has(c.classification))
+    .filter((c) => daysBetween(now, new Date(c.ts)) <= config.staleAfterDays);
+  const boost = isCritical ? 2 : 1;
+
+  const lines: string[] = [
+    '',
+    `Area: ${areaId} (${heading})`,
+    '',
+    `Risk score: ${risk}`,
+    '  recent_tickets × critical_boost + recent_bugs',
+    `  = ${recentTickets.length} × ${boost} + ${recentBugs.length} = ${risk}`,
+    '',
+    `Recent tickets (${recentTickets.length}, last ${config.staleAfterDays}d):`,
+  ];
+  for (const t of recentTickets) {
+    lines.push(`  ${t.id}  ${t.fetchedAt.slice(0, 10)}  ${t.summary}`);
+  }
+  if (recentTickets.length === 0) lines.push('  (none)');
+  lines.push('');
+  if (recentBugs.length > 0) {
+    lines.push(`Recent bugs (${recentBugs.length}, last ${config.staleAfterDays}d):`);
+    for (const b of recentBugs) {
+      lines.push(`  ${b.ts.slice(0, 10)}  ${pad(b.classification, 14)} scenario ${b.scenarioId}`);
+    }
+    lines.push('');
+  }
+  if (status === 'UNCOVERED') {
+    lines.push('No POM covers this area. To draft scenarios:');
+    lines.push(`  /xera-fill-gap ${areaId}`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+export function buildWhyTicket(
+  ticketId: string,
+  snap: Snapshot,
+  config: CoverageConfig,
+  now: Date,
+): string {
+  const ticket = snap.tickets[ticketId];
+  if (!ticket) return `Unknown ticket: ${ticketId}\n`;
+
+  const status = computeTicketStatus(ticketId, snap, config.staleAfterDays, now);
+  const acs = Object.values(snap.acNodes)
+    .filter((ac) => ac.ticketId === ticketId)
+    .sort((a, b) => a.index - b.index);
+  const satisfiedCount = acs.filter(
+    (ac) => computeAcStatus(ac.id, snap, config.staleAfterDays, now) === 'SATISFIED',
+  ).length;
+  const gapScore = computeAcGapScore(ticketId, snap, config, now);
+
+  const days = daysBetween(now, new Date(ticket.fetchedAt));
+  let boostLabel: string;
+  if (days <= RISK_WEIGHTS.recencyThresholdDays) boostLabel = '×2.0';
+  else if (days <= config.staleAfterDays) boostLabel = '×1.0';
+  else boostLabel = '×0.5';
+
+  const lines: string[] = [
+    '',
+    `Ticket: ${ticketId} (${status}, ${satisfiedCount}/${acs.length} ACs covered)`,
+    `  Title: ${ticket.summary}`,
+    `  Fetched: ${ticket.fetchedAt.slice(0, 10)} (${Math.floor(days)}d ago, recency boost ${boostLabel})`,
+    `  AC gap score: ${gapScore}`,
+    '',
+    'Acceptance Criteria:',
+  ];
+  for (const ac of acs) {
+    const acStatus = computeAcStatus(ac.id, snap, config.staleAfterDays, now);
+    const marker = acStatus === 'SATISFIED' ? '✓' : '✗';
+    const satisfyingScenarios = snap.edges
+      .filter((e) => e.kind === 'satisfies' && e.to === ac.id)
+      .map((e) => e.from);
+    const scenarioRef =
+      satisfyingScenarios.length > 0 ? ` — scenario "${satisfyingScenarios[0]}"` : '';
+    lines.push(`  ${marker} AC-${ac.index}  ${ac.text}${scenarioRef}`);
+  }
+  lines.push('');
+  if (status === 'INCOMPLETE') {
+    lines.push('To draft scenarios for unsatisfied ACs:');
+    lines.push(`  /xera-fill-gap --ticket ${ticketId}`);
+  }
+  return `${lines.join('\n')}\n`;
+}

package/src/graph/render.ts

@@ -1,7 +1,8 @@
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import type { EdgeRecord, Snapshot } from './types';
+import type { CoverageReport } from '../coverage/report';
+import type { CoverageSnapshotPayload, EdgeRecord, Snapshot } from './types';
 
 export interface VisNode {
   id: string;
@@ -299,10 +300,16 @@ function statsToHuman(s: GraphStats): string {
   return `${s.tickets} tickets · ${s.scenarios} scenarios · ${s.poms} POMs · ${s.edges} edges`;
 }
 
+export interface CoverageInput {
+  report: CoverageReport;
+  snapshots: CoverageSnapshotPayload[]; // Trend tab data (deduped by day, sorted asc)
+}
+
 export interface RenderHtmlInput {
   data: { nodes: VisNode[]; edges: VisEdge[] };
   stats: GraphStats;
   generatedAt: string;
+  coverage?: CoverageInput; // NEW v0.8.1
 }
 
 export function renderHtml(input: RenderHtmlInput): string {
@@ -314,11 +321,18 @@ export function renderHtml(input: RenderHtmlInput): string {
   const graphJson = JSON.stringify(input.data);
   const statsHuman = statsToHuman(input.stats);
 
+  const coverageTabButton = input.coverage ? '<button data-tab="coverage">Coverage</button>' : '';
+  const coverageTabPanel = input.coverage ? loadTemplate('coverage-panel.html.fragment') : '';
+  const coverageJson = input.coverage ? JSON.stringify(input.coverage) : 'null';
+
   return template
     .replace('{{CSS}}', () => css)
     .replace('{{STATS}}', () => statsHuman)
     .replace('{{GENERATED_AT}}', () => input.generatedAt)
     .replace('{{VIS_NETWORK_JS}}', () => visNetwork)
     .replace('{{GRAPH_DATA}}', () => graphJson)
-    .replace('{{INTERACTION_JS}}', () => js);
+    .replace('{{INTERACTION_JS}}', () => js)
+    .replace('{{COVERAGE_TAB_BUTTON}}', () => coverageTabButton)
+    .replace('{{COVERAGE_TAB_PANEL}}', () => coverageTabPanel)
+    .replace('{{COVERAGE_DATA}}', () => coverageJson);
 }

package/src/graph/schema.ts

@@ -38,6 +38,7 @@ const scenarioGenerated = z
     priority: z.enum(['p0', 'p1', 'p2']),
     featureHash: z.string(),
     generatedAt: iso,
+    satisfiesAcs: z.array(z.number().int().nonnegative()).optional(),
   })
   .passthrough();
 
@@ -105,7 +106,16 @@ const classificationDisputed = z
 
 const edgeDiscovered = z
   .object({
-    kind: z.enum(['tests', 'uses', 'covers', 'modifies', 'jira-linked', 'similar', 'ran']),
+    kind: z.enum([
+      'tests',
+      'uses',
+      'covers',
+      'modifies',
+      'jira-linked',
+      'similar',
+      'ran',
+      'satisfies',
+    ]),
     from: z.string(),
     to: z.string(),
     confidence: z.number().min(0).max(1).optional(),
@@ -113,6 +123,47 @@ const edgeDiscovered = z
   })
   .passthrough();
 
+const coverageSnapshot = z
+  .object({
+    ts: iso,
+    windowDays: z.number().int().positive(),
+    areas: z.array(
+      z.object({
+        id: z.string().regex(/^[a-z0-9-]+$/),
+        status: z.enum(['UNCOVERED', 'STALE', 'COVERED']),
+        risk: z.number().nonnegative(),
+        breakdown: z.object({
+          recentTickets: z.number().int().nonnegative(),
+          recentBugs: z.number().int().nonnegative(),
+          criticalBoost: z.union([z.literal(1), z.literal(2)]),
+        }),
+      }),
+    ),
+    tickets: z.array(
+      z.object({
+        id: z.string().regex(/^[A-Z][A-Z0-9]*-\d+$/),
+        acCount: z.number().int().nonnegative(),
+        satisfiedCount: z.number().int().nonnegative(),
+        gapScore: z.number().nonnegative(),
+      }),
+    ),
+  })
+  .passthrough();
+
+const acCoverageBackfilled = z
+  .object({
+    ts: iso,
+    ticketId: z.string().regex(/^[A-Z][A-Z0-9]*-\d+$/),
+    mappings: z.array(
+      z.object({
+        scenarioId: z.string().min(1),
+        satisfiesAcs: z.array(z.number().int().nonnegative()),
+        confidence: z.number().min(0).max(1),
+      }),
+    ),
+  })
+  .passthrough();
+
 const base = {
   event_id: z.string().min(20),
   schema_version: schemaV,
@@ -134,6 +185,8 @@ export const EventSchema = z.discriminatedUnion('type', [
     payload: classificationDisputed,
   }),
   z.object({ ...base, type: z.literal('edge.discovered'), payload: edgeDiscovered }),
+  z.object({ ...base, type: z.literal('coverage.snapshot'), payload: coverageSnapshot }),
+  z.object({ ...base, type: z.literal('ac-coverage.backfilled'), payload: acCoverageBackfilled }),
 ]);
 
 export function safeParseEvent(