@xera-ai/core 0.4.0 → 0.4.2

package/dist/bin/internal.js

@@ -98,7 +98,14 @@ var init_schema = __esm(() => {
     traceId: z.string().optional(),
     runtime: z.number().nonnegative()
   }).passthrough();
-  classification = z.enum(["REAL_BUG", "TEST_BUG", "SELECTOR_DRIFT", "FLAKY", "PASS"]);
+  classification = z.enum([
+    "REAL_BUG",
+    "TEST_BUG",
+    "SELECTOR_DRIFT",
+    "FLAKY",
+    "PASS",
+    "TEST_OUTDATED"
+  ]);
   runClassified = z.object({
     scenarioId: z.string(),
     runId: z.string(),
@@ -7730,7 +7737,7 @@ function parseFlags2(args) {
 async function graphRecordCmd(argv) {
   const [action, ...rest] = argv;
   if (!action) {
-    console.error(`Usage: xera-internal graph-record <fetch|script|exec|classify|promote> [args]`);
+    console.error(`Usage: xera-internal graph-record <fetch|script|exec|classify|promote|dispute> [args]`);
     return 1;
   }
   const repoRoot = process.cwd();
@@ -7774,6 +7781,43 @@ async function graphRecordCmd(argv) {
     case "promote": {
       return recordPromote(repoRoot, parseFlags2(rest));
     }
+    case "dispute": {
+      const flags = parseFlags2(rest);
+      const runId = flags.get("--run-id");
+      const scenarioIdArg = flags.get("--scenario-id");
+      const from = flags.get("--from");
+      const to = flags.get("--to");
+      const actor = flags.get("--actor");
+      const reason = flags.get("--reason");
+      if (!runId || !scenarioIdArg || !from || !to || !actor) {
+        console.error("[graph-record dispute] required: --run-id --scenario-id --from --to --actor [--reason]");
+        return 1;
+      }
+      const validClass = [
+        "REAL_BUG",
+        "TEST_BUG",
+        "SELECTOR_DRIFT",
+        "FLAKY",
+        "PASS",
+        "TEST_OUTDATED"
+      ];
+      if (!validClass.includes(from) || !validClass.includes(to)) {
+        console.error(`[graph-record dispute] --from and --to must be one of: ${validClass.join(", ")}`);
+        return 1;
+      }
+      const payload = {
+        runId,
+        scenarioId: scenarioIdArg,
+        originalClassification: from,
+        disputedTo: to,
+        qaActor: actor
+      };
+      if (reason)
+        payload.qaReason = reason;
+      const e = makeEvent("xera-report", "classification.disputed", payload);
+      appendEvents(repoRoot, [e], { skill: "xera-report", ticketId: scenarioIdArg.slice(0, 12) });
+      return 0;
+    }
     default:
       console.error(`Unknown action: ${action}`);
       return 1;
@@ -7831,7 +7875,9 @@ var IN_SCOPE_PROMPTS = [
   "feature-from-story.md",
   "script-from-feature.md",
   "heal-locator.md",
-  "extract-areas.md"
+  "extract-areas.md",
+  "similarity-match.md",
+  "classify-outdated.md"
 ];
 var REQUIRED_SECTION_HEADING = "## Handling untrusted input";
 var REQUIRED_KEYWORDS = ["UNTRUSTED", "injection-follow", "<XR_"];
@@ -8836,11 +8882,18 @@ var ReportingSchema = z4.object({
   }).prefault({}),
   artifactLinks: z4.enum(["git", "local"]).default("git")
 }).prefault({});
+var RunSchema = z4.object({
+  autoImpact: z4.object({
+    enabled: z4.boolean().default(true),
+    threshold: z4.number().nonnegative().default(6)
+  }).prefault({})
+}).prefault({});
 var XeraConfigSchema = z4.object({
   jira: JiraSchema,
   web: WebSchema,
   ai: AISchema,
   reporting: ReportingSchema,
+  run: RunSchema.prefault({}),
   adapters: z4.array(z4.string().min(1)).min(1).default(["web"])
 });
 
@@ -9266,6 +9319,96 @@ async function graphBackfillCmd(argv) {
   return 0;
 }
 
+// src/graph/enrich.ts
+init_store();
+init_ulid();
+import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
+import { join as join15 } from "path";
+import { z as z6 } 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 EnrichmentInputSchema = z6.object({
+  similar: z6.array(SimilarEntrySchema)
+});
+var nowIso3 = () => new Date().toISOString();
+var mk2 = (actor, type, payload) => ({
+  event_id: ulid(),
+  schema_version: SCHEMA_VERSION,
+  ts: nowIso3(),
+  actor,
+  type,
+  payload
+});
+async function enrichTicket(repoRoot, ticketId, opts) {
+  const inputPath = join15(repoRoot, ".xera", ticketId, "enrichment-input.json");
+  if (!existsSync19(inputPath)) {
+    throw new Error(`enrichment-input.json not found at ${inputPath}`);
+  }
+  const raw = JSON.parse(readFileSync16(inputPath, "utf8"));
+  const parsed = EnrichmentInputSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new Error(`invalid enrichment-input.json: ${parsed.error.message}`);
+  }
+  const snapshot = deriveSnapshot(loadAllEvents(repoRoot));
+  if (!snapshot.tickets[ticketId]) {
+    throw new Error(`ticket ${ticketId} not in graph; run /xera-fetch first`);
+  }
+  if (snapshot.tickets[ticketId].enrichedAt && !opts.force) {
+    return { ticketId, similarCount: 0, enrichedAt: snapshot.tickets[ticketId].enrichedAt };
+  }
+  const validated = parsed.data.similar.map((s) => ({ ...s, confidence: Math.max(0, Math.min(1, s.confidence)) })).filter((s) => s.confidence >= MIN_CONFIDENCE).filter((s) => snapshot.tickets[s.ticketId] !== undefined).filter((s) => s.ticketId !== ticketId).slice(0, MAX_SIMILAR_EDGES);
+  const events = [];
+  for (const s of validated) {
+    const payload = {
+      kind: "similar",
+      from: ticketId,
+      to: s.ticketId,
+      confidence: s.confidence,
+      source: `llm-similarity:${s.reason.slice(0, 80)}`
+    };
+    events.push(mk2("graph-enrich", "edge.discovered", payload));
+  }
+  const enrichedAt = nowIso3();
+  const enrichedPayload = {
+    ticketId,
+    enrichedAt,
+    similarCount: validated.length
+  };
+  events.push(mk2("graph-enrich", "ticket.enriched", enrichedPayload));
+  appendEvents(repoRoot, events, { skill: "graph-enrich", ticketId });
+  return { ticketId, similarCount: validated.length, enrichedAt };
+}
+
+// src/bin-internal/graph-enrich.ts
+async function graphEnrichCmd(argv) {
+  let ticket;
+  let force = false;
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === "--ticket")
+      ticket = argv[++i];
+    else if (argv[i] === "--force")
+      force = true;
+  }
+  const repoRoot = process.cwd();
+  if (!ticket) {
+    console.error("[graph-enrich] usage: graph-enrich --ticket <id> [--force]");
+    return 1;
+  }
+  try {
+    const result = await enrichTicket(repoRoot, ticket, { force });
+    console.log(`[graph-enrich] ${ticket} enriched (${result.similarCount} similar edges, at ${result.enrichedAt})`);
+    return 0;
+  } catch (e) {
+    console.error(`[graph-enrich] ${ticket} failed: ${e.message}`);
+    return 1;
+  }
+}
+
 // src/bin-internal/graph-query.ts
 init_store();
 function filterByTicket(snap, ticket) {
@@ -9339,8 +9482,8 @@ async function graphSnapshotCmd(argv) {
 }
 
 // src/bin-internal/heal-prepare.ts
-import { existsSync as existsSync19, readdirSync as readdirSync6, readFileSync as readFileSync16, writeFileSync as writeFileSync10 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync6, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "fs";
+import { join as join16 } from "path";
 import { scrubFreeText } from "@xera-ai/web";
 
 // ../../node_modules/.bun/fflate@0.8.3/node_modules/fflate/esm/index.mjs
@@ -9687,15 +9830,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, z6) {
+var zh = function(d, b, z7) {
   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, z6, 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, z7, 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, z6, sc, su, off) {
+var z64hs = function(d, b, l, z7, sc, su, off) {
   var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
   var nf = nsc + nsu + noff;
-  if (z6 && nf) {
+  if (z7 && nf) {
     for (;b + 4 < e; b += 4 + b2(d, b + 2)) {
       if (b2(d, b) == 1) {
         return [
@@ -9706,7 +9849,7 @@ var z64hs = function(d, b, l, z6, sc, su, off) {
         ];
       }
     }
-    if (z6 < 2)
+    if (z7 < 2)
       err(13);
   }
   return [sc, su, off, 0];
@@ -9722,18 +9865,18 @@ function unzipSync(data, opts) {
   if (!c)
     return {};
   var o = b4(data, e + 16);
-  var z6 = b4(data, e - 20) == 117853008;
-  if (z6) {
+  var z7 = b4(data, e - 20) == 117853008;
+  if (z7) {
     var ze = b4(data, e - 12);
-    z6 = b4(data, ze) == 101075792;
-    if (z6) {
+    z7 = b4(data, ze) == 101075792;
+    if (z7) {
       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, z6), 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, z7), 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,
@@ -9768,9 +9911,9 @@ function classifyKind(raw) {
   return "other";
 }
 function extractDomSnapshot(tracePath) {
-  if (!existsSync19(tracePath))
+  if (!existsSync20(tracePath))
     return "";
-  const buf = readFileSync16(tracePath);
+  const buf = readFileSync17(tracePath);
   const entries = unzipSync(buf);
   const traceKey = Object.keys(entries).find((name) => name.endsWith(".trace"));
   let chosenKey = null;
@@ -9818,16 +9961,16 @@ function extractDomSnapshot(tracePath) {
   return scrubFreeText(html);
 }
 function findPomLine(ticketDir, rawLocator) {
-  const pomDir = join15(ticketDir, "page-objects");
+  const pomDir = join16(ticketDir, "page-objects");
   const candidates = [];
-  if (existsSync19(pomDir)) {
+  if (existsSync20(pomDir)) {
     for (const name of readdirSync6(pomDir)) {
       if (name.endsWith(".ts"))
-        candidates.push(join15(pomDir, name));
+        candidates.push(join16(pomDir, name));
     }
   }
   for (const file of candidates) {
-    const text = readFileSync16(file, "utf8");
+    const text = readFileSync17(file, "utf8");
     const lines = text.split(`
 `);
     for (let i2 = 0;i2 < lines.length; i2++) {
@@ -9865,13 +10008,13 @@ function findGherkinStep(featureText, rawLocator) {
 }
 function healPrepare(repoRoot, ticket, runId, scenarioName) {
   const paths = resolveArtifactPaths(repoRoot, ticket);
-  const classifierPath = join15(paths.ticketDir, "classifier-input.json");
-  const classifier = JSON.parse(readFileSync16(classifierPath, "utf8"));
+  const classifierPath = join16(paths.ticketDir, "classifier-input.json");
+  const classifier = JSON.parse(readFileSync17(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 = join15(paths.runsDir, runId);
-  const normalized = JSON.parse(readFileSync16(join15(runDir, "normalized.json"), "utf8"));
+  const runDir = join16(paths.runsDir, runId);
+  const normalized = JSON.parse(readFileSync17(join16(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}"`);
@@ -9882,9 +10025,9 @@ function healPrepare(repoRoot, ticket, runId, scenarioName) {
   const raw = m[1].trim();
   const kind = classifyKind(raw);
   const pomLoc = findPomLine(paths.ticketDir, raw);
-  const featureText = readFileSync16(paths.featurePath, "utf8");
+  const featureText = readFileSync17(paths.featurePath, "utf8");
   const gherkinStep = findGherkinStep(featureText, raw);
-  const domSnapshotAtFailure = extractDomSnapshot(join15(runDir, "trace.zip"));
+  const domSnapshotAtFailure = extractDomSnapshot(join16(runDir, "trace.zip"));
   return {
     ticket,
     runId,
@@ -9904,7 +10047,7 @@ async function healPrepareCmd(argv) {
   try {
     const result = healPrepare(process.cwd(), ticket, runId, scenarioName);
     const paths = resolveArtifactPaths(process.cwd(), ticket);
-    const outPath = join15(paths.runsDir, runId, "heal-input.json");
+    const outPath = join16(paths.runsDir, runId, "heal-input.json");
     writeFileSync10(outPath, JSON.stringify(result, null, 2));
     console.log(`[xera:heal-prepare] wrote ${outPath}`);
     return 0;
@@ -9914,6 +10057,267 @@ 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";
+
+// src/graph/impact.ts
+var PRIORITY_WEIGHT = { p0: 3, p1: 2, p2: 1 };
+var EDGE_WEIGHT_FIXED = {
+  modifies: 5,
+  uses: 4,
+  covers: 4
+};
+function jiraRelationWeight(source) {
+  if (!source)
+    return 0;
+  if (source.endsWith("blocks"))
+    return 4;
+  if (source.endsWith("duplicates"))
+    return 3;
+  if (source.endsWith("relates"))
+    return 2;
+  if (source.endsWith("supersedes"))
+    return 3;
+  return 1;
+}
+function edgeWeight(edge) {
+  if (edge.kind === "modifies")
+    return EDGE_WEIGHT_FIXED.modifies ?? 0;
+  if (edge.kind === "uses" || edge.kind === "covers")
+    return EDGE_WEIGHT_FIXED.uses ?? 0;
+  if (edge.kind === "jira-linked")
+    return jiraRelationWeight(edge.source);
+  if (edge.kind === "similar")
+    return 1 * (edge.confidence ?? 0);
+  return 0;
+}
+function riskScore(scenario, daysSinceLastPass) {
+  const pri = PRIORITY_WEIGHT[scenario.priority] * 3;
+  const firstEdge = scenario.edgePath[0];
+  const edgeW = firstEdge ? edgeWeight(firstEdge) : 0;
+  const confW = firstEdge?.confidence !== undefined ? firstEdge.confidence * 2 : 0;
+  const decay = daysSinceLastPass * 0.1;
+  return pri + edgeW + confW - decay;
+}
+var PRIORITY_RANK = { p0: 3, p1: 2, p2: 1 };
+function daysSince(ts) {
+  if (!ts)
+    return 0;
+  const ms = Date.now() - Date.parse(ts);
+  return ms < 0 ? 0 : ms / (86400 * 1000);
+}
+function walkImpact(graph, target, opts) {
+  const result = [];
+  const seen = new Set;
+  const targetAreas = new Set(target.modifiesAreas);
+  const pomIds = graph.edges.filter((e) => e.kind === "covers" && targetAreas.has(e.to)).map((e) => e.from);
+  const directScenarios = graph.edges.filter((e) => e.kind === "uses" && pomIds.includes(e.to)).map((e) => e.from);
+  for (const scenarioId2 of directScenarios) {
+    if (seen.has(scenarioId2))
+      continue;
+    const scenario = graph.scenarios[scenarioId2];
+    if (!scenario)
+      continue;
+    if (scenario.ticketId === target.id)
+      continue;
+    const usingPom = graph.edges.find((e) => e.kind === "uses" && e.from === scenarioId2);
+    const modifyEdge = graph.edges.find((e) => e.kind === "modifies" && e.from === target.id && targetAreas.has(e.to));
+    const edgePath = [];
+    if (modifyEdge)
+      edgePath.push({ kind: "modifies", from: modifyEdge.from, to: modifyEdge.to });
+    if (usingPom)
+      edgePath.push({ kind: "uses", from: usingPom.from, to: usingPom.to });
+    seen.add(scenarioId2);
+    const impact = {
+      scenarioId: scenarioId2,
+      ticketId: scenario.ticketId,
+      name: scenario.name,
+      priority: scenario.priority,
+      edgePath,
+      riskScore: 0
+    };
+    impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId2]?.ts));
+    result.push(impact);
+  }
+  if (opts.depth >= 2) {
+    const linked = graph.edges.filter((e) => e.kind === "jira-linked" && e.from === target.id).map((e) => ({ to: e.to, source: e.source }));
+    for (const link of linked) {
+      const sceneIds = graph.edges.filter((e) => e.kind === "tests" && e.from === link.to).map((e) => e.to);
+      for (const scenarioId2 of sceneIds) {
+        if (seen.has(scenarioId2))
+          continue;
+        const scenario = graph.scenarios[scenarioId2];
+        if (!scenario || scenario.ticketId === target.id)
+          continue;
+        seen.add(scenarioId2);
+        const edge = { kind: "jira-linked", from: target.id, to: link.to };
+        if (link.source !== undefined)
+          edge.source = link.source;
+        const impact = {
+          scenarioId: scenarioId2,
+          ticketId: scenario.ticketId,
+          name: scenario.name,
+          priority: scenario.priority,
+          edgePath: [edge],
+          riskScore: 0
+        };
+        impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId2]?.ts));
+        result.push(impact);
+      }
+    }
+  }
+  if (opts.depth >= 3) {
+    const similar = graph.edges.filter((e) => e.kind === "similar" && e.from === target.id).map((e) => ({ to: e.to, confidence: e.confidence }));
+    for (const link of similar) {
+      const sceneIds = graph.edges.filter((e) => e.kind === "tests" && e.from === link.to).map((e) => e.to);
+      for (const scenarioId2 of sceneIds) {
+        if (seen.has(scenarioId2))
+          continue;
+        const scenario = graph.scenarios[scenarioId2];
+        if (!scenario || scenario.ticketId === target.id)
+          continue;
+        seen.add(scenarioId2);
+        const edge = { kind: "similar", from: target.id, to: link.to };
+        if (link.confidence !== undefined)
+          edge.confidence = link.confidence;
+        const impact = {
+          scenarioId: scenarioId2,
+          ticketId: scenario.ticketId,
+          name: scenario.name,
+          priority: scenario.priority,
+          edgePath: [edge],
+          riskScore: 0
+        };
+        impact.riskScore = riskScore(impact, daysSince(graph.latest_failures[scenarioId2]?.ts));
+        result.push(impact);
+      }
+    }
+  }
+  let filtered = result;
+  if (opts.minPriority) {
+    const min = PRIORITY_RANK[opts.minPriority];
+    filtered = filtered.filter((s) => PRIORITY_RANK[s.priority] >= min);
+  }
+  filtered.sort((a, b) => b.riskScore - a.riskScore);
+  return filtered;
+}
+var HIGH_THRESHOLD = 7;
+var MEDIUM_THRESHOLD = 4;
+function bucket(score) {
+  if (score >= HIGH_THRESHOLD)
+    return "high";
+  if (score >= MEDIUM_THRESHOLD)
+    return "medium";
+  return "low";
+}
+function fmtEdgePath(path) {
+  return path.map((e) => `${e.from} \u2192[${e.kind}]\u2192 ${e.to}`).join(" \xB7 ");
+}
+function renderImpactMarkdown(report) {
+  const lines = [];
+  lines.push(`# Impact Analysis \u2014 ${report.targetTicket}`);
+  lines.push("");
+  lines.push(`**Modified areas:** ${report.modifiedAreas.join(", ") || "(none)"}`);
+  lines.push(`**Generated:** ${report.generatedAt}`);
+  lines.push("");
+  if (report.scenarios.length === 0) {
+    lines.push("No prior scenarios in the modified areas. This may be a new feature area.");
+    lines.push("");
+    return lines.join(`
+`);
+  }
+  const bySeverity = {
+    high: [],
+    medium: [],
+    low: []
+  };
+  for (const s of report.scenarios)
+    bySeverity[bucket(s.riskScore)].push(s);
+  lines.push(`**Total impacted:** ${report.scenarios.length} scenarios (${bySeverity.high.length} high \xB7 ${bySeverity.medium.length} medium \xB7 ${bySeverity.low.length} low)`);
+  lines.push("");
+  for (const [name, scenarios] of [
+    ["High-risk", bySeverity.high],
+    ["Medium-risk", bySeverity.medium],
+    ["Low-risk", bySeverity.low]
+  ]) {
+    if (scenarios.length === 0)
+      continue;
+    lines.push(`## ${name}`);
+    lines.push("");
+    for (const s of scenarios) {
+      lines.push(`### ${s.ticketId} / "${s.name}" [${s.priority.toUpperCase()}]   score ${s.riskScore.toFixed(1)}`);
+      lines.push(`- Edge: ${fmtEdgePath(s.edgePath)}`);
+      if (s.lastPassedAt)
+        lines.push(`- Last passed: ${s.lastPassedAt}`);
+      lines.push("");
+    }
+  }
+  lines.push("## Re-run commands");
+  lines.push(`- All:        \`bun run xera:exec --from-impact ${report.targetTicket}\``);
+  lines.push(`- P0 only:    \`bun run xera:exec --from-impact ${report.targetTicket} --min-priority p0\``);
+  lines.push(`- Select:     \`bun run xera:exec --from-impact ${report.targetTicket} --select\``);
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+// src/bin-internal/impact-prepare.ts
+init_store();
+function parseDepth(s) {
+  const n = s ? Number.parseInt(s, 10) : 2;
+  if (n === 1 || n === 3)
+    return n;
+  return 2;
+}
+function parseMinPriority(s) {
+  if (s === "p0" || s === "p1" || s === "p2")
+    return s;
+  return;
+}
+async function impactPrepareCmd(argv) {
+  const ticket = argv[0];
+  if (!ticket || ticket.startsWith("--")) {
+    console.error("[impact-prepare] usage: impact-prepare <TICKET> [--depth 1|2|3] [--min-priority p0|p1|p2] [--quiet]");
+    return 1;
+  }
+  let depth = 2;
+  let minPriority;
+  let quiet = false;
+  for (let i2 = 1;i2 < argv.length; i2++) {
+    if (argv[i2] === "--depth")
+      depth = parseDepth(argv[++i2]);
+    else if (argv[i2] === "--min-priority")
+      minPriority = parseMinPriority(argv[++i2]);
+    else if (argv[i2] === "--quiet")
+      quiet = true;
+  }
+  const repoRoot = process.cwd();
+  const graph = deriveSnapshot(loadAllEvents(repoRoot));
+  const target = graph.tickets[ticket];
+  if (!target) {
+    console.error(`[impact-prepare] ticket ${ticket} not in graph; run /xera-fetch first`);
+    return 2;
+  }
+  const opts = { depth };
+  if (minPriority)
+    opts.minPriority = minPriority;
+  const scenarios = walkImpact(graph, target, opts);
+  const report = {
+    targetTicket: ticket,
+    modifiedAreas: target.modifiesAreas,
+    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));
+  if (!quiet) {
+    writeFileSync11(join17(impactDir, `${ticket}.md`), renderImpactMarkdown(report));
+  }
+  return 0;
+}
+
 // src/bin-internal/lint.ts
 import { lintTicket } from "@xera-ai/web";
 async function lintCmd(argv) {
@@ -9934,8 +10338,8 @@ async function lintCmd(argv) {
 }
 
 // src/bin-internal/normalize.ts
-import { existsSync as existsSync20, readdirSync as readdirSync7 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync21, readdirSync as readdirSync7 } from "fs";
+import { join as join18 } from "path";
 import { normalizeRun } from "@xera-ai/web";
 async function normalizeCmd(argv) {
   const ticket = argv[0];
@@ -9950,8 +10354,8 @@ async function normalizeCmd(argv) {
     console.error("[xera:normalize] no run found");
     return 1;
   }
-  const runDir = join16(paths.runsDir, runId);
-  if (!existsSync20(runDir)) {
+  const runDir = join18(paths.runsDir, runId);
+  if (!existsSync21(runDir)) {
     console.error(`[xera:normalize] runs/${runId} missing`);
     return 1;
   }
@@ -9961,45 +10365,52 @@ async function normalizeCmd(argv) {
 }
 
 // src/bin-internal/post.ts
-import { existsSync as existsSync22, readFileSync as readFileSync18 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync19 } from "fs";
+import { join as join19 } from "path";
 
 // src/artifact/status.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync17, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname6 } from "path";
-import { z as z6 } from "zod";
-var ClassificationEnum = z6.enum(["PASS", "REAL_BUG", "SELECTOR_DRIFT", "FLAKY", "TEST_BUG"]);
-var ResultEnum = z6.enum(["PASS", "FAIL"]);
-var ConfidenceEnum = z6.enum(["low", "medium", "high"]);
-var HistoryEntrySchema = z6.object({
-  ts: z6.string(),
+import { z as z7 } from "zod";
+var ClassificationEnum = z7.enum([
+  "PASS",
+  "REAL_BUG",
+  "SELECTOR_DRIFT",
+  "FLAKY",
+  "TEST_BUG",
+  "TEST_OUTDATED"
+]);
+var ResultEnum = z7.enum(["PASS", "FAIL"]);
+var ConfidenceEnum = z7.enum(["low", "medium", "high"]);
+var HistoryEntrySchema = z7.object({
+  ts: z7.string(),
   result: ResultEnum,
   class: ClassificationEnum
 });
-var StatusJsonSchema = z6.object({
-  ticket: z6.string(),
-  lastRun: z6.string(),
+var StatusJsonSchema = z7.object({
+  ticket: z7.string(),
+  lastRun: z7.string(),
   result: ResultEnum,
   classification: ClassificationEnum,
   confidence: ConfidenceEnum,
-  scenarios: z6.object({
-    total: z6.number().int().nonnegative(),
-    passed: z6.number().int().nonnegative(),
-    failed: z6.number().int().nonnegative(),
-    skipped: z6.number().int().nonnegative()
+  scenarios: z7.object({
+    total: z7.number().int().nonnegative(),
+    passed: z7.number().int().nonnegative(),
+    failed: z7.number().int().nonnegative(),
+    skipped: z7.number().int().nonnegative()
   }),
-  history: z6.array(HistoryEntrySchema).default([]),
-  last_jira_comment_id: z6.string().optional()
+  history: z7.array(HistoryEntrySchema).default([]),
+  last_jira_comment_id: z7.string().optional()
 });
 var HISTORY_CAP = 20;
 function readStatus(path) {
-  if (!existsSync21(path))
+  if (!existsSync22(path))
     return null;
-  return StatusJsonSchema.parse(JSON.parse(readFileSync17(path, "utf8")));
+  return StatusJsonSchema.parse(JSON.parse(readFileSync18(path, "utf8")));
 }
 function writeStatus(path, status) {
-  mkdirSync11(dirname6(path), { recursive: true });
-  writeFileSync11(path, JSON.stringify(status, null, 2));
+  mkdirSync12(dirname6(path), { recursive: true });
+  writeFileSync12(path, JSON.stringify(status, null, 2));
 }
 function appendHistory(path, entry) {
   const s = readStatus(path);
@@ -10025,12 +10436,12 @@ async function postCmd(argv) {
     return 0;
   }
   const paths = resolveArtifactPaths(cwd, ticket);
-  const draftPath = join17(paths.ticketDir, "jira-comment.draft.md");
-  if (!existsSync22(draftPath)) {
+  const draftPath = join19(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 = readFileSync18(draftPath, "utf8");
+  const body = readFileSync19(draftPath, "utf8");
   const client = await createJiraClient({
     baseUrl: config.jira.baseUrl,
     preferMcp: true,
@@ -10058,12 +10469,13 @@ async function promoteCmd(argv) {
 }
 
 // src/bin-internal/report.ts
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync20, writeFileSync as writeFileSync13 } from "fs";
+import { join as join20 } from "path";
 
 // src/classifier/aggregate.ts
 var CLASS_PRIORITY = [
   "REAL_BUG",
+  "TEST_OUTDATED",
   "TEST_BUG",
   "SELECTOR_DRIFT",
   "FLAKY",
@@ -10089,6 +10501,80 @@ function aggregateScenarios(scenarios) {
   return { overall: chosen, overallConfidence: minConf, scenarios };
 }
 
+// src/graph/classify.ts
+var DEFAULT_THRESHOLD = 0.7;
+var SHORT_CIRCUIT = ["FLAKY", "PASS"];
+function findCandidateTickets(graph, scenario) {
+  const poms = graph.edges.filter((e) => e.kind === "uses" && e.from === scenario.id).map((e) => e.to);
+  if (poms.length === 0)
+    return [];
+  const areas = graph.edges.filter((e) => e.kind === "covers" && poms.includes(e.from)).map((e) => e.to);
+  if (areas.length === 0)
+    return [];
+  const ticketIds = graph.edges.filter((e) => e.kind === "modifies" && areas.includes(e.to)).map((e) => e.from);
+  const seen = new Set;
+  const out = [];
+  for (const id of ticketIds) {
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    if (id === scenario.ticketId)
+      continue;
+    const t = graph.tickets[id];
+    if (!t)
+      continue;
+    if (t.fetchedAt <= scenario.generatedAt)
+      continue;
+    out.push(t);
+  }
+  return out;
+}
+async function enhanceClassification(input, graph, decideOutdated, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  if (SHORT_CIRCUIT.includes(input.traceClassification)) {
+    return { classification: input.traceClassification, confidence: 1 };
+  }
+  const scenario = graph.scenarios[input.scenarioId];
+  if (!scenario)
+    return { classification: input.traceClassification, confidence: 1 };
+  const candidates = findCandidateTickets(graph, scenario);
+  if (candidates.length === 0) {
+    return { classification: input.traceClassification, confidence: 1 };
+  }
+  const candidateEvidence = candidates.map((t) => {
+    const area = graph.edges.find((e) => e.kind === "modifies" && e.from === t.id)?.to ?? "";
+    const ev = { ticketId: t.id, summary: t.summary, modifiedArea: area };
+    if (t.ac[0])
+      ev.relevantAcRef = t.ac[0];
+    return ev;
+  });
+  const decision = await decideOutdated({ scenario, candidates });
+  if (decision.classification === "TEST_OUTDATED" && decision.confidence >= threshold) {
+    const evidence = {
+      candidateTickets: candidateEvidence,
+      reasoning: decision.evidence.reasoning,
+      proposedAction: "regenerate-scenario"
+    };
+    if (decision.evidence.expectedByTest)
+      evidence.expectedByTest = decision.evidence.expectedByTest;
+    if (decision.evidence.actualInApp)
+      evidence.actualInApp = decision.evidence.actualInApp;
+    return {
+      classification: "TEST_OUTDATED",
+      confidence: decision.confidence,
+      evidence
+    };
+  }
+  return {
+    classification: input.traceClassification,
+    confidence: 1,
+    evidence: { candidateTickets: candidateEvidence }
+  };
+}
+
+// src/bin-internal/report.ts
+init_store();
+
 // src/reporter/jira-comment.ts
 function buildJiraComment(input) {
   const passed = input.scenarios.filter((s) => s.outcome === "PASS").length;
@@ -10119,11 +10605,11 @@ xera v${input.xeraVersion} \u2022 prompts v${input.promptsVersion}`;
 }
 
 // src/reporter/status-writer.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } 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 (!existsSync23(path)) {
+  if (!existsSync24(path)) {
     writeStatus(path, {
       ticket: input.ticket,
       lastRun: input.runTs,
@@ -10156,26 +10642,59 @@ async function reportCmd(argv) {
     return 1;
   }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
-  const input = JSON.parse(readFileSync19(inputArg.slice("--input=".length), "utf8"));
+  const input = JSON.parse(readFileSync20(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 graph = deriveSnapshot(loadAllEvents(process.cwd()));
+  const normalizeScenarioName = (name) => name.trim().toLowerCase().replace(/\s+/g, " ");
+  const scenarioIdByName = {};
+  for (const [id, node] of Object.entries(graph.scenarios)) {
+    if (node.ticketId === ticket) {
+      scenarioIdByName[normalizeScenarioName(node.name)] = id;
+    }
+  }
+  const enhancedScenarios = await Promise.all(aggregated.scenarios.map(async (s) => {
+    if (s.outcome !== "FAIL")
+      return s;
+    const scenarioId2 = scenarioIdByName[normalizeScenarioName(s.name)];
+    if (!scenarioId2)
+      return s;
+    const decision = decisions[scenarioId2];
+    const decideOutdated = async () => decision ?? {
+      classification: "BUG",
+      confidence: 0,
+      evidence: { reasoning: "no LLM decision" }
+    };
+    const enhanced = await enhanceClassification({ scenarioId: scenarioId2, traceClassification: s.class }, graph, decideOutdated);
+    if (enhanced.classification !== s.class) {
+      return {
+        ...s,
+        class: enhanced.classification,
+        rationale: `${s.rationale} | TEST_OUTDATED override (conf ${enhanced.confidence})`
+      };
+    }
+    return s;
+  }));
+  const reAggregated = aggregateScenarios(enhancedScenarios);
   const ts = new Date().toISOString();
   writeStatusFromClassification(paths.statusPath, {
     ticket,
     runTs: ts,
-    classification: aggregated,
+    classification: reAggregated,
     scenarioCounts: input.scenarioCounts
   });
   const md = buildJiraComment({
     ticket,
     runId: input.runId,
-    overall: aggregated.overall,
-    overallConfidence: aggregated.overallConfidence,
-    scenarios: aggregated.scenarios,
+    overall: reAggregated.overall,
+    overallConfidence: reAggregated.overallConfidence,
+    scenarios: reAggregated.scenarios,
     xeraVersion: "0.1.0",
     promptsVersion: "1.0.0"
   });
-  const draftPath = join18(paths.ticketDir, "jira-comment.draft.md");
-  writeFileSync12(draftPath, md);
+  const draftPath = join20(paths.ticketDir, "jira-comment.draft.md");
+  writeFileSync13(draftPath, md);
   console.log(`[xera:report] wrote status.json and ${draftPath}`);
   return 0;
 }
@@ -10242,7 +10761,7 @@ async function unlockCmd(argv) {
 }
 
 // src/bin-internal/validate-feature.ts
-import { existsSync as existsSync24, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
 import { validateGherkin as validateGherkin2 } from "@xera-ai/web";
 async function validateFeatureCmd(argv) {
   const ticket = argv[0];
@@ -10251,11 +10770,11 @@ async function validateFeatureCmd(argv) {
     return 1;
   }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
-  if (!existsSync24(paths.featurePath)) {
+  if (!existsSync26(paths.featurePath)) {
     console.error(`[xera:validate-feature] missing ${paths.featurePath}`);
     return 1;
   }
-  const r = validateGherkin2(readFileSync20(paths.featurePath, "utf8"));
+  const r = validateGherkin2(readFileSync21(paths.featurePath, "utf8"));
   if (r.ok) {
     console.log("[xera:validate-feature] ok");
     return 0;
@@ -10274,10 +10793,12 @@ var COMMANDS = {
   exec: execCmd,
   fetch: fetchCmd,
   "graph-backfill": graphBackfillCmd,
+  "graph-enrich": graphEnrichCmd,
   "graph-query": graphQueryCmd,
   "graph-record": graphRecordCmd,
   "graph-snapshot": graphSnapshotCmd,
   "heal-prepare": healPrepareCmd,
+  "impact-prepare": impactPrepareCmd,
   lint: lintCmd,
   normalize: normalizeCmd,
   post: postCmd,