@xera-ai/core 0.1.6 → 0.3.0

package/src/bin-internal/exec.ts

@@ -1,17 +1,20 @@
-import { resolveArtifactPaths, generateRunId } from '../artifact/paths';
-import { acquireLock, releaseLock, isLockStale, readLock, forceUnlock } from '../lock/file-lock';
-import { NdjsonLogger } from '../logging/ndjson-logger';
-import { loadConfig } from '../config/load';
-import { readAuthState } from '../auth/state';
-import { needsRefresh } from '../auth/refresh';
-import { stagePlaywrightState, runAuthSetup, runPlaywright } from '@xera-ai/web';
-import { chromium } from '@playwright/test';
-import { mkdirSync, existsSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { chromium } from '@playwright/test';
+import { runAuthSetup, runPlaywright, stagePlaywrightState } from '@xera-ai/web';
+import { generateRunId, resolveArtifactPaths } from '../artifact/paths';
+import { needsRefresh } from '../auth/refresh';
+import { readAuthState } from '../auth/state';
+import { loadConfig } from '../config/load';
+import { acquireLock, forceUnlock, isLockStale, readLock, releaseLock } from '../lock/file-lock';
+import { NdjsonLogger } from '../logging/ndjson-logger';
 
 export async function execCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:exec] usage: exec <TICKET>'); return 1; }
+  if (!ticket) {
+    console.error('[xera:exec] usage: exec <TICKET>');
+    return 1;
+  }
   const cwd = process.cwd();
   const config = await loadConfig(cwd);
   const paths = resolveArtifactPaths(cwd, ticket);
