@xera-ai/core 0.11.4 → 0.11.5

package/dist/bin/internal.js

@@ -668,6 +668,7 @@ function deriveSnapshot(events) {
   const latestFailures = {};
   const acNodes = {};
   const classifications = [];
+  const classByRun = new Map;
   for (const e of events) {
     switch (e.type) {
       case "ticket.fetched": {
@@ -778,6 +779,11 @@ function deriveSnapshot(events) {
           };
           if (e.payload.traceId)
             fail.traceId = e.payload.traceId;
+          const prior = classByRun.get(`${e.payload.scenarioId}:${e.payload.runId}`);
+          if (prior) {
+            fail.classification = prior.classification;
+            fail.confidence = prior.confidence;
+          }
           latestFailures[e.payload.scenarioId] = fail;
         } else {
           delete latestFailures[e.payload.scenarioId];
@@ -803,13 +809,23 @@ function deriveSnapshot(events) {
         }
         break;
       }
-      case "run.classified":
+      case "run.classified": {
         classifications.push({
           scenarioId: e.payload.scenarioId,
           classification: e.payload.classification,
           ts: e.ts
         });
+        classByRun.set(`${e.payload.scenarioId}:${e.payload.runId}`, {
+          classification: e.payload.classification,
+          confidence: e.payload.confidence
+        });
+        const existing = latestFailures[e.payload.scenarioId];
+        if (existing && existing.runId === e.payload.runId) {
+          existing.classification = e.payload.classification;
+          existing.confidence = e.payload.confidence;
+        }
         break;
+      }
       case "ac-coverage.backfilled": {
         const { ts, ticketId, mappings } = e.payload;
         for (let i = edges.length - 1;i >= 0; i--) {
@@ -8186,6 +8202,60 @@ function makeEvent(actor, type, payload) {
     payload
   };
 }
+function levenshtein(a, b) {
+  if (a === b)
+    return 0;
+  if (a.length === 0)
+    return b.length;
+  if (b.length === 0)
+    return a.length;
+  const m = a.length;
+  const n = b.length;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0;j <= n; j++)
+    prev[j] = j;
+  for (let i = 1;i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1;j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function findClosestName(target, candidates) {
+  if (candidates.length === 0)
+    return;
+  const norm = target.trim().toLowerCase();
+  let best;
+  for (const c of candidates) {
+    const d = levenshtein(norm, c.trim().toLowerCase());
+    if (best === undefined || d < best.dist)
+      best = { name: c, dist: d };
+  }
+  if (!best)
+    return;
+  const maxLen = Math.max(norm.length, best.name.trim().length);
+  if (maxLen > 0 && best.dist > maxLen * 0.5)
+    return;
+  return best.name;
+}
+function warnUnmatchedScenarios(context, source, ticket, total, unmatched) {
+  if (unmatched.length === 0)
+    return;
+  console.warn(`[graph-record ${context}] ${unmatched.length} of ${total} scenario name(s) in ${source} could not be matched to graph scenarios for ${ticket}.`);
+  for (const u of unmatched) {
+    console.warn(`  Unmatched: "${u.name}"`);
+    if (u.suggestion)
+      console.warn(`    Did you mean: "${u.suggestion}"?`);
+  }
+}
+function knownScenariosForTicket(repoRoot, ticket) {
+  const snap = deriveSnapshot(loadAllEvents(repoRoot));
+  return Object.values(snap.scenarios).filter((s) => s.ticketId === ticket);
+}
 function readStoryFrontmatter(repoRoot, ticket) {
   const path = join10(repoRoot, ".xera", ticket, "story.md");
   if (!existsSync8(path))
@@ -8255,12 +8325,23 @@ async function recordExec(repoRoot, ticket, runId) {
     return 1;
   }
   const data = JSON.parse(readFileSync7(normalizedPath, "utf8"));
+  const known = knownScenariosForTicket(repoRoot, ticket);
+  const knownIds = new Set(known.map((s) => s.id));
+  const knownNames = known.map((s) => s.name);
   const events = [];
+  const unmatched = [];
+  let considered = 0;
   for (const s of data.scenarios) {
     if (s.outcome === "SKIPPED")
       continue;
+    considered++;
+    const sid = scenarioId(ticket, s.name);
+    if (known.length > 0 && !knownIds.has(sid)) {
+      const suggestion = findClosestName(s.name, knownNames);
+      unmatched.push(suggestion ? { name: s.name, suggestion } : { name: s.name });
+    }
     const p = {
-      scenarioId: scenarioId(ticket, s.name),
+      scenarioId: sid,
       ticketId: ticket,
       runId,
       status: s.outcome === "PASS" ? "pass" : "fail",
@@ -8268,6 +8349,7 @@ async function recordExec(repoRoot, ticket, runId) {
     };
     events.push(makeEvent("xera-exec", "run.completed", p));
   }
+  warnUnmatchedScenarios("exec", "normalized.json", ticket, considered, unmatched);
   appendEvents(repoRoot, events, { skill: "xera-exec", ticketId: ticket });
   return 0;
 }
@@ -8279,16 +8361,26 @@ async function recordClassify(repoRoot, ticket, runId) {
     return 1;
   }
   const data = JSON.parse(readFileSync7(classifyPath, "utf8"));
+  const known = knownScenariosForTicket(repoRoot, ticket);
+  const knownIds = new Set(known.map((s) => s.id));
+  const knownNames = known.map((s) => s.name);
   const events = [];
+  const unmatched = [];
   for (const s of data.scenarios) {
+    const sid = scenarioId(ticket, s.name);
+    if (known.length > 0 && !knownIds.has(sid)) {
+      const suggestion = findClosestName(s.name, knownNames);
+      unmatched.push(suggestion ? { name: s.name, suggestion } : { name: s.name });
+    }
     const p = {
-      scenarioId: scenarioId(ticket, s.name),
+      scenarioId: sid,
       runId,
       classification: s.class,
       confidence: s.confidence
     };
     events.push(makeEvent("xera-report", "run.classified", p));
   }
+  warnUnmatchedScenarios("classify", "classifier-input.json", ticket, data.scenarios.length, unmatched);
   appendEvents(repoRoot, events, { skill: "xera-report", ticketId: ticket });
   return 0;
 }
@@ -8518,14 +8610,20 @@ async function acCoverageBackfillFinalizeCmd(argv) {
   }
   if (parsed.mappings.length === 0)
     return 0;
+  const snap = deriveSnapshot(loadAllEvents(cwd));
   const byTicket = {};
   for (const m of parsed.mappings) {
-    const ticketId = m.scenarioId.split("#")[0];
-    if (!ticketId)
+    let ticketId = snap.scenarios[m.scenarioId]?.ticketId;
+    if (!ticketId && m.scenarioId.includes("#")) {
+      ticketId = m.scenarioId.split("#")[0];
+    }
+    if (!ticketId) {
+      console.error(`[ac-coverage-backfill-finalize] cannot resolve ticketId for scenario ${m.scenarioId}; skipping`);
       continue;
-    if (!byTicket[ticketId])
-      byTicket[ticketId] = [];
-    byTicket[ticketId].push(m);
+    }
+    const bucket = byTicket[ticketId] ?? [];
+    bucket.push(m);
+    byTicket[ticketId] = bucket;
   }
   const ts = args.snapshotTs ?? new Date().toISOString();
   const now = new Date(ts);

package/package.json

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

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

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { appendEvents } from '../graph/store';
+import { appendEvents, deriveSnapshot, loadAllEvents } from '../graph/store';
 import type { Event } from '../graph/types';
 import { SCHEMA_VERSION } from '../graph/types';
 import { ulid } from '../graph/ulid';
@@ -62,13 +62,28 @@ export async function acCoverageBackfillFinalizeCmd(argv: string[]): Promise<num
 
   if (parsed.mappings.length === 0) return 0;
 
-  // Group mappings by ticketId (extracted from scenarioId prefix)
+  const snap = deriveSnapshot(loadAllEvents(cwd));
+
+  // Group mappings by ticketId. Resolve via the snapshot's scenario nodes —
+  // scenarioIds are content-derived hashes, not `${ticketId}#...`, so parsing
+  // the prefix would put every scenario in its own bucket (and the resulting
+  // payload.ticketId would be the hash). Fall back to a `#`-split only for
+  // legacy scenarioIds shaped like `${ticketId}#scenario-N`.
   const byTicket: Record<string, z.infer<typeof DecisionsSchema>['mappings']> = {};
   for (const m of parsed.mappings) {
-    const ticketId = m.scenarioId.split('#')[0];
-    if (!ticketId) continue;
-    if (!byTicket[ticketId]) byTicket[ticketId] = [];
-    byTicket[ticketId].push(m);
+    let ticketId = snap.scenarios[m.scenarioId]?.ticketId;
+    if (!ticketId && m.scenarioId.includes('#')) {
+      ticketId = m.scenarioId.split('#')[0];
+    }
+    if (!ticketId) {
+      console.error(
+        `[ac-coverage-backfill-finalize] cannot resolve ticketId for scenario ${m.scenarioId}; skipping`,
+      );
+      continue;
+    }
+    const bucket = byTicket[ticketId] ?? [];
+    bucket.push(m);
+    byTicket[ticketId] = bucket;
   }
 
   const ts = args.snapshotTs ?? new Date().toISOString();

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

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { resolveArtifactPaths } from '../artifact/paths';
-import { appendEvents } from '../graph/store';
+import { appendEvents, deriveSnapshot, loadAllEvents } from '../graph/store';
 import type {
   Classification,
   ClassificationDisputedPayload,
@@ -12,6 +12,7 @@ import type {
   PomPromotedPayload,
   RunClassifiedPayload,
   RunCompletedPayload,
+  ScenarioNode,
   TicketFetchedPayload,
 } from '../graph/types';
 import { SCHEMA_VERSION } from '../graph/types';
@@ -55,6 +56,64 @@ interface StoryFrontmatter {
   }>;
 }
 
+function levenshtein(a: string, b: string): number {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  const m = a.length;
+  const n = b.length;
+  let prev = new Array<number>(n + 1);
+  let curr = new Array<number>(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j]! + 1, curr[j - 1]! + 1, prev[j - 1]! + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n]!;
+}
+
+function findClosestName(target: string, candidates: string[]): string | undefined {
+  if (candidates.length === 0) return undefined;
+  const norm = target.trim().toLowerCase();
+  let best: { name: string; dist: number } | undefined;
+  for (const c of candidates) {
+    const d = levenshtein(norm, c.trim().toLowerCase());
+    if (best === undefined || d < best.dist) best = { name: c, dist: d };
+  }
+  if (!best) return undefined;
+  // Only suggest when the candidate is within 50% edit distance of the target —
+  // otherwise the "Did you mean" line is noise.
+  const maxLen = Math.max(norm.length, best.name.trim().length);
+  if (maxLen > 0 && best.dist > maxLen * 0.5) return undefined;
+  return best.name;
+}
+
+function warnUnmatchedScenarios(
+  context: 'exec' | 'classify',
+  source: string,
+  ticket: string,
+  total: number,
+  unmatched: Array<{ name: string; suggestion?: string }>,
+): void {
+  if (unmatched.length === 0) return;
+  console.warn(
+    `[graph-record ${context}] ${unmatched.length} of ${total} scenario name(s) in ${source} could not be matched to graph scenarios for ${ticket}.`,
+  );
+  for (const u of unmatched) {
+    console.warn(`  Unmatched: "${u.name}"`);
+    if (u.suggestion) console.warn(`    Did you mean: "${u.suggestion}"?`);
+  }
+}
+
+function knownScenariosForTicket(repoRoot: string, ticket: string): ScenarioNode[] {
+  const snap = deriveSnapshot(loadAllEvents(repoRoot));
+  return Object.values(snap.scenarios).filter((s) => s.ticketId === ticket);
+}
+
 function readStoryFrontmatter(repoRoot: string, ticket: string): StoryFrontmatter | null {
   const path = join(repoRoot, '.xera', ticket, 'story.md');
   if (!existsSync(path)) return null;
@@ -127,11 +186,22 @@ async function recordExec(repoRoot: string, ticket: string, runId: string): Prom
   const data = JSON.parse(readFileSync(normalizedPath, 'utf8')) as {
     scenarios: Array<{ name: string; outcome: 'PASS' | 'FAIL' | 'SKIPPED' }>;
   };
+  const known = knownScenariosForTicket(repoRoot, ticket);
+  const knownIds = new Set(known.map((s) => s.id));
+  const knownNames = known.map((s) => s.name);
   const events: Event[] = [];
+  const unmatched: Array<{ name: string; suggestion?: string }> = [];
+  let considered = 0;
   for (const s of data.scenarios) {
     if (s.outcome === 'SKIPPED') continue;
+    considered++;
+    const sid = scenarioId(ticket, s.name);
+    if (known.length > 0 && !knownIds.has(sid)) {
+      const suggestion = findClosestName(s.name, knownNames);
+      unmatched.push(suggestion ? { name: s.name, suggestion } : { name: s.name });
+    }
     const p: RunCompletedPayload = {
-      scenarioId: scenarioId(ticket, s.name),
+      scenarioId: sid,
       ticketId: ticket,
       runId,
       status: s.outcome === 'PASS' ? 'pass' : 'fail',
@@ -139,6 +209,7 @@ async function recordExec(repoRoot: string, ticket: string, runId: string): Prom
     };
     events.push(makeEvent('xera-exec', 'run.completed', p));
   }
+  warnUnmatchedScenarios('exec', 'normalized.json', ticket, considered, unmatched);
   appendEvents(repoRoot, events, { skill: 'xera-exec', ticketId: ticket });
   return 0;
 }
@@ -153,16 +224,32 @@ async function recordClassify(repoRoot: string, ticket: string, runId: string):
   const data = JSON.parse(readFileSync(classifyPath, 'utf8')) as {
     scenarios: Array<{ name: string; class: string; confidence: 'low' | 'medium' | 'high' }>;
   };
+  const known = knownScenariosForTicket(repoRoot, ticket);
+  const knownIds = new Set(known.map((s) => s.id));
+  const knownNames = known.map((s) => s.name);
   const events: Event[] = [];
+  const unmatched: Array<{ name: string; suggestion?: string }> = [];
   for (const s of data.scenarios) {
+    const sid = scenarioId(ticket, s.name);
+    if (known.length > 0 && !knownIds.has(sid)) {
+      const suggestion = findClosestName(s.name, knownNames);
+      unmatched.push(suggestion ? { name: s.name, suggestion } : { name: s.name });
+    }
     const p: RunClassifiedPayload = {
-      scenarioId: scenarioId(ticket, s.name),
+      scenarioId: sid,
       runId,
       classification: s.class as RunClassifiedPayload['classification'],
       confidence: s.confidence,
     };
     events.push(makeEvent('xera-report', 'run.classified', p));
   }
+  warnUnmatchedScenarios(
+    'classify',
+    'classifier-input.json',
+    ticket,
+    data.scenarios.length,
+    unmatched,
+  );
   appendEvents(repoRoot, events, { skill: 'xera-report', ticketId: ticket });
   return 0;
 }

package/src/graph/store.ts

@@ -106,6 +106,14 @@ export function deriveSnapshot(events: Event[]): Snapshot {
     classification: Classification;
     ts: string;
   }> = [];
+  // Side index keyed by `${scenarioId}:${runId}` so a run.classified event can
+  // either join onto an existing FailureNode or be picked up when its
+  // run.completed sibling arrives later (event order isn't guaranteed —
+  // events live in separate JSONL files written by separate skills).
+  const classByRun = new Map<
+    string,
+    { classification: Classification; confidence: 'low' | 'medium' | 'high' }
+  >();
 
   for (const e of events) {
     switch (e.type) {
@@ -218,6 +226,11 @@ export function deriveSnapshot(events: Event[]): Snapshot {
             ts: e.ts,
           };
           if (e.payload.traceId) fail.traceId = e.payload.traceId;
+          const prior = classByRun.get(`${e.payload.scenarioId}:${e.payload.runId}`);
+          if (prior) {
+            fail.classification = prior.classification;
+            fail.confidence = prior.confidence;
+          }
           latestFailures[e.payload.scenarioId] = fail;
         } else {
           delete latestFailures[e.payload.scenarioId];
@@ -242,13 +255,26 @@ export function deriveSnapshot(events: Event[]): Snapshot {
         }
         break;
       }
-      case 'run.classified':
+      case 'run.classified': {
         classifications.push({
           scenarioId: e.payload.scenarioId,
           classification: e.payload.classification,
           ts: e.ts,
         });
+        classByRun.set(`${e.payload.scenarioId}:${e.payload.runId}`, {
+          classification: e.payload.classification,
+          confidence: e.payload.confidence,
+        });
+        // If the matching FailureNode is already in latest_failures, project
+        // the classification onto it now so the snapshot is correct regardless
+        // of which event arrived first.
+        const existing = latestFailures[e.payload.scenarioId];
+        if (existing && existing.runId === e.payload.runId) {
+          existing.classification = e.payload.classification;
+          existing.confidence = e.payload.confidence;
+        }
         break;
+      }
       case 'ac-coverage.backfilled': {
         const { ts, ticketId, mappings } = e.payload;
         // Remove prior backfill edges for this ticket (idempotent)

package/src/graph/types.ts

@@ -207,6 +207,8 @@ export interface FailureNode {
   traceId?: string;
   ts: string;
   disputed?: boolean;
+  classification?: Classification;
+  confidence?: 'low' | 'medium' | 'high';
 }
 
 export interface EdgeRecord {