@xera-ai/core 0.9.8 → 0.10.0

package/dist/bin/internal.js

@@ -404,15 +404,15 @@ var require_main = __commonJS((exports, module) => {
 });
 
 // src/graph/paths.ts
-import { join as join3 } from "path";
+import { join } from "path";
 function graphPaths(repoRoot) {
-  const eventsDir = join3(repoRoot, ".xera/graph/events");
+  const eventsDir = join(repoRoot, ".xera/graph/events");
   return {
     eventsDir,
-    snapshotFile: join3(repoRoot, ".xera/graph/snapshot.json"),
-    costLog: join3(repoRoot, ".xera/cost-log.jsonl"),
-    eventsMonthDir: (yyyyMm) => join3(eventsDir, yyyyMm),
-    eventFile: (ulid, skill, ticketId, yyyyMm) => join3(eventsDir, yyyyMm, `${ulid}-${skill}-${ticketId}.jsonl`)
+    snapshotFile: join(repoRoot, ".xera/graph/snapshot.json"),
+    costLog: join(repoRoot, ".xera/cost-log.jsonl"),
+    eventsMonthDir: (yyyyMm) => join(eventsDir, yyyyMm),
+    eventFile: (ulid, skill, ticketId, yyyyMm) => join(eventsDir, yyyyMm, `${ulid}-${skill}-${ticketId}.jsonl`)
   };
 }
 function currentYyyyMm(now = new Date) {
@@ -426,64 +426,65 @@ var init_paths = () => {};
 var SCHEMA_VERSION = 1;
 
 // src/graph/schema.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 function safeParseEvent(value) {
   const r = EventSchema.safeParse(value);
   if (r.success)
     return { success: true, data: r.data };
   return { success: false, error: r.error };
 }
