@xera-ai/core 0.9.7 → 0.10.0

package/dist/src/index.js

@@ -396,6 +396,11 @@ var RunSchema = z4.object({
     threshold: z4.number().nonnegative().default(8)
   }).prefault({})
 }).prefault({});
+var CoverageSchema = z4.object({
+  staleAfterDays: z4.number().int().positive().default(30),
+  criticalAreas: z4.array(z4.string().regex(/^[a-z0-9-]+$/)).default([]),
+  autoSnapshotOnCoverage: z4.boolean().default(true)
+}).prefault({});
 var XeraConfigSchema = z4.object({
   jira: JiraSchema,
   web: WebSchema.optional(),
@@ -403,6 +408,7 @@ var XeraConfigSchema = z4.object({
   ai: AISchema,
   reporting: ReportingSchema,
   run: RunSchema.prefault({}),
+  coverage: CoverageSchema,
   adapters: z4.array(z4.enum(["web", "http"])).min(1).default(["web"])
 }).refine((c) => c.web !== undefined || c.http !== undefined, {
   message: "At least one of `web` or `http` must be configured"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xera-ai/core",
-  "version": "0.9.7",
+  "version": "0.10.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "zod": "4.4.3",
-    "@xera-ai/web": "^0.9.7",
-    "@xera-ai/http": "^0.9.7",
+    "@xera-ai/web": "^0.10.0",
+    "@xera-ai/http": "^0.10.0",
     "@playwright/test": "1.60.0",
     "dotenv": "^16.0.0",
     "fflate": "0.8.3",

package/src/bin-internal/ac-coverage-backfill-finalize.ts

@@ -0,0 +1,90 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { appendEvents } from '../graph/store';
+import type { Event } from '../graph/types';
+import { SCHEMA_VERSION } from '../graph/types';
+import { ulid } from '../graph/ulid';
+
+const DecisionsSchema = z.object({
+  mappings: z.array(
+    z.object({
+      scenarioId: z.string().min(1),
+      satisfiesAcs: z.array(z.number().int().nonnegative()),
+      confidence: z.number().min(0).max(1),
+    }),
+  ),
+});
+
+interface ParsedArgs {
+  inputFile?: string;
+  snapshotTs?: string;
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  const args: ParsedArgs = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--input') {
+      const v = argv[++i];
+      if (v !== undefined) args.inputFile = v;
+    } else if (a === '--snapshot-ts') {
+      const v = argv[++i];
+      if (v !== undefined) args.snapshotTs = v;
+    } else if (a === '--help-stub') {
+      /* no-op */
+    } else {
+      console.error(`[ac-coverage-backfill-finalize] unknown flag: ${a}`);
+      return args;
+    }
+  }
+  return args;
+}
+
+export async function acCoverageBackfillFinalizeCmd(argv: string[]): Promise<number> {
+  const args = parseArgs(argv);
+  const cwd = process.cwd();
+  const inputPath = args.inputFile ?? join(cwd, '.xera/coverage/ac-backfill-decisions.json');
+
+  if (!existsSync(inputPath)) {
+    console.error(`[ac-coverage-backfill-finalize] decisions file not found: ${inputPath}`);
+    return 2;
+  }
+
+  let parsed: z.infer<typeof DecisionsSchema>;
+  try {
+    const raw = JSON.parse(readFileSync(inputPath, 'utf8'));
+    parsed = DecisionsSchema.parse(raw);
+  } catch (e) {
+    console.error(`[ac-coverage-backfill-finalize] invalid decisions: ${(e as Error).message}`);
+    return 2;
+  }
+
+  if (parsed.mappings.length === 0) return 0;
+
+  // Group mappings by ticketId (extracted from scenarioId prefix)
+  const byTicket: Record<string, z.infer<typeof DecisionsSchema>['mappings']> = {};
+  for (const m of parsed.mappings) {
+    const ticketId = m.scenarioId.split('#')[0];
+    if (!ticketId) continue;
+    if (!byTicket[ticketId]) byTicket[ticketId] = [];
+    byTicket[ticketId].push(m);
+  }
+
+  const ts = args.snapshotTs ?? new Date().toISOString();
+  const now = new Date(ts);
+
+  for (const [ticketId, mappings] of Object.entries(byTicket)) {
+    const event: Event = {
+      event_id: ulid(),
+      schema_version: SCHEMA_VERSION,
+      ts,
+      actor: 'xera-coverage',
+      type: 'ac-coverage.backfilled',
+      payload: { ts, ticketId, mappings },
+    };
+    appendEvents(cwd, [event], { skill: 'ac-coverage', ticketId, now });
+  }
+
+  return 0;
+}

package/src/bin-internal/ac-coverage-backfill-prepare.ts

@@ -0,0 +1,72 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { deriveSnapshot, loadAllEvents } from '../graph/store';
+import type { Snapshot } from '../graph/types';
+
+interface BackfillInput {
+  tickets: Array<{
+    id: string;
+    summary: string;
+    acs: string[];
+    scenarios: Array<{ id: string; name: string; gherkin: string }>;
+  }>;
+}
+
+function findUnmapped(snap: Snapshot): BackfillInput {
+  const out: BackfillInput['tickets'] = [];
+  for (const ticket of Object.values(snap.tickets)) {
+    if (ticket.ac.length === 0) continue;
+    const ticketScenarios = Object.values(snap.scenarios).filter((s) => s.ticketId === ticket.id);
+    if (ticketScenarios.length === 0) continue;
+    const acsForTicket = Object.values(snap.acNodes).filter((ac) => ac.ticketId === ticket.id);
+    const hasAnyEdge = snap.edges.some(
+      (e) => e.kind === 'satisfies' && acsForTicket.some((ac) => ac.id === e.to),
+    );
+    if (hasAnyEdge) continue;
+    out.push({
+      id: ticket.id,
+      summary: ticket.summary,
+      acs: ticket.ac,
+      scenarios: ticketScenarios.map((s) => ({
+        id: s.id,
+        name: s.name,
+        gherkin: s.gherkin,
+      })),
+    });
+  }
+  return { tickets: out };
+}
+
+interface ParsedArgs {
+  outputFile?: string;
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  const args: ParsedArgs = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--output') {
+      const v = argv[++i];
+      if (v !== undefined) args.outputFile = v;
+    } else if (a === '--help-stub') {
+      /* no-op */
+    } else {
+      console.error(`[ac-coverage-backfill-prepare] unknown flag: ${a}`);
+      return args;
+    }
+  }
+  return args;
+}
+
+export async function acCoverageBackfillPrepareCmd(argv: string[]): Promise<number> {
+  const args = parseArgs(argv);
+  const cwd = process.cwd();
+  const snap = deriveSnapshot(loadAllEvents(cwd));
+  const input = findUnmapped(snap);
+
+  const outDir = join(cwd, '.xera/coverage');
+  mkdirSync(outDir, { recursive: true });
+  const outPath = args.outputFile ?? join(outDir, 'ac-backfill-input.json');
+  writeFileSync(outPath, JSON.stringify(input, null, 2));
+  return 0;
+}