@@ -21,12 +24,16 @@ export async function execCmd(argv: string[]): Promise<number> {
   // Acquire lock
   if (!acquireLock(paths.lockPath, runId)) {
     if (isLockStale(paths.lockPath)) {
-      console.error(`[xera:exec] stale lock detected; force unlocking. Run \`xera-internal unlock ${ticket}\` to clear manually.`);
+      console.error(
+        `[xera:exec] stale lock detected; force unlocking. Run \`xera-internal unlock ${ticket}\` to clear manually.`,
+      );
       forceUnlock(paths.lockPath);
       acquireLock(paths.lockPath, runId);
     } else {
       const existing = readLock(paths.lockPath);
-      console.error(`[xera:exec] another run in progress (PID ${existing?.pid} on ${existing?.hostname}, started ${existing?.started_at}). Wait or run \`xera-internal unlock ${ticket}\`.`);
+      console.error(
+        `[xera:exec] another run in progress (PID ${existing?.pid} on ${existing?.hostname}, started ${existing?.started_at}). Wait or run \`xera-internal unlock ${ticket}\`.`,
+      );
       return 1;
     }
   }
@@ -39,11 +46,18 @@ export async function execCmd(argv: string[]): Promise<number> {
       try {
         for (const [roleName, roleCreds] of Object.entries(config.web.auth.roles)) {
           const entry = readAuthState(paths.authDir, roleName);
-          if (needsRefresh(entry, { ttl: config.web.auth.ttl, refreshBuffer: config.web.auth.refreshBuffer })) {
+          if (
+            needsRefresh(entry, {
+              ttl: config.web.auth.ttl,
+              refreshBuffer: config.web.auth.refreshBuffer,
+            })
+          ) {
             const email = process.env[roleCreds.envEmail];
             const password = process.env[roleCreds.envPassword];
             if (!email || !password) {
-              console.error(`[xera:exec] missing env ${roleCreds.envEmail} or ${roleCreds.envPassword} for role "${roleName}"`);
+              console.error(
+                `[xera:exec] missing env ${roleCreds.envEmail} or ${roleCreds.envPassword} for role "${roleName}"`,
+              );
               return 1;
             }
             await runAuthSetup({
@@ -88,12 +102,21 @@ export async function execCmd(argv: string[]): Promise<number> {
     const envName = process.env.XERA_ENV ?? config.web.defaultEnv;
     const baseURL = config.web.baseUrl[envName] ?? config.web.baseUrl[config.web.defaultEnv]!;
 
+    const reportJsonPath = join(runDir, 'report.json');
+
     log.log({ step: 'exec.start', runId, env: envName, baseURL });
     const r = await runPlaywright({
       specPath: paths.specPath,
       configPath: cfgPath,
       outputDir: runDir,
-      env: { XERA_BASE_URL: baseURL, XERA_ENV: envName },
+      env: {
+        XERA_BASE_URL: baseURL,
+        XERA_ENV: envName,
+        // Playwright's JSON reporter prints to stdout by default. Redirect it
+        // to a file inside the run dir so xera:normalize has a deterministic
+        // path to read.
+        PLAYWRIGHT_JSON_OUTPUT_NAME: reportJsonPath,
+      },
     });
     log.log({ step: 'exec.done', runId, exit: r.exitCode, ms: Date.now() - t0 });
 
@@ -104,4 +127,3 @@ export async function execCmd(argv: string[]): Promise<number> {
     releaseLock(paths.lockPath);
   }
 }
-

package/src/bin-internal/fetch.ts

@@ -1,13 +1,15 @@
-import { writeFileSync, mkdirSync } from 'node:fs';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { loadConfig } from '../config/load';
-import { resolveArtifactPaths } from '../artifact/paths';
 import { hashString } from '../artifact/hash';
-import { writeMeta, readMeta } from '../artifact/meta';
+import { readMeta, writeMeta } from '../artifact/meta';
+import { resolveArtifactPaths } from '../artifact/paths';
+import { loadConfig } from '../config/load';
 import { createJiraClient } from '../jira/client';
 import type { JiraTicket } from '../jira/types';
 
-export interface FetchCmdOpts { cwd?: string; }
+export interface FetchCmdOpts {
+  cwd?: string;
+}
 
 export async function fetchCmd(argv: string[], opts: FetchCmdOpts = {}): Promise<number> {
   const cwd = opts.cwd ?? process.cwd();
@@ -31,9 +33,13 @@ export async function fetchCmd(argv: string[], opts: FetchCmdOpts = {}): Promise
         ? { rest: { email: process.env.JIRA_EMAIL, apiToken: process.env.JIRA_API_TOKEN } }
         : {}),
     });
-    const fieldMap = config.jira.fields.acceptanceCriteria !== undefined
-      ? { story: config.jira.fields.story, acceptanceCriteria: config.jira.fields.acceptanceCriteria }
-      : { story: config.jira.fields.story };
+    const fieldMap =
+      config.jira.fields.acceptanceCriteria !== undefined
+        ? {
+            story: config.jira.fields.story,
+            acceptanceCriteria: config.jira.fields.acceptanceCriteria,
+          }
+        : { story: config.jira.fields.story };
     t = await client.fetchTicket(ticket, fieldMap);
   }
 
@@ -69,7 +75,7 @@ function renderStory(t: JiraTicket): string {
     lines.push('## Story', '', story, '');
   }
 
-  if (t.acceptanceCriteria && t.acceptanceCriteria.trim()) {
+  if (t.acceptanceCriteria?.trim()) {
     const ac = t.acceptanceCriteria.trim();
     if (/^##\s+acceptance\s+criteria\b/i.test(ac)) {
       lines.push(ac, '');
@@ -78,7 +84,12 @@ function renderStory(t: JiraTicket): string {
     }
   }
   if (t.attachments.length > 0) {
-    lines.push('## Attachments', '', ...t.attachments.map((a) => `- [${a.filename}](${a.url})`), '');
+    lines.push(
+      '## Attachments',
+      '',
+      ...t.attachments.map((a) => `- [${a.filename}](${a.url})`),
+      '',
+    );
   }
   return lines.join('\n');
 }

package/src/bin-internal/heal-prepare.ts

@@ -0,0 +1,230 @@
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { scrubFreeText } from '@xera-ai/web';
+import { unzipSync } from 'fflate';
+import { resolveArtifactPaths } from '../artifact/paths';
+
+export type FailedLocatorKind = 'role' | 'test-id' | 'css-class' | 'text' | 'label' | 'other';
+
+export interface HealInput {
+  ticket: string;
+  runId: string;
+  scenarioName: string;
+  failedLocator: {
+    raw: string;
+    kind: FailedLocatorKind;
+    pomFile: string;
+    pomLine: number;
+    pomLineContent: string;
+    pomMethodName: string;
+  };
+  gherkinStep: string;
+  domSnapshotAtFailure: string;
+}
+
+interface ClassifierInput {
+  runId: string;
+  scenarios: Array<{
+    name: string;
+    outcome: string;
+    class: string;
+    confidence: string;
+    rationale: string;
+  }>;
+}
+
+interface NormalizedRunFile {
+  runId: string;
+  scenarios: Array<{
+    name: string;
+    outcome: 'PASS' | 'FAIL' | 'SKIPPED';
+    failure?: { errorMessage?: string };
+  }>;
+}
+
+const LOCATOR_LINE_RE = /^Locator:\s*(.+)$/m;
+
+function classifyKind(raw: string): FailedLocatorKind {
+  if (/^getByRole\b/.test(raw)) return 'role';
+  if (/^getByTestId\b/.test(raw)) return 'test-id';
+  if (/^getByLabel\b/.test(raw)) return 'label';
+  if (/^getByText\b/.test(raw)) return 'text';
+  if (/^locator\(\s*['"`]\s*\.[A-Za-z_-]/.test(raw)) return 'css-class';
+  return 'other';
+}
+
+function extractDomSnapshot(tracePath: string): string {
+  if (!existsSync(tracePath)) return '';
+  const buf = readFileSync(tracePath);
+  const entries = unzipSync(buf);
+
+  // Strategy: parse the .trace JSONL event file to find the last frame-snapshot
+  // event, then extract the HTML resource it references. This gives us the DOM
+  // snapshot closest to the failure point rather than a lexicographic approximation.
+  // Falls back to last .html by lex sort if the .trace file is missing or unparseable.
+  const traceKey = Object.keys(entries).find((name) => name.endsWith('.trace'));
+  let chosenKey: string | null = null;
+
+  if (traceKey) {
+    const traceText = new TextDecoder().decode(entries[traceKey]!);
+    const lines = traceText.split('\n').filter(Boolean);
+    // Walk events in REVERSE order to find the most recent frame-snapshot.
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const evt = JSON.parse(lines[i]!);
+        const isSnapshot = evt.type === 'frame-snapshot' || evt.type === 'snapshot';
+        if (!isSnapshot) continue;
+        const snap = evt.snapshot ?? {};
+        // Try direct resource reference (older format).
+        const resourceName: unknown = snap.resourceName;
+        if (typeof resourceName === 'string') {
+          if (entries[resourceName]) {
+            chosenKey = resourceName;
+            break;
+          }
+          // Some traces store .html files under resources/ with the resourceName as the basename.
+          const guessed = `resources/${resourceName.replace(/^resources\//, '')}`;
+          if (entries[guessed]) {
+            chosenKey = guessed;
+            break;
+          }
+        }
+        // Try snapshot name → look for matching .html in resources/.
+        const snapshotName: unknown = snap.snapshotName;
+        if (typeof snapshotName === 'string') {
+          const directGuess = Object.keys(entries).find(
+            (k) => k.endsWith('.html') && k.includes(snapshotName),
+          );
+          if (directGuess) {
+            chosenKey = directGuess;
+            break;
+          }
+        }
+      } catch {
+        // Skip unparseable trace lines.
+      }
+    }
+  }
+
+  // Fallback: last .html by lexicographic sort (existing heuristic).
+  if (!chosenKey) {
+    const htmlKeys = Object.keys(entries)
+      .filter((name) => name.endsWith('.html'))
+      .sort();
+    chosenKey = htmlKeys[htmlKeys.length - 1] ?? null;
+  }
+
+  if (!chosenKey) return '';
+  const html = new TextDecoder().decode(entries[chosenKey]!);
+  return scrubFreeText(html);
+}
+
+function findPomLine(
+  ticketDir: string,
+  rawLocator: string,
+): { pomFile: string; pomLine: number; pomLineContent: string; pomMethodName: string } {
+  const pomDir = join(ticketDir, 'page-objects');
+  const candidates: string[] = [];
+  if (existsSync(pomDir)) {
+    for (const name of readdirSync(pomDir)) {
+      if (name.endsWith('.ts')) candidates.push(join(pomDir, name));
+    }
+  }
+  for (const file of candidates) {
+    const text = readFileSync(file, 'utf8');
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!;
+      if (line.includes(rawLocator)) {
+        const methodMatch = /^\s*(\w+)\s*=/.exec(line);
+        return {
+          pomFile: file,
+          pomLine: i + 1,
+          pomLineContent: line,
+          pomMethodName: methodMatch?.[1] ?? '<anonymous>',
+        };
+      }
+    }
+  }
+  throw new Error(`POM line not found for locator: ${rawLocator}`);
+}
+
+function findGherkinStep(featureText: string, rawLocator: string): string {
+  // Best-effort: find the first step line that mentions a quoted string
+  // appearing in the locator (e.g. a button name). Falls back to the
+  // first When/Then line if no match.
+  const quoteMatch = /['"`]([^'"`]{2,})['"`]/.exec(rawLocator);
+  if (quoteMatch) {
+    const needle = quoteMatch[1]!;
+    for (const line of featureText.split('\n')) {
+      if (line.includes(needle) && /^\s*(When|Then|And|Given)\b/.test(line)) {
+        return line.trim();
+      }
+    }
+  }
+  for (const line of featureText.split('\n')) {
+    if (/^\s*(When|Then)\b/.test(line)) return line.trim();
+  }
+  return '';
+}
+
+export function healPrepare(
+  repoRoot: string,
+  ticket: string,
+  runId: string,
+  scenarioName: string,
+): HealInput {
+  const paths = resolveArtifactPaths(repoRoot, ticket);
+  const classifierPath = join(paths.ticketDir, 'classifier-input.json');
+  const classifier: ClassifierInput = JSON.parse(readFileSync(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 = join(paths.runsDir, runId);
+  const normalized: NormalizedRunFile = JSON.parse(
+    readFileSync(join(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}"`);
+  const errorMessage = normSc.failure.errorMessage ?? '';
+  const m = LOCATOR_LINE_RE.exec(errorMessage);
+  if (!m) throw new Error(`cannot extract locator from errorMessage: ${errorMessage.slice(0, 80)}`);
+  const raw = m[1]!.trim();
+  const kind = classifyKind(raw);
+
+  const pomLoc = findPomLine(paths.ticketDir, raw);
+
+  const featureText = readFileSync(paths.featurePath, 'utf8');
+  const gherkinStep = findGherkinStep(featureText, raw);
+
+  const domSnapshotAtFailure = extractDomSnapshot(join(runDir, 'trace.zip'));
+
+  return {
+    ticket,
+    runId,
+    scenarioName,
+    failedLocator: { raw, kind, ...pomLoc },
+    gherkinStep,
+    domSnapshotAtFailure,
+  };
+}
+
+export async function healPrepareCmd(argv: string[]): Promise<number> {
+  const [ticket, runId, ...scenarioParts] = argv;
+  if (!ticket || !runId || scenarioParts.length === 0) {
+    console.error('[xera:heal-prepare] usage: heal-prepare <TICKET> <RUN_ID> <SCENARIO_NAME>');
+    return 1;
+  }
+  const scenarioName = scenarioParts.join(' ');
+  try {
+    const result = healPrepare(process.cwd(), ticket, runId, scenarioName);
+    const paths = resolveArtifactPaths(process.cwd(), ticket);
+    const outPath = join(paths.runsDir, runId, 'heal-input.json');
+    writeFileSync(outPath, JSON.stringify(result, null, 2));
+    console.log(`[xera:heal-prepare] wrote ${outPath}`);
+    return 0;
+  } catch (err) {
+    console.error(`[xera:heal-prepare] ${(err as Error).message}`);
+    return 1;
+  }
+}

package/src/bin-internal/index.ts

@@ -1,33 +1,47 @@
+import { doctorCmd } from './doctor';
+import { evalDeterministicCmd } from './eval-deterministic';
+import { evalPrepareCmd } from './eval-prepare';
+import { evalReportCmd } from './eval-report';
+import { execCmd } from './exec';
 import { fetchCmd } from './fetch';
-import { validateFeatureCmd } from './validate-feature';
-import { typecheckCmd } from './typecheck';
+import { healPrepareCmd } from './heal-prepare';
 import { lintCmd } from './lint';
-import { execCmd } from './exec';
 import { normalizeCmd } from './normalize';
-import { reportCmd } from './report';
 import { postCmd } from './post';
+import { promoteCmd } from './promote';
+import { reportCmd } from './report';
 import { statusCmd } from './status-cmd';
+import { typecheckCmd } from './typecheck';
 import { unlockCmd } from './unlock';
-import { promoteCmd } from './promote';
+import { validateFeatureCmd } from './validate-feature';
+import { verifyPromptsCmd } from './verify-prompts';
 
 const COMMANDS: Record<string, (argv: string[]) => Promise<number>> = {
+  doctor: doctorCmd,
+  'eval-deterministic': evalDeterministicCmd,
+  'eval-prepare': evalPrepareCmd,
+  'eval-report': evalReportCmd,
+  exec: execCmd,
   fetch: fetchCmd,
-  'validate-feature': validateFeatureCmd,
-  typecheck: typecheckCmd,
+  'heal-prepare': healPrepareCmd,
   lint: lintCmd,
-  exec: execCmd,
   normalize: normalizeCmd,
-  report: reportCmd,
   post: postCmd,
+  promote: promoteCmd,
+  report: reportCmd,
   status: statusCmd,
+  typecheck: typecheckCmd,
   unlock: unlockCmd,
-  promote: promoteCmd,
+  'validate-feature': validateFeatureCmd,
+  'verify-prompts': verifyPromptsCmd,
 };
 
 export async function run(argv: string[]): Promise<number> {
   const [cmd, ...rest] = argv;
   if (!cmd || !COMMANDS[cmd]) {
-    console.error(`Usage: xera-internal <command> [args...]\nCommands: ${Object.keys(COMMANDS).join(', ')}`);
+    console.error(
+      `Usage: xera-internal <command> [args...]\nCommands: ${Object.keys(COMMANDS).join(', ')}`,
+    );
     return 1;
   }
   try {

package/src/bin-internal/lint.ts

@@ -1,12 +1,19 @@
-import { resolveArtifactPaths } from '../artifact/paths';
 import { lintTicket } from '@xera-ai/web';
+import { resolveArtifactPaths } from '../artifact/paths';
 
 export async function lintCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:lint] usage: lint <TICKET>'); return 1; }
+  if (!ticket) {
+    console.error('[xera:lint] usage: lint <TICKET>');
+    return 1;
+  }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
   const r = await lintTicket(paths.ticketDir);
-  if (r.ok) { console.log('[xera:lint] ok'); return 0; }
-  for (const w of r.warnings) console.error(`[xera:lint] ${w.file}:${w.line} [${w.rule}] ${w.message}`);
+  if (r.ok) {
+    console.log('[xera:lint] ok');
+    return 0;
+  }
+  for (const w of r.warnings)
+    console.error(`[xera:lint] ${w.file}:${w.line} [${w.rule}] ${w.message}`);
   return 2;
 }

package/src/bin-internal/normalize.ts

@@ -1,20 +1,34 @@
-import { resolveArtifactPaths } from '../artifact/paths';
-import { normalizeRun } from '@xera-ai/web';
-import { readdirSync, existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { normalizeRun } from '@xera-ai/web';
+import { resolveArtifactPaths } from '../artifact/paths';
 
 export async function normalizeCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:normalize] usage: normalize <TICKET> [--run=<runId>]'); return 1; }
+  if (!ticket) {
+    console.error('[xera:normalize] usage: normalize <TICKET> [--run=<runId>]');
+    return 1;
+  }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
-  const runArg = argv.find(a => a.startsWith('--run='));
+  const runArg = argv.find((a) => a.startsWith('--run='));
   const runId = runArg
     ? runArg.split('=')[1]!
-    : readdirSync(paths.runsDir).filter(n => !n.startsWith('.')).sort().pop()!;
-  if (!runId) { console.error('[xera:normalize] no run found'); return 1; }
+    : readdirSync(paths.runsDir)
+        .filter((n) => !n.startsWith('.'))
+        .sort()
+        .pop()!;
+  if (!runId) {
+    console.error('[xera:normalize] no run found');
+    return 1;
+  }
   const runDir = join(paths.runsDir, runId);
-  if (!existsSync(runDir)) { console.error(`[xera:normalize] runs/${runId} missing`); return 1; }
+  if (!existsSync(runDir)) {
+    console.error(`[xera:normalize] runs/${runId} missing`);
+    return 1;
+  }
   const r = await normalizeRun({ runId, runDir });
-  console.log(`[xera:normalize] wrote normalized.json (scrubbed_fields_count=${r.scrubbed_fields_count})`);
+  console.log(
+    `[xera:normalize] wrote normalized.json (scrubbed_fields_count=${r.scrubbed_fields_count})`,
+  );
   return 0;
 }

package/src/bin-internal/post.ts

@@ -1,13 +1,16 @@
-import { readFileSync, existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolveArtifactPaths } from '../artifact/paths';
-import { loadConfig } from '../config/load';
 import { readStatus, writeStatus } from '../artifact/status';
+import { loadConfig } from '../config/load';
 import { createJiraClient } from '../jira/client';
 
 export async function postCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:post] usage: post <TICKET>'); return 1; }
+  if (!ticket) {
+    console.error('[xera:post] usage: post <TICKET>');
+    return 1;
+  }
   const cwd = process.cwd();
   const config = await loadConfig(cwd);
   if (!config.reporting.postToJira) {
@@ -16,7 +19,10 @@ export async function postCmd(argv: string[]): Promise<number> {
   }
   const paths = resolveArtifactPaths(cwd, ticket);
   const draftPath = join(paths.ticketDir, 'jira-comment.draft.md');
-  if (!existsSync(draftPath)) { console.error(`[xera:post] no draft at ${draftPath}; run \`xera-internal report\` first.`); return 1; }
+  if (!existsSync(draftPath)) {
+    console.error(`[xera:post] no draft at ${draftPath}; run \`xera-internal report\` first.`);
+    return 1;
+  }
   const body = readFileSync(draftPath, 'utf8');
 
   const client = await createJiraClient({

package/src/bin-internal/report.ts

@@ -2,9 +2,9 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolveArtifactPaths } from '../artifact/paths';
 import { aggregateScenarios } from '../classifier/aggregate';
-import { writeStatusFromClassification } from '../reporter/status-writer';
-import { buildJiraComment } from '../reporter/jira-comment';
 import type { ScenarioClassification } from '../classifier/types';
+import { buildJiraComment } from '../reporter/jira-comment';
+import { writeStatusFromClassification } from '../reporter/status-writer';
 
 interface ReportInput {
   scenarios: ScenarioClassification[];
@@ -14,7 +14,7 @@ interface ReportInput {
 
 export async function reportCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  const inputArg = argv.find(a => a.startsWith('--input='));
+  const inputArg = argv.find((a) => a.startsWith('--input='));
   if (!ticket || !inputArg) {
     console.error('[xera:report] usage: report <TICKET> --input=<classifier-output.json>');
     return 1;

package/src/bin-internal/status-cmd.ts

@@ -3,11 +3,19 @@ import { readStatus } from '../artifact/status';
 
 export async function statusCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:status] usage: status <TICKET>'); return 1; }
+  if (!ticket) {
+    console.error('[xera:status] usage: status <TICKET>');
+    return 1;
+  }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
   const s = readStatus(paths.statusPath);
-  if (!s) { console.log(`[xera:status] no status yet for ${ticket}`); return 0; }
-  console.log(`${ticket}: ${s.result} (${s.classification}, conf=${s.confidence}) — ${s.scenarios.passed}/${s.scenarios.total} passed, last run ${s.lastRun}`);
+  if (!s) {
+    console.log(`[xera:status] no status yet for ${ticket}`);
+    return 0;
+  }
+  console.log(
+    `${ticket}: ${s.result} (${s.classification}, conf=${s.confidence}) — ${s.scenarios.passed}/${s.scenarios.total} passed, last run ${s.lastRun}`,
+  );
   for (const h of s.history.slice(0, 5)) console.log(`  ${h.ts}  ${h.result}  ${h.class}`);
   return 0;
 }

package/src/bin-internal/typecheck.ts

@@ -1,12 +1,18 @@
-import { resolveArtifactPaths } from '../artifact/paths';
 import { typecheckTicket } from '@xera-ai/web';
+import { resolveArtifactPaths } from '../artifact/paths';
 
 export async function typecheckCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:typecheck] usage: typecheck <TICKET>'); return 1; }
+  if (!ticket) {
+    console.error('[xera:typecheck] usage: typecheck <TICKET>');
+    return 1;
+  }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
   const r = await typecheckTicket(paths.ticketDir);
-  if (r.ok) { console.log('[xera:typecheck] ok'); return 0; }
+  if (r.ok) {
+    console.log('[xera:typecheck] ok');
+    return 0;
+  }
   for (const e of r.errors) console.error(`[xera:typecheck] ${e}`);
   return 2;
 }

package/src/bin-internal/unlock.ts

@@ -1,15 +1,23 @@
 import { resolveArtifactPaths } from '../artifact/paths';
-import { isLockStale, readLock, forceUnlock } from '../lock/file-lock';
+import { forceUnlock, isLockStale, readLock } from '../lock/file-lock';
 
 export async function unlockCmd(argv: string[]): Promise<number> {
   const ticket = argv[0];
-  if (!ticket) { console.error('[xera:unlock] usage: unlock <TICKET> [--force]'); return 1; }
+  if (!ticket) {
+    console.error('[xera:unlock] usage: unlock <TICKET> [--force]');
+    return 1;
+  }
   const paths = resolveArtifactPaths(process.cwd(), ticket);
   const lock = readLock(paths.lockPath);
-  if (!lock) { console.log(`[xera:unlock] no lock for ${ticket}`); return 0; }
+  if (!lock) {
+    console.log(`[xera:unlock] no lock for ${ticket}`);
+    return 0;
+  }
   const force = argv.includes('--force');
   if (!force && !isLockStale(paths.lockPath)) {
-    console.error(`[xera:unlock] lock is held by PID ${lock.pid} on ${lock.hostname} (active). Pass --force to override.`);
+    console.error(
+      `[xera:unlock] lock is held by PID ${lock.pid} on ${lock.hostname} (active). Pass --force to override.`,
+    );
     return 1;
   }
   forceUnlock(paths.lockPath);