-var schemaV, iso, ticketFetched, ticketEnriched, scenarioGenerated, pomGenerated, pomPromoted, runCompleted, classification, runClassified, classificationDisputed, edgeDiscovered, base, EventSchema;
+var schemaV, iso, ticketFetched, ticketEnriched, scenarioGenerated, pomGenerated, pomPromoted, runCompleted, classification, runClassified, classificationDisputed, edgeDiscovered, coverageSnapshot, acCoverageBackfilled, base, EventSchema;
 var init_schema = __esm(() => {
-  schemaV = z2.literal(SCHEMA_VERSION);
-  iso = z2.string().datetime({ offset: false });
-  ticketFetched = z2.object({
-    ticketId: z2.string().regex(/^[A-Z][A-Z0-9]*-\d+$/),
-    summary: z2.string(),
-    ac: z2.array(z2.string()),
-    jiraLinks: z2.array(z2.object({
-      ticketId: z2.string().regex(/^[A-Z][A-Z0-9]*-\d+$/),
-      relation: z2.enum(["blocks", "duplicates", "relates", "supersedes"])
+  schemaV = z.literal(SCHEMA_VERSION);
+  iso = z.string().datetime({ offset: false });
+  ticketFetched = z.object({
+    ticketId: z.string().regex(/^[A-Z][A-Z0-9]*-\d+$/),
+    summary: z.string(),
+    ac: z.array(z.string()),
+    jiraLinks: z.array(z.object({
+      ticketId: z.string().regex(/^[A-Z][A-Z0-9]*-\d+$/),
+      relation: z.enum(["blocks", "duplicates", "relates", "supersedes"])
     })),
-    storyHash: z2.string(),
-    modifiesAreas: z2.array(z2.string().regex(/^[a-z0-9-]+$/))
+    storyHash: z.string(),
+    modifiesAreas: z.array(z.string().regex(/^[a-z0-9-]+$/))
   }).passthrough();
-  ticketEnriched = z2.object({
-    ticketId: z2.string(),
+  ticketEnriched = z.object({
+    ticketId: z.string(),
     enrichedAt: iso,
-    similarCount: z2.number().int().nonnegative()
+    similarCount: z.number().int().nonnegative()
   }).passthrough();
-  scenarioGenerated = z2.object({
-    scenarioId: z2.string(),
-    ticketId: z2.string(),
-    name: z2.string(),
-    gherkin: z2.string(),
-    priority: z2.enum(["p0", "p1", "p2"]),
-    featureHash: z2.string(),
-    generatedAt: iso
+  scenarioGenerated = z.object({
+    scenarioId: z.string(),
+    ticketId: z.string(),
+    name: z.string(),
+    gherkin: z.string(),
+    priority: z.enum(["p0", "p1", "p2"]),
+    featureHash: z.string(),
+    generatedAt: iso,
+    satisfiesAcs: z.array(z.number().int().nonnegative()).optional()
   }).passthrough();
-  pomGenerated = z2.object({
-    pomId: z2.string(),
-    ticketId: z2.string(),
-    filePath: z2.string(),
-    route: z2.string(),
-    locators: z2.array(z2.string()),
-    scope: z2.enum(["local", "shared"])
+  pomGenerated = z.object({
+    pomId: z.string(),
+    ticketId: z.string(),
+    filePath: z.string(),
+    route: z.string(),
+    locators: z.array(z.string()),
+    scope: z.enum(["local", "shared"])
   }).passthrough();
-  pomPromoted = z2.object({
-    pomId: z2.string(),
-    fromPath: z2.string(),
-    toPath: z2.string()
+  pomPromoted = z.object({
+    pomId: z.string(),
+    fromPath: z.string(),
+    toPath: z.string()
   }).passthrough();
-  runCompleted = z2.object({
-    scenarioId: z2.string(),
-    ticketId: z2.string(),
-    runId: z2.string(),
-    status: z2.enum(["pass", "fail"]),
-    traceId: z2.string().optional(),
-    runtime: z2.number().nonnegative()
+  runCompleted = z.object({
+    scenarioId: z.string(),
+    ticketId: z.string(),
+    runId: z.string(),
+    status: z.enum(["pass", "fail"]),
+    traceId: z.string().optional(),
+    runtime: z.number().nonnegative()
   }).passthrough();
-  classification = z2.enum([
+  classification = z.enum([
     "REAL_BUG",
     "TEST_BUG",
     "SELECTOR_DRIFT",
@@ -494,54 +495,94 @@ var init_schema = __esm(() => {
     "RATE_LIMITED",
     "AUTH_EXPIRED"
   ]);
-  runClassified = z2.object({
-    scenarioId: z2.string(),
-    runId: z2.string(),
+  runClassified = z.object({
+    scenarioId: z.string(),
+    runId: z.string(),
     classification,
-    confidence: z2.enum(["low", "medium", "high"])
+    confidence: z.enum(["low", "medium", "high"])
   }).passthrough();
-  classificationDisputed = z2.object({
-    runId: z2.string(),
-    scenarioId: z2.string(),
+  classificationDisputed = z.object({
+    runId: z.string(),
+    scenarioId: z.string(),
     originalClassification: classification,
     disputedTo: classification,
-    qaActor: z2.string(),
-    qaReason: z2.string().optional()
+    qaActor: z.string(),
+    qaReason: z.string().optional()
+  }).passthrough();
+  edgeDiscovered = z.object({
+    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(),
+    source: z.string()
   }).passthrough();
-  edgeDiscovered = z2.object({
-    kind: z2.enum(["tests", "uses", "covers", "modifies", "jira-linked", "similar", "ran"]),
-    from: z2.string(),
-    to: z2.string(),
-    confidence: z2.number().min(0).max(1).optional(),
-    source: z2.string()
+  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();
+  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();
   base = {
-    event_id: z2.string().min(20),
+    event_id: z.string().min(20),
     schema_version: schemaV,
     ts: iso,
-    actor: z2.string()
+    actor: z.string()
   };
-  EventSchema = z2.discriminatedUnion("type", [
-    z2.object({ ...base, type: z2.literal("ticket.fetched"), payload: ticketFetched }),
-    z2.object({ ...base, type: z2.literal("ticket.enriched"), payload: ticketEnriched }),
-    z2.object({ ...base, type: z2.literal("scenario.generated"), payload: scenarioGenerated }),
-    z2.object({ ...base, type: z2.literal("pom.generated"), payload: pomGenerated }),
-    z2.object({ ...base, type: z2.literal("pom.promoted"), payload: pomPromoted }),
-    z2.object({ ...base, type: z2.literal("run.completed"), payload: runCompleted }),
-    z2.object({ ...base, type: z2.literal("run.classified"), payload: runClassified }),
-    z2.object({
+  EventSchema = z.discriminatedUnion("type", [
+    z.object({ ...base, type: z.literal("ticket.fetched"), payload: ticketFetched }),
+    z.object({ ...base, type: z.literal("ticket.enriched"), payload: ticketEnriched }),
+    z.object({ ...base, type: z.literal("scenario.generated"), payload: scenarioGenerated }),
+    z.object({ ...base, type: z.literal("pom.generated"), payload: pomGenerated }),
+    z.object({ ...base, type: z.literal("pom.promoted"), payload: pomPromoted }),
+    z.object({ ...base, type: z.literal("run.completed"), payload: runCompleted }),
+    z.object({ ...base, type: z.literal("run.classified"), payload: runClassified }),
+    z.object({
       ...base,
-      type: z2.literal("classification.disputed"),
+      type: z.literal("classification.disputed"),
       payload: classificationDisputed
     }),
-    z2.object({ ...base, type: z2.literal("edge.discovered"), payload: edgeDiscovered })
+    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 })
   ]);
 });
 
 // src/graph/store.ts
 import { createHash } from "crypto";
 import {
-  existsSync as existsSync3,
+  existsSync,
   mkdirSync,
   readdirSync,
   readFileSync,
@@ -568,7 +609,7 @@ function appendEvents(repoRoot, events, opts) {
 }
 function loadAllEvents(repoRoot) {
   const paths = graphPaths(repoRoot);
-  if (!existsSync3(paths.eventsDir))
+  if (!existsSync(paths.eventsDir))
     return [];
   const files = [];
   for (const monthDir of readdirSync(paths.eventsDir, { withFileTypes: true })) {
@@ -625,11 +666,14 @@ function deriveSnapshot(events) {
   const areas = {};
   const edges = [];
   const latestFailures = {};
+  const acNodes = {};
+  const classifications = [];
   for (const e of events) {
     switch (e.type) {
-      case "ticket.fetched":
-        tickets[e.payload.ticketId] = {
-          id: e.payload.ticketId,
+      case "ticket.fetched": {
+        const tid = e.payload.ticketId;
+        tickets[tid] = {
+          id: tid,
           summary: e.payload.summary,
           ac: e.payload.ac,
           storyHash: e.payload.storyHash,
@@ -641,18 +685,34 @@ function deriveSnapshot(events) {
         for (const link of e.payload.jiraLinks) {
           edges.push({
             kind: "jira-linked",
-            from: e.payload.ticketId,
+            from: tid,
             to: link.ticketId,
             source: `jira:${link.relation}`,
             discoveredAt: e.ts
           });
         }
+        for (const acId of Object.keys(acNodes)) {
+          if (acNodes[acId]?.ticketId === tid)
+            delete acNodes[acId];
+        }
+        e.payload.ac.forEach((text, index) => {
+          const acId = `${tid}#ac-${index}`;
+          acNodes[acId] = { id: acId, ticketId: tid, index, text };
+        });
+        for (let i = edges.length - 1;i >= 0; i--) {
+          const ed = edges[i];
+          if (ed.kind !== "satisfies")
+            continue;
+          if (acNodes[ed.to] === undefined)
+            edges.splice(i, 1);
+        }
         break;
+      }
       case "ticket.enriched":
         if (tickets[e.payload.ticketId])
           tickets[e.payload.ticketId].enrichedAt = e.payload.enrichedAt;
         break;
-      case "scenario.generated":
+      case "scenario.generated": {
         scenarios[e.payload.scenarioId] = {
           id: e.payload.scenarioId,
           ticketId: e.payload.ticketId,
@@ -669,7 +729,29 @@ function deriveSnapshot(events) {
           source: "xera-script",
           discoveredAt: e.ts
         });
+        if (e.payload.satisfiesAcs && e.payload.satisfiesAcs.length > 0) {
+          for (let i = edges.length - 1;i >= 0; i--) {
+            const ed = edges[i];
+            if (ed.kind === "satisfies" && ed.from === e.payload.scenarioId && ed.source === "xera-script") {
+              edges.splice(i, 1);
+            }
+          }
+          for (const acIdx of e.payload.satisfiesAcs) {
+            const acId = `${e.payload.ticketId}#ac-${acIdx}`;
+            if (acNodes[acId] === undefined)
+              continue;
+            edges.push({
+              kind: "satisfies",
+              from: e.payload.scenarioId,
+              to: acId,
+              confidence: 1,
+              source: "xera-script",
+              discoveredAt: e.ts
+            });
+          }
+        }
         break;
+      }
       case "pom.generated":
         poms[e.payload.pomId] = {
           id: e.payload.pomId,
@@ -721,6 +803,40 @@ function deriveSnapshot(events) {
         }
         break;
       }
+      case "run.classified":
+        classifications.push({
+          scenarioId: e.payload.scenarioId,
+          classification: e.payload.classification,
+          ts: e.ts
+        });
+        break;
+      case "ac-coverage.backfilled": {
+        const { ts, ticketId, mappings } = e.payload;
+        for (let i = edges.length - 1;i >= 0; i--) {
+          const ed = edges[i];
+          if (ed.kind === "satisfies" && ed.source === "ac-coverage" && ed.to.startsWith(`${ticketId}#ac-`)) {
+            edges.splice(i, 1);
+          }
+        }
+        for (const m of mappings) {
+          for (const acIdx of m.satisfiesAcs) {
+            const acId = `${ticketId}#ac-${acIdx}`;
+            if (acNodes[acId] === undefined)
+              continue;
+            edges.push({
+              kind: "satisfies",
+              from: m.scenarioId,
+              to: acId,
+              confidence: m.confidence,
+              source: "ac-coverage",
+              discoveredAt: ts
+            });
+          }
+        }
+        break;
+      }
+      case "coverage.snapshot":
+        break;
       default:
         break;
     }
@@ -735,7 +851,9 @@ function deriveSnapshot(events) {
     poms,
     areas,
     edges,
-    latest_failures: latestFailures
+    latest_failures: latestFailures,
+    acNodes,
+    classifications
   };
 }
 function writeSnapshot(repoRoot, snap) {
@@ -747,7 +865,7 @@ function writeSnapshot(repoRoot, snap) {
 }
 function loadSnapshot(repoRoot) {
   const paths = graphPaths(repoRoot);
-  if (!existsSync3(paths.snapshotFile))
+  if (!existsSync(paths.snapshotFile))
     return null;
   try {
     return JSON.parse(readFileSync(paths.snapshotFile, "utf8"));
@@ -825,8 +943,8 @@ __export(exports_graph_record_script, {
   recordScriptImpl: () => recordScriptImpl
 });
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
-import { basename, join as join5 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { basename, join as join8 } from "path";
 function inferPriority(name, gherkin) {
   const haystack = `${name} ${gherkin}`.toLowerCase();
   for (const kw of P0_KEYWORDS) {
@@ -868,9 +986,9 @@ function parseFeature(text) {
   return scenarios;
 }
 function listPomFiles(dir) {
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return [];
-  return readdirSync2(dir).filter((f) => f.endsWith(".ts")).map((f) => join5(dir, f));
+  return readdirSync2(dir).filter((f) => f.endsWith(".ts")).map((f) => join8(dir, f));
 }
 function extractRoute(pomContent) {
   const m = pomContent.match(/goto\s*\(\s*['"]([^'"]+)['"]/);
@@ -897,15 +1015,15 @@ function extractPomUsage(specContent) {
   return [...names];
 }
 async function recordScriptImpl(repoRoot, ticket) {
-  const ticketDir = join5(repoRoot, ".xera", ticket);
-  const featurePath = existsSync6(join5(ticketDir, "test.feature")) ? join5(ticketDir, "test.feature") : join5(ticketDir, "feature", `${ticket}.feature`);
-  const specPath = existsSync6(join5(ticketDir, "spec.ts")) ? join5(ticketDir, "spec.ts") : join5(ticketDir, "tests", `${ticket}.spec.ts`);
-  const pomDir = existsSync6(join5(ticketDir, "page-objects")) ? join5(ticketDir, "page-objects") : join5(ticketDir, "poms");
-  if (!existsSync6(featurePath)) {
+  const ticketDir = join8(repoRoot, ".xera", ticket);
+  const featurePath = existsSync7(join8(ticketDir, "test.feature")) ? join8(ticketDir, "test.feature") : join8(ticketDir, "feature", `${ticket}.feature`);
+  const specPath = existsSync7(join8(ticketDir, "spec.ts")) ? join8(ticketDir, "spec.ts") : join8(ticketDir, "tests", `${ticket}.spec.ts`);
+  const pomDir = existsSync7(join8(ticketDir, "page-objects")) ? join8(ticketDir, "page-objects") : join8(ticketDir, "poms");
+  if (!existsSync7(featurePath)) {
     console.error(`[graph-record script] feature missing`);
     return 1;
   }
-  const featureText = readFileSync4(featurePath, "utf8");
+  const featureText = readFileSync6(featurePath, "utf8");
   const featureHash = sha1(featureText);
   const scenarios = parseFeature(featureText);
   const events = [];
@@ -925,7 +1043,7 @@ async function recordScriptImpl(repoRoot, ticket) {
   const pomFiles = listPomFiles(pomDir);
   const pomNameToId = new Map;
   for (const pomFile of pomFiles) {
-    const content = readFileSync4(pomFile, "utf8");
+    const content = readFileSync6(pomFile, "utf8");
     const id = pId(pomFile);
     const className = content.match(/export\s+class\s+([A-Z][A-Za-z0-9]*Page)/)?.[1] ?? "";
     pomNameToId.set(className, id);
@@ -939,8 +1057,8 @@ async function recordScriptImpl(repoRoot, ticket) {
     };
     events.push(mk("xera-script", "pom.generated", pg));
   }
-  if (existsSync6(specPath)) {
-    const specContent = readFileSync4(specPath, "utf8");
+  if (existsSync7(specPath)) {
+    const specContent = readFileSync6(specPath, "utf8");
     const usedPoms = extractPomUsage(specContent);
     for (const scenario of scenarios) {
       const scId = sId(ticket, scenario.name);
@@ -7998,33 +8116,33 @@ var init_dist = __esm(() => {
 });
 
 // src/artifact/paths.ts
-import { join as join6 } from "path";
+import { join as join9 } from "path";
 function resolveArtifactPaths(repoRoot, ticket) {
-  if (!TICKET_RE.test(ticket)) {
+  if (!TICKET_RE2.test(ticket)) {
     throw new Error(`Invalid ticket key: "${ticket}" (expected e.g. JIRA-123 or SAMPLE-001)`);
   }
-  const ticketDir = join6(repoRoot, ".xera", ticket);
+  const ticketDir = join9(repoRoot, ".xera", ticket);
   return {
     ticketDir,
-    storyPath: join6(ticketDir, "story.md"),
-    featurePath: join6(ticketDir, "test.feature"),
-    specPath: join6(ticketDir, "spec.ts"),
-    pageObjectsDir: join6(ticketDir, "page-objects"),
-    runsDir: join6(ticketDir, "runs"),
-    metaPath: join6(ticketDir, "meta.json"),
-    statusPath: join6(ticketDir, "status.json"),
-    logPath: join6(ticketDir, "xera.log"),
-    lockPath: join6(ticketDir, ".lock"),
-    authDir: join6(repoRoot, ".xera", ".auth"),
+    storyPath: join9(ticketDir, "story.md"),
+    featurePath: join9(ticketDir, "test.feature"),
+    specPath: join9(ticketDir, "spec.ts"),
+    pageObjectsDir: join9(ticketDir, "page-objects"),
+    runsDir: join9(ticketDir, "runs"),
+    metaPath: join9(ticketDir, "meta.json"),
+    statusPath: join9(ticketDir, "status.json"),
+    logPath: join9(ticketDir, "xera.log"),
+    lockPath: join9(ticketDir, ".lock"),
+    authDir: join9(repoRoot, ".xera", ".auth"),
     runPath: (runId) => {
-      const runDir = join6(ticketDir, "runs", runId);
+      const runDir = join9(ticketDir, "runs", runId);
       return {
         runDir,
-        reportJsonPath: join6(runDir, "report.json"),
-        tracePath: join6(runDir, "trace.zip"),
-        normalizedPath: join6(runDir, "normalized.json"),
-        screenshotsDir: join6(runDir, "screenshots"),
-        videoDir: join6(runDir, "videos")
+        reportJsonPath: join9(runDir, "report.json"),
+        tracePath: join9(runDir, "trace.zip"),
+        normalizedPath: join9(runDir, "normalized.json"),
+        screenshotsDir: join9(runDir, "screenshots"),
+        videoDir: join9(runDir, "videos")
       };
     }
   };
@@ -8032,9 +8150,9 @@ function resolveArtifactPaths(repoRoot, ticket) {
 function generateRunId(now = new Date) {
   return now.toISOString().replace(/[:.]/g, "-").replace("Z", "");
 }
-var TICKET_RE;
+var TICKET_RE2;
 var init_paths2 = __esm(() => {
-  TICKET_RE = /^[A-Z][A-Z0-9_]*-\d+$|^SAMPLE-\d+$/;
+  TICKET_RE2 = /^[A-Z][A-Z0-9_]*-\d+$|^SAMPLE-\d+$/;
 });
 
 // src/bin-internal/graph-record.ts
@@ -8044,8 +8162,8 @@ __export(exports_graph_record, {
   graphRecordCmd: () => graphRecordCmd
 });
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { basename as basename2, join as join7 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
+import { basename as basename2, join as join10 } from "path";
 function nowIso2() {
   return new Date().toISOString();
 }
@@ -8069,21 +8187,21 @@ function makeEvent(actor, type, payload) {
   };
 }
 function readStoryFrontmatter(repoRoot, ticket) {
-  const path = join7(repoRoot, ".xera", ticket, "story.md");
-  if (!existsSync7(path))
+  const path = join10(repoRoot, ".xera", ticket, "story.md");
+  if (!existsSync8(path))
     return null;
-  const raw = readFileSync5(path, "utf8");
+  const raw = readFileSync7(path, "utf8");
   const m = raw.match(/^---\n([\s\S]*?)\n---/);
   if (!m)
     return null;
   return $parse(m[1]);
 }
 function readGraphInput(repoRoot, ticket) {
-  const path = join7(repoRoot, ".xera", ticket, "graph-input.json");
-  if (!existsSync7(path))
+  const path = join10(repoRoot, ".xera", ticket, "graph-input.json");
+  if (!existsSync8(path))
     return { modifiesAreas: [] };
   try {
-    return JSON.parse(readFileSync5(path, "utf8"));
+    return JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return { modifiesAreas: [] };
   }
@@ -8132,11 +8250,11 @@ async function recordScript(repoRoot, ticket) {
 }
 async function recordExec(repoRoot, ticket, runId) {
   const { normalizedPath } = resolveArtifactPaths(repoRoot, ticket).runPath(runId);
-  if (!existsSync7(normalizedPath)) {
+  if (!existsSync8(normalizedPath)) {
     console.error(`[graph-record exec] normalized.json missing`);
     return 1;
   }
-  const data = JSON.parse(readFileSync5(normalizedPath, "utf8"));
+  const data = JSON.parse(readFileSync7(normalizedPath, "utf8"));
   const events = [];
   for (const s of data.scenarios) {
     if (s.outcome === "SKIPPED")
@@ -8155,12 +8273,12 @@ async function recordExec(repoRoot, ticket, runId) {
 }
 async function recordClassify(repoRoot, ticket, runId) {
   const { ticketDir } = resolveArtifactPaths(repoRoot, ticket);
-  const classifyPath = join7(ticketDir, "classifier-input.json");
-  if (!existsSync7(classifyPath)) {
+  const classifyPath = join10(ticketDir, "classifier-input.json");
+  if (!existsSync8(classifyPath)) {
     console.error(`[graph-record classify] classifier-input.json missing`);
     return 1;
   }
-  const data = JSON.parse(readFileSync5(classifyPath, "utf8"));
+  const data = JSON.parse(readFileSync7(classifyPath, "utf8"));
   const events = [];
   for (const s of data.scenarios) {
     const p = {
@@ -8302,11 +8420,11 @@ var exports_graph_backfill = {};
 __export(exports_graph_backfill, {
   graphBackfillCmd: () => graphBackfillCmd
 });
-import { existsSync as existsSync8, readdirSync as readdirSync3 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
+import { join as join11 } from "path";
 async function backfillTicket(repoRoot, ticket, dryRun) {
-  const storyPath = join8(repoRoot, ".xera", ticket, "story.md");
-  if (!existsSync8(storyPath))
+  const storyPath = join11(repoRoot, ".xera", ticket, "story.md");
+  if (!existsSync9(storyPath))
     return 0;
   const { recordFetch: recordFetch2 } = await Promise.resolve().then(() => (init_graph_record(), exports_graph_record));
   if (dryRun) {
@@ -8320,8 +8438,8 @@ async function backfillTicket(repoRoot, ticket, dryRun) {
 async function graphBackfillCmd(argv) {
   const dryRun = argv.includes("--dry-run");
   const repoRoot = process.cwd();
-  const xeraDir = join8(repoRoot, ".xera");
-  if (!existsSync8(xeraDir)) {
+  const xeraDir = join11(repoRoot, ".xera");
+  if (!existsSync9(xeraDir)) {
     console.log("[backfill] no .xera/ directory");
     return 0;
   }
@@ -8350,109 +8468,246 @@ var init_graph_backfill = __esm(() => {
 // bin/internal.ts
 var import_dotenv = __toESM(require_main(), 1);
 
-// src/bin-internal/auth-setup.ts
-import { existsSync as existsSync2 } from "fs";
+// src/bin-internal/ac-coverage-backfill-finalize.ts
+init_store();
+init_ulid();
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { join as join2 } from "path";
+import { z as z2 } from "zod";
+var DecisionsSchema = z2.object({
+  mappings: z2.array(z2.object({
+    scenarioId: z2.string().min(1),
+    satisfiesAcs: z2.array(z2.number().int().nonnegative()),
+    confidence: z2.number().min(0).max(1)
+  }))
+});
+function parseArgs(argv) {
+  const args = {};
+  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") {} else {
+      console.error(`[ac-coverage-backfill-finalize] unknown flag: ${a}`);
+      return args;
+    }
+  }
+  return args;
+}
+async function acCoverageBackfillFinalizeCmd(argv) {
+  const args = parseArgs(argv);
+  const cwd = process.cwd();
+  const inputPath = args.inputFile ?? join2(cwd, ".xera/coverage/ac-backfill-decisions.json");
+  if (!existsSync2(inputPath)) {
+    console.error(`[ac-coverage-backfill-finalize] decisions file not found: ${inputPath}`);
+    return 2;
+  }
+  let parsed;
+  try {
+    const raw = JSON.parse(readFileSync2(inputPath, "utf8"));
+    parsed = DecisionsSchema.parse(raw);
+  } catch (e) {
+    console.error(`[ac-coverage-backfill-finalize] invalid decisions: ${e.message}`);
+    return 2;
+  }
+  if (parsed.mappings.length === 0)
+    return 0;
+  const byTicket = {};
+  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_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;
+}
+
+// src/bin-internal/ac-coverage-backfill-prepare.ts
+init_store();
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+function findUnmapped(snap) {
+  const out = [];
+  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 };
+}
+function parseArgs2(argv) {
+  const args = {};
+  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") {} else {
+      console.error(`[ac-coverage-backfill-prepare] unknown flag: ${a}`);
+      return args;
+    }
+  }
+  return args;
+}
+async function acCoverageBackfillPrepareCmd(argv) {
+  const args = parseArgs2(argv);
+  const cwd = process.cwd();
+  const snap = deriveSnapshot(loadAllEvents(cwd));
+  const input = findUnmapped(snap);
+  const outDir = join3(cwd, ".xera/coverage");
+  mkdirSync2(outDir, { recursive: true });
+  const outPath = args.outputFile ?? join3(outDir, "ac-backfill-input.json");
+  writeFileSync2(outPath, JSON.stringify(input, null, 2));
+  return 0;
+}
+
+// src/bin-internal/auth-setup.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/config/load.ts
-import { existsSync } from "fs";
-import { join } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
 import { pathToFileURL } from "url";
 
 // src/config/schema.ts
-import { z } from "zod";
-var AuthRoleSchema = z.object({
-  envEmail: z.string().min(1),
-  envPassword: z.string().min(1)
+import { z as z3 } from "zod";
+var AuthRoleSchema = z3.object({
+  envEmail: z3.string().min(1),
+  envPassword: z3.string().min(1)
 });
-var AuthSchema = z.object({
-  strategy: z.enum(["storageState", "apiToken", "none"]).default("none"),
-  ttl: z.string().default("8h"),
-  refreshBuffer: z.string().default("30m"),
-  setupScript: z.string().optional(),
-  roles: z.record(z.string(), AuthRoleSchema).default({})
+var AuthSchema = z3.object({
+  strategy: z3.enum(["storageState", "apiToken", "none"]).default("none"),
+  ttl: z3.string().default("8h"),
+  refreshBuffer: z3.string().default("30m"),
+  setupScript: z3.string().optional(),
+  roles: z3.record(z3.string(), AuthRoleSchema).default({})
 });
-var WebSchema = z.object({
-  baseUrl: z.record(z.string(), z.string().url()).refine((m) => Object.keys(m).length > 0, {
+var WebSchema = z3.object({
+  baseUrl: z3.record(z3.string(), z3.string().url()).refine((m) => Object.keys(m).length > 0, {
     message: "baseUrl must have at least one environment"
   }),
-  defaultEnv: z.string(),
+  defaultEnv: z3.string(),
   auth: AuthSchema.prefault({}),
-  testData: z.object({
-    users: z.record(z.string(), z.object({ fromAuth: z.string() })).default({})
+  testData: z3.object({
+    users: z3.record(z3.string(), z3.object({ fromAuth: z3.string() })).default({})
   }).prefault({})
 }).refine((w) => w.baseUrl[w.defaultEnv] !== undefined, {
   message: "defaultEnv must exist in baseUrl map",
   path: ["defaultEnv"]
 });
-var HttpAuthRoleSchema = z.object({
-  tokenEnv: z.string().optional(),
-  userEnv: z.string().optional(),
-  passEnv: z.string().optional(),
-  tokenUrl: z.string().url().optional(),
-  clientIdEnv: z.string().optional(),
-  clientSecretEnv: z.string().optional(),
-  scope: z.string().optional()
+var HttpAuthRoleSchema = z3.object({
+  tokenEnv: z3.string().optional(),
+  userEnv: z3.string().optional(),
+  passEnv: z3.string().optional(),
+  tokenUrl: z3.string().url().optional(),
+  clientIdEnv: z3.string().optional(),
+  clientSecretEnv: z3.string().optional(),
+  scope: z3.string().optional()
 });
-var HttpAuthSchema = z.object({
-  strategy: z.enum(["bearer", "apiKey", "basic", "oauth-cc", "custom", "none"]).default("none"),
-  ttl: z.string().default("8h"),
-  refreshBuffer: z.string().default("30m"),
-  roles: z.record(z.string(), HttpAuthRoleSchema).default({})
+var HttpAuthSchema = z3.object({
+  strategy: z3.enum(["bearer", "apiKey", "basic", "oauth-cc", "custom", "none"]).default("none"),
+  ttl: z3.string().default("8h"),
+  refreshBuffer: z3.string().default("30m"),
+  roles: z3.record(z3.string(), HttpAuthRoleSchema).default({})
 });
-var HttpSchema = z.object({
-  baseUrl: z.record(z.string(), z.string().url()).refine((m) => Object.keys(m).length > 0, {
+var HttpSchema = z3.object({
+  baseUrl: z3.record(z3.string(), z3.string().url()).refine((m) => Object.keys(m).length > 0, {
     message: "baseUrl must have at least one environment"
   }),
-  defaultEnv: z.string(),
-  spec: z.string().optional(),
+  defaultEnv: z3.string(),
+  spec: z3.string().optional(),
   auth: HttpAuthSchema.prefault({})
 }).refine((h) => h.baseUrl[h.defaultEnv] !== undefined, {
   message: "defaultEnv must exist in baseUrl map",
   path: ["defaultEnv"]
 });
-var JiraSchema = z.object({
-  baseUrl: z.string().url(),
-  projectKeys: z.array(z.string().min(1)).min(1),
-  fields: z.object({
-    story: z.string().min(1),
-    acceptanceCriteria: z.string().optional(),
-    attachments: z.string().default("attachment")
+var JiraSchema = z3.object({
+  baseUrl: z3.string().url(),
+  projectKeys: z3.array(z3.string().min(1)).min(1),
+  fields: z3.object({
+    story: z3.string().min(1),
+    acceptanceCriteria: z3.string().optional(),
+    attachments: z3.string().default("attachment")
   })
 });
-var AISchema = z.object({
-  livePageSnapshot: z.boolean().default(true),
-  confidenceThreshold: z.enum(["low", "medium", "high"]).default("medium"),
-  maxRetries: z.object({
-    typecheck: z.number().int().min(0).max(5).default(2),
-    lint: z.number().int().min(0).max(5).default(2),
-    validateFeature: z.number().int().min(0).max(5).default(2)
+var AISchema = z3.object({
+  livePageSnapshot: z3.boolean().default(true),
+  confidenceThreshold: z3.enum(["low", "medium", "high"]).default("medium"),
+  maxRetries: z3.object({
+    typecheck: z3.number().int().min(0).max(5).default(2),
+    lint: z3.number().int().min(0).max(5).default(2),
+    validateFeature: z3.number().int().min(0).max(5).default(2)
   }).prefault({})
 }).prefault({});
-var ReportingSchema = z.object({
-  language: z.enum(["en", "vi"]).default("en"),
-  postToJira: z.boolean().default(true),
-  transition: z.object({
-    onPass: z.string().nullable().default(null),
-    onFail: z.string().nullable().default(null)
+var ReportingSchema = z3.object({
+  language: z3.enum(["en", "vi"]).default("en"),
+  postToJira: z3.boolean().default(true),
+  transition: z3.object({
+    onPass: z3.string().nullable().default(null),
+    onFail: z3.string().nullable().default(null)
   }).prefault({}),
-  artifactLinks: z.enum(["git", "local"]).default("git")
+  artifactLinks: z3.enum(["git", "local"]).default("git")
 }).prefault({});
-var RunSchema = z.object({
-  autoImpact: z.object({
-    enabled: z.boolean().default(true),
-    threshold: z.number().nonnegative().default(8)
+var RunSchema = z3.object({
+  autoImpact: z3.object({
+    enabled: z3.boolean().default(true),
+    threshold: z3.number().nonnegative().default(8)
   }).prefault({})
 }).prefault({});
-var XeraConfigSchema = z.object({
+var CoverageSchema = z3.object({
+  staleAfterDays: z3.number().int().positive().default(30),
+  criticalAreas: z3.array(z3.string().regex(/^[a-z0-9-]+$/)).default([]),
+  autoSnapshotOnCoverage: z3.boolean().default(true)
+}).prefault({});
+var XeraConfigSchema = z3.object({
   jira: JiraSchema,
   web: WebSchema.optional(),
   http: HttpSchema.optional(),
   ai: AISchema,
   reporting: ReportingSchema,
   run: RunSchema.prefault({}),
-  adapters: z.array(z.enum(["web", "http"])).min(1).default(["web"])
+  coverage: CoverageSchema,
+  adapters: z3.array(z3.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"
 }).refine((c) => c.adapters.every((a) => (a === "web" ? c.web : c.http) !== undefined), {
@@ -8462,8 +8717,8 @@ var XeraConfigSchema = z.object({
 
 // src/config/load.ts
 async function loadConfig(cwd) {
-  const path = join(cwd, "xera.config.ts");
-  if (!existsSync(path)) {
+  const path = join4(cwd, "xera.config.ts");
+  if (!existsSync3(path)) {
     throw new Error(`xera.config.ts not found in ${cwd}`);
   }
   const mod = await import(pathToFileURL(path).href);
@@ -8492,8 +8747,8 @@ async function authSetupCmd(argv) {
   const opts = parseOpts(argv);
   const cwd = process.cwd();
   const config = await loadConfig(cwd);
-  const authSetupScript = join2(cwd, "shared", "auth-setup.ts");
-  if (!existsSync2(authSetupScript)) {
+  const authSetupScript = join5(cwd, "shared", "auth-setup.ts");
+  if (!existsSync4(authSetupScript)) {
     console.error(`[xera:auth-setup] auth-setup.ts not found at ${authSetupScript}. Run 'bunx @xera-ai/cli init' first.`);
     return 1;
   }
@@ -8519,7 +8774,7 @@ async function authSetupCmd(argv) {
             role: roleName,
             creds: { email, password },
             setupScriptPath: authSetupScript,
-            authDir: join2(cwd, ".xera", ".auth"),
+            authDir: join5(cwd, ".xera", ".auth"),
             browser
           });
           console.log(`[xera:auth-setup] \u2713 ${roleName}.json (web)`);
@@ -8540,7 +8795,7 @@ async function authSetupCmd(argv) {
         continue;
       try {
         await runHttpAuthSetup({
-          authDir: join2(cwd, ".xera", ".auth"),
+          authDir: join5(cwd, ".xera", ".auth"),
           role: roleName,
           config: config.http,
           setupFn: mod.http,
@@ -8556,6 +8811,401 @@ async function authSetupCmd(argv) {
   return exitCode;
 }
 
+// src/bin-internal/coverage-prepare.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join6 } from "path";
+
+// src/coverage/status.ts
+function daysBetween(a, b) {
+  return Math.abs(a.getTime() - b.getTime()) / (1000 * 60 * 60 * 24);
+}
+function computeScenarioStatus(scenarioId, snap, windowDays, now) {
+  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";
+}
+function computeAreaStatus(areaId, snap, windowDays, now) {
+  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";
+}
+function computeAcStatus(acId, snap, windowDays, now) {
+  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";
+}
+function computeTicketStatus(ticketId, snap, windowDays, now) {
+  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";
+}
+
+// src/coverage/risk.ts
+var RISK_WEIGHTS = {
+  criticalBoost: 2,
+  bugClassifications: new Set(["REAL_BUG", "TEST_OUTDATED"]),
+  recencyBoosts: { recent: 2, withinWindow: 1, older: 0.5 },
+  recencyThresholdDays: 7
+};
+function daysBetween2(a, b) {
+  return Math.abs(a.getTime() - b.getTime()) / (1000 * 60 * 60 * 24);
+}
+function 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 !== undefined).filter((t) => daysBetween2(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) => daysBetween2(now, new Date(c.ts)) <= config.staleAfterDays).length;
+  const criticalBoost = config.criticalAreas.includes(areaId) ? RISK_WEIGHTS.criticalBoost : 1;
+  return recentTickets * criticalBoost + recentBugs;
+}
+function computeAcGapScore(ticketId, snap, config, now) {
+  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 = daysBetween2(now, new Date(ticket.fetchedAt));
+  let boost;
+  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;
+}
+
+// src/coverage/report.ts
+var STATUS_RANK = {
+  UNCOVERED: 0,
+  STALE: 1,
+  COVERED: 2
+};
+function daysBetween3(a, b) {
+  return Math.abs(a.getTime() - b.getTime()) / (1000 * 60 * 60 * 24);
+}
+function buildCoverageReport(snap, config, now) {
+  const areas = 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 !== undefined).filter((t) => daysBetween3(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) => daysBetween3(now, new Date(c.ts)) <= config.staleAfterDays).length;
+    const criticalBoost = 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 = 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) {
+  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;
+}
+function pad(s, n) {
+  return s.length >= n ? s : `${s}${" ".repeat(n - s.length)}`;
+}
+function renderMarkdown(report, options = {}) {
+  const lines = [];
+  const dateOnly = report.generatedAt.slice(0, 10);
+  lines.push("", `Coverage report \u2014 generated ${dateOnly} \xB7 window ${report.windowDays}d`, "");
+  const uncovered = report.areas.filter((a) => a.status === "UNCOVERED");
+  if (uncovered.length > 0) {
+    lines.push(`UNCOVERED \u2014 ${uncovered.length} area${uncovered.length === 1 ? "" : "s"}, sorted by risk`);
+    lines.push("");
+    uncovered.forEach((a, i) => {
+      const parts = [`${a.breakdown.recentTickets} tickets`];
+      if (a.breakdown.recentBugs > 0)
+        parts.push(`${a.breakdown.recentBugs} bugs`);
+      if (a.breakdown.criticalBoost === 2)
+        parts.push("critical \xD72");
+      lines.push(`  #${i + 1}  ${pad(a.id, 10)} risk ${a.risk}    ${parts.join(" \xB7 ")}`);
+    });
+    lines.push("");
+  }
+  const stale = report.areas.filter((a) => a.status === "STALE");
+  if (stale.length > 0) {
+    lines.push(`STALE \u2014 ${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 \u2014 ${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 \xB7 gap_score ${t.gapScore}`);
+      for (const ac of t.unsatisfiedAcs) {
+        lines.push(`    \u2717 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 \u2014 ${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 \u2014 ${covered.length} area${covered.length === 1 ? "" : "s"} (collapsed; show with --all)`);
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+// src/coverage/why.ts
+function daysBetween4(a, b) {
+  return Math.abs(a.getTime() - b.getTime()) / (1000 * 60 * 60 * 24);
+}
+function pad2(s, n) {
+  return s.length >= n ? s : `${s}${" ".repeat(n - s.length)}`;
+}
+function buildWhyArea(areaId, snap, config, now) {
+  if (snap.areas[areaId] === undefined)
+    return `Unknown area: ${areaId}
+`;
+  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 !== undefined).filter((t) => daysBetween4(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) => daysBetween4(now, new Date(c.ts)) <= config.staleAfterDays);
+  const boost = isCritical ? 2 : 1;
+  const lines = [
+    "",
+    `Area: ${areaId} (${heading})`,
+    "",
+    `Risk score: ${risk}`,
+    "  recent_tickets \xD7 critical_boost + recent_bugs",
+    `  = ${recentTickets.length} \xD7 ${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)}  ${pad2(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(`
+`)}
+`;
+}
+function buildWhyTicket(ticketId, snap, config, now) {
+  const ticket = snap.tickets[ticketId];
+  if (!ticket)
+    return `Unknown ticket: ${ticketId}
+`;
+  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 = daysBetween4(now, new Date(ticket.fetchedAt));
+  let boostLabel;
+  if (days <= RISK_WEIGHTS.recencyThresholdDays)
+    boostLabel = "\xD72.0";
+  else if (days <= config.staleAfterDays)
+    boostLabel = "\xD71.0";
+  else
+    boostLabel = "\xD70.5";
+  const lines = [
+    "",
+    `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" ? "\u2713" : "\u2717";
+    const satisfyingScenarios = snap.edges.filter((e) => e.kind === "satisfies" && e.to === ac.id).map((e) => e.from);
+    const scenarioRef = satisfyingScenarios.length > 0 ? ` \u2014 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(`
+`)}
+`;
+}
+// src/bin-internal/coverage-prepare.ts
+init_store();
+init_ulid();
+function parseArgs3(argv) {
+  const args = { 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") {} else {
+      console.error(`[coverage-prepare] unknown flag: ${a}`);
+      return { ...args, emitEvent: false };
+    }
+  }
+  return args;
+}
+var TICKET_RE = /^[A-Z][A-Z0-9]*-\d+$/;
+async function coveragePrepareCmd(argv) {
+  const args = parseArgs3(argv);
+  const cwd = process.cwd();
+  let config;
+  try {
+    config = await loadConfig(cwd);
+  } catch (e) {
+    console.error(`[coverage-prepare] ${e.message}`);
+    return 2;
+  }
+  let snap;
+  if (args.snapshotFile) {
+    snap = JSON.parse(readFileSync3(args.snapshotFile, "utf8"));
+  } 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)}
+`);
+    return 0;
+  }
+  const outDir = join6(cwd, ".xera/coverage");
+  mkdirSync3(outDir, { recursive: true });
+  writeFileSync3(join6(outDir, "report.json"), JSON.stringify(report, null, 2));
+  const renderOpts = { includeCovered: args.all };
+  writeFileSync3(join6(outDir, "report.md"), renderMarkdown(report, renderOpts));
+  if (args.emitEvent && config.coverage.autoSnapshotOnCoverage) {
+    const 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;
+}
+
 // src/bin-internal/disputes.ts
 init_store();
 function parseDuration(s) {
@@ -8632,19 +9282,19 @@ async function disputesCmd(argv) {
 }
 
 // src/bin-internal/doctor.ts
-import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
+import { join as join12 } from "path";
 
 // src/graph/cost.ts
-import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "fs";
+import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4 } from "fs";
 init_paths();
 function summarizeCost(repoRoot, daysBack) {
   const paths = graphPaths(repoRoot);
   const result = { totalCalls: 0, totalUsd: 0, bySkill: {}, windowDays: daysBack };
-  if (!existsSync4(paths.costLog))
+  if (!existsSync5(paths.costLog))
     return result;
   const cutoff = Date.now() - daysBack * 86400 * 1000;
-  for (const line of readFileSync2(paths.costLog, "utf8").split(`
+  for (const line of readFileSync4(paths.costLog, "utf8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -8671,8 +9321,8 @@ function summarizeCost(repoRoot, daysBack) {
 init_store();
 
 // src/bin-internal/verify-prompts.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
 var IN_SCOPE_PROMPTS = [
   "feature-from-story.md",
   "script-from-feature-web.md",
@@ -8680,23 +9330,25 @@ var IN_SCOPE_PROMPTS = [
   "heal-locator.md",
   "extract-areas.md",
   "similarity-match.md",
-  "classify-outdated.md"
+  "classify-outdated.md",
+  "map-ac-to-scenarios.md",
+  "propose-scenarios.md"
 ];
 var REQUIRED_SECTION_HEADING = "## Handling untrusted input";
 var REQUIRED_KEYWORDS = ["UNTRUSTED", "injection-follow", "<XR_"];
 function verifyPrompts(repoRoot) {
-  const promptsDir = join4(repoRoot, "packages/prompts");
+  const promptsDir = join7(repoRoot, "packages/prompts");
   const results = [];
   for (const filename of IN_SCOPE_PROMPTS) {
-    const path = join4(promptsDir, filename);
-    if (!existsSync5(path)) {
+    const path = join7(promptsDir, filename);
+    if (!existsSync6(path)) {
       results.push({
         ok: false,
         message: `${filename}: file missing at packages/prompts/${filename}`
       });
       continue;
     }
-    const text = readFileSync3(path, "utf8");
+    const text = readFileSync5(path, "utf8");
     if (!text.includes(REQUIRED_SECTION_HEADING)) {
       results.push({
         ok: false,
@@ -8744,8 +9396,8 @@ function frontmatterField(content, field) {
   return m?.[1] ?? null;
 }
 function checkGoldenEvalDir(repoRoot) {
-  const root = join9(repoRoot, "fixtures/golden-eval");
-  if (!existsSync9(root))
+  const root = join12(repoRoot, "fixtures/golden-eval");
+  if (!existsSync10(root))
     return [{ ok: false, message: "fixtures/golden-eval/ does not exist" }];
   const dirs = readdirSync4(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("."));
   const results = [];
@@ -8756,15 +9408,15 @@ function checkGoldenEvalDir(repoRoot) {
     });
   }
   for (const entry of dirs) {
-    const dir = join9(root, entry.name);
-    const metaPath = join9(dir, "meta.json");
-    if (!existsSync9(metaPath)) {
+    const dir = join12(root, entry.name);
+    const metaPath = join12(dir, "meta.json");
+    if (!existsSync10(metaPath)) {
       results.push({ ok: false, message: `${entry.name}: meta.json missing` });
       continue;
     }
     let meta;
     try {
-      meta = JSON.parse(readFileSync6(metaPath, "utf8"));
+      meta = JSON.parse(readFileSync8(metaPath, "utf8"));
     } catch (err) {
       results.push({
         ok: false,
@@ -8775,12 +9427,12 @@ function checkGoldenEvalDir(repoRoot) {
     const stages = Array.isArray(meta.stages) ? meta.stages : [];
     if (stages.length === 0)
       results.push({ ok: false, message: `${entry.name}: meta.stages is empty` });
-    if (!existsSync9(join9(dir, "story.md")))
+    if (!existsSync10(join12(dir, "story.md")))
       results.push({ ok: false, message: `${entry.name}: story.md missing` });
     for (const stage of stages) {
       const required = REQUIRED_FILES_PER_STAGE[stage] ?? [];
       for (const rel of required) {
-        if (!existsSync9(join9(dir, rel))) {
+        if (!existsSync10(join12(dir, rel))) {
           results.push({
             ok: false,
             message: `${meta.id ?? entry.name}: stage "${stage}" declared but ${rel} missing`
@@ -8792,10 +9444,10 @@ function checkGoldenEvalDir(repoRoot) {
   return results;
 }
 function checkRubricPrompt(repoRoot) {
-  const path = join9(repoRoot, "packages/prompts/eval-rubric.md");
-  if (!existsSync9(path))
+  const path = join12(repoRoot, "packages/prompts/eval-rubric.md");
+  if (!existsSync10(path))
     return [{ ok: false, message: "packages/prompts/eval-rubric.md missing" }];
-  const text = readFileSync6(path, "utf8");
+  const text = readFileSync8(path, "utf8");
   const id = frontmatterField(text, "id");
   const version = frontmatterField(text, "version");
   if (id !== "eval-rubric")
@@ -8805,10 +9457,10 @@ function checkRubricPrompt(repoRoot) {
   return [];
 }
 function checkEvalSkill(repoRoot) {
-  const path = join9(repoRoot, "packages/skills/xera-eval.md");
-  if (!existsSync9(path))
+  const path = join12(repoRoot, "packages/skills/xera-eval.md");
+  if (!existsSync10(path))
     return [{ ok: false, message: "packages/skills/xera-eval.md missing" }];
-  const text = readFileSync6(path, "utf8");
+  const text = readFileSync8(path, "utf8");
   if (!frontmatterField(text, "name"))
     return [{ ok: false, message: 'xera-eval.md frontmatter "name" missing' }];
   return [];
@@ -8817,16 +9469,16 @@ function checkPromptInjectionPreamble(repoRoot) {
   return verifyPrompts(repoRoot);
 }
 function checkRootScripts(repoRoot) {
-  const path = join9(repoRoot, "package.json");
-  if (!existsSync9(path))
+  const path = join12(repoRoot, "package.json");
+  if (!existsSync10(path))
     return [{ ok: false, message: "root package.json missing" }];
-  const pkg = JSON.parse(readFileSync6(path, "utf8"));
+  const pkg = JSON.parse(readFileSync8(path, "utf8"));
   const scripts = pkg.scripts ?? {};
   const missing = REQUIRED_SCRIPTS.filter((s) => typeof scripts[s] !== "string");
   return missing.map((s) => ({ ok: false, message: `root package.json missing script: ${s}` }));
 }
 function isXeraMonorepo(repoRoot) {
-  return existsSync9(join9(repoRoot, "packages/skills")) && existsSync9(join9(repoRoot, "packages/prompts"));
+  return existsSync10(join12(repoRoot, "packages/skills")) && existsSync10(join12(repoRoot, "packages/prompts"));
 }
 async function doctorCmd(argv, opts = {}) {
   const repoRoot = opts.cwd ?? process.cwd();
@@ -8848,8 +9500,8 @@ async function doctorCmd(argv, opts = {}) {
     if (top)
       console.log(`  Top skill:   ${top[0]} (${top[1].calls} calls, $${top[1].usd.toFixed(2)})`);
   }
-  const xeraDir = join9(repoRoot, ".xera");
-  if (existsSync9(xeraDir)) {
+  const xeraDir = join12(repoRoot, ".xera");
+  if (existsSync10(xeraDir)) {
     const ticketDirs = readdirSync4(xeraDir, { withFileTypes: true }).filter((e) => e.isDirectory() && /^[A-Z]+-\d+$/.test(e.name));
     if (ticketDirs.length > 0) {
       const events = loadAllEvents(repoRoot);
@@ -8884,115 +9536,115 @@ async function doctorCmd(argv, opts = {}) {
 }
 
 // src/bin-internal/eval-deterministic.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+import { join as join14 } from "path";
 import { validateGherkin } from "@xera-ai/web";
 
 // src/eval/paths.ts
-import { join as join10 } from "path";
+import { join as join13 } from "path";
 function resolveEvalPaths(cwd, runId) {
-  const root = join10(cwd, ".xera", "eval", runId);
+  const root = join13(cwd, ".xera", "eval", runId);
   return {
     root,
-    manifest: join10(root, "manifest.json"),
-    lock: join10(root, ".lock"),
-    deterministicScores: join10(root, "deterministic-scores.json"),
-    judgeScores: join10(root, "judge-scores.json"),
-    report: join10(root, "report.md"),
-    summary: join10(root, "summary.json"),
-    inputsDir: join10(root, "inputs"),
-    actualDir: join10(root, "actual"),
-    ticketInputsDir: (ticket) => join10(root, "inputs", ticket),
-    ticketActualDir: (ticket) => join10(root, "actual", ticket)
+    manifest: join13(root, "manifest.json"),
+    lock: join13(root, ".lock"),
+    deterministicScores: join13(root, "deterministic-scores.json"),
+    judgeScores: join13(root, "judge-scores.json"),
+    report: join13(root, "report.md"),
+    summary: join13(root, "summary.json"),
+    inputsDir: join13(root, "inputs"),
+    actualDir: join13(root, "actual"),
+    ticketInputsDir: (ticket) => join13(root, "inputs", ticket),
+    ticketActualDir: (ticket) => join13(root, "actual", ticket)
   };
 }
 
 // src/eval/types.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var STAGES = ["feature-from-story", "script-from-feature", "diagnose-failure"];
-var StageSchema = z3.enum(STAGES);
-var VerdictSchema = z3.enum(["PASS", "FAIL", "NA"]);
-var PromptVersionsSchema = z3.object({
-  "feature-from-story": z3.string(),
-  "script-from-feature": z3.string(),
-  "diagnose-failure": z3.string(),
-  "eval-rubric": z3.string()
+var StageSchema = z4.enum(STAGES);
+var VerdictSchema = z4.enum(["PASS", "FAIL", "NA"]);
+var PromptVersionsSchema = z4.object({
+  "feature-from-story": z4.string(),
+  "script-from-feature": z4.string(),
+  "diagnose-failure": z4.string(),
+  "eval-rubric": z4.string()
 });
-var ManifestSchema = z3.object({
-  run_id: z3.string(),
-  started_at: z3.string(),
-  git_sha: z3.string(),
-  tickets: z3.array(z3.string()).min(1),
-  stages: z3.array(StageSchema).min(1),
-  ticket_stages: z3.record(z3.string(), z3.array(StageSchema).min(1)),
+var ManifestSchema = z4.object({
+  run_id: z4.string(),
+  started_at: z4.string(),
+  git_sha: z4.string(),
+  tickets: z4.array(z4.string()).min(1),
+  stages: z4.array(StageSchema).min(1),
+  ticket_stages: z4.record(z4.string(), z4.array(StageSchema).min(1)),
   prompt_versions: PromptVersionsSchema,
-  flags: z3.object({
-    force: z3.boolean(),
+  flags: z4.object({
+    force: z4.boolean(),
     only_prompt: StageSchema.nullable(),
-    only_ticket: z3.string().nullable(),
-    judge_only: z3.boolean()
+    only_ticket: z4.string().nullable(),
+    judge_only: z4.boolean()
   })
 });
-var DimensionSchema = z3.object({
-  name: z3.string(),
+var DimensionSchema = z4.object({
+  name: z4.string(),
   verdict: VerdictSchema,
-  notes: z3.string()
+  notes: z4.string()
 });
-var JudgmentSchema = z3.object({
+var JudgmentSchema = z4.object({
   stage: StageSchema,
-  ticket: z3.string(),
-  dimensions: z3.array(DimensionSchema).min(1)
+  ticket: z4.string(),
+  dimensions: z4.array(DimensionSchema).min(1)
 });
-var JudgeScoresSchema = z3.object({
-  run_id: z3.string(),
-  judgments: z3.array(JudgmentSchema)
+var JudgeScoresSchema = z4.object({
+  run_id: z4.string(),
+  judgments: z4.array(JudgmentSchema)
 });
-var DeterministicEntrySchema = z3.object({
-  ticket: z3.string(),
+var DeterministicEntrySchema = z4.object({
+  ticket: z4.string(),
   stage: StageSchema,
-  passed: z3.boolean(),
-  checks: z3.array(z3.string()),
-  error: z3.string().optional()
+  passed: z4.boolean(),
+  checks: z4.array(z4.string()),
+  error: z4.string().optional()
 });
-var DeterministicScoresSchema = z3.object({
-  run_id: z3.string(),
-  entries: z3.array(DeterministicEntrySchema)
+var DeterministicScoresSchema = z4.object({
+  run_id: z4.string(),
+  entries: z4.array(DeterministicEntrySchema)
 });
-var ResultSchema = z3.object({
-  ticket: z3.string(),
+var ResultSchema = z4.object({
+  ticket: z4.string(),
   stage: StageSchema,
-  deterministic: z3.object({
-    passed: z3.boolean(),
-    checks: z3.array(z3.string()),
-    error: z3.string().optional()
+  deterministic: z4.object({
+    passed: z4.boolean(),
+    checks: z4.array(z4.string()),
+    error: z4.string().optional()
   }),
-  judge: z3.object({
-    passed: z3.boolean(),
-    dimensions: z3.array(DimensionSchema),
-    score: z3.number().min(0).max(1)
+  judge: z4.object({
+    passed: z4.boolean(),
+    dimensions: z4.array(DimensionSchema),
+    score: z4.number().min(0).max(1)
   }).nullable(),
-  skipped: z3.boolean().optional()
+  skipped: z4.boolean().optional()
 });
-var SummarySchema = z3.object({
-  run_id: z3.string(),
-  git_sha: z3.string(),
+var SummarySchema = z4.object({
+  run_id: z4.string(),
+  git_sha: z4.string(),
   prompt_versions: PromptVersionsSchema,
-  results: z3.array(ResultSchema),
-  overall: z3.object({
-    passed: z3.number().int().nonnegative(),
-    failed: z3.number().int().nonnegative(),
-    total: z3.number().int().nonnegative(),
-    score: z3.number().min(0).max(1)
+  results: z4.array(ResultSchema),
+  overall: z4.object({
+    passed: z4.number().int().nonnegative(),
+    failed: z4.number().int().nonnegative(),
+    total: z4.number().int().nonnegative(),
+    score: z4.number().min(0).max(1)
   })
 });
 
 // src/bin-internal/eval-deterministic.ts
 function checkFeatureFromStory(actualFeaturePath) {
-  if (!existsSync10(actualFeaturePath)) {
+  if (!existsSync11(actualFeaturePath)) {
     return { passed: false, checks: ["validate-feature"], error: "actual missing: test.feature" };
   }
   try {
-    const r = validateGherkin(readFileSync7(actualFeaturePath, "utf8"));
+    const r = validateGherkin(readFileSync9(actualFeaturePath, "utf8"));
     if (r.ok)
       return { passed: true, checks: ["validate-feature"] };
     return {
@@ -9005,31 +9657,31 @@ function checkFeatureFromStory(actualFeaturePath) {
   }
 }
 function checkScriptFromFeature(actualTicketDir) {
-  const specPath = join11(actualTicketDir, "spec.ts");
-  if (!existsSync10(specPath)) {
+  const specPath = join14(actualTicketDir, "spec.ts");
+  if (!existsSync11(specPath)) {
     return { passed: false, checks: ["file-presence"], error: "actual missing: spec.ts" };
   }
   return { passed: true, checks: ["file-presence"] };
 }
 function checkDiagnoseFailure(inputsTicketDir, actualTicketDir) {
-  const inputPath = join11(inputsTicketDir, "classifier-input.json");
-  const actualPath = join11(actualTicketDir, "classification.json");
-  if (!existsSync10(actualPath)) {
+  const inputPath = join14(inputsTicketDir, "classifier-input.json");
+  const actualPath = join14(actualTicketDir, "classification.json");
+  if (!existsSync11(actualPath)) {
     return {
       passed: false,
       checks: ["bucket-match"],
       error: "actual missing: classification.json"
     };
   }
-  if (!existsSync10(inputPath)) {
+  if (!existsSync11(inputPath)) {
     return {
       passed: false,
       checks: ["bucket-match"],
       error: "inputs missing: classifier-input.json"
     };
   }
-  const golden = JSON.parse(readFileSync7(inputPath, "utf8"));
-  const actual = JSON.parse(readFileSync7(actualPath, "utf8"));
+  const golden = JSON.parse(readFileSync9(inputPath, "utf8"));
+  const actual = JSON.parse(readFileSync9(actualPath, "utf8"));
   const goldScens = golden.scenarios ?? [];
   const actScens = actual.scenarios ?? [];
   const mismatches = [];
@@ -9059,11 +9711,11 @@ async function evalDeterministicCmd(argv, opts = {}) {
     return 1;
   }
   const paths = resolveEvalPaths(cwd, runId);
-  if (!existsSync10(paths.manifest)) {
+  if (!existsSync11(paths.manifest)) {
     console.error(`[xera:eval-deterministic] missing manifest.json at ${paths.manifest}`);
     return 1;
   }
-  const manifest = ManifestSchema.parse(JSON.parse(readFileSync7(paths.manifest, "utf8")));
+  const manifest = ManifestSchema.parse(JSON.parse(readFileSync9(paths.manifest, "utf8")));
   const entries = [];
   for (const [ticket, ticketStages] of Object.entries(manifest.ticket_stages)) {
     for (const stage of ticketStages) {
@@ -9071,7 +9723,7 @@ async function evalDeterministicCmd(argv, opts = {}) {
       const actualDir = paths.ticketActualDir(ticket);
       let result;
       if (stage === "feature-from-story") {
-        result = checkFeatureFromStory(join11(actualDir, "test.feature"));
+        result = checkFeatureFromStory(join14(actualDir, "test.feature"));
       } else if (stage === "script-from-feature") {
         result = checkScriptFromFeature(actualDir);
       } else {
@@ -9090,7 +9742,7 @@ async function evalDeterministicCmd(argv, opts = {}) {
   }
   const scores = { run_id: runId, entries };
   DeterministicScoresSchema.parse(scores);
-  writeFileSync2(paths.deterministicScores, JSON.stringify(scores, null, 2));
+  writeFileSync4(paths.deterministicScores, JSON.stringify(scores, null, 2));
   console.log(`[xera:eval-deterministic] wrote ${entries.length} entries`);
   return 0;
 }
@@ -9098,13 +9750,13 @@ async function evalDeterministicCmd(argv, opts = {}) {
 // src/bin-internal/eval-prepare.ts
 import {
   copyFileSync,
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync13,
+  mkdirSync as mkdirSync6,
   readdirSync as readdirSync5,
-  readFileSync as readFileSync9,
-  writeFileSync as writeFileSync4
+  readFileSync as readFileSync11,
+  writeFileSync as writeFileSync6
 } from "fs";
-import { join as join12 } from "path";
+import { join as join15 } from "path";
 
 // src/eval/run-id.ts
 import { execSync } from "child_process";
@@ -9115,27 +9767,27 @@ function defaultGetGitSha() {
     return null;
   }
 }
-function pad(n) {
+function pad3(n) {
   return n.toString().padStart(2, "0");
 }
 function generateRunId2(opts = {}) {
   const getGitSha = opts.getGitSha ?? defaultGetGitSha;
   const now = (opts.now ?? (() => new Date))();
-  const date = `${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}`;
-  const time = `${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`;
+  const date = `${now.getUTCFullYear()}${pad3(now.getUTCMonth() + 1)}${pad3(now.getUTCDate())}`;
+  const time = `${pad3(now.getUTCHours())}${pad3(now.getUTCMinutes())}${pad3(now.getUTCSeconds())}`;
   const sha = getGitSha();
   const short = sha ? sha.slice(0, 7) : "nogit";
   return `${date}-${time}-${short}`;
 }
 
 // src/lock/file-lock.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync10, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
 import { hostname } from "os";
 import { dirname as dirname2 } from "path";
 function acquireLock(path, runId) {
-  if (existsSync11(path))
+  if (existsSync12(path))
     return false;
-  mkdirSync3(dirname2(path), { recursive: true });
+  mkdirSync5(dirname2(path), { recursive: true });
   const data = {
     pid: process.pid,
     hostname: hostname(),
@@ -9143,20 +9795,20 @@ function acquireLock(path, runId) {
     run_id: runId
   };
   try {
-    writeFileSync3(path, JSON.stringify(data), { flag: "wx" });
+    writeFileSync5(path, JSON.stringify(data), { flag: "wx" });
     return true;
   } catch {
     return false;
   }
 }
 function releaseLock(path) {
-  if (existsSync11(path))
+  if (existsSync12(path))
     unlinkSync(path);
 }
 function readLock(path) {
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return null;
-  return JSON.parse(readFileSync8(path, "utf8"));
+  return JSON.parse(readFileSync10(path, "utf8"));
 }
 function isLockStale(path) {
   const lock = readLock(path);
@@ -9197,16 +9849,16 @@ function parseFlags2(argv) {
   return flags;
 }
 function readPromptVersion(repoRoot, name) {
-  const path = join12(repoRoot, "packages/prompts", `${name}.md`);
-  if (!existsSync12(path))
+  const path = join15(repoRoot, "packages/prompts", `${name}.md`);
+  if (!existsSync13(path))
     return "0.0.0";
-  const text = readFileSync9(path, "utf8");
+  const text = readFileSync11(path, "utf8");
   const m = /^version:\s*(\S+)\s*$/m.exec(text);
   return m?.[1] ?? "0.0.0";
 }
 function discoverEvalTickets(repoRoot) {
-  const root = join12(repoRoot, "fixtures/golden-eval");
-  if (!existsSync12(root))
+  const root = join15(repoRoot, "fixtures/golden-eval");
+  if (!existsSync13(root))
     return [];
   const out = [];
   for (const entry of readdirSync5(root, { withFileTypes: true })) {
@@ -9214,25 +9866,25 @@ function discoverEvalTickets(repoRoot) {
       continue;
     if (entry.name === "README.md" || entry.name.startsWith("."))
       continue;
-    const dir = join12(root, entry.name);
-    const metaPath = join12(dir, "meta.json");
-    if (!existsSync12(metaPath))
+    const dir = join15(root, entry.name);
+    const metaPath = join15(dir, "meta.json");
+    if (!existsSync13(metaPath))
       continue;
-    const meta = JSON.parse(readFileSync9(metaPath, "utf8"));
+    const meta = JSON.parse(readFileSync11(metaPath, "utf8"));
     out.push({ id: meta.id, dir, stages: meta.stages });
   }
   return out.sort((a, b) => a.id.localeCompare(b.id));
 }
 function discoverClassifierTickets(repoRoot) {
-  const root = join12(repoRoot, "fixtures/golden-tickets");
-  if (!existsSync12(root))
+  const root = join15(repoRoot, "fixtures/golden-tickets");
+  if (!existsSync13(root))
     return [];
   const out = [];
   for (const entry of readdirSync5(root, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".json"))
       continue;
-    const path = join12(root, entry.name);
-    const data = JSON.parse(readFileSync9(path, "utf8"));
+    const path = join15(root, entry.name);
+    const data = JSON.parse(readFileSync11(path, "utf8"));
     if (typeof data.ticket === "string")
       out.push({ id: data.ticket, path });
   }
@@ -9291,25 +9943,25 @@ async function evalPrepareCmd(argv, opts = {}) {
     ...opts.getGitSha ? { getGitSha: opts.getGitSha } : {}
   });
   const paths = resolveEvalPaths(repoRoot, runId);
-  if (existsSync12(paths.root) && !flags.force) {
+  if (existsSync13(paths.root) && !flags.force) {
     console.error(`[xera:eval-prepare] run dir already exists: ${paths.root}. Pass --force to re-run.`);
     return 1;
   }
-  mkdirSync4(paths.inputsDir, { recursive: true });
-  mkdirSync4(paths.actualDir, { recursive: true });
+  mkdirSync6(paths.inputsDir, { recursive: true });
+  mkdirSync6(paths.actualDir, { recursive: true });
   for (const ticket of selectedTickets) {
     const ticketInputs = paths.ticketInputsDir(ticket);
-    mkdirSync4(ticketInputs, { recursive: true });
+    mkdirSync6(ticketInputs, { recursive: true });
     const evalT = evalTickets.find((t) => t.id === ticket);
     const classT = classifierTickets.find((t) => t.id === ticket);
     if (evalT) {
-      copyFileSync(join12(evalT.dir, "story.md"), join12(ticketInputs, "story.md"));
-      const featurePath = join12(evalT.dir, "golden/test.feature");
-      if (existsSync12(featurePath))
-        copyFileSync(featurePath, join12(ticketInputs, "test.feature"));
+      copyFileSync(join15(evalT.dir, "story.md"), join15(ticketInputs, "story.md"));
+      const featurePath = join15(evalT.dir, "golden/test.feature");
+      if (existsSync13(featurePath))
+        copyFileSync(featurePath, join15(ticketInputs, "test.feature"));
     }
     if (classT) {
-      copyFileSync(classT.path, join12(ticketInputs, "classifier-input.json"));
+      copyFileSync(classT.path, join15(ticketInputs, "classifier-input.json"));
     }
   }
   const now = (opts.now ?? (() => new Date))();
@@ -9334,7 +9986,7 @@ async function evalPrepareCmd(argv, opts = {}) {
     }
   };
   ManifestSchema.parse(manifest);
-  writeFileSync4(paths.manifest, JSON.stringify(manifest, null, 2));
+  writeFileSync6(paths.manifest, JSON.stringify(manifest, null, 2));
   if (!acquireLock(paths.lock, runId)) {
     console.error(`[xera:eval-prepare] failed to acquire lock at ${paths.lock}`);
     return 4;
@@ -9345,7 +9997,7 @@ async function evalPrepareCmd(argv, opts = {}) {
 }
 
 // src/bin-internal/eval-report.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
 function scoreJudgment(j) {
   const nonNa = j.dimensions.filter((d) => d.verdict !== "NA");
   if (nonNa.length === 0)
@@ -9400,22 +10052,22 @@ async function evalReportCmd(argv, opts = {}) {
     return 1;
   }
   const paths = resolveEvalPaths(cwd, runId);
-  if (!existsSync13(paths.manifest)) {
+  if (!existsSync14(paths.manifest)) {
     console.error(`[xera:eval-report] missing manifest.json at ${paths.manifest}`);
     return 1;
   }
-  const manifest = ManifestSchema.parse(JSON.parse(readFileSync10(paths.manifest, "utf8")));
+  const manifest = ManifestSchema.parse(JSON.parse(readFileSync12(paths.manifest, "utf8")));
   try {
     let det;
     let judge;
     try {
-      det = DeterministicScoresSchema.parse(JSON.parse(readFileSync10(paths.deterministicScores, "utf8")));
+      det = DeterministicScoresSchema.parse(JSON.parse(readFileSync12(paths.deterministicScores, "utf8")));
     } catch (err) {
       console.error(`[xera:eval-report] invalid deterministic-scores.json: ${err.message}`);
       return 2;
     }
     try {
-      judge = JudgeScoresSchema.parse(JSON.parse(readFileSync10(paths.judgeScores, "utf8")));
+      judge = JudgeScoresSchema.parse(JSON.parse(readFileSync12(paths.judgeScores, "utf8")));
     } catch (err) {
       console.error(`[xera:eval-report] invalid judge-scores.json: ${err.message}`);
       return 2;
@@ -9477,8 +10129,8 @@ async function evalReportCmd(argv, opts = {}) {
       overall: { passed: passedCount, failed: failedCount, total: counted.length, score: avgScore }
     };
     SummarySchema.parse(summary);
-    writeFileSync5(paths.summary, JSON.stringify(summary, null, 2));
-    writeFileSync5(paths.report, renderReport(summary));
+    writeFileSync7(paths.summary, JSON.stringify(summary, null, 2));
+    writeFileSync7(paths.report, renderReport(summary));
     console.log(`[xera:eval-report] ${passedCount}/${counted.length} PASS (avg ${(avgScore * 100).toFixed(0)}%)`);
     return 0;
   } finally {
@@ -9487,37 +10139,37 @@ async function evalReportCmd(argv, opts = {}) {
 }
 
 // src/bin-internal/exec.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync8 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10 } from "fs";
+import { join as join17 } from "path";
 import { chromium } from "@playwright/test";
 import { runAuthSetup, runPlaywright, stagePlaywrightState } from "@xera-ai/web";
 
 // src/artifact/meta.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname3 } from "path";
-import { z as z4 } from "zod";
-var MetaJsonSchema = z4.object({
-  ticket: z4.string(),
-  adapter: z4.string(),
-  xera_version: z4.string(),
-  prompts_version: z4.string(),
-  fetched_at: z4.string().optional(),
-  story_hash: z4.string().optional(),
-  feature_generated_at: z4.string().optional(),
-  feature_generated_from_story_hash: z4.string().optional(),
-  feature_hash: z4.string().optional(),
-  script_generated_at: z4.string().optional(),
-  script_generated_from_feature_hash: z4.string().optional(),
-  script_warnings: z4.array(z4.string()).optional()
+import { z as z5 } from "zod";
+var MetaJsonSchema = z5.object({
+  ticket: z5.string(),
+  adapter: z5.string(),
+  xera_version: z5.string(),
+  prompts_version: z5.string(),
+  fetched_at: z5.string().optional(),
+  story_hash: z5.string().optional(),
+  feature_generated_at: z5.string().optional(),
+  feature_generated_from_story_hash: z5.string().optional(),
+  feature_hash: z5.string().optional(),
+  script_generated_at: z5.string().optional(),
+  script_generated_from_feature_hash: z5.string().optional(),
+  script_warnings: z5.array(z5.string()).optional()
 });
 function readMeta(path) {
-  if (!existsSync14(path))
+  if (!existsSync15(path))
     return null;
-  return MetaJsonSchema.parse(JSON.parse(readFileSync11(path, "utf8")));
+  return MetaJsonSchema.parse(JSON.parse(readFileSync13(path, "utf8")));
 }
 function writeMeta(path, meta) {
-  mkdirSync5(dirname3(path), { recursive: true });
-  writeFileSync6(path, JSON.stringify(meta, null, 2));
+  mkdirSync7(dirname3(path), { recursive: true });
+  writeFileSync8(path, JSON.stringify(meta, null, 2));
 }
 function updateMeta(path, patch) {
   const existing = readMeta(path);
@@ -9561,9 +10213,9 @@ function needsRefresh(entry, policy, now = new Date) {
 }
 
 // src/auth/state.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync6, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
-import { join as join13 } from "path";
-import { z as z5 } from "zod";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "fs";
+import { join as join16 } from "path";
+import { z as z6 } from "zod";
 
 // src/auth/encrypt.ts
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
@@ -9620,39 +10272,39 @@ function resolveAuthKey() {
 }
 
 // src/auth/state.ts
-var AuthStateEntrySchema = z5.object({
-  role: z5.string(),
-  strategy: z5.enum(["storageState", "apiToken"]),
-  created_at: z5.string(),
-  expires_at: z5.string(),
-  payload: z5.record(z5.string(), z5.unknown())
+var AuthStateEntrySchema = z6.object({
+  role: z6.string(),
+  strategy: z6.enum(["storageState", "apiToken"]),
+  created_at: z6.string(),
+  expires_at: z6.string(),
+  payload: z6.record(z6.string(), z6.unknown())
 });
 function pathFor(authDir, role) {
-  return join13(authDir, `${role}.json`);
+  return join16(authDir, `${role}.json`);
 }
 function writeAuthState(authDir, entry) {
-  mkdirSync6(authDir, { recursive: true });
+  mkdirSync8(authDir, { recursive: true });
   const ct = encrypt(JSON.stringify(entry), resolveAuthKey());
-  writeFileSync7(pathFor(authDir, entry.role), ct);
+  writeFileSync9(pathFor(authDir, entry.role), ct);
 }
 function readAuthState(authDir, role) {
   const p = pathFor(authDir, role);
-  if (!existsSync15(p))
+  if (!existsSync16(p))
     return null;
-  const txt = readFileSync12(p, "utf8");
+  const txt = readFileSync14(p, "utf8");
   const plain = decrypt(txt, resolveAuthKey());
   return AuthStateEntrySchema.parse(JSON.parse(plain));
 }
 
 // src/logging/ndjson-logger.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync13 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync15 } from "fs";
 import { dirname as dirname4 } from "path";
 
 class NdjsonLogger {
   path;
   constructor(path) {
     this.path = path;
-    mkdirSync7(dirname4(path), { recursive: true });
+    mkdirSync9(dirname4(path), { recursive: true });
   }
   log(payload) {
     const entry = { ts: new Date().toISOString(), ...payload };
@@ -9660,9 +10312,9 @@ class NdjsonLogger {
 `);
   }
   static readAll(path) {
-    if (!existsSync16(path))
+    if (!existsSync17(path))
       return [];
-    const txt = readFileSync13(path, "utf8").trim();
+    const txt = readFileSync15(path, "utf8").trim();
     if (!txt)
       return [];
     return txt.split(`
@@ -9742,7 +10394,7 @@ async function execCmd(argv) {
             await runAuthSetup({
               role: roleName,
               creds: { email, password },
-              setupScriptPath: join14(cwd, webConfig.auth.setupScript),
+              setupScriptPath: join17(cwd, webConfig.auth.setupScript),
               authDir: paths.authDir,
               browser
             });
@@ -9760,16 +10412,16 @@ async function execCmd(argv) {
         }
       }
     }
-    const cfgPath = join14(cwd, "playwright.config.ts");
-    if (!existsSync17(cfgPath)) {
+    const cfgPath = join17(cwd, "playwright.config.ts");
+    if (!existsSync18(cfgPath)) {
       console.error(`[xera:exec] missing ${cfgPath}. Run \`xera init\` to scaffold it, then re-run.`);
       return 1;
     }
     const runDir = paths.runPath(runId).runDir;
-    mkdirSync8(runDir, { recursive: true });
+    mkdirSync10(runDir, { recursive: true });
     const envName = process.env.XERA_ENV ?? webConfig.defaultEnv;
     const baseURL = webConfig.baseUrl[envName] ?? webConfig.baseUrl[webConfig.defaultEnv];
-    const reportJsonPath = join14(runDir, "report.json");
+    const reportJsonPath = join17(runDir, "report.json");
     log.log({ step: "exec.start", runId, env: envName, baseURL });
     const r = await runPlaywright({
       specPath: paths.specPath,
@@ -9791,20 +10443,20 @@ async function execCmd(argv) {
 }
 
 // src/bin-internal/fetch.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname5 } from "path";
 
 // src/artifact/hash.ts
 import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync18, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
 function hashString(s) {
   return `sha256:${createHash4("sha256").update(s).digest("hex")}`;
 }
 function hashFile(path) {
-  return hashString(readFileSync14(path, "utf8"));
+  return hashString(readFileSync16(path, "utf8"));
 }
 function hashFileIfExists(path) {
-  if (!existsSync18(path))
+  if (!existsSync19(path))
     return null;
   return hashFile(path);
 }
@@ -9813,33 +10465,33 @@ function hashFileIfExists(path) {
 init_paths2();
 
 // src/jira/mcp-backend.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
 import { tmpdir } from "os";
-import { join as join15 } from "path";
+import { join as join18 } from "path";
 var MCP_ENV = "XERA_MCP_JIRA";
 async function createMcpBackend(_baseUrl) {
   if (process.env[MCP_ENV] !== "1")
     return null;
-  const tmpDir = join15(tmpdir(), "xera-mcp");
-  mkdirSync9(tmpDir, { recursive: true });
+  const tmpDir = join18(tmpdir(), "xera-mcp");
+  mkdirSync11(tmpDir, { recursive: true });
   return {
     backend: "mcp",
     async fetchTicket(key, _fields) {
-      const cachePath = join15(tmpDir, `${key}.json`);
-      if (!existsSync19(cachePath)) {
+      const cachePath = join18(tmpDir, `${key}.json`);
+      if (!existsSync20(cachePath)) {
         throw new Error(`MCP-mode fetch requires the skill to first call mcp__atlassian__getJiraIssue and write ${cachePath}. ` + `If you are running this directly, unset ${MCP_ENV} to use REST.`);
       }
-      const parsed = JSON.parse(readFileSync15(cachePath, "utf8"));
+      const parsed = JSON.parse(readFileSync17(cachePath, "utf8"));
       return parsed;
     },
     async postComment(key, body) {
-      const outPath = join15(tmpDir, `${key}.comment.json`);
-      writeFileSync8(outPath, JSON.stringify({ key, body }));
+      const outPath = join18(tmpDir, `${key}.comment.json`);
+      writeFileSync10(outPath, JSON.stringify({ key, body }));
       return { id: "mcp-pending" };
     },
     async transitionStatus(key, statusName) {
-      const outPath = join15(tmpDir, `${key}.transition.json`);
-      writeFileSync8(outPath, JSON.stringify({ key, statusName }));
+      const outPath = join18(tmpDir, `${key}.transition.json`);
+      writeFileSync10(outPath, JSON.stringify({ key, statusName }));
     },
     async listFields(_sampleKey) {
       throw new Error("listFields is REST-only; init flow uses REST for field discovery.");
@@ -9992,8 +10644,8 @@ async function fetchCmd(argv, opts = {}) {
   const storyHash = hashString(body);
   const acLines = parseAcLines(t.acceptanceCriteria);
   const full = renderStory(t.key, t.summary, storyHash, acLines, body);
-  mkdirSync10(dirname5(paths.storyPath), { recursive: true });
-  writeFileSync9(paths.storyPath, full);
+  mkdirSync12(dirname5(paths.storyPath), { recursive: true });
+  writeFileSync11(paths.storyPath, full);
   const existing = readMeta(paths.metaPath);
   writeMeta(paths.metaPath, {
     ticket,
@@ -10053,24 +10705,223 @@ function renderStory(key, summary, storyHash, acLines, body) {
 `) + body;
 }
 
+// src/bin-internal/fill-gap-finalize.ts
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
+import { join as join19 } from "path";
+import { z as z7 } from "zod";
+var ProposalsSchema = z7.object({
+  proposals: z7.array(z7.object({
+    id: z7.string().min(1),
+    ticketId: z7.string().min(1),
+    title: z7.string().min(1),
+    rationale: z7.string().min(1),
+    gherkin: z7.string().min(1),
+    satisfiesAcs: z7.array(z7.number().int().nonnegative())
+  }))
+});
+function parseArgs4(argv) {
+  let accept;
+  let ticket;
+  let source;
+  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") {} else {
+      return { error: `unknown flag: ${a}` };
+    }
+  }
+  if (!accept || !ticket)
+    return { error: "required: --accept <proposal-id> --ticket <TICKET>" };
+  const out = { accept, ticket, force };
+  if (source !== undefined)
+    out.source = source;
+  return out;
+}
+function formatDraft(ticketId, proposal) {
+  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(`
+`);
+}
+async function fillGapFinalizeCmd(argv) {
+  if (argv.includes("--help-stub")) {}
+  const parsed = parseArgs4(argv);
+  if ("error" in parsed) {
+    console.error(`[fill-gap-finalize] ${parsed.error}`);
+    return 1;
+  }
+  const cwd = process.cwd();
+  const sourcePath = parsed.source ?? join19(cwd, ".xera/coverage/proposals.json");
+  if (!existsSync21(sourcePath)) {
+    console.error(`[fill-gap-finalize] source not found: ${sourcePath}`);
+    return 2;
+  }
+  let proposals;
+  try {
+    const raw = JSON.parse(readFileSync18(sourcePath, "utf8"));
+    proposals = ProposalsSchema.parse(raw);
+  } catch (e) {
+    console.error(`[fill-gap-finalize] invalid proposals: ${e.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 = join19(cwd, ".xera", parsed.ticket);
+  mkdirSync13(ticketDir, { recursive: true });
+  const draftPath = join19(ticketDir, "feature.draft.md");
+  if (existsSync21(draftPath) && !parsed.force) {
+    console.error(`[fill-gap-finalize] ${draftPath} exists; pass --force to overwrite`);
+    return 3;
+  }
+  writeFileSync12(draftPath, formatDraft(parsed.ticket, proposal));
+  return 0;
+}
+
+// src/bin-internal/fill-gap-prepare.ts
+init_store();
+import { mkdirSync as mkdirSync14, writeFileSync as writeFileSync13 } from "fs";
+import { join as join20 } from "path";
+function parseArgs5(argv) {
+  const args = {};
+  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") {} 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, area) {
+  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;
+  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, ticketId) {
+  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
+  };
+}
+async function fillGapPrepareCmd(argv) {
+  const parsed = parseArgs5(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;
+  let scope;
+  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 ?? join20(cwd, ".xera/coverage", scope);
+  mkdirSync14(outDir, { recursive: true });
+  writeFileSync13(join20(outDir, "context.json"), JSON.stringify(context, null, 2));
+  return 0;
+}
+
 // src/bin-internal/index.ts
 init_graph_backfill();
 
 // src/graph/enrich.ts
 init_store();
 init_ulid();
-import { existsSync as existsSync20, readFileSync as readFileSync16 } from "fs";
-import { join as join16 } from "path";
-import { z as z6 } from "zod";
+import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
+import { join as join21 } from "path";
+import { z as z8 } from "zod";
 var MAX_SIMILAR_EDGES = 10;
 var MIN_CONFIDENCE = 0.7;
-var SimilarEntrySchema = z6.object({
-  ticketId: z6.string().regex(/^[A-Z][A-Z0-9]*-\d+$/),
-  confidence: z6.number(),
-  reason: z6.string()
+var SimilarEntrySchema = z8.object({
+  ticketId: z8.string().regex(/^[A-Z][A-Z0-9]*-\d+$/),
+  confidence: z8.number(),
+  reason: z8.string()
 });
-var EnrichmentInputSchema = z6.object({
-  similar: z6.array(SimilarEntrySchema)
+var EnrichmentInputSchema = z8.object({
+  similar: z8.array(SimilarEntrySchema)
 });
 var nowIso3 = () => new Date().toISOString();
 var mk2 = (actor, type, payload) => ({
@@ -10082,11 +10933,11 @@ var mk2 = (actor, type, payload) => ({
   payload
 });
 async function enrichTicket(repoRoot, ticketId, opts) {
-  const inputPath = join16(repoRoot, ".xera", ticketId, "enrichment-input.json");
-  if (!existsSync20(inputPath)) {
+  const inputPath = join21(repoRoot, ".xera", ticketId, "enrichment-input.json");
+  if (!existsSync22(inputPath)) {
     throw new Error(`enrichment-input.json not found at ${inputPath}`);
   }
-  const raw = JSON.parse(readFileSync16(inputPath, "utf8"));
+  const raw = JSON.parse(readFileSync19(inputPath, "utf8"));
   const parsed = EnrichmentInputSchema.safeParse(raw);
   if (!parsed.success) {
     throw new Error(`invalid enrichment-input.json: ${parsed.error.message}`);
@@ -10195,12 +11046,12 @@ async function graphQueryCmd(argv) {
 init_graph_record();
 
 // src/bin-internal/graph-render.ts
-import { mkdirSync as mkdirSync11, renameSync as renameSync2, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname7, join as join18 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync21, renameSync as renameSync2, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname7, join as join23 } from "path";
 
 // src/graph/render.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { dirname as dirname6, join as join17 } from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname6, join as join22 } from "path";
 import { fileURLToPath } from "url";
 var COLORS = {
   ticket: "#3B82F6",
@@ -10419,9 +11270,9 @@ function transformForVisNetwork(snap, opts) {
 }
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname6(__filename2);
-var TEMPLATES_DIR = join17(__dirname2, "templates");
+var TEMPLATES_DIR = join22(__dirname2, "templates");
 function loadTemplate(name) {
-  return readFileSync17(join17(TEMPLATES_DIR, name), "utf8");
+  return readFileSync20(join22(TEMPLATES_DIR, name), "utf8");
 }
 function statsToHuman(s) {
   return `${s.tickets} tickets \xB7 ${s.scenarios} scenarios \xB7 ${s.poms} POMs \xB7 ${s.edges} edges`;
@@ -10433,7 +11284,10 @@ function renderHtml(input) {
   const visNetwork = loadTemplate("vis-network.min.js");
   const graphJson = JSON.stringify(input.data);
   const statsHuman = statsToHuman(input.stats);
-  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);
+  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("{{COVERAGE_TAB_BUTTON}}", () => coverageTabButton).replace("{{COVERAGE_TAB_PANEL}}", () => coverageTabPanel).replace("{{COVERAGE_DATA}}", () => coverageJson);
 }
 
 // src/bin-internal/graph-render.ts
@@ -10456,6 +11310,7 @@ async function graphRenderCmd(argv) {
   let ticketId;
   let since;
   let depth = 2;
+  let includeCoverage = false;
   for (let i = 0;i < argv.length; i++) {
     if (argv[i] === "--out")
       outPath = argv[++i];
@@ -10465,16 +11320,19 @@ async function graphRenderCmd(argv) {
       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 ?? join18(repoRoot, ".xera/graph.html");
-  const snap = deriveSnapshot(loadAllEvents(repoRoot));
+  const finalPath = outPath ?? join23(repoRoot, ".xera/graph.html");
+  const events = loadAllEvents(repoRoot);
+  const snap = deriveSnapshot(events);
   const totalNodeCount = Object.keys(snap.tickets).length + Object.keys(snap.scenarios).length + Object.keys(snap.poms).length + Object.keys(snap.areas).length;
   const performanceMode = decidePerformanceMode(totalNodeCount);
   if (performanceMode === "text-fallback") {
     const txtPath = finalPath.replace(/\.html$/, ".txt");
-    mkdirSync11(dirname7(txtPath), { recursive: true });
-    writeFileSync10(txtPath, `Graph too large for HTML viewer (${totalNodeCount} nodes). Use 'xera:graph-query --format text' instead.
+    mkdirSync15(dirname7(txtPath), { recursive: true });
+    writeFileSync14(txtPath, `Graph too large for HTML viewer (${totalNodeCount} nodes). Use 'xera:graph-query --format text' instead.
 `);
     console.log(`[graph-render] graph too large (${totalNodeCount} nodes); wrote ${txtPath}`);
     return 0;
@@ -10484,11 +11342,29 @@ async function graphRenderCmd(argv) {
     opts.ticketId = ticketId;
   if (since)
     opts.since = since;
+  let coverage;
+  if (includeCoverage) {
+    const reportPath = join23(repoRoot, ".xera/coverage/report.json");
+    if (existsSync23(reportPath)) {
+      const report = JSON.parse(readFileSync21(reportPath, "utf8"));
+      const snapshots = events.filter((e) => e.type === "coverage.snapshot").map((e) => e.payload);
+      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() });
-  mkdirSync11(dirname7(finalPath), { recursive: true });
+  const renderInput = {
+    data,
+    stats: data.stats,
+    generatedAt: new Date().toISOString()
+  };
+  if (coverage)
+    renderInput.coverage = coverage;
+  const html = renderHtml(renderInput);
+  mkdirSync15(dirname7(finalPath), { recursive: true });
   const tmpPath = `${finalPath}.tmp`;
-  writeFileSync10(tmpPath, html);
+  writeFileSync14(tmpPath, html);
   renameSync2(tmpPath, finalPath);
   console.log(`[graph-render] wrote ${finalPath} (${data.stats.tickets} tickets \xB7 ${data.stats.scenarios} scenarios \xB7 ${html.length} bytes)`);
   return 0;
@@ -10519,8 +11395,8 @@ async function graphSnapshotCmd(argv) {
 }
 
 // src/bin-internal/heal-prepare.ts
-import { existsSync as existsSync21, readdirSync as readdirSync6, readFileSync as readFileSync18, writeFileSync as writeFileSync11 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync6, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "fs";
+import { join as join24 } from "path";
 import { scrubFreeText } from "@xera-ai/web";
 
 // ../../node_modules/fflate/esm/index.mjs
@@ -10867,15 +11743,15 @@ function strFromU8(dat, latin1) {
 var slzh = function(d, b) {
   return b + 30 + b2(d, b + 26) + b2(d, b + 28);
 };
-var zh = function(d, b, z7) {
+var zh = function(d, b, z9) {
   var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
-  var _a2 = z64hs(d, es, efl, z7, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
+  var _a2 = z64hs(d, es, efl, z9, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a2[0], su = _a2[1], off = _a2[2];
   return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
 };
-var z64hs = function(d, b, l, z7, sc, su, off) {
+var z64hs = function(d, b, l, z9, sc, su, off) {
   var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
   var nf = nsc + nsu + noff;
-  if (z7 && nf) {
+  if (z9 && nf) {
     for (;b + 4 < e; b += 4 + b2(d, b + 2)) {
       if (b2(d, b) == 1) {
         return [
@@ -10886,7 +11762,7 @@ var z64hs = function(d, b, l, z7, sc, su, off) {
         ];
       }
     }
-    if (z7 < 2)
+    if (z9 < 2)
       err(13);
   }
   return [sc, su, off, 0];
@@ -10902,18 +11778,18 @@ function unzipSync(data, opts) {
   if (!c)
     return {};
   var o = b4(data, e + 16);
-  var z7 = b4(data, e - 20) == 117853008;
-  if (z7) {
+  var z9 = b4(data, e - 20) == 117853008;
+  if (z9) {
     var ze = b4(data, e - 12);
-    z7 = b4(data, ze) == 101075792;
-    if (z7) {
+    z9 = b4(data, ze) == 101075792;
+    if (z9) {
       c = b4(data, ze + 32);
       o = b4(data, ze + 48);
     }
   }
   var fltr = opts && opts.filter;
   for (var i2 = 0;i2 < c; ++i2) {
-    var _a2 = zh(data, o, z7), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
+    var _a2 = zh(data, o, z9), c_2 = _a2[0], sc = _a2[1], su = _a2[2], fn = _a2[3], no = _a2[4], off = _a2[5], b = slzh(data, off);
     o = no;
     if (!fltr || fltr({
       name: fn,
@@ -10949,9 +11825,9 @@ function classifyKind(raw) {
   return "other";
 }
 function extractDomSnapshot(tracePath) {
-  if (!existsSync21(tracePath))
+  if (!existsSync24(tracePath))
     return "";
-  const buf = readFileSync18(tracePath);
+  const buf = readFileSync22(tracePath);
   const entries = unzipSync(buf);
   const traceKey = Object.keys(entries).find((name) => name.endsWith(".trace"));
   let chosenKey = null;
@@ -10999,16 +11875,16 @@ function extractDomSnapshot(tracePath) {
   return scrubFreeText(html);
 }
 function findPomLine(ticketDir, rawLocator) {
-  const pomDir = join19(ticketDir, "page-objects");
+  const pomDir = join24(ticketDir, "page-objects");
   const candidates = [];
-  if (existsSync21(pomDir)) {
+  if (existsSync24(pomDir)) {
     for (const name of readdirSync6(pomDir)) {
       if (name.endsWith(".ts"))
-        candidates.push(join19(pomDir, name));
+        candidates.push(join24(pomDir, name));
     }
   }
   for (const file of candidates) {
-    const text = readFileSync18(file, "utf8");
+    const text = readFileSync22(file, "utf8");
     const lines = text.split(`
 `);
     for (let i2 = 0;i2 < lines.length; i2++) {
@@ -11046,13 +11922,13 @@ function findGherkinStep(featureText, rawLocator) {
 }
 function healPrepare(repoRoot, ticket, runId, scenarioName) {
   const paths = resolveArtifactPaths(repoRoot, ticket);
-  const classifierPath = join19(paths.ticketDir, "classifier-input.json");
-  const classifier = JSON.parse(readFileSync18(classifierPath, "utf8"));
+  const classifierPath = join24(paths.ticketDir, "classifier-input.json");
+  const classifier = JSON.parse(readFileSync22(classifierPath, "utf8"));
   const cls = classifier.scenarios.find((s) => s.name === scenarioName);
   if (!cls)
     throw new Error(`scenario not found in classifier-input: "${scenarioName}"`);
-  const runDir = join19(paths.runsDir, runId);
-  const normalized = JSON.parse(readFileSync18(join19(runDir, "normalized.json"), "utf8"));
+  const runDir = join24(paths.runsDir, runId);
+  const normalized = JSON.parse(readFileSync22(join24(runDir, "normalized.json"), "utf8"));
   const normSc = normalized.scenarios.find((s) => s.name === scenarioName);
   if (!normSc?.failure)
     throw new Error(`no failure recorded for scenario "${scenarioName}"`);
@@ -11063,9 +11939,9 @@ function healPrepare(repoRoot, ticket, runId, scenarioName) {
   const raw = m[1].trim();
   const kind = classifyKind(raw);
   const pomLoc = findPomLine(paths.ticketDir, raw);
-  const featureText = readFileSync18(paths.featurePath, "utf8");
+  const featureText = readFileSync22(paths.featurePath, "utf8");
   const gherkinStep = findGherkinStep(featureText, raw);
-  const domSnapshotAtFailure = extractDomSnapshot(join19(runDir, "trace.zip"));
+  const domSnapshotAtFailure = extractDomSnapshot(join24(runDir, "trace.zip"));
   return {
     ticket,
     runId,
@@ -11085,8 +11961,8 @@ async function healPrepareCmd(argv) {
   try {
     const result = healPrepare(process.cwd(), ticket, runId, scenarioName);
     const paths = resolveArtifactPaths(process.cwd(), ticket);
-    const outPath = join19(paths.runsDir, runId, "heal-input.json");
-    writeFileSync11(outPath, JSON.stringify(result, null, 2));
+    const outPath = join24(paths.runsDir, runId, "heal-input.json");
+    writeFileSync15(outPath, JSON.stringify(result, null, 2));
     console.log(`[xera:heal-prepare] wrote ${outPath}`);
     return 0;
   } catch (err2) {
@@ -11096,8 +11972,8 @@ async function healPrepareCmd(argv) {
 }
 
 // src/bin-internal/impact-prepare.ts
-import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "fs";
-import { join as join20 } from "path";
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync16 } from "fs";
+import { join as join25 } from "path";
 
 // src/graph/impact.ts
 var PRIORITY_WEIGHT = { p0: 3, p1: 2, p2: 1 };
@@ -11347,11 +12223,11 @@ async function impactPrepareCmd(argv) {
     scenarios,
     generatedAt: new Date().toISOString()
   };
-  const impactDir = join20(repoRoot, ".xera/impact");
-  mkdirSync12(impactDir, { recursive: true });
-  writeFileSync12(join20(impactDir, `${ticket}.json`), JSON.stringify(report, null, 2));
+  const impactDir = join25(repoRoot, ".xera/impact");
+  mkdirSync16(impactDir, { recursive: true });
+  writeFileSync16(join25(impactDir, `${ticket}.json`), JSON.stringify(report, null, 2));
   if (!quiet) {
-    writeFileSync12(join20(impactDir, `${ticket}.md`), renderImpactMarkdown(report));
+    writeFileSync16(join25(impactDir, `${ticket}.md`), renderImpactMarkdown(report));
   }
   return 0;
 }
@@ -11377,8 +12253,8 @@ async function lintCmd(argv) {
 }
 
 // src/bin-internal/normalize.ts
-import { existsSync as existsSync22, readdirSync as readdirSync7 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync7 } from "fs";
+import { join as join26 } from "path";
 init_paths2();
 async function normalizeCmd(argv) {
   const ticket = argv[0];
@@ -11393,8 +12269,8 @@ async function normalizeCmd(argv) {
     console.error("[xera:normalize] no run found");
     return 1;
   }
-  const runDir = join21(paths.runsDir, runId);
-  if (!existsSync22(runDir)) {
+  const runDir = join26(paths.runsDir, runId);
+  if (!existsSync25(runDir)) {
     console.error(`[xera:normalize] runs/${runId} missing`);
     return 1;
   }
@@ -11414,14 +12290,14 @@ async function normalizeCmd(argv) {
 
 // src/bin-internal/post.ts
 init_paths2();
-import { existsSync as existsSync24, readFileSync as readFileSync20 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync24 } from "fs";
+import { join as join27 } from "path";
 
 // src/artifact/status.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync13, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
 import { dirname as dirname8 } from "path";
-import { z as z7 } from "zod";
-var ClassificationEnum = z7.enum([
+import { z as z9 } from "zod";
+var ClassificationEnum = z9.enum([
   "PASS",
   "REAL_BUG",
   "SELECTOR_DRIFT",
@@ -11432,37 +12308,37 @@ var ClassificationEnum = z7.enum([
   "RATE_LIMITED",
   "AUTH_EXPIRED"
 ]);
-var ResultEnum = z7.enum(["PASS", "FAIL"]);
-var ConfidenceEnum = z7.enum(["low", "medium", "high"]);
-var HistoryEntrySchema = z7.object({
-  ts: z7.string(),
+var ResultEnum = z9.enum(["PASS", "FAIL"]);
+var ConfidenceEnum = z9.enum(["low", "medium", "high"]);
+var HistoryEntrySchema = z9.object({
+  ts: z9.string(),
   result: ResultEnum,
   class: ClassificationEnum
 });
-var StatusJsonSchema = z7.object({
-  ticket: z7.string(),
-  lastRun: z7.string(),
+var StatusJsonSchema = z9.object({
+  ticket: z9.string(),
+  lastRun: z9.string(),
   result: ResultEnum,
   classification: ClassificationEnum,
   confidence: ConfidenceEnum,
-  scenarios: z7.object({
-    total: z7.number().int().nonnegative(),
-    passed: z7.number().int().nonnegative(),
-    failed: z7.number().int().nonnegative(),
-    skipped: z7.number().int().nonnegative()
+  scenarios: z9.object({
+    total: z9.number().int().nonnegative(),
+    passed: z9.number().int().nonnegative(),
+    failed: z9.number().int().nonnegative(),
+    skipped: z9.number().int().nonnegative()
   }),
-  history: z7.array(HistoryEntrySchema).default([]),
-  last_jira_comment_id: z7.string().optional()
+  history: z9.array(HistoryEntrySchema).default([]),
+  last_jira_comment_id: z9.string().optional()
 });
 var HISTORY_CAP = 20;
 function readStatus(path) {
-  if (!existsSync23(path))
+  if (!existsSync26(path))
     return null;
-  return StatusJsonSchema.parse(JSON.parse(readFileSync19(path, "utf8")));
+  return StatusJsonSchema.parse(JSON.parse(readFileSync23(path, "utf8")));
 }
 function writeStatus(path, status) {
-  mkdirSync13(dirname8(path), { recursive: true });
-  writeFileSync13(path, JSON.stringify(status, null, 2));
+  mkdirSync17(dirname8(path), { recursive: true });
+  writeFileSync17(path, JSON.stringify(status, null, 2));
 }
 function appendHistory(path, entry) {
   const s = readStatus(path);
@@ -11488,12 +12364,12 @@ async function postCmd(argv) {
     return 0;
   }
   const paths = resolveArtifactPaths(cwd, ticket);
-  const draftPath = join22(paths.ticketDir, "jira-comment.draft.md");
-  if (!existsSync24(draftPath)) {
+  const draftPath = join27(paths.ticketDir, "jira-comment.draft.md");
+  if (!existsSync27(draftPath)) {
     console.error(`[xera:post] no draft at ${draftPath}; run \`xera-internal report\` first.`);
     return 1;
   }
-  const body = readFileSync20(draftPath, "utf8");
+  const body = readFileSync24(draftPath, "utf8");
   const client = await createJiraClient({
     baseUrl: config.jira.baseUrl,
     preferMcp: true,
@@ -11521,8 +12397,8 @@ async function promoteCmd(argv) {
 }
 
 // src/bin-internal/report.ts
-import { existsSync as existsSync26, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync25, writeFileSync as writeFileSync18 } from "fs";
+import { join as join28 } from "path";
 init_paths2();
 
 // src/classifier/aggregate.ts
@@ -11789,11 +12665,11 @@ xera v${input.xeraVersion} \u2022 prompts v${input.promptsVersion}`;
 }
 
 // src/reporter/status-writer.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 function writeStatusFromClassification(path, input) {
   const result = input.classification.overall === "PASS" ? "PASS" : "FAIL";
   const entry = { ts: input.runTs, result, class: input.classification.overall };
-  if (!existsSync25(path)) {
+  if (!existsSync28(path)) {
     writeStatus(path, {
       ticket: input.ticket,
       lastRun: input.runTs,
@@ -11827,22 +12703,22 @@ async function reportCmd(argv) {
   }
   const cwd = process.cwd();
   const paths = resolveArtifactPaths(cwd, ticket);
-  const input = JSON.parse(readFileSync21(inputArg.slice("--input=".length), "utf8"));
+  const input = JSON.parse(readFileSync25(inputArg.slice("--input=".length), "utf8"));
   let httpRuleOverride = null;
   const meta = readMeta(paths.metaPath);
   if (meta?.adapter === "http") {
     const config = await loadConfig(cwd);
     if (config.http) {
-      const normalizedPath = join23(paths.ticketDir, "runs", input.runId, "normalized.json");
-      if (existsSync26(normalizedPath)) {
-        const norm = JSON.parse(readFileSync21(normalizedPath, "utf8"));
+      const normalizedPath = join28(paths.ticketDir, "runs", input.runId, "normalized.json");
+      if (existsSync29(normalizedPath)) {
+        const norm = JSON.parse(readFileSync25(normalizedPath, "utf8"));
         const calls = norm.http?.calls ?? [];
         const rate = classifyRateLimited({ calls });
         if (rate)
           httpRuleOverride = rate;
         if (!httpRuleOverride) {
           const authFiles = {};
-          const httpAuthDir = join23(cwd, ".xera", ".auth", "http");
+          const httpAuthDir = join28(cwd, ".xera", ".auth", "http");
           for (const role of Object.keys(config.http.auth.roles)) {
             const entry = readAuthState(httpAuthDir, role);
             if (entry) {
@@ -11887,8 +12763,8 @@ async function reportCmd(argv) {
     confidence: "high"
   } : s) : input.scenarios;
   const aggregated = aggregateScenarios(scenariosForAggregation);
-  const decisionsPath = join23(paths.ticketDir, "runs", input.runId, "outdated-decisions.json");
-  const decisions = existsSync26(decisionsPath) ? JSON.parse(readFileSync21(decisionsPath, "utf8")) : {};
+  const decisionsPath = join28(paths.ticketDir, "runs", input.runId, "outdated-decisions.json");
+  const decisions = existsSync29(decisionsPath) ? JSON.parse(readFileSync25(decisionsPath, "utf8")) : {};
   const graph = deriveSnapshot(loadAllEvents(process.cwd()));
   const normalizeScenarioName = (name) => name.trim().toLowerCase().replace(/\s+/g, " ");
   const scenarioIdByName = {};
@@ -11936,8 +12812,8 @@ async function reportCmd(argv) {
     xeraVersion: XERA_VERSION,
     promptsVersion: PROMPTS_VERSION
   });
-  const draftPath = join23(paths.ticketDir, "jira-comment.draft.md");
-  writeFileSync14(draftPath, md);
+  const draftPath = join28(paths.ticketDir, "jira-comment.draft.md");
+  writeFileSync18(draftPath, md);
   console.log(`[xera:report] wrote status.json and ${draftPath}`);
   return 0;
 }
@@ -12008,7 +12884,7 @@ async function unlockCmd(argv) {
 
 // src/bin-internal/validate-feature.ts
 init_paths2();
-import { existsSync as existsSync27, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
 import { validateGherkin as validateGherkin2 } from "@xera-ai/web";
 async function validateFeatureCmd(argv) {
   const ticket = argv[0];
@@ -12017,11 +12893,11 @@ async function validateFeatureCmd(argv) {
     return 1;
   }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
-  if (!existsSync27(paths.featurePath)) {
+  if (!existsSync30(paths.featurePath)) {
     console.error(`[xera:validate-feature] missing ${paths.featurePath}`);
     return 1;
   }
-  const r = validateGherkin2(readFileSync22(paths.featurePath, "utf8"));
+  const r = validateGherkin2(readFileSync26(paths.featurePath, "utf8"));
   if (r.ok) {
     console.log("[xera:validate-feature] ok");
     return 0;
@@ -12033,13 +12909,18 @@ async function validateFeatureCmd(argv) {
 
 // src/bin-internal/index.ts
 var COMMANDS = {
+  "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,