@xera-ai/core 0.4.2 → 0.4.4

package/dist/bin/internal.js

@@ -153,10 +153,10 @@ var init_schema = __esm(() => {
 // src/graph/store.ts
 import { createHash } from "crypto";
 import {
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
+  existsSync,
+  mkdirSync,
   readdirSync,
-  readFileSync as readFileSync2,
+  readFileSync,
   renameSync,
   writeFileSync
 } from "fs";
@@ -167,7 +167,7 @@ function appendEvents(repoRoot, events, opts) {
   const paths = graphPaths(repoRoot);
   const yyyyMm = currentYyyyMm(opts.now);
   const monthDir = paths.eventsMonthDir(yyyyMm);
-  mkdirSync2(monthDir, { recursive: true });
+  mkdirSync(monthDir, { recursive: true });
   const ulid = events[0].event_id;
   const finalPath = paths.eventFile(ulid, opts.skill, opts.ticketId, yyyyMm);
   const tmpPath = `${finalPath}.tmp`;
@@ -180,7 +180,7 @@ function appendEvents(repoRoot, events, opts) {
 }
 function loadAllEvents(repoRoot) {
   const paths = graphPaths(repoRoot);
-  if (!existsSync2(paths.eventsDir))
+  if (!existsSync(paths.eventsDir))
     return [];
   const files = [];
   for (const monthDir of readdirSync(paths.eventsDir, { withFileTypes: true })) {
@@ -200,7 +200,7 @@ function loadAllEvents(repoRoot) {
   const events = [];
   for (const file of files) {
     try {
-      const lines = readFileSync2(file, "utf8").split(`
+      const lines = readFileSync(file, "utf8").split(`
 `).filter(Boolean);
       for (const line of lines) {
         let parsed;
@@ -326,6 +326,13 @@ function deriveSnapshot(events) {
         edges.push(ed);
         break;
       }
+      case "classification.disputed": {
+        const existing = latestFailures[e.payload.scenarioId];
+        if (existing && existing.runId === e.payload.runId) {
+          existing.disputed = true;
+        }
+        break;
+      }
       default:
         break;
     }
@@ -345,17 +352,17 @@ function deriveSnapshot(events) {
 }
 function writeSnapshot(repoRoot, snap) {
   const paths = graphPaths(repoRoot);
-  mkdirSync2(dirname(paths.snapshotFile), { recursive: true });
+  mkdirSync(dirname(paths.snapshotFile), { recursive: true });
   const tmp = `${paths.snapshotFile}.tmp`;
   writeFileSync(tmp, JSON.stringify(snap, null, 2));
   renameSync(tmp, paths.snapshotFile);
 }
 function loadSnapshot(repoRoot) {
   const paths = graphPaths(repoRoot);
-  if (!existsSync2(paths.snapshotFile))
+  if (!existsSync(paths.snapshotFile))
     return null;
   try {
-    return JSON.parse(readFileSync2(paths.snapshotFile, "utf8"));
+    return JSON.parse(readFileSync(paths.snapshotFile, "utf8"));
   } catch {
     return null;
   }
@@ -429,21 +436,29 @@ var exports_graph_record_script = {};
 __export(exports_graph_record_script, {
   recordScriptImpl: () => recordScriptImpl
 });
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync14 } from "fs";
-import { basename, join as join12 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
+import { basename, join as join3 } from "path";
+function inferPriority(name, gherkin) {
+  const haystack = `${name} ${gherkin}`.toLowerCase();
+  for (const kw of P0_KEYWORDS) {
+    if (haystack.includes(kw))
+      return "p0";
+  }
+  return "p1";
+}
 function parseFeature(text) {
   const scenarios = [];
   const lines = text.split(`
 `);
-  let currentTagPriority = "p1";
+  let explicitTag = null;
   let i = 0;
   while (i < lines.length) {
     const line = lines[i].trim();
     if (line.startsWith("@")) {
       const tag = line.slice(1).split(/\s+/)[0].toLowerCase();
       if (tag === "p0" || tag === "p1" || tag === "p2")
-        currentTagPriority = tag;
+        explicitTag = tag;
       i++;
       continue;
     }
@@ -453,13 +468,11 @@ function parseFeature(text) {
       i++;
       while (i < lines.length && !lines[i].trim().startsWith("Scenario") && !lines[i].trim().startsWith("@"))
         i++;
-      scenarios.push({
-        name,
-        priority: currentTagPriority,
-        gherkin: lines.slice(start, i).join(`
-`)
-      });
-      currentTagPriority = "p1";
+      const gherkin = lines.slice(start, i).join(`
+`);
+      const priority = explicitTag !== null ? explicitTag : inferPriority(name, gherkin);
+      scenarios.push({ name, priority, gherkin });
+      explicitTag = null;
       continue;
     }
     i++;
@@ -467,9 +480,9 @@ function parseFeature(text) {
   return scenarios;
 }
 function listPomFiles(dir) {
-  if (!existsSync16(dir))
+  if (!existsSync4(dir))
     return [];
-  return readdirSync4(dir).filter((f) => f.endsWith(".ts")).map((f) => join12(dir, f));
+  return readdirSync2(dir).filter((f) => f.endsWith(".ts")).map((f) => join3(dir, f));
 }
 function extractRoute(pomContent) {
   const m = pomContent.match(/goto\s*\(\s*['"]([^'"]+)['"]/);
@@ -496,15 +509,15 @@ function extractPomUsage(specContent) {
   return [...names];
 }
 async function recordScriptImpl(repoRoot, ticket) {
-  const ticketDir = join12(repoRoot, ".xera", ticket);
-  const featurePath = join12(ticketDir, "feature", `${ticket}.feature`);
-  const specPath = join12(ticketDir, "tests", `${ticket}.spec.ts`);
-  const pomDir = join12(ticketDir, "poms");
-  if (!existsSync16(featurePath)) {
+  const ticketDir = join3(repoRoot, ".xera", ticket);
+  const featurePath = join3(ticketDir, "feature", `${ticket}.feature`);
+  const specPath = join3(ticketDir, "tests", `${ticket}.spec.ts`);
+  const pomDir = join3(ticketDir, "poms");
+  if (!existsSync4(featurePath)) {
     console.error(`[graph-record script] feature missing`);
     return 1;
   }
-  const featureText = readFileSync14(featurePath, "utf8");
+  const featureText = readFileSync4(featurePath, "utf8");
   const featureHash = sha1(featureText);
   const scenarios = parseFeature(featureText);
   const events = [];
@@ -524,7 +537,7 @@ async function recordScriptImpl(repoRoot, ticket) {
   const pomFiles = listPomFiles(pomDir);
   const pomNameToId = new Map;
   for (const pomFile of pomFiles) {
-    const content = readFileSync14(pomFile, "utf8");
+    const content = readFileSync4(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);
@@ -538,8 +551,8 @@ async function recordScriptImpl(repoRoot, ticket) {
     };
     events.push(mk("xera-script", "pom.generated", pg));
   }
-  if (existsSync16(specPath)) {
-    const specContent = readFileSync14(specPath, "utf8");
+  if (existsSync4(specPath)) {
+    const specContent = readFileSync4(specPath, "utf8");
     const usedPoms = extractPomUsage(specContent);
     for (const scenario of scenarios) {
       const scId = sId(ticket, scenario.name);
@@ -571,17 +584,39 @@ async function recordScriptImpl(repoRoot, ticket) {
   appendEvents(repoRoot, events, { skill: "xera-script", ticketId: ticket });
   return 0;
 }
-var sha1 = (s) => createHash3("sha1").update(s).digest("hex"), sId = (ticket, name) => sha1(`${ticket}:${name.trim().toLowerCase().replace(/\s+/g, " ")}`), pId = (file) => sha1(basename(file)), nowIso = () => new Date().toISOString(), mk = (actor, type, payload) => ({
+var sha1 = (s) => createHash2("sha1").update(s).digest("hex"), sId = (ticket, name) => sha1(`${ticket}:${name.trim().toLowerCase().replace(/\s+/g, " ")}`), pId = (file) => sha1(basename(file)), nowIso = () => new Date().toISOString(), mk = (actor, type, payload) => ({
   event_id: ulid(),
   schema_version: SCHEMA_VERSION,
   ts: nowIso(),
   actor,
   type,
   payload
-});
+}), P0_KEYWORDS;
 var init_graph_record_script = __esm(() => {
   init_store();
   init_ulid();
+  P0_KEYWORDS = [
+    "log in",
+    "login",
+    "sign in",
+    "signin",
+    "sign up",
+    "signup",
+    "auth",
+    "authentic",
+    "payment",
+    "pay ",
+    "checkout",
+    "purchase",
+    "charge",
+    "password",
+    "credential",
+    "admin",
+    "permission",
+    "role",
+    "must ",
+    "critical"
+  ];
 });
 
 // ../../node_modules/.bun/yaml@2.9.0/node_modules/yaml/dist/nodes/identity.js
@@ -7580,14 +7615,14 @@ __export(exports_graph_record, {
   recordFetch: () => recordFetch,
   graphRecordCmd: () => graphRecordCmd
 });
-import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
-import { basename as basename2, join as join13 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { basename as basename2, join as join4 } from "path";
 function nowIso2() {
   return new Date().toISOString();
 }
 function sha12(s) {
-  return createHash4("sha1").update(s).digest("hex");
+  return createHash3("sha1").update(s).digest("hex");
 }
 function scenarioId(ticket, name) {
   return sha12(`${ticket}:${name.trim().toLowerCase().replace(/\s+/g, " ")}`);
@@ -7606,21 +7641,21 @@ function makeEvent(actor, type, payload) {
   };
 }
 function readStoryFrontmatter(repoRoot, ticket) {
-  const path = join13(repoRoot, ".xera", ticket, "story.md");
-  if (!existsSync17(path))
+  const path = join4(repoRoot, ".xera", ticket, "story.md");
+  if (!existsSync5(path))
     return null;
-  const raw = readFileSync15(path, "utf8");
+  const raw = readFileSync5(path, "utf8");
   const m = raw.match(/^---\n([\s\S]*?)\n---/);
   if (!m)
     return null;
   return $parse(m[1]);
 }
 function readGraphInput(repoRoot, ticket) {
-  const path = join13(repoRoot, ".xera", ticket, "graph-input.json");
-  if (!existsSync17(path))
+  const path = join4(repoRoot, ".xera", ticket, "graph-input.json");
+  if (!existsSync5(path))
     return { modifiesAreas: [] };
   try {
-    return JSON.parse(readFileSync15(path, "utf8"));
+    return JSON.parse(readFileSync5(path, "utf8"));
   } catch {
     return { modifiesAreas: [] };
   }
@@ -7668,12 +7703,12 @@ async function recordScript(repoRoot, ticket) {
   return recordScriptImpl2(repoRoot, ticket);
 }
 async function recordExec(repoRoot, ticket, runId) {
-  const reporterPath = join13(repoRoot, ".xera", ticket, "runs", runId, "reporter.json");
-  if (!existsSync17(reporterPath)) {
+  const reporterPath = join4(repoRoot, ".xera", ticket, "runs", runId, "reporter.json");
+  if (!existsSync5(reporterPath)) {
     console.error(`[graph-record exec] reporter.json missing`);
     return 1;
   }
-  const data = JSON.parse(readFileSync15(reporterPath, "utf8"));
+  const data = JSON.parse(readFileSync5(reporterPath, "utf8"));
   const events = [];
   for (const s of data.scenarios) {
     const p = {
@@ -7691,12 +7726,12 @@ async function recordExec(repoRoot, ticket, runId) {
   return 0;
 }
 async function recordClassify(repoRoot, ticket, runId) {
-  const classifyPath = join13(repoRoot, ".xera", ticket, "runs", runId, "classifier-output.json");
-  if (!existsSync17(classifyPath)) {
+  const classifyPath = join4(repoRoot, ".xera", ticket, "runs", runId, "classifier-output.json");
+  if (!existsSync5(classifyPath)) {
     console.error(`[graph-record classify] classifier-output.json missing`);
     return 1;
   }
-  const data = JSON.parse(readFileSync15(classifyPath, "utf8"));
+  const data = JSON.parse(readFileSync5(classifyPath, "utf8"));
   const events = [];
   for (const s of data.scenarios) {
     const p = {
@@ -7724,7 +7759,7 @@ async function recordPromote(repoRoot, args) {
   appendEvents(repoRoot, [e], { skill: "xera-promote", ticketId: "shared" });
   return 0;
 }
-function parseFlags2(args) {
+function parseFlags(args) {
   const m = new Map;
   for (let i = 0;i < args.length; i++) {
     if (args[i].startsWith("--")) {
@@ -7760,7 +7795,7 @@ async function graphRecordCmd(argv) {
     }
     case "exec": {
       const ticket = rest[0];
-      const flags = parseFlags2(rest);
+      const flags = parseFlags(rest);
       const runId = flags.get("--run-id");
       if (!ticket || !runId) {
         console.error("ticket + --run-id required");
@@ -7770,7 +7805,7 @@ async function graphRecordCmd(argv) {
     }
     case "classify": {
       const ticket = rest[0];
-      const flags = parseFlags2(rest);
+      const flags = parseFlags(rest);
       const runId = flags.get("--run-id");
       if (!ticket || !runId) {
         console.error("ticket + --run-id required");
@@ -7779,10 +7814,10 @@ async function graphRecordCmd(argv) {
       return recordClassify(repoRoot, ticket, runId);
     }
     case "promote": {
-      return recordPromote(repoRoot, parseFlags2(rest));
+      return recordPromote(repoRoot, parseFlags(rest));
     }
     case "dispute": {
-      const flags = parseFlags2(rest);
+      const flags = parseFlags(rest);
       const runId = flags.get("--run-id");
       const scenarioIdArg = flags.get("--scenario-id");
       const from = flags.get("--from");
@@ -7829,20 +7864,145 @@ var init_graph_record = __esm(() => {
   init_ulid();
 });
 
+// src/bin-internal/graph-backfill.ts
+var exports_graph_backfill = {};
+__export(exports_graph_backfill, {
+  graphBackfillCmd: () => graphBackfillCmd
+});
+import { existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join5 } from "path";
+async function backfillTicket(repoRoot, ticket, dryRun) {
+  const storyPath = join5(repoRoot, ".xera", ticket, "story.md");
+  if (!existsSync6(storyPath))
+    return 0;
+  const { recordFetch: recordFetch2 } = await Promise.resolve().then(() => (init_graph_record(), exports_graph_record));
+  if (dryRun) {
+    console.log(`[backfill dry-run] would backfill ${ticket}`);
+    return 0;
+  }
+  await recordScriptImpl(repoRoot, ticket);
+  await recordFetch2(repoRoot, ticket);
+  return 0;
+}
+async function graphBackfillCmd(argv) {
+  const dryRun = argv.includes("--dry-run");
+  const repoRoot = process.cwd();
+  const xeraDir = join5(repoRoot, ".xera");
+  if (!existsSync6(xeraDir)) {
+    console.log("[backfill] no .xera/ directory");
+    return 0;
+  }
+  const tickets = [];
+  for (const entry of readdirSync3(xeraDir, { withFileTypes: true })) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name === "graph")
+      continue;
+    if (entry.name.startsWith("."))
+      continue;
+    if (!/^[A-Z]+-\d+$/.test(entry.name))
+      continue;
+    tickets.push(entry.name);
+  }
+  console.log(`[backfill] found ${tickets.length} tickets`);
+  for (const t of tickets)
+    await backfillTicket(repoRoot, t, dryRun);
+  console.log(`[backfill] done`);
+  return 0;
+}
+var init_graph_backfill = __esm(() => {
+  init_graph_record_script();
+});
+
+// src/bin-internal/disputes.ts
+init_store();
+function parseDuration(s) {
+  const match = s.match(/^(\d+)([dhm])$/);
+  if (!match)
+    return 0;
+  const n = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === "d")
+    return n * 86400 * 1000;
+  if (unit === "h")
+    return n * 3600 * 1000;
+  if (unit === "m")
+    return n * 60 * 1000;
+  return 0;
+}
+function eventToRow(e) {
+  const p = e.payload;
+  const row = {
+    ts: e.ts,
+    runId: p.runId,
+    scenarioId: p.scenarioId,
+    originalClassification: p.originalClassification,
+    disputedTo: p.disputedTo,
+    qaActor: p.qaActor
+  };
+  if (p.qaReason)
+    row.qaReason = p.qaReason;
+  return row;
+}
+function renderText(rows) {
+  if (rows.length === 0)
+    return `No disputes recorded.
+`;
+  const lines = [];
+  lines.push(`${rows.length} dispute(s):`);
+  for (const r of rows) {
+    lines.push(`  ${r.ts} | ${r.scenarioId} | ${r.originalClassification} \u2192 ${r.disputedTo} | ${r.qaActor}`);
+    if (r.qaReason)
+      lines.push(`    reason: ${r.qaReason}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+async function disputesCmd(argv) {
+  let since;
+  let format = "text";
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === "--since") {
+      since = argv[++i];
+    } else if (argv[i] === "--format") {
+      const v = argv[++i];
+      if (v === "json" || v === "text")
+        format = v;
+    }
+  }
+  const repoRoot = process.cwd();
+  const events = loadAllEvents(repoRoot);
+  const disputes = events.filter((e) => e.type === "classification.disputed");
+  let cutoffMs;
+  if (since) {
+    const sinceMs = parseDuration(since);
+    if (sinceMs > 0)
+      cutoffMs = Date.now() - sinceMs;
+  }
+  const rows = disputes.filter((e) => cutoffMs === undefined || Date.parse(e.ts) >= cutoffMs).map(eventToRow).sort((a, b) => a.ts < b.ts ? 1 : -1);
+  if (format === "json") {
+    process.stdout.write(JSON.stringify(rows, null, 2));
+  } else {
+    process.stdout.write(renderText(rows));
+  }
+  return 0;
+}
+
 // src/bin-internal/doctor.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
+import { join as join6 } from "path";
 
 // src/graph/cost.ts
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "fs";
 init_paths();
 function summarizeCost(repoRoot, daysBack) {
   const paths = graphPaths(repoRoot);
   const result = { totalCalls: 0, totalUsd: 0, bySkill: {}, windowDays: daysBack };
-  if (!existsSync(paths.costLog))
+  if (!existsSync2(paths.costLog))
     return result;
   const cutoff = Date.now() - daysBack * 86400 * 1000;
-  for (const line of readFileSync(paths.costLog, "utf8").split(`
+  for (const line of readFileSync2(paths.costLog, "utf8").split(`
 `)) {
     if (!line.trim())
       continue;
@@ -7941,10 +8101,10 @@ function frontmatterField(content, field) {
   return m?.[1] ?? null;
 }
 function checkGoldenEvalDir(repoRoot) {
-  const root = join3(repoRoot, "fixtures/golden-eval");
-  if (!existsSync4(root))
+  const root = join6(repoRoot, "fixtures/golden-eval");
+  if (!existsSync7(root))
     return [{ ok: false, message: "fixtures/golden-eval/ does not exist" }];
-  const dirs = readdirSync2(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("."));
+  const dirs = readdirSync4(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith("."));
   const results = [];
   if (dirs.length < 3) {
     results.push({
@@ -7953,15 +8113,15 @@ function checkGoldenEvalDir(repoRoot) {
     });
   }
   for (const entry of dirs) {
-    const dir = join3(root, entry.name);
-    const metaPath = join3(dir, "meta.json");
-    if (!existsSync4(metaPath)) {
+    const dir = join6(root, entry.name);
+    const metaPath = join6(dir, "meta.json");
+    if (!existsSync7(metaPath)) {
       results.push({ ok: false, message: `${entry.name}: meta.json missing` });
       continue;
     }
     let meta;
     try {
-      meta = JSON.parse(readFileSync4(metaPath, "utf8"));
+      meta = JSON.parse(readFileSync6(metaPath, "utf8"));
     } catch (err) {
       results.push({
         ok: false,
@@ -7972,12 +8132,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 (!existsSync4(join3(dir, "story.md")))
+    if (!existsSync7(join6(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 (!existsSync4(join3(dir, rel))) {
+        if (!existsSync7(join6(dir, rel))) {
           results.push({
             ok: false,
             message: `${meta.id ?? entry.name}: stage "${stage}" declared but ${rel} missing`
@@ -7989,10 +8149,10 @@ function checkGoldenEvalDir(repoRoot) {
   return results;
 }
 function checkRubricPrompt(repoRoot) {
-  const path = join3(repoRoot, "packages/prompts/eval-rubric.md");
-  if (!existsSync4(path))
+  const path = join6(repoRoot, "packages/prompts/eval-rubric.md");
+  if (!existsSync7(path))
     return [{ ok: false, message: "packages/prompts/eval-rubric.md missing" }];
-  const text = readFileSync4(path, "utf8");
+  const text = readFileSync6(path, "utf8");
   const id = frontmatterField(text, "id");
   const version = frontmatterField(text, "version");
   if (id !== "eval-rubric")
@@ -8002,10 +8162,10 @@ function checkRubricPrompt(repoRoot) {
   return [];
 }
 function checkEvalSkill(repoRoot) {
-  const path = join3(repoRoot, "packages/skills/xera-eval.md");
-  if (!existsSync4(path))
+  const path = join6(repoRoot, "packages/skills/xera-eval.md");
+  if (!existsSync7(path))
     return [{ ok: false, message: "packages/skills/xera-eval.md missing" }];
-  const text = readFileSync4(path, "utf8");
+  const text = readFileSync6(path, "utf8");
   if (!frontmatterField(text, "name"))
     return [{ ok: false, message: 'xera-eval.md frontmatter "name" missing' }];
   return [];
@@ -8014,16 +8174,17 @@ function checkPromptInjectionPreamble(repoRoot) {
   return verifyPrompts(repoRoot);
 }
 function checkRootScripts(repoRoot) {
-  const path = join3(repoRoot, "package.json");
-  if (!existsSync4(path))
+  const path = join6(repoRoot, "package.json");
+  if (!existsSync7(path))
     return [{ ok: false, message: "root package.json missing" }];
-  const pkg = JSON.parse(readFileSync4(path, "utf8"));
+  const pkg = JSON.parse(readFileSync6(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}` }));
 }
-async function doctorCmd(_argv, opts = {}) {
+async function doctorCmd(argv, opts = {}) {
   const repoRoot = opts.cwd ?? process.cwd();
+  const autoEnrich = argv.includes("--auto-enrich");
   const results = [
     ...checkGoldenEvalDir(repoRoot),
     ...checkRubricPrompt(repoRoot),
@@ -8041,9 +8202,9 @@ async function doctorCmd(_argv, opts = {}) {
     if (top)
       console.log(`  Top skill:   ${top[0]} (${top[1].calls} calls, $${top[1].usd.toFixed(2)})`);
   }
-  const xeraDir = join3(repoRoot, ".xera");
-  if (existsSync4(xeraDir)) {
-    const ticketDirs = readdirSync2(xeraDir, { withFileTypes: true }).filter((e) => e.isDirectory() && /^[A-Z]+-\d+$/.test(e.name));
+  const xeraDir = join6(repoRoot, ".xera");
+  if (existsSync7(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);
       const fetchedTickets = new Set(events.filter((e) => e.type === "ticket.fetched").map((e) => e.payload.ticketId));
@@ -8054,6 +8215,16 @@ async function doctorCmd(_argv, opts = {}) {
         console.log(`  These won't participate in v0.6.1+ features (TEST_OUTDATED, /xera-impact).`);
         console.log(`  Run: bun run xera:graph-backfill`);
         console.log(`  (Use --dry-run to preview.)`);
+        if (autoEnrich) {
+          console.log("[doctor] --auto-enrich: running backfill for unbackfilled tickets...");
+          const { graphBackfillCmd: graphBackfillCmd2 } = await Promise.resolve().then(() => (init_graph_backfill(), exports_graph_backfill));
+          const exitCode = await graphBackfillCmd2([]);
+          if (exitCode === 0) {
+            console.log(`[doctor] auto-enrich: backfilled ${unbackfilled.length} tickets`);
+          } else {
+            console.error("[doctor] auto-enrich: backfill failed");
+          }
+        }
       }
     }
   }
@@ -8067,26 +8238,26 @@ async function doctorCmd(_argv, opts = {}) {
 }
 
 // src/bin-internal/eval-deterministic.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8 } from "path";
 import { validateGherkin } from "@xera-ai/web";
 
 // src/eval/paths.ts
-import { join as join4 } from "path";
+import { join as join7 } from "path";
 function resolveEvalPaths(cwd, runId) {
-  const root = join4(cwd, ".xera", "eval", runId);
+  const root = join7(cwd, ".xera", "eval", runId);
   return {
     root,
-    manifest: join4(root, "manifest.json"),
-    lock: join4(root, ".lock"),
-    deterministicScores: join4(root, "deterministic-scores.json"),
-    judgeScores: join4(root, "judge-scores.json"),
-    report: join4(root, "report.md"),
-    summary: join4(root, "summary.json"),
-    inputsDir: join4(root, "inputs"),
-    actualDir: join4(root, "actual"),
-    ticketInputsDir: (ticket) => join4(root, "inputs", ticket),
-    ticketActualDir: (ticket) => join4(root, "actual", ticket)
+    manifest: join7(root, "manifest.json"),
+    lock: join7(root, ".lock"),
+    deterministicScores: join7(root, "deterministic-scores.json"),
+    judgeScores: join7(root, "judge-scores.json"),
+    report: join7(root, "report.md"),
+    summary: join7(root, "summary.json"),
+    inputsDir: join7(root, "inputs"),
+    actualDir: join7(root, "actual"),
+    ticketInputsDir: (ticket) => join7(root, "inputs", ticket),
+    ticketActualDir: (ticket) => join7(root, "actual", ticket)
   };
 }
 
@@ -8171,11 +8342,11 @@ var SummarySchema = z2.object({
 
 // src/bin-internal/eval-deterministic.ts
 function checkFeatureFromStory(actualFeaturePath) {
-  if (!existsSync5(actualFeaturePath)) {
+  if (!existsSync8(actualFeaturePath)) {
     return { passed: false, checks: ["validate-feature"], error: "actual missing: test.feature" };
   }
   try {
-    const r = validateGherkin(readFileSync5(actualFeaturePath, "utf8"));
+    const r = validateGherkin(readFileSync7(actualFeaturePath, "utf8"));
     if (r.ok)
       return { passed: true, checks: ["validate-feature"] };
     return {
@@ -8188,31 +8359,31 @@ function checkFeatureFromStory(actualFeaturePath) {
   }
 }
 function checkScriptFromFeature(actualTicketDir) {
-  const specPath = join5(actualTicketDir, "spec.ts");
-  if (!existsSync5(specPath)) {
+  const specPath = join8(actualTicketDir, "spec.ts");
+  if (!existsSync8(specPath)) {
     return { passed: false, checks: ["file-presence"], error: "actual missing: spec.ts" };
   }
   return { passed: true, checks: ["file-presence"] };
 }
 function checkDiagnoseFailure(inputsTicketDir, actualTicketDir) {
-  const inputPath = join5(inputsTicketDir, "classifier-input.json");
-  const actualPath = join5(actualTicketDir, "classification.json");
-  if (!existsSync5(actualPath)) {
+  const inputPath = join8(inputsTicketDir, "classifier-input.json");
+  const actualPath = join8(actualTicketDir, "classification.json");
+  if (!existsSync8(actualPath)) {
     return {
       passed: false,
       checks: ["bucket-match"],
       error: "actual missing: classification.json"
     };
   }
-  if (!existsSync5(inputPath)) {
+  if (!existsSync8(inputPath)) {
     return {
       passed: false,
       checks: ["bucket-match"],
       error: "inputs missing: classifier-input.json"
     };
   }
-  const golden = JSON.parse(readFileSync5(inputPath, "utf8"));
-  const actual = JSON.parse(readFileSync5(actualPath, "utf8"));
+  const golden = JSON.parse(readFileSync7(inputPath, "utf8"));
+  const actual = JSON.parse(readFileSync7(actualPath, "utf8"));
   const goldScens = golden.scenarios ?? [];
   const actScens = actual.scenarios ?? [];
   const mismatches = [];
@@ -8242,11 +8413,11 @@ async function evalDeterministicCmd(argv, opts = {}) {
     return 1;
   }
   const paths = resolveEvalPaths(cwd, runId);
-  if (!existsSync5(paths.manifest)) {
+  if (!existsSync8(paths.manifest)) {
     console.error(`[xera:eval-deterministic] missing manifest.json at ${paths.manifest}`);
     return 1;
   }
-  const manifest = ManifestSchema.parse(JSON.parse(readFileSync5(paths.manifest, "utf8")));
+  const manifest = ManifestSchema.parse(JSON.parse(readFileSync7(paths.manifest, "utf8")));
   const entries = [];
   for (const [ticket, ticketStages] of Object.entries(manifest.ticket_stages)) {
     for (const stage of ticketStages) {
@@ -8254,7 +8425,7 @@ async function evalDeterministicCmd(argv, opts = {}) {
       const actualDir = paths.ticketActualDir(ticket);
       let result;
       if (stage === "feature-from-story") {
-        result = checkFeatureFromStory(join5(actualDir, "test.feature"));
+        result = checkFeatureFromStory(join8(actualDir, "test.feature"));
       } else if (stage === "script-from-feature") {
         result = checkScriptFromFeature(actualDir);
       } else {
@@ -8281,13 +8452,13 @@ async function evalDeterministicCmd(argv, opts = {}) {
 // src/bin-internal/eval-prepare.ts
 import {
   copyFileSync,
-  existsSync as existsSync7,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync7,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync9,
   writeFileSync as writeFileSync4
 } from "fs";
-import { join as join6 } from "path";
+import { join as join9 } from "path";
 
 // src/eval/run-id.ts
 import { execSync } from "child_process";
@@ -8312,11 +8483,11 @@ function generateRunId(opts = {}) {
 }
 
 // src/lock/file-lock.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync8, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { hostname } from "os";
 import { dirname as dirname2 } from "path";
 function acquireLock(path, runId) {
-  if (existsSync6(path))
+  if (existsSync9(path))
     return false;
   mkdirSync3(dirname2(path), { recursive: true });
   const data = {
@@ -8333,13 +8504,13 @@ function acquireLock(path, runId) {
   }
 }
 function releaseLock(path) {
-  if (existsSync6(path))
+  if (existsSync9(path))
     unlinkSync(path);
 }
 function readLock(path) {
-  if (!existsSync6(path))
+  if (!existsSync9(path))
     return null;
-  return JSON.parse(readFileSync6(path, "utf8"));
+  return JSON.parse(readFileSync8(path, "utf8"));
 }
 function isLockStale(path) {
   const lock = readLock(path);
@@ -8360,7 +8531,7 @@ function forceUnlock(path) {
 }
 
 // src/bin-internal/eval-prepare.ts
-function parseFlags(argv) {
+function parseFlags2(argv) {
   const flags = { force: false, only_prompt: null, only_ticket: null };
   for (const arg of argv) {
     if (arg === "--force")
@@ -8380,42 +8551,42 @@ function parseFlags(argv) {
   return flags;
 }
 function readPromptVersion(repoRoot, name) {
-  const path = join6(repoRoot, "packages/prompts", `${name}.md`);
-  if (!existsSync7(path))
+  const path = join9(repoRoot, "packages/prompts", `${name}.md`);
+  if (!existsSync10(path))
     return "0.0.0";
-  const text = readFileSync7(path, "utf8");
+  const text = readFileSync9(path, "utf8");
   const m = /^version:\s*(\S+)\s*$/m.exec(text);
   return m?.[1] ?? "0.0.0";
 }
 function discoverEvalTickets(repoRoot) {
-  const root = join6(repoRoot, "fixtures/golden-eval");
-  if (!existsSync7(root))
+  const root = join9(repoRoot, "fixtures/golden-eval");
+  if (!existsSync10(root))
     return [];
   const out = [];
-  for (const entry of readdirSync3(root, { withFileTypes: true })) {
+  for (const entry of readdirSync5(root, { withFileTypes: true })) {
     if (!entry.isDirectory())
       continue;
     if (entry.name === "README.md" || entry.name.startsWith("."))
       continue;
-    const dir = join6(root, entry.name);
-    const metaPath = join6(dir, "meta.json");
-    if (!existsSync7(metaPath))
+    const dir = join9(root, entry.name);
+    const metaPath = join9(dir, "meta.json");
+    if (!existsSync10(metaPath))
       continue;
-    const meta = JSON.parse(readFileSync7(metaPath, "utf8"));
+    const meta = JSON.parse(readFileSync9(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 = join6(repoRoot, "fixtures/golden-tickets");
-  if (!existsSync7(root))
+  const root = join9(repoRoot, "fixtures/golden-tickets");
+  if (!existsSync10(root))
     return [];
   const out = [];
-  for (const entry of readdirSync3(root, { withFileTypes: true })) {
+  for (const entry of readdirSync5(root, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.endsWith(".json"))
       continue;
-    const path = join6(root, entry.name);
-    const data = JSON.parse(readFileSync7(path, "utf8"));
+    const path = join9(root, entry.name);
+    const data = JSON.parse(readFileSync9(path, "utf8"));
     if (typeof data.ticket === "string")
       out.push({ id: data.ticket, path });
   }
@@ -8423,7 +8594,7 @@ function discoverClassifierTickets(repoRoot) {
 }
 async function evalPrepareCmd(argv, opts = {}) {
   const repoRoot = opts.cwd ?? process.cwd();
-  const flags = parseFlags(argv);
+  const flags = parseFlags2(argv);
   if ("error" in flags) {
     console.error(`[xera:eval-prepare] ${flags.error}`);
     return 1;
@@ -8474,7 +8645,7 @@ async function evalPrepareCmd(argv, opts = {}) {
     ...opts.getGitSha ? { getGitSha: opts.getGitSha } : {}
   });
   const paths = resolveEvalPaths(repoRoot, runId);
-  if (existsSync7(paths.root) && !flags.force) {
+  if (existsSync10(paths.root) && !flags.force) {
     console.error(`[xera:eval-prepare] run dir already exists: ${paths.root}. Pass --force to re-run.`);
     return 1;
   }
@@ -8486,13 +8657,13 @@ async function evalPrepareCmd(argv, opts = {}) {
     const evalT = evalTickets.find((t) => t.id === ticket);
     const classT = classifierTickets.find((t) => t.id === ticket);
     if (evalT) {
-      copyFileSync(join6(evalT.dir, "story.md"), join6(ticketInputs, "story.md"));
-      const featurePath = join6(evalT.dir, "golden/test.feature");
-      if (existsSync7(featurePath))
-        copyFileSync(featurePath, join6(ticketInputs, "test.feature"));
+      copyFileSync(join9(evalT.dir, "story.md"), join9(ticketInputs, "story.md"));
+      const featurePath = join9(evalT.dir, "golden/test.feature");
+      if (existsSync10(featurePath))
+        copyFileSync(featurePath, join9(ticketInputs, "test.feature"));
     }
     if (classT) {
-      copyFileSync(classT.path, join6(ticketInputs, "classifier-input.json"));
+      copyFileSync(classT.path, join9(ticketInputs, "classifier-input.json"));
     }
   }
   const now = (opts.now ?? (() => new Date))();
@@ -8528,7 +8699,7 @@ async function evalPrepareCmd(argv, opts = {}) {
 }
 
 // src/bin-internal/eval-report.ts
-import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
 function scoreJudgment(j) {
   const nonNa = j.dimensions.filter((d) => d.verdict !== "NA");
   if (nonNa.length === 0)
@@ -8583,22 +8754,22 @@ async function evalReportCmd(argv, opts = {}) {
     return 1;
   }
   const paths = resolveEvalPaths(cwd, runId);
-  if (!existsSync8(paths.manifest)) {
+  if (!existsSync11(paths.manifest)) {
     console.error(`[xera:eval-report] missing manifest.json at ${paths.manifest}`);
     return 1;
   }
-  const manifest = ManifestSchema.parse(JSON.parse(readFileSync8(paths.manifest, "utf8")));
+  const manifest = ManifestSchema.parse(JSON.parse(readFileSync10(paths.manifest, "utf8")));
   try {
     let det;
     let judge;
     try {
-      det = DeterministicScoresSchema.parse(JSON.parse(readFileSync8(paths.deterministicScores, "utf8")));
+      det = DeterministicScoresSchema.parse(JSON.parse(readFileSync10(paths.deterministicScores, "utf8")));
     } catch (err) {
       console.error(`[xera:eval-report] invalid deterministic-scores.json: ${err.message}`);
       return 2;
     }
     try {
-      judge = JudgeScoresSchema.parse(JSON.parse(readFileSync8(paths.judgeScores, "utf8")));
+      judge = JudgeScoresSchema.parse(JSON.parse(readFileSync10(paths.judgeScores, "utf8")));
     } catch (err) {
       console.error(`[xera:eval-report] invalid judge-scores.json: ${err.message}`);
       return 2;
@@ -8670,40 +8841,40 @@ async function evalReportCmd(argv, opts = {}) {
 }
 
 // src/bin-internal/exec.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync7 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7 } from "fs";
+import { join as join13 } from "path";
 import { chromium } from "@playwright/test";
 import { runAuthSetup, runPlaywright, stagePlaywrightState } from "@xera-ai/web";
 
 // src/artifact/paths.ts
-import { join as join7 } from "path";
+import { join as join10 } from "path";
 var TICKET_RE = /^[A-Z][A-Z0-9_]*-\d+$|^SAMPLE-\d+$/;
 function resolveArtifactPaths(repoRoot, ticket) {
   if (!TICKET_RE.test(ticket)) {
     throw new Error(`Invalid ticket key: "${ticket}" (expected e.g. JIRA-123 or SAMPLE-001)`);
   }
-  const ticketDir = join7(repoRoot, ".xera", ticket);
+  const ticketDir = join10(repoRoot, ".xera", ticket);
   return {
     ticketDir,
-    storyPath: join7(ticketDir, "story.md"),
-    featurePath: join7(ticketDir, "test.feature"),
-    specPath: join7(ticketDir, "spec.ts"),
-    pageObjectsDir: join7(ticketDir, "page-objects"),
-    runsDir: join7(ticketDir, "runs"),
-    metaPath: join7(ticketDir, "meta.json"),
-    statusPath: join7(ticketDir, "status.json"),
-    logPath: join7(ticketDir, "xera.log"),
-    lockPath: join7(ticketDir, ".lock"),
-    authDir: join7(repoRoot, ".xera", ".auth"),
+    storyPath: join10(ticketDir, "story.md"),
+    featurePath: join10(ticketDir, "test.feature"),
+    specPath: join10(ticketDir, "spec.ts"),
+    pageObjectsDir: join10(ticketDir, "page-objects"),
+    runsDir: join10(ticketDir, "runs"),
+    metaPath: join10(ticketDir, "meta.json"),
+    statusPath: join10(ticketDir, "status.json"),
+    logPath: join10(ticketDir, "xera.log"),
+    lockPath: join10(ticketDir, ".lock"),
+    authDir: join10(repoRoot, ".xera", ".auth"),
     runPath: (runId) => {
-      const runDir = join7(ticketDir, "runs", runId);
+      const runDir = join10(ticketDir, "runs", runId);
       return {
         runDir,
-        reportJsonPath: join7(runDir, "report.json"),
-        tracePath: join7(runDir, "trace.zip"),
-        normalizedPath: join7(runDir, "normalized.json"),
-        screenshotsDir: join7(runDir, "screenshots"),
-        videoDir: join7(runDir, "videos")
+        reportJsonPath: join10(runDir, "report.json"),
+        tracePath: join10(runDir, "trace.zip"),
+        normalizedPath: join10(runDir, "normalized.json"),
+        screenshotsDir: join10(runDir, "screenshots"),
+        videoDir: join10(runDir, "videos")
       };
     }
   };
@@ -8714,7 +8885,7 @@ function generateRunId2(now = new Date) {
 
 // src/auth/refresh.ts
 var RE = /^(\d+)([hms])$/;
-function parseDuration(d) {
+function parseDuration2(d) {
   const m = RE.exec(d);
   if (!m)
     throw new Error(`Bad duration "${d}" \u2014 expected e.g. "8h", "30m", "45s"`);
@@ -8729,8 +8900,8 @@ function parseDuration(d) {
 function needsRefresh(entry, policy, now = new Date) {
   if (!entry)
     return true;
-  const ttlMs = parseDuration(policy.ttl);
-  const bufMs = parseDuration(policy.refreshBuffer);
+  const ttlMs = parseDuration2(policy.ttl);
+  const bufMs = parseDuration2(policy.refreshBuffer);
   const createdAt = new Date(entry.created_at).getTime();
   if (now.getTime() - createdAt > ttlMs)
     return true;
@@ -8741,8 +8912,8 @@ function needsRefresh(entry, policy, now = new Date) {
 }
 
 // src/auth/state.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11 } from "path";
 import { z as z3 } from "zod";
 
 // src/auth/encrypt.ts
@@ -8808,7 +8979,7 @@ var AuthStateEntrySchema = z3.object({
   payload: z3.record(z3.string(), z3.unknown())
 });
 function pathFor(authDir, role) {
-  return join8(authDir, `${role}.json`);
+  return join11(authDir, `${role}.json`);
 }
 function writeAuthState(authDir, entry) {
   mkdirSync5(authDir, { recursive: true });
@@ -8817,16 +8988,16 @@ function writeAuthState(authDir, entry) {
 }
 function readAuthState(authDir, role) {
   const p = pathFor(authDir, role);
-  if (!existsSync9(p))
+  if (!existsSync12(p))
     return null;
-  const txt = readFileSync9(p, "utf8");
+  const txt = readFileSync11(p, "utf8");
   const plain = decrypt(txt, resolveAuthKey());
   return AuthStateEntrySchema.parse(JSON.parse(plain));
 }
 
 // src/config/load.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join12 } from "path";
 import { pathToFileURL } from "url";
 
 // src/config/schema.ts
@@ -8885,7 +9056,7 @@ var ReportingSchema = z4.object({
 var RunSchema = z4.object({
   autoImpact: z4.object({
     enabled: z4.boolean().default(true),
-    threshold: z4.number().nonnegative().default(6)
+    threshold: z4.number().nonnegative().default(8)
   }).prefault({})
 }).prefault({});
 var XeraConfigSchema = z4.object({
@@ -8899,8 +9070,8 @@ var XeraConfigSchema = z4.object({
 
 // src/config/load.ts
 async function loadConfig(cwd) {
-  const path = join9(cwd, "xera.config.ts");
-  if (!existsSync10(path)) {
+  const path = join12(cwd, "xera.config.ts");
+  if (!existsSync13(path)) {
     throw new Error(`xera.config.ts not found in ${cwd}`);
   }
   const mod = await import(pathToFileURL(path).href);
@@ -8909,7 +9080,7 @@ async function loadConfig(cwd) {
 }
 
 // src/logging/ndjson-logger.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync12 } from "fs";
 import { dirname as dirname3 } from "path";
 
 class NdjsonLogger {
@@ -8924,9 +9095,9 @@ class NdjsonLogger {
 `);
   }
   static readAll(path) {
-    if (!existsSync11(path))
+    if (!existsSync14(path))
       return [];
-    const txt = readFileSync10(path, "utf8").trim();
+    const txt = readFileSync12(path, "utf8").trim();
     if (!txt)
       return [];
     return txt.split(`
@@ -8941,6 +9112,8 @@ async function execCmd(argv) {
     console.error("[xera:exec] usage: exec <TICKET>");
     return 1;
   }
+  const grepIdx = argv.indexOf("--grep");
+  const grep = grepIdx > -1 ? argv[grepIdx + 1] : undefined;
   const cwd = process.cwd();
   const config = await loadConfig(cwd);
   const paths = resolveArtifactPaths(cwd, ticket);
@@ -8977,7 +9150,7 @@ async function execCmd(argv) {
             await runAuthSetup({
               role: roleName,
               creds: { email, password },
-              setupScriptPath: join10(cwd, config.web.auth.setupScript),
+              setupScriptPath: join13(cwd, config.web.auth.setupScript),
               authDir: paths.authDir,
               browser
             });
@@ -8995,8 +9168,8 @@ async function execCmd(argv) {
         }
       }
     }
-    const cfgPath = join10(cwd, "playwright.config.ts");
-    if (!existsSync12(cfgPath)) {
+    const cfgPath = join13(cwd, "playwright.config.ts");
+    if (!existsSync15(cfgPath)) {
       console.error(`[xera:exec] missing ${cfgPath}. Run \`xera init\` to scaffold it, then re-run.`);
       return 1;
     }
@@ -9004,7 +9177,7 @@ async function execCmd(argv) {
     mkdirSync7(runDir, { recursive: true });
     const envName = process.env.XERA_ENV ?? config.web.defaultEnv;
     const baseURL = config.web.baseUrl[envName] ?? config.web.baseUrl[config.web.defaultEnv];
-    const reportJsonPath = join10(runDir, "report.json");
+    const reportJsonPath = join13(runDir, "report.json");
     log.log({ step: "exec.start", runId, env: envName, baseURL });
     const r = await runPlaywright({
       specPath: paths.specPath,
@@ -9014,7 +9187,8 @@ async function execCmd(argv) {
         XERA_BASE_URL: baseURL,
         XERA_ENV: envName,
         PLAYWRIGHT_JSON_OUTPUT_NAME: reportJsonPath
-      }
+      },
+      ...grep && { grep }
     });
     log.log({ step: "exec.done", runId, exit: r.exitCode, ms: Date.now() - t0 });
     console.log(`[xera:exec] runId=${runId} outcome=${r.outcome}`);
@@ -9029,22 +9203,22 @@ import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname5 } from "path";
 
 // src/artifact/hash.ts
-import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
 function hashString(s) {
-  return `sha256:${createHash2("sha256").update(s).digest("hex")}`;
+  return `sha256:${createHash4("sha256").update(s).digest("hex")}`;
 }
 function hashFile(path) {
-  return hashString(readFileSync11(path, "utf8"));
+  return hashString(readFileSync13(path, "utf8"));
 }
 function hashFileIfExists(path) {
-  if (!existsSync13(path))
+  if (!existsSync16(path))
     return null;
   return hashFile(path);
 }
 
 // src/artifact/meta.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname4 } from "path";
 import { z as z5 } from "zod";
 var MetaJsonSchema = z5.object({
@@ -9062,9 +9236,9 @@ var MetaJsonSchema = z5.object({
   script_warnings: z5.array(z5.string()).optional()
 });
 function readMeta(path) {
-  if (!existsSync14(path))
+  if (!existsSync17(path))
     return null;
-  return MetaJsonSchema.parse(JSON.parse(readFileSync12(path, "utf8")));
+  return MetaJsonSchema.parse(JSON.parse(readFileSync14(path, "utf8")));
 }
 function writeMeta(path, meta) {
   mkdirSync8(dirname4(path), { recursive: true });
@@ -9081,32 +9255,32 @@ function updateMeta(path, patch) {
 }
 
 // src/jira/mcp-backend.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
 import { tmpdir } from "os";
-import { join as join11 } from "path";
+import { join as join14 } from "path";
 var MCP_ENV = "XERA_MCP_JIRA";
 async function createMcpBackend(_baseUrl) {
   if (process.env[MCP_ENV] !== "1")
     return null;
-  const tmpDir = join11(tmpdir(), "xera-mcp");
+  const tmpDir = join14(tmpdir(), "xera-mcp");
   mkdirSync9(tmpDir, { recursive: true });
   return {
     backend: "mcp",
     async fetchTicket(key, _fields) {
-      const cachePath = join11(tmpDir, `${key}.json`);
-      if (!existsSync15(cachePath)) {
+      const cachePath = join14(tmpDir, `${key}.json`);
+      if (!existsSync18(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(readFileSync13(cachePath, "utf8"));
+      const parsed = JSON.parse(readFileSync15(cachePath, "utf8"));
       return parsed;
     },
     async postComment(key, body) {
-      const outPath = join11(tmpDir, `${key}.comment.json`);
+      const outPath = join14(tmpDir, `${key}.comment.json`);
       writeFileSync8(outPath, JSON.stringify({ key, body }));
       return { id: "mcp-pending" };
     },
     async transitionStatus(key, statusName) {
-      const outPath = join11(tmpDir, `${key}.transition.json`);
+      const outPath = join14(tmpDir, `${key}.transition.json`);
       writeFileSync8(outPath, JSON.stringify({ key, statusName }));
     },
     async listFields(_sampleKey) {
@@ -9275,49 +9449,8 @@ function renderStory(t) {
 `);
 }
 
-// src/bin-internal/graph-backfill.ts
-init_graph_record_script();
-import { existsSync as existsSync18, readdirSync as readdirSync5 } from "fs";
-import { join as join14 } from "path";
-async function backfillTicket(repoRoot, ticket, dryRun) {
-  const storyPath = join14(repoRoot, ".xera", ticket, "story.md");
-  if (!existsSync18(storyPath))
-    return 0;
-  const { recordFetch: recordFetch2 } = await Promise.resolve().then(() => (init_graph_record(), exports_graph_record));
-  if (dryRun) {
-    console.log(`[backfill dry-run] would backfill ${ticket}`);
-    return 0;
-  }
-  await recordScriptImpl(repoRoot, ticket);
-  await recordFetch2(repoRoot, ticket);
-  return 0;
-}
-async function graphBackfillCmd(argv) {
-  const dryRun = argv.includes("--dry-run");
-  const repoRoot = process.cwd();
-  const xeraDir = join14(repoRoot, ".xera");
-  if (!existsSync18(xeraDir)) {
-    console.log("[backfill] no .xera/ directory");
-    return 0;
-  }
-  const tickets = [];
-  for (const entry of readdirSync5(xeraDir, { withFileTypes: true })) {
-    if (!entry.isDirectory())
-      continue;
-    if (entry.name === "graph")
-      continue;
-    if (entry.name.startsWith("."))
-      continue;
-    if (!/^[A-Z]+-\d+$/.test(entry.name))
-      continue;
-    tickets.push(entry.name);
-  }
-  console.log(`[backfill] found ${tickets.length} tickets`);
-  for (const t of tickets)
-    await backfillTicket(repoRoot, t, dryRun);
-  console.log(`[backfill] done`);
-  return 0;
-}
+// src/bin-internal/index.ts
+init_graph_backfill();
 
 // src/graph/enrich.ts
 init_store();
@@ -9421,7 +9554,7 @@ function filterByTicket(snap, ticket) {
   };
   return out;
 }
-function renderText(snap) {
+function renderText2(snap) {
   const out = [];
   out.push(`Graph snapshot \u2014 ${snap.event_count} events`);
   out.push(`Tickets: ${Object.keys(snap.tickets).length}`);
@@ -9450,13 +9583,313 @@ async function graphQueryCmd(argv) {
   if (format === "json")
     process.stdout.write(JSON.stringify(snap, null, 2));
   else
-    process.stdout.write(renderText(snap));
+    process.stdout.write(renderText2(snap));
   return 0;
 }
 
 // src/bin-internal/index.ts
 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 join17 } from "path";
+
+// src/graph/render.ts
+import { readFileSync as readFileSync17 } from "fs";
+import { dirname as dirname6, join as join16 } from "path";
+import { fileURLToPath } from "url";
+var COLORS = {
+  ticket: "#3B82F6",
+  scenarioPass: "#10B981",
+  scenarioFail: "#EF4444",
+  pom: "#F59E0B",
+  area: "#6B7280",
+  failure: "#EF4444",
+  edgeModifies: "#EF4444",
+  edgeDefault: "#9CA3AF",
+  edgeJira: "#3B82F6",
+  edgeSimilar: "#A855F7"
+};
+function ticketsAfter(since, fetchedAt) {
+  if (!since)
+    return true;
+  return Date.parse(fetchedAt) >= Date.parse(since);
+}
+function scenariosAfter(since, generatedAt) {
+  if (!since)
+    return true;
+  return Date.parse(generatedAt) >= Date.parse(since);
+}
+function buildTicketNode(snap, ticketId) {
+  const t = snap.tickets[ticketId];
+  const usageCount = snap.edges.filter((e) => e.kind === "tests" && e.from === ticketId).length;
+  const node = {
+    id: t.id,
+    label: t.id,
+    group: "Ticket",
+    color: COLORS.ticket,
+    shape: "dot",
+    size: 10 + Math.min(usageCount * 2, 20),
+    title: `${t.id} \u2014 ${t.summary}`
+  };
+  return node;
+}
+function buildScenarioNode(snap, scenarioId2) {
+  const s = snap.scenarios[scenarioId2];
+  const failed = snap.latest_failures[scenarioId2];
+  const sizeBase = s.priority === "p0" ? 14 : s.priority === "p1" ? 11 : 9;
+  const node = {
+    id: s.id,
+    label: s.name,
+    group: "Scenario",
+    color: failed ? COLORS.scenarioFail : COLORS.scenarioPass,
+    shape: "square",
+    size: sizeBase,
+    title: `${s.ticketId} / ${s.name} [${s.priority.toUpperCase()}]`
+  };
+  return node;
+}
+function buildPomNode(snap, pomId2) {
+  const p = snap.poms[pomId2];
+  const usageCount = snap.edges.filter((e) => e.kind === "uses" && e.to === pomId2).length;
+  const node = {
+    id: p.id,
+    label: p.filePath.split("/").pop() ?? p.id,
+    group: "POM",
+    color: COLORS.pom,
+    shape: "diamond",
+    size: 8 + Math.min(usageCount * 2, 16),
+    title: `${p.filePath} (${p.route || "no route"})`
+  };
+  return node;
+}
+function buildAreaNode(snap, areaId) {
+  const a = snap.areas[areaId];
+  const node = {
+    id: a.id,
+    label: a.id,
+    group: "SUTArea",
+    color: COLORS.area,
+    shape: "hexagon",
+    size: 12,
+    title: `area: ${a.id}`
+  };
+  return node;
+}
+function buildFailureNode(_snap, failure) {
+  const node = {
+    id: failure.id,
+    label: "fail",
+    group: "Failure",
+    color: COLORS.failure,
+    shape: "triangle",
+    size: 10,
+    title: `failure on ${failure.scenarioId} @ ${failure.ts}`
+  };
+  return node;
+}
+function buildEdge(edge, idx) {
+  const v = {
+    id: `e-${idx}`,
+    from: edge.from,
+    to: edge.to,
+    label: edge.kind,
+    arrows: "to",
+    width: 1
+  };
+  switch (edge.kind) {
+    case "modifies":
+      v.color = COLORS.edgeModifies;
+      v.dashes = true;
+      v.width = 2;
+      break;
+    case "jira-linked":
+      v.color = COLORS.edgeJira;
+      v.dashes = true;
+      break;
+    case "similar":
+      v.color = COLORS.edgeSimilar;
+      v.dashes = false;
+      v.width = 1 + Math.round((edge.confidence ?? 0) * 3);
+      break;
+    default:
+      v.color = COLORS.edgeDefault;
+      break;
+  }
+  return v;
+}
+function bfsFromTicket(snap, ticketId, depth) {
+  const nodeIds = new Set([ticketId]);
+  const edgeIdxs = new Set;
+  let frontier = new Set([ticketId]);
+  for (let d = 0;d < depth; d++) {
+    const next = new Set;
+    snap.edges.forEach((e, i) => {
+      if (frontier.has(e.from) && !nodeIds.has(e.to)) {
+        nodeIds.add(e.to);
+        next.add(e.to);
+        edgeIdxs.add(i);
+      } else if (frontier.has(e.to) && !nodeIds.has(e.from)) {
+        nodeIds.add(e.from);
+        next.add(e.from);
+        edgeIdxs.add(i);
+      } else if (frontier.has(e.from) && nodeIds.has(e.to)) {
+        edgeIdxs.add(i);
+      } else if (frontier.has(e.to) && nodeIds.has(e.from)) {
+        edgeIdxs.add(i);
+      }
+    });
+    frontier = next;
+    if (frontier.size === 0)
+      break;
+  }
+  return { nodeIds, edgeIdxs };
+}
+function transformForVisNetwork(snap, opts) {
+  const mode = opts.performanceMode ?? "full";
+  const nodes = [];
+  const edges = [];
+  let includeTickets = new Set;
+  let includeScenarios = new Set;
+  let includePoms = new Set;
+  let includeAreas = new Set;
+  let includeEdgeIdxs = new Set;
+  if (opts.ticketId) {
+    const result = bfsFromTicket(snap, opts.ticketId, opts.depth ?? 2);
+    for (const id of result.nodeIds) {
+      if (snap.tickets[id])
+        includeTickets.add(id);
+      else if (snap.scenarios[id])
+        includeScenarios.add(id);
+      else if (snap.poms[id])
+        includePoms.add(id);
+      else if (snap.areas[id])
+        includeAreas.add(id);
+    }
+    includeEdgeIdxs = result.edgeIdxs;
+  } else {
+    includeTickets = new Set(Object.keys(snap.tickets).filter((id) => ticketsAfter(opts.since, snap.tickets[id].fetchedAt)));
+    includeScenarios = new Set(Object.keys(snap.scenarios).filter((id) => scenariosAfter(opts.since, snap.scenarios[id].generatedAt)));
+    includePoms = new Set(Object.keys(snap.poms));
+    includeAreas = new Set(Object.keys(snap.areas));
+    snap.edges.forEach((_, i) => {
+      includeEdgeIdxs.add(i);
+    });
+  }
+  if (mode === "ticket-only") {
+    includeScenarios.clear();
+    includePoms.clear();
+    includeAreas.clear();
+  }
+  for (const id of includeTickets)
+    nodes.push(buildTicketNode(snap, id));
+  for (const id of includeScenarios)
+    nodes.push(buildScenarioNode(snap, id));
+  for (const id of includePoms)
+    nodes.push(buildPomNode(snap, id));
+  for (const id of includeAreas)
+    nodes.push(buildAreaNode(snap, id));
+  for (const failure of Object.values(snap.latest_failures)) {
+    if (includeScenarios.has(failure.scenarioId)) {
+      nodes.push(buildFailureNode(snap, failure));
+    }
+  }
+  const visibleNodeIds = new Set(nodes.map((n) => n.id));
+  for (const i of includeEdgeIdxs) {
+    const e = snap.edges[i];
+    if (!e)
+      continue;
+    if (!visibleNodeIds.has(e.from) || !visibleNodeIds.has(e.to))
+      continue;
+    edges.push(buildEdge(e, i));
+  }
+  const stats = {
+    tickets: includeTickets.size,
+    scenarios: includeScenarios.size,
+    poms: includePoms.size,
+    areas: includeAreas.size,
+    failures: nodes.filter((n) => n.group === "Failure").length,
+    edges: edges.length
+  };
+  return { nodes, edges, stats };
+}
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname6(__filename2);
+var TEMPLATES_DIR = join16(__dirname2, "templates");
+function loadTemplate(name) {
+  return readFileSync17(join16(TEMPLATES_DIR, name), "utf8");
+}
+function statsToHuman(s) {
+  return `${s.tickets} tickets \xB7 ${s.scenarios} scenarios \xB7 ${s.poms} POMs \xB7 ${s.edges} edges`;
+}
+function renderHtml(input) {
+  const template = loadTemplate("graph.html.template");
+  const css = loadTemplate("graph.css");
+  const js = loadTemplate("graph.js");
+  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);
+}
+
+// src/bin-internal/graph-render.ts
+init_store();
+function parseDepth(s) {
+  const n = s ? Number.parseInt(s, 10) : 2;
+  if (n === 1 || n === 3)
+    return n;
+  return 2;
+}
+function decidePerformanceMode(nodeCount) {
+  if (nodeCount > 2000)
+    return "text-fallback";
+  if (nodeCount > 500)
+    return "ticket-only";
+  return "full";
+}
+async function graphRenderCmd(argv) {
+  let outPath;
+  let ticketId;
+  let since;
+  let depth = 2;
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === "--out")
+      outPath = argv[++i];
+    else if (argv[i] === "--ticket")
+      ticketId = argv[++i];
+    else if (argv[i] === "--since")
+      since = argv[++i];
+    else if (argv[i] === "--depth")
+      depth = parseDepth(argv[++i]);
+  }
+  const repoRoot = process.cwd();
+  const finalPath = outPath ?? join17(repoRoot, ".xera/graph.html");
+  const snap = deriveSnapshot(loadAllEvents(repoRoot));
+  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.
+`);
+    console.log(`[graph-render] graph too large (${totalNodeCount} nodes); wrote ${txtPath}`);
+    return 0;
+  }
+  const opts = { depth, performanceMode };
+  if (ticketId)
+    opts.ticketId = ticketId;
+  if (since)
+    opts.since = since;
+  const data = transformForVisNetwork(snap, opts);
+  const html = renderHtml({ data, stats: data.stats, generatedAt: new Date().toISOString() });
+  mkdirSync11(dirname7(finalPath), { recursive: true });
+  const tmpPath = `${finalPath}.tmp`;
+  writeFileSync10(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;
+}
+
 // src/bin-internal/graph-snapshot.ts
 init_store();
 async function graphSnapshotCmd(argv) {
@@ -9482,8 +9915,8 @@ async function graphSnapshotCmd(argv) {
 }
 
 // src/bin-internal/heal-prepare.ts
-import { existsSync as existsSync20, readdirSync as readdirSync6, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync6, readFileSync as readFileSync18, writeFileSync as writeFileSync11 } from "fs";
+import { join as join18 } from "path";
 import { scrubFreeText } from "@xera-ai/web";
 
 // ../../node_modules/.bun/fflate@0.8.3/node_modules/fflate/esm/index.mjs
@@ -9913,7 +10346,7 @@ function classifyKind(raw) {
 function extractDomSnapshot(tracePath) {
   if (!existsSync20(tracePath))
     return "";
-  const buf = readFileSync17(tracePath);
+  const buf = readFileSync18(tracePath);
   const entries = unzipSync(buf);
   const traceKey = Object.keys(entries).find((name) => name.endsWith(".trace"));
   let chosenKey = null;
@@ -9961,16 +10394,16 @@ function extractDomSnapshot(tracePath) {
   return scrubFreeText(html);
 }
 function findPomLine(ticketDir, rawLocator) {
-  const pomDir = join16(ticketDir, "page-objects");
+  const pomDir = join18(ticketDir, "page-objects");
   const candidates = [];
   if (existsSync20(pomDir)) {
     for (const name of readdirSync6(pomDir)) {
       if (name.endsWith(".ts"))
-        candidates.push(join16(pomDir, name));
+        candidates.push(join18(pomDir, name));
     }
   }
   for (const file of candidates) {
-    const text = readFileSync17(file, "utf8");
+    const text = readFileSync18(file, "utf8");
     const lines = text.split(`
 `);
     for (let i2 = 0;i2 < lines.length; i2++) {
@@ -10008,13 +10441,13 @@ function findGherkinStep(featureText, rawLocator) {
 }
 function healPrepare(repoRoot, ticket, runId, scenarioName) {
   const paths = resolveArtifactPaths(repoRoot, ticket);
-  const classifierPath = join16(paths.ticketDir, "classifier-input.json");
-  const classifier = JSON.parse(readFileSync17(classifierPath, "utf8"));
+  const classifierPath = join18(paths.ticketDir, "classifier-input.json");
+  const classifier = JSON.parse(readFileSync18(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 = join16(paths.runsDir, runId);
-  const normalized = JSON.parse(readFileSync17(join16(runDir, "normalized.json"), "utf8"));
+  const runDir = join18(paths.runsDir, runId);
+  const normalized = JSON.parse(readFileSync18(join18(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}"`);
@@ -10025,9 +10458,9 @@ function healPrepare(repoRoot, ticket, runId, scenarioName) {
   const raw = m[1].trim();
   const kind = classifyKind(raw);
   const pomLoc = findPomLine(paths.ticketDir, raw);
-  const featureText = readFileSync17(paths.featurePath, "utf8");
+  const featureText = readFileSync18(paths.featurePath, "utf8");
   const gherkinStep = findGherkinStep(featureText, raw);
-  const domSnapshotAtFailure = extractDomSnapshot(join16(runDir, "trace.zip"));
+  const domSnapshotAtFailure = extractDomSnapshot(join18(runDir, "trace.zip"));
   return {
     ticket,
     runId,
@@ -10047,8 +10480,8 @@ async function healPrepareCmd(argv) {
   try {
     const result = healPrepare(process.cwd(), ticket, runId, scenarioName);
     const paths = resolveArtifactPaths(process.cwd(), ticket);
-    const outPath = join16(paths.runsDir, runId, "heal-input.json");
-    writeFileSync10(outPath, JSON.stringify(result, null, 2));
+    const outPath = join18(paths.runsDir, runId, "heal-input.json");
+    writeFileSync11(outPath, JSON.stringify(result, null, 2));
     console.log(`[xera:heal-prepare] wrote ${outPath}`);
     return 0;
   } catch (err2) {
@@ -10058,8 +10491,8 @@ async function healPrepareCmd(argv) {
 }
 
 // src/bin-internal/impact-prepare.ts
-import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
-import { join as join17 } from "path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync12 } from "fs";
+import { join as join19 } from "path";
 
 // src/graph/impact.ts
 var PRIORITY_WEIGHT = { p0: 3, p1: 2, p2: 1 };
@@ -10264,7 +10697,7 @@ function renderImpactMarkdown(report) {
 
 // src/bin-internal/impact-prepare.ts
 init_store();
-function parseDepth(s) {
+function parseDepth2(s) {
   const n = s ? Number.parseInt(s, 10) : 2;
   if (n === 1 || n === 3)
     return n;
@@ -10286,7 +10719,7 @@ async function impactPrepareCmd(argv) {
   let quiet = false;
   for (let i2 = 1;i2 < argv.length; i2++) {
     if (argv[i2] === "--depth")
-      depth = parseDepth(argv[++i2]);
+      depth = parseDepth2(argv[++i2]);
     else if (argv[i2] === "--min-priority")
       minPriority = parseMinPriority(argv[++i2]);
     else if (argv[i2] === "--quiet")
@@ -10309,11 +10742,11 @@ async function impactPrepareCmd(argv) {
     scenarios,
     generatedAt: new Date().toISOString()
   };
-  const impactDir = join17(repoRoot, ".xera/impact");
-  mkdirSync11(impactDir, { recursive: true });
-  writeFileSync11(join17(impactDir, `${ticket}.json`), JSON.stringify(report, null, 2));
+  const impactDir = join19(repoRoot, ".xera/impact");
+  mkdirSync12(impactDir, { recursive: true });
+  writeFileSync12(join19(impactDir, `${ticket}.json`), JSON.stringify(report, null, 2));
   if (!quiet) {
-    writeFileSync11(join17(impactDir, `${ticket}.md`), renderImpactMarkdown(report));
+    writeFileSync12(join19(impactDir, `${ticket}.md`), renderImpactMarkdown(report));
   }
   return 0;
 }
@@ -10339,7 +10772,7 @@ async function lintCmd(argv) {
 
 // src/bin-internal/normalize.ts
 import { existsSync as existsSync21, readdirSync as readdirSync7 } from "fs";
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 import { normalizeRun } from "@xera-ai/web";
 async function normalizeCmd(argv) {
   const ticket = argv[0];
@@ -10354,7 +10787,7 @@ async function normalizeCmd(argv) {
     console.error("[xera:normalize] no run found");
     return 1;
   }
-  const runDir = join18(paths.runsDir, runId);
+  const runDir = join20(paths.runsDir, runId);
   if (!existsSync21(runDir)) {
     console.error(`[xera:normalize] runs/${runId} missing`);
     return 1;
@@ -10365,12 +10798,12 @@ async function normalizeCmd(argv) {
 }
 
 // src/bin-internal/post.ts
-import { existsSync as existsSync23, readFileSync as readFileSync19 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
+import { join as join21 } from "path";
 
 // src/artifact/status.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname6 } from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync13, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "fs";
+import { dirname as dirname8 } from "path";
 import { z as z7 } from "zod";
 var ClassificationEnum = z7.enum([
   "PASS",
@@ -10406,11 +10839,11 @@ var HISTORY_CAP = 20;
 function readStatus(path) {
   if (!existsSync22(path))
     return null;
-  return StatusJsonSchema.parse(JSON.parse(readFileSync18(path, "utf8")));
+  return StatusJsonSchema.parse(JSON.parse(readFileSync19(path, "utf8")));
 }
 function writeStatus(path, status) {
-  mkdirSync12(dirname6(path), { recursive: true });
-  writeFileSync12(path, JSON.stringify(status, null, 2));
+  mkdirSync13(dirname8(path), { recursive: true });
+  writeFileSync13(path, JSON.stringify(status, null, 2));
 }
 function appendHistory(path, entry) {
   const s = readStatus(path);
@@ -10436,12 +10869,12 @@ async function postCmd(argv) {
     return 0;
   }
   const paths = resolveArtifactPaths(cwd, ticket);
-  const draftPath = join19(paths.ticketDir, "jira-comment.draft.md");
+  const draftPath = join21(paths.ticketDir, "jira-comment.draft.md");
   if (!existsSync23(draftPath)) {
     console.error(`[xera:post] no draft at ${draftPath}; run \`xera-internal report\` first.`);
     return 1;
   }
-  const body = readFileSync19(draftPath, "utf8");
+  const body = readFileSync20(draftPath, "utf8");
   const client = await createJiraClient({
     baseUrl: config.jira.baseUrl,
     preferMcp: true,
@@ -10469,8 +10902,8 @@ async function promoteCmd(argv) {
 }
 
 // src/bin-internal/report.ts
-import { existsSync as existsSync25, readFileSync as readFileSync20, writeFileSync as writeFileSync13 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
+import { join as join22 } from "path";
 
 // src/classifier/aggregate.ts
 var CLASS_PRIORITY = [
@@ -10642,10 +11075,10 @@ async function reportCmd(argv) {
     return 1;
   }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
-  const input = JSON.parse(readFileSync20(inputArg.slice("--input=".length), "utf8"));
+  const input = JSON.parse(readFileSync21(inputArg.slice("--input=".length), "utf8"));
   const aggregated = aggregateScenarios(input.scenarios);
-  const decisionsPath = join20(paths.ticketDir, "runs", input.runId, "outdated-decisions.json");
-  const decisions = existsSync25(decisionsPath) ? JSON.parse(readFileSync20(decisionsPath, "utf8")) : {};
+  const decisionsPath = join22(paths.ticketDir, "runs", input.runId, "outdated-decisions.json");
+  const decisions = existsSync25(decisionsPath) ? JSON.parse(readFileSync21(decisionsPath, "utf8")) : {};
   const graph = deriveSnapshot(loadAllEvents(process.cwd()));
   const normalizeScenarioName = (name) => name.trim().toLowerCase().replace(/\s+/g, " ");
   const scenarioIdByName = {};
@@ -10693,8 +11126,8 @@ async function reportCmd(argv) {
     xeraVersion: "0.1.0",
     promptsVersion: "1.0.0"
   });
-  const draftPath = join20(paths.ticketDir, "jira-comment.draft.md");
-  writeFileSync13(draftPath, md);
+  const draftPath = join22(paths.ticketDir, "jira-comment.draft.md");
+  writeFileSync14(draftPath, md);
   console.log(`[xera:report] wrote status.json and ${draftPath}`);
   return 0;
 }
@@ -10761,7 +11194,7 @@ async function unlockCmd(argv) {
 }
 
 // src/bin-internal/validate-feature.ts
-import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync22 } from "fs";
 import { validateGherkin as validateGherkin2 } from "@xera-ai/web";
 async function validateFeatureCmd(argv) {
   const ticket = argv[0];
@@ -10774,7 +11207,7 @@ async function validateFeatureCmd(argv) {
     console.error(`[xera:validate-feature] missing ${paths.featurePath}`);
     return 1;
   }
-  const r = validateGherkin2(readFileSync21(paths.featurePath, "utf8"));
+  const r = validateGherkin2(readFileSync22(paths.featurePath, "utf8"));
   if (r.ok) {
     console.log("[xera:validate-feature] ok");
     return 0;
@@ -10786,6 +11219,7 @@ async function validateFeatureCmd(argv) {
 
 // src/bin-internal/index.ts
 var COMMANDS = {
+  disputes: disputesCmd,
   doctor: doctorCmd,
   "eval-deterministic": evalDeterministicCmd,
   "eval-prepare": evalPrepareCmd,
@@ -10794,6 +11228,7 @@ var COMMANDS = {
   fetch: fetchCmd,
   "graph-backfill": graphBackfillCmd,
   "graph-enrich": graphEnrichCmd,
+  "graph-render": graphRenderCmd,
   "graph-query": graphQueryCmd,
   "graph-record": graphRecordCmd,
   "graph-snapshot": graphSnapshotCmd,