package/src/bin-internal/coverage-prepare.ts

@@ -0,0 +1,123 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadConfig } from '../config/load';
+import type { XeraConfig } from '../config/schema';
+import {
+  buildCoverageReport,
+  buildWhyArea,
+  buildWhyTicket,
+  type RenderOptions,
+  renderMarkdown,
+} from '../coverage';
+import { appendEvents, deriveSnapshot, loadAllEvents } from '../graph/store';
+import type { Event, Snapshot } from '../graph/types';
+import { ulid } from '../graph/ulid';
+
+interface ParsedArgs {
+  snapshotTs?: string;
+  emitEvent: boolean;
+  why?: string;
+  json: boolean;
+  all: boolean;
+  snapshotFile?: string;
+}
+
+function parseArgs(argv: string[]): ParsedArgs {
+  const args: ParsedArgs = { emitEvent: true, json: false, all: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--snapshot-ts') {
+      const v = argv[++i];
+      if (v !== undefined) args.snapshotTs = v;
+    } else if (a === '--no-emit-event') args.emitEvent = false;
+    else if (a === '--why') {
+      const v = argv[++i];
+      if (v !== undefined) args.why = v;
+    } else if (a === '--json') args.json = true;
+    else if (a === '--all') args.all = true;
+    else if (a === '--snapshot-file') {
+      const v = argv[++i];
+      if (v !== undefined) args.snapshotFile = v;
+    } else if (a === '--help-stub') {
+      /* no-op for test scaffold */
+    } else {
+      console.error(`[coverage-prepare] unknown flag: ${a}`);
+      return { ...args, emitEvent: false };
+    }
+  }
+  return args;
+}
+
+const TICKET_RE = /^[A-Z][A-Z0-9]*-\d+$/;
+
+export async function coveragePrepareCmd(argv: string[]): Promise<number> {
+  const args = parseArgs(argv);
+
+  const cwd = process.cwd();
+  let config: XeraConfig;
+  try {
+    config = await loadConfig(cwd);
+  } catch (e) {
+    console.error(`[coverage-prepare] ${(e as Error).message}`);
+    return 2;
+  }
+
+  let snap: Snapshot;
+  if (args.snapshotFile) {
+    snap = JSON.parse(readFileSync(args.snapshotFile, 'utf8')) as Snapshot;
+  } else {
+    snap = deriveSnapshot(loadAllEvents(cwd));
+  }
+
+  const now = args.snapshotTs ? new Date(args.snapshotTs) : new Date();
+
+  if (args.why) {
+    const out = TICKET_RE.test(args.why)
+      ? buildWhyTicket(args.why, snap, config.coverage, now)
+      : buildWhyArea(args.why, snap, config.coverage, now);
+    process.stdout.write(out);
+    return 0;
+  }
+
+  const report = buildCoverageReport(snap, config.coverage, now);
+
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return 0;
+  }
+
+  const outDir = join(cwd, '.xera/coverage');
+  mkdirSync(outDir, { recursive: true });
+  writeFileSync(join(outDir, 'report.json'), JSON.stringify(report, null, 2));
+  const renderOpts: RenderOptions = { includeCovered: args.all };
+  writeFileSync(join(outDir, 'report.md'), renderMarkdown(report, renderOpts));
+
+  if (args.emitEvent && config.coverage.autoSnapshotOnCoverage) {
+    const event: Event = {
+      event_id: ulid(),
+      schema_version: 1,
+      ts: now.toISOString(),
+      actor: 'xera-coverage',
+      type: 'coverage.snapshot',
+      payload: {
+        ts: now.toISOString(),
+        windowDays: config.coverage.staleAfterDays,
+        areas: report.areas.map((a) => ({
+          id: a.id,
+          status: a.status,
+          risk: a.risk,
+          breakdown: a.breakdown,
+        })),
+        tickets: report.tickets.map((t) => ({
+          id: t.id,
+          acCount: t.acCount,
+          satisfiedCount: t.satisfiedCount,
+          gapScore: t.gapScore,
+        })),
+      },
+    };
+    appendEvents(cwd, [event], { skill: 'coverage', ticketId: 'session', now });
+  }
+
+  return 0;
+}

