@xera-ai/core 0.4.0 → 0.4.1

package/dist/artifact/status.d.ts

@@ -5,6 +5,7 @@ declare const ClassificationEnum: z.ZodEnum<{
     SELECTOR_DRIFT: "SELECTOR_DRIFT";
     FLAKY: "FLAKY";
     TEST_BUG: "TEST_BUG";
+    TEST_OUTDATED: "TEST_OUTDATED";
 }>;
 export declare const HistoryEntrySchema: z.ZodObject<{
     ts: z.ZodString;
@@ -18,6 +19,7 @@ export declare const HistoryEntrySchema: z.ZodObject<{
         SELECTOR_DRIFT: "SELECTOR_DRIFT";
         FLAKY: "FLAKY";
         TEST_BUG: "TEST_BUG";
+        TEST_OUTDATED: "TEST_OUTDATED";
     }>;
 }, z.core.$strip>;
 export declare const StatusJsonSchema: z.ZodObject<{
@@ -33,6 +35,7 @@ export declare const StatusJsonSchema: z.ZodObject<{
         SELECTOR_DRIFT: "SELECTOR_DRIFT";
         FLAKY: "FLAKY";
         TEST_BUG: "TEST_BUG";
+        TEST_OUTDATED: "TEST_OUTDATED";
     }>;
     confidence: z.ZodEnum<{
         low: "low";
@@ -57,6 +60,7 @@ export declare const StatusJsonSchema: z.ZodObject<{
             SELECTOR_DRIFT: "SELECTOR_DRIFT";
             FLAKY: "FLAKY";
             TEST_BUG: "TEST_BUG";
+            TEST_OUTDATED: "TEST_OUTDATED";
         }>;
     }, z.core.$strip>>>;
     last_jira_comment_id: z.ZodOptional<z.ZodString>;

package/dist/artifact/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/artifact/status.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,kBAAkB;;;;;;EAAsE,CAAC;AAI/F,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;iBAI7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAc3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAIhE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAG1D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAGlE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,UAAU,CAQ3E"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/artifact/status.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,kBAAkB;;;;;;;EAOtB,CAAC;AAIH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;iBAI7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAc3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAIhE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAG1D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAGlE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,UAAU,CAQ3E"}

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_"];
@@ -9266,6 +9312,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 +9475,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 +9823,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 +9842,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 +9858,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 +9904,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 +9954,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 +10001,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 +10018,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 +10040,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;
@@ -9934,8 +10070,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 join17 } from "path";
 import { normalizeRun } from "@xera-ai/web";
 async function normalizeCmd(argv) {
   const ticket = argv[0];
@@ -9950,8 +10086,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 = join17(paths.runsDir, runId);
+  if (!existsSync21(runDir)) {
     console.error(`[xera:normalize] runs/${runId} missing`);
     return 1;
   }
@@ -9961,41 +10097,48 @@ 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 join18 } 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 mkdirSync11, readFileSync as readFileSync18, writeFileSync as writeFileSync11 } 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 });
@@ -10025,12 +10168,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 = join18(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 +10201,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 writeFileSync12 } from "fs";
+import { join as join19 } from "path";
 
 // src/classifier/aggregate.ts
 var CLASS_PRIORITY = [
   "REAL_BUG",
+  "TEST_OUTDATED",
   "TEST_BUG",
   "SELECTOR_DRIFT",
   "FLAKY",
@@ -10089,6 +10233,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 +10337,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,25 +10374,58 @@ 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 = join19(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");
+  const draftPath = join19(paths.ticketDir, "jira-comment.draft.md");
   writeFileSync12(draftPath, md);
   console.log(`[xera:report] wrote status.json and ${draftPath}`);
   return 0;
@@ -10242,7 +10493,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 +10502,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,6 +10525,7 @@ var COMMANDS = {
   exec: execCmd,
   fetch: fetchCmd,
   "graph-backfill": graphBackfillCmd,
+  "graph-enrich": graphEnrichCmd,
   "graph-query": graphQueryCmd,
   "graph-record": graphRecordCmd,
   "graph-snapshot": graphSnapshotCmd,

package/dist/bin-internal/graph-enrich.d.ts

@@ -0,0 +1,2 @@
+export declare function graphEnrichCmd(argv: string[]): Promise<number>;
+//# sourceMappingURL=graph-enrich.d.ts.map

package/dist/bin-internal/graph-enrich.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-enrich.d.ts","sourceRoot":"","sources":["../../src/bin-internal/graph-enrich.ts"],"names":[],"mappings":"AAEA,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAyBpE"}

package/dist/bin-internal/graph-record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph-record.d.ts","sourceRoot":"","sources":["../../src/bin-internal/graph-record.ts"],"names":[],"mappings":"AAyEA,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAqCnF;AAiFD,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAmDpE"}
+{"version":3,"file":"graph-record.d.ts","sourceRoot":"","sources":["../../src/bin-internal/graph-record.ts"],"names":[],"mappings":"AA2EA,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAqCnF;AAiFD,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA6FpE"}

package/dist/bin-internal/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin-internal/index.ts"],"names":[],"mappings":"AA8CA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAczD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin-internal/index.ts"],"names":[],"mappings":"AAgDA,wBAAsB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAczD"}