package/src/bin-internal/fill-gap-finalize.ts

@@ -0,0 +1,115 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+
+const ProposalsSchema = z.object({
+  proposals: z.array(
+    z.object({
+      id: z.string().min(1),
+      ticketId: z.string().min(1),
+      title: z.string().min(1),
+      rationale: z.string().min(1),
+      gherkin: z.string().min(1),
+      satisfiesAcs: z.array(z.number().int().nonnegative()),
+    }),
+  ),
+});
+
+interface ParsedArgs {
+  accept: string;
+  ticket: string;
+  source?: string;
+  force: boolean;
+}
+
+function parseArgs(argv: string[]): ParsedArgs | { error: string } {
+  let accept: string | undefined;
+  let ticket: string | undefined;
+  let source: string | undefined;
+  let force = false;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--accept') {
+      const v = argv[++i];
+      if (v !== undefined) accept = v;
+    } else if (a === '--ticket') {
+      const v = argv[++i];
+      if (v !== undefined) ticket = v;
+    } else if (a === '--source') {
+      const v = argv[++i];
+      if (v !== undefined) source = v;
+    } else if (a === '--force') {
+      force = true;
+    } else if (a === '--help-stub') {
+      /* no-op */
+    } else {
+      return { error: `unknown flag: ${a}` };
+    }
+  }
+  if (!accept || !ticket) return { error: 'required: --accept <proposal-id> --ticket <TICKET>' };
+  const out: ParsedArgs = { accept, ticket, force };
+  if (source !== undefined) out.source = source;
+  return out;
+}
+
+function formatDraft(
+  ticketId: string,
+  proposal: z.infer<typeof ProposalsSchema>['proposals'][number],
+): string {
+  const lines = [
+    `# Draft scenario for ${ticketId}`,
+    '',
+    `> ${proposal.rationale}`,
+    '',
+    proposal.gherkin,
+    '',
+  ];
+  if (proposal.satisfiesAcs.length > 0) {
+    lines.push(`<!-- satisfiesAcs: [${proposal.satisfiesAcs.join(', ')}] -->`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+export async function fillGapFinalizeCmd(argv: string[]): Promise<number> {
+  if (argv.includes('--help-stub')) {
+    /* test scaffold no-op */
+  }
+  const parsed = parseArgs(argv);
+  if ('error' in parsed) {
+    console.error(`[fill-gap-finalize] ${parsed.error}`);
+    return 1;
+  }
+
+  const cwd = process.cwd();
+  const sourcePath = parsed.source ?? join(cwd, '.xera/coverage/proposals.json');
+  if (!existsSync(sourcePath)) {
+    console.error(`[fill-gap-finalize] source not found: ${sourcePath}`);
+    return 2;
+  }
+
+  let proposals: z.infer<typeof ProposalsSchema>;
+  try {
+    const raw = JSON.parse(readFileSync(sourcePath, 'utf8'));
+    proposals = ProposalsSchema.parse(raw);
+  } catch (e) {
+    console.error(`[fill-gap-finalize] invalid proposals: ${(e as Error).message}`);
+    return 2;
+  }
+
+  const proposal = proposals.proposals.find((p) => p.id === parsed.accept);
+  if (!proposal) {
+    console.error(`[fill-gap-finalize] proposal id "${parsed.accept}" not in source`);
+    return 2;
+  }
+
+  const ticketDir = join(cwd, '.xera', parsed.ticket);
+  mkdirSync(ticketDir, { recursive: true });
+  const draftPath = join(ticketDir, 'feature.draft.md');
+  if (existsSync(draftPath) && !parsed.force) {
+    console.error(`[fill-gap-finalize] ${draftPath} exists; pass --force to overwrite`);
+    return 3;
+  }
+  writeFileSync(draftPath, formatDraft(parsed.ticket, proposal));
+  return 0;
+}

package/src/bin-internal/fill-gap-prepare.ts

@@ -0,0 +1,150 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { deriveSnapshot, loadAllEvents } from '../graph/store';
+import type { Snapshot } from '../graph/types';
+
+interface AreaContext {
+  mode: 'area';
+  area: string;
+  tickets: Array<{ id: string; summary: string; ac: string[] }>;
+  existingScenarios: Array<{ areaSlug: string; gherkin: string }>;
+}
+
+interface TicketContext {
+  mode: 'ticket';
+  ticket: { id: string; summary: string; ac: string[] };
+  unsatisfiedAcs: Array<{ index: number; text: string }>;
+  existingScenarios: Array<{ scenarioId: string; name: string; gherkin: string }>;
+}
+
+interface ParsedArgs {
+  area?: string;
+  ticket?: string;
+  outputDir?: string;
+}
+
+function parseArgs(argv: string[]): ParsedArgs | { error: string } {
+  const args: ParsedArgs = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--area') {
+      const v = argv[++i];
+      if (v !== undefined) args.area = v;
+    } else if (a === '--ticket') {
+      const v = argv[++i];
+      if (v !== undefined) args.ticket = v;
+    } else if (a === '--output-dir') {
+      const v = argv[++i];
+      if (v !== undefined) args.outputDir = v;
+    } else if (a === '--help-stub') {
+      /* no-op */
+    } else {
+      return { error: `unknown flag: ${a}` };
+    }
+  }
+  if (!args.area && !args.ticket) return { error: 'one of --area or --ticket required' };
+  if (args.area && args.ticket) return { error: '--area and --ticket are mutually exclusive' };
+  return args;
+}
+
+function buildAreaContext(snap: Snapshot, area: string): AreaContext | null {
+  // Use modifiesAreas on ticket nodes (set from ticket.fetched) to find tickets for this area.
+  // edge.discovered with kind='modifies' is an additional source, but ticket.fetched also
+  // populates ticket.modifiesAreas directly — so check both.
+  const edgeTicketIds = new Set(
+    snap.edges.filter((e) => e.kind === 'modifies' && e.to === area).map((e) => e.from),
+  );
+  const ticketsForArea = Object.values(snap.tickets).filter(
+    (t) => t.modifiesAreas.includes(area) || edgeTicketIds.has(t.id),
+  );
+  if (ticketsForArea.length === 0) return null;
+
+  // existingScenarios from other areas — limit to 3 to keep prompt input small
+  const scenariosFromOtherAreas = Object.values(snap.scenarios)
+    .filter((s) => {
+      const t = snap.tickets[s.ticketId];
+      if (!t) return false;
+      return !t.modifiesAreas.includes(area) && t.modifiesAreas.length > 0;
+    })
+    .slice(0, 3)
+    .map((s) => {
+      const ownerTicket = snap.tickets[s.ticketId];
+      const areaSlug = ownerTicket?.modifiesAreas[0] ?? 'unknown';
+      return { areaSlug, gherkin: s.gherkin };
+    });
+
+  return {
+    mode: 'area',
+    area,
+    tickets: ticketsForArea.map((t) => ({ id: t.id, summary: t.summary, ac: t.ac })),
+    existingScenarios: scenariosFromOtherAreas,
+  };
+}
+
+function buildTicketContext(snap: Snapshot, ticketId: string): TicketContext | null {
+  const ticket = snap.tickets[ticketId];
+  if (!ticket) return null;
+
+  const acNodesForTicket = Object.values(snap.acNodes)
+    .filter((ac) => ac.ticketId === ticketId)
+    .sort((a, b) => a.index - b.index);
+  const satisfiedAcIds = new Set(
+    snap.edges
+      .filter((e) => e.kind === 'satisfies' && acNodesForTicket.some((ac) => ac.id === e.to))
+      .map((e) => e.to),
+  );
+  const unsatisfiedAcs = acNodesForTicket
+    .filter((ac) => !satisfiedAcIds.has(ac.id))
+    .map((ac) => ({ index: ac.index, text: ac.text }));
+
+  if (unsatisfiedAcs.length === 0) return null;
+
+  const existingScenarios = Object.values(snap.scenarios)
+    .filter((s) => s.ticketId === ticketId)
+    .map((s) => ({ scenarioId: s.id, name: s.name, gherkin: s.gherkin }));
+
+  return {
+    mode: 'ticket',
+    ticket: { id: ticket.id, summary: ticket.summary, ac: ticket.ac },
+    unsatisfiedAcs,
+    existingScenarios,
+  };
+}
+
+export async function fillGapPrepareCmd(argv: string[]): Promise<number> {
+  const parsed = parseArgs(argv);
+  if ('error' in parsed) {
+    console.error(`[fill-gap-prepare] ${parsed.error}`);
+    return 1;
+  }
+
+  const cwd = process.cwd();
+  const snap = deriveSnapshot(loadAllEvents(cwd));
+
+  let context: AreaContext | TicketContext | null;
+  let scope: string;
+  if (parsed.area) {
+    context = buildAreaContext(snap, parsed.area);
+    scope = parsed.area;
+    if (!context) {
+      console.error(
+        `[fill-gap-prepare] area "${parsed.area}" has no tickets modifying it; cannot fill`,
+      );
+      return 2;
+    }
+  } else {
+    context = buildTicketContext(snap, parsed.ticket!);
+    scope = parsed.ticket!;
+    if (!context) {
+      console.error(
+        `[fill-gap-prepare] ticket "${parsed.ticket}" not found or has no unsatisfied ACs`,
+      );
+      return 2;
+    }
+  }
+
+  const outDir = parsed.outputDir ?? join(cwd, '.xera/coverage', scope);
+  mkdirSync(outDir, { recursive: true });
+  writeFileSync(join(outDir, 'context.json'), JSON.stringify(context, null, 2));
+  return 0;
+}

package/src/bin-internal/graph-render.ts

@@ -1,8 +1,9 @@
-import { mkdirSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import type { RenderOpts } from '../graph/render';
+import type { CoverageInput, RenderOpts } from '../graph/render';
 import { renderHtml, transformForVisNetwork } from '../graph/render';
 import { deriveSnapshot, loadAllEvents } from '../graph/store';
+import type { CoverageSnapshotPayload, Event } from '../graph/types';
 
 function parseDepth(s: string | undefined): 1 | 2 | 3 {
   const n = s ? Number.parseInt(s, 10) : 2;
@@ -21,18 +22,21 @@ export async function graphRenderCmd(argv: string[]): Promise<number> {
   let ticketId: string | undefined;
   let since: string | undefined;
   let depth: 1 | 2 | 3 = 2;
+  let includeCoverage = false;
 
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--out') outPath = argv[++i];
     else if (argv[i] === '--ticket') ticketId = argv[++i];
     else if (argv[i] === '--since') since = argv[++i];
     else if (argv[i] === '--depth') depth = parseDepth(argv[++i]);
+    else if (argv[i] === '--include-coverage') includeCoverage = true;
   }
 
   const repoRoot = process.cwd();
   const finalPath = outPath ?? join(repoRoot, '.xera/graph.html');
 
-  const snap = deriveSnapshot(loadAllEvents(repoRoot));
+  const events = loadAllEvents(repoRoot);
+  const snap = deriveSnapshot(events);
   const totalNodeCount =
     Object.keys(snap.tickets).length +
     Object.keys(snap.scenarios).length +
@@ -55,8 +59,32 @@ export async function graphRenderCmd(argv: string[]): Promise<number> {
   if (ticketId) opts.ticketId = ticketId;
   if (since) opts.since = since;
 
+  let coverage: CoverageInput | undefined;
+  if (includeCoverage) {
+    const reportPath = join(repoRoot, '.xera/coverage/report.json');
+    if (existsSync(reportPath)) {
+      const report = JSON.parse(readFileSync(reportPath, 'utf8'));
+      const snapshots = events
+        .filter(
+          (e): e is Extract<Event, { type: 'coverage.snapshot' }> => e.type === 'coverage.snapshot',
+        )
+        .map((e) => e.payload as CoverageSnapshotPayload);
+      coverage = { report, snapshots };
+    } else {
+      console.warn(
+        '[graph-render] --include-coverage: report.json not found; run /xera-coverage first',
+      );
+    }
+  }
+
   const data = transformForVisNetwork(snap, opts);
-  const html = renderHtml({ data, stats: data.stats, generatedAt: new Date().toISOString() });
+  const renderInput: Parameters<typeof renderHtml>[0] = {
+    data,
+    stats: data.stats,
+    generatedAt: new Date().toISOString(),
+  };
+  if (coverage) renderInput.coverage = coverage;
+  const html = renderHtml(renderInput);
 
   mkdirSync(dirname(finalPath), { recursive: true });
   const tmpPath = `${finalPath}.tmp`;

package/src/bin-internal/index.ts

@@ -1,4 +1,7 @@
+import { acCoverageBackfillFinalizeCmd } from './ac-coverage-backfill-finalize';
+import { acCoverageBackfillPrepareCmd } from './ac-coverage-backfill-prepare';
 import { authSetupCmd } from './auth-setup';
+import { coveragePrepareCmd } from './coverage-prepare';
 import { disputesCmd } from './disputes';
 import { doctorCmd } from './doctor';
 import { evalDeterministicCmd } from './eval-deterministic';
@@ -6,6 +9,8 @@ import { evalPrepareCmd } from './eval-prepare';
 import { evalReportCmd } from './eval-report';
 import { execCmd } from './exec';
 import { fetchCmd } from './fetch';
+import { fillGapFinalizeCmd } from './fill-gap-finalize';
+import { fillGapPrepareCmd } from './fill-gap-prepare';
 import { graphBackfillCmd } from './graph-backfill';
 import { graphEnrichCmd } from './graph-enrich';
 import { graphQueryCmd } from './graph-query';
@@ -26,13 +31,18 @@ import { validateFeatureCmd } from './validate-feature';
 import { verifyPromptsCmd } from './verify-prompts';
 
 const COMMANDS: Record<string, (argv: string[]) => Promise<number>> = {
+  'ac-coverage-backfill-finalize': acCoverageBackfillFinalizeCmd,
+  'ac-coverage-backfill-prepare': acCoverageBackfillPrepareCmd,
   'auth-setup': authSetupCmd,
+  'coverage-prepare': coveragePrepareCmd,
   disputes: disputesCmd,
   doctor: doctorCmd,
   'eval-deterministic': evalDeterministicCmd,
   'eval-prepare': evalPrepareCmd,
   'eval-report': evalReportCmd,
   exec: execCmd,
+  'fill-gap-finalize': fillGapFinalizeCmd,
+  'fill-gap-prepare': fillGapPrepareCmd,
   fetch: fetchCmd,
   'graph-backfill': graphBackfillCmd,
   'graph-enrich': graphEnrichCmd,