elanous 0.2.5 → 0.2.7

package/scripts/landing-heal/run-mission.ts

@@ -7,6 +7,7 @@ import { debug } from '../../src/debug/log.js';
 import { emitDecision } from '../../src/live/detail-switch.js';
 import { parse } from '../../src/agent-substrate/pr-comment-meta.js';
 import { classifyReviewRounds, matchMustFix, type MustFixVerdict } from './must-fix-match.js';
+import { verifyCleanCheckout, type CheckoutResult } from './clean-checkout.js';
 
 interface PullRequest {
   number: number;
@@ -17,7 +18,7 @@ interface PullRequest {
   files: Array<{ path: string }>;
 }
 interface Match { pr: number; text: string; verdict: MustFixVerdict | 'rereviewed' | 'open'; run?: string; round?: number; resolvedIn?: number[] }
-interface GraphContext { runId?: string; input?: { windowMinutes?: number; mustFixByPr?: Record<string, string[]> }; outputs?: Record<string, unknown>; decision?: typeof emitDecision }
+interface GraphContext { runId?: string; input?: { windowMinutes?: number; mustFixByPr?: Record<string, string[]>; postVerified?: boolean }; outputs?: Record<string, unknown>; decision?: typeof emitDecision }
 export type RunCommand = (args: string[]) => string;
 // 상주 루프(30분마다)는 사람 계정 한도를 쓰지 않는다 — 부른 쪽이 GH_TOKEN 을 주지 않았으면 GitHub App 설치 토큰으로(09-29 한도 소진).
 // 발급 함수마다 한 번(프로세스 전역 한 칸이면 앞선 호출의 진짜 토큰이 주입한 가짜를 이긴다 — 09-29 시험 실패 출력에 토큰이 찍혔다).
@@ -93,7 +94,7 @@ export function resolvedInPrs(body: string | undefined): number[] {
   return match ? [...match[1]!.matchAll(/#(\d+)/g)].map((m) => Number(m[1])) : [];
 }
 
-export function runMission(mission: string, ctx: GraphContext, run: RunCommand = gh, now = new Date()): Record<string, unknown> {
+export function runMission(mission: string, ctx: GraphContext, run: RunCommand = gh, now = new Date(), verify = verifyCleanCheckout): Record<string, unknown> {
   switch (mission) {
     case 'collect': {
       const minutes = ctx.input?.windowMinutes ?? 60;
@@ -156,6 +157,37 @@ export function runMission(mission: string, ctx: GraphContext, run: RunCommand =
       }).map((pr) => pr.number);
       return { outcome: 'ok', verifyNeeded, verified };
     }
+    case 'clean-checkout': {
+      const needed = output(ctx, 'verify-needed').verifyNeeded as number[];
+      const candidates = pullRequests(ctx).filter((pr) => needed.includes(pr.number))
+        .sort((a, b) => Date.parse(a.mergedAt ?? '') - Date.parse(b.mergedAt ?? '') || a.number - b.number).slice(0, 2);
+      const results: CheckoutResult[] = [];
+      for (const pr of candidates) {
+        let mergeSha = '';
+        try {
+          const details = JSON.parse(run(['pr', 'view', String(pr.number), '--json', 'mergeCommit'])) as { mergeCommit?: { oid?: string } };
+          mergeSha = details.mergeCommit?.oid ?? '';
+          if (!/^[a-f0-9]{40,64}$/i.test(mergeSha)) throw new Error('mergeCommit.oid unavailable or invalid');
+        } catch (error) {
+          results.push({ pr: pr.number, mergeSha: '', ok: false, steps: [{ name: 'merge commit', ok: false, seconds: 0, tail: String(error).split('\n').slice(-20).join('\n') }] });
+          debug.log('landing-heal', 'clean-checkout', { pr: pr.number, ok: false, seconds: 0 });
+          continue;
+        }
+        let result: CheckoutResult;
+        try {
+          result = verify({ pr: pr.number, mergeSha, files: pr.files.map((file) => file.path) });
+        } catch (error) {
+          result = { pr: pr.number, mergeSha, ok: false, steps: [{ name: 'clean checkout', ok: false, seconds: 0, tail: String(error).split('\n').slice(-20).join('\n') }] };
+        }
+        results.push(result);
+        debug.log('landing-heal', 'clean-checkout', { pr: pr.number, ok: result.ok, seconds: result.steps.reduce((sum, step) => sum + step.seconds, 0) });
+        if (result.ok && ctx.input?.postVerified === true) {
+          const summary = result.steps.filter((step) => step.name !== 'worktree remove').map((step) => step.name).join(' · ');
+          run(['pr', 'comment', String(pr.number), '--body', `landing-verified: ${mergeSha.slice(0, 8)} · clean checkout · ${summary}`]);
+        }
+      }
+      return { outcome: 'ok', results };
+    }
     case 'report': {
       const collected = pullRequests(ctx);
       const prs = collected.length;
@@ -165,6 +197,9 @@ export function runMission(mission: string, ctx: GraphContext, run: RunCommand =
       const mustFixRereviewed = matches.filter((item) => item.verdict === 'rereviewed').length;
       const mustFixUnresolved = mustFixOpen + mustFixUnknown;
       const verifyNeeded = output(ctx, 'verify-needed').verifyNeeded as number[];
+      const checkoutResults = ctx.outputs?.['clean-checkout'] ? output(ctx, 'clean-checkout').results as CheckoutResult[] : undefined;
+      const checkoutPassed = checkoutResults?.filter((item) => item.ok).length ?? 0;
+      const checkoutFailed = checkoutResults?.filter((item) => !item.ok).map((item) => item.pr) ?? [];
       const mergedPrs = new Set(collected.filter((pr) => pr.state === 'MERGED').map((pr) => pr.number));
       const landedOpen = matches.filter((item) => item.verdict === 'open' && mergedPrs.has(item.pr));
       const unresolved = matches.filter((item) => item.verdict === 'unresolved').length;
@@ -174,7 +209,7 @@ export function runMission(mission: string, ctx: GraphContext, run: RunCommand =
       (ctx.decision ?? emitDecision)({
         kind: 'VERIFY',
         what: `착지·치유 관측: PR ${prs}건${open ? ` — 열린 must-fix ${open}건(PR ${openPrs.map((pr) => `#${pr}`).join(', ')})` : ''}`,
-        reason: `열린 채 착지 ${open}건 · 미해결 ${unresolved}건 · 미상 ${mustFixUnknown}건 · 다시 봄 ${mustFixRereviewed}건 · 착지 뒤 검증 필요 ${verifyNeeded.length}건`,
+        reason: `열린 채 착지 ${open}건 · 미해결 ${unresolved}건 · 미상 ${mustFixUnknown}건 · 다시 봄 ${mustFixRereviewed}건 · 착지 뒤 검증 필요 ${verifyNeeded.length}건${checkoutResults ? ` · 검증 성공 ${checkoutPassed} · 실패 ${checkoutFailed.length}(PR ${checkoutFailed.map((pr) => `#${pr}`).join(', ') || '없음'})` : ''}`,
         purpose: '착지 후속 작업 관측', target: 'landing-heal', ...(ctx.runId ? { runId: ctx.runId } : {}),
       });
       return { outcome: 'ok', prs, mustFixUnresolved, mustFixOpen, mustFixUnknown, mustFixRereviewed, verifyNeeded };

package/scripts/lib/android-test-device.ts

@@ -0,0 +1,32 @@
+// 계측 시험(`connectedDebugAndroidTest`)을 «어느 기기»에서 돌리나.
+// ⛔ Gradle 은 시험이 끝나면 앱을 «지운다»(데이터까지). 실기기에서 돌면 대표 폰의 앱이 사라진다
+//    (2026-09-30 실측: pr land 의 android-gate 가 USB 로 꽂힌 폴드 8 에서 돌아 설치본이 지워졌다).
+// ⇒ 에뮬레이터(`emulator-*`)만 고른다. 실기기를 쓰려면 serial 을 «명시»해야 한다.
+
+export type TestDevicePick =
+  | { kind: 'use'; serial: string }
+  | { kind: 'skip'; reason: string };
+
+/** `adb devices` 출력에서 «device» 상태인 serial 들. */
+export function attachedSerials(adbDevicesOutput: string): string[] {
+  return adbDevicesOutput
+    .split('\n')
+    .slice(1)
+    .map((line) => line.trim().split(/\s+/))
+    .filter((cols) => cols.length >= 2 && cols[1] === 'device')
+    .map((cols) => cols[0]!);
+}
+
+export function pickInstrumentedTestDevice(adbDevicesOutput: string, explicitSerial?: string): TestDevicePick {
+  const serials = attachedSerials(adbDevicesOutput);
+  if (explicitSerial) {
+    return serials.includes(explicitSerial)
+      ? { kind: 'use', serial: explicitSerial }
+      : { kind: 'skip', reason: `지정한 기기 ${explicitSerial} 가 연결돼 있지 않다` };
+  }
+  const emulator = serials.find((s) => s.startsWith('emulator-'));
+  if (emulator) return { kind: 'use', serial: emulator };
+  return serials.length > 0
+    ? { kind: 'skip', reason: `에뮬레이터가 없다 — 실기기 ${serials.length}대에서는 돌리지 않는다(시험이 앱과 데이터를 지운다) · 실기기를 쓰려면 ELANOUS_ANDROID_TEST_SERIAL=<serial>` }
+    : { kind: 'skip', reason: '연결된 기기·에뮬레이터가 없다' };
+}

package/scripts/lib/pwa-scenarios/scenarios.ts

@@ -43,7 +43,8 @@ const tab = 'button[aria-label^="switch to "]';
 const terminal = '.xterm';
 const connected = '[aria-live="polite"]';
 // ChatInput 의 입력창(`apps/pwa/src/components/chat/ChatInput.tsx` placeholder) — testid 가 없어 placeholder 로 고른다.
-const chatInput = 'textarea[placeholder^="message"]';
+// Placeholder text is user copy (10-01 #22558 localized it and silently broke C1·C2a·C2b) — match both locales.
+const chatInput = 'textarea[placeholder^="message"], textarea[placeholder^="메시지"]';
 const intakeField = '[data-testid="intake-front-door-field"]';
 const terminalIdentity = `(() => { const sessionId = localStorage.getItem('elanous.daemon.sessionId'); const terminalId = Array.from(document.querySelectorAll('button[aria-label^="switch to "]')).find(node => node.title?.includes('지금 보는 터미널'))?.getAttribute('aria-label')?.slice('switch to '.length); return sessionId && terminalId ? { sessionId, terminalId } : null; })()`;
 const identity = (value: unknown): { sessionId: string; terminalId: string } | null => {

package/scripts/public-export.ts

@@ -11,6 +11,7 @@
  *     표지 = LEAK_MARKERS(줄 단위 흔적 · 문서 링크는 private 에 «실재»하는 이름만) — rc 는 이것만 센다.
  *     참고 = `runtime-path-outside-export`(공개 코드가 공개본에 없는 경로를 쥔다) — rc 에 안 센다 · 판정은 public-export-test-run 의 exportOnly=0.
  *   bun scripts/public-export.ts --out <dir>            # 트리 복사 ⊕ replace 적용 ⊕ 유출 검사(있으면 rc=1 · 복사는 한다)
+ *   bun scripts/public-export.ts --leak-check --files a b …  # 그 파일들만 — prepare 와 같은 변환·치환 «뒤»에 잰다(pr land 가 부른다)
  *
  * ⛔ 목록 밖은 «전부» private 에 남는다 — 이 스크립트가 무엇을 «더» 넣는 일은 없다.
  * ⛔ 원천은 `git ls-files`(추적 파일)다 — 작업 트리의 untracked·ignored 는 원리상 안 간다.
@@ -379,6 +380,9 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
   const pathIndex = argv.indexOf('--path');
   const pathPrefix = pathIndex >= 0 ? argv[pathIndex + 1] : undefined;
   if (pathIndex >= 0 && !pathPrefix) { console.error('⛔ --path needs a prefix'); return 2; }
+  const filesIndex = argv.indexOf('--files');
+  const onlyFiles = filesIndex >= 0 ? new Set(argv.slice(filesIndex + 1).filter((a) => !a.startsWith('--'))) : undefined;
+  const inScope = (f: string) => (!pathPrefix || f.startsWith(pathPrefix)) && (!onlyFiles || onlyFiles.has(f));
   const outIndex = argv.indexOf('--out');
   const out = outIndex >= 0 ? argv[outIndex + 1] : undefined;
   if (outIndex >= 0 && !out) { console.error('⛔ --out needs a directory'); return 2; }
@@ -411,9 +415,9 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
       if (!existsSync(join(root, src))) { console.error(`⛔ replace source missing: ${src}`); return 2; }
       contents.set(dest, readFileSync(join(root, src), 'utf8'));
     }
-    const scanned = pathPrefix ? files.filter((f) => f.startsWith(pathPrefix)) : files;
+    const scanned = files.filter(inScope);
     const realDocs = privateDocNames(tracked, files);
-    const before = [...scanLeaks(root, scanned, LEAK_MARKERS, undefined, realDocs), ...scanRuntimePaths(root, files, tracked).filter((h) => !pathPrefix || h.file.startsWith(pathPrefix))];
+    const before = [...scanLeaks(root, scanned, LEAK_MARKERS, undefined, realDocs), ...scanRuntimePaths(root, files, tracked).filter((h) => inScope(h.file))];
     const transformedByRules = transformExportFiles(contents, config, files);
     // ⭐ 개인 치환표(저장소 밖) — 규칙 변환 «뒤»에 건다. 없으면 «못 봤다»로 막는다.
     const redactions = loadPrivateRedactions();
@@ -445,12 +449,12 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
       console.error(`exported ${files.length} files (+${Object.keys(config.replace).length} replaced) → ${target}`);
     }
     const hits = [
-      ...gitIgnoredExportFiles(root, files).filter((f) => !pathPrefix || f.startsWith(pathPrefix)).map((file) => ({ marker: 'export-gitignored', file, line: 0, text: '공개본 .gitignore 에 걸린다 — 커밋하면 사라진다' })),
+      ...gitIgnoredExportFiles(root, files).filter(inScope).map((file) => ({ marker: 'export-gitignored', file, line: 0, text: '공개본 .gitignore 에 걸린다 — 커밋하면 사라진다' })),
       ...scanLeaks(root, scanned, LEAK_MARKERS, transformed.contents, realDocs),
       ...(redactions ? scanLeaks(root, scanned, privateIdentifierMarkers(redactions), transformed.contents, realDocs) : []),
       ...(!redactions && !noPrivateList ? [{ marker: 'private-identifiers-unchecked', file: privateRedactionsPath(), line: 0, text: 'private redaction list missing' }] : []),
     ];
-    const advisory = scanRuntimePaths(root, files, tracked, transformed.contents).filter((h) => !pathPrefix || h.file.startsWith(pathPrefix));
+    const advisory = scanRuntimePaths(root, files, tracked, transformed.contents).filter((h) => inScope(h.file));
     const summary = summarizeLeaks(hits);
     const advisorySummary = summarizeLeaks(advisory);
     const beforeSummary = summarizeLeaks(before);

package/scripts/release-loop/baseline-from-logs.ts

@@ -0,0 +1,92 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { junitFailures, parseFailures } from './gate-diff';
+
+export function baselineFromCutLogs(dir: string, expectedCommit?: string): { failures: string[]; errors: string[]; files: number; complete: boolean } | undefined {
+  if (!existsSync(dir)) return undefined;
+  let names: string[];
+  try { names = readdirSync(dir); }
+  catch { return undefined; }
+  const metadata = (name: string): { rc?: unknown; files?: unknown; shardCount?: unknown; commit?: unknown } | undefined => {
+    try {
+      const value: unknown = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+      return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+    } catch { return undefined; }
+  };
+  const logs = names.filter((name) => /^pod-\d+(?:-[\w-]+)?\.log$/.test(name));
+  if (!logs.length) return undefined;
+
+  // A split parent's output is partial; only its measured leaves belong to the cut.
+  const leaves = logs.filter((name) => !names.some((other) => other.startsWith(name.slice(0, -4) + '-')
+    && /^pod-\d+(?:-[\w-]+)?\.json$/.test(other)));
+  const failures = new Set<string>();
+  const errors = new Set<string>();
+  const files = new Set<string>();
+  let measured = true;
+  const measuredFiles = new Set<string>();
+  for (const name of leaves) {
+    const prefix = name.slice(0, -4);
+    const junitName = `${prefix}.junit.xml`;
+    let output: string;
+    let xml: string;
+    try {
+      output = readFileSync(join(dir, name), 'utf8');
+      xml = names.includes(junitName) ? readFileSync(join(dir, junitName), 'utf8') : '';
+    } catch {
+      measured = false;
+      continue;
+    }
+    const named = new Set([...parseFailures(output), ...junitFailures(xml)]);
+    for (const id of named) failures.add(id);
+    for (const match of xml.matchAll(/<testsuite\b[^>]*\bfile="([^"]+)"/g)) files.add(match[1]!);
+    const shard = names.includes(`${prefix}.json`) ? metadata(`${prefix}.json`) : undefined;
+    const ran = [...output.matchAll(/Ran (\d+) tests? across (\d+) files?/g)].at(-1);
+    const reported = [...output.matchAll(/(?:^|\n)\s*(\d+) fail\s*(?=\n|$)/g)].at(-1);
+    const junitFiles = new Set([...xml.matchAll(/<testsuite\b[^>]*\bfile="([^"]+)"/g)].map((match) => match[1]!));
+    if (!shard || (shard.rc !== 0 && shard.rc !== 1) || (expectedCommit && shard.commit !== expectedCommit)
+      || !ran || Number(ran[1]) < 1 || junitFiles.size !== Number(ran[2])
+      || !reported || Number(reported[1]) !== named.size || !Array.isArray(shard.files)
+      || !shard.files.every((file): file is string => typeof file === 'string')) measured = false;
+    else for (const file of shard.files) measuredFiles.add(file);
+    let file: string | undefined;
+    let attributedErrors = 0;
+    for (const raw of output.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '').split(/\r?\n/)) {
+      const line = raw.trim();
+      const header = /^(?:\.\/)?((?:[\w.-]+\/)+[\w.-]+\.test\.tsx?):(?:\s|$)/.exec(line);
+      if (header) file = header[1];
+      if (/^# Unhandled error between tests/.test(line)) {
+        if (!file) measured = false;
+        else {
+          errors.add(`${file} > [error]`);
+          attributedErrors++;
+          file = undefined;
+        }
+      }
+    }
+    const reportedErrors = [...output.matchAll(/(?:^|\n)\s*(\d+) errors?\s*(?=\n|$)/g)].at(-1);
+    if ((reportedErrors ? Number(reportedErrors[1]) : 0) !== attributedErrors
+      || (shard?.rc === 1 && named.size + attributedErrors === 0)
+      || (shard?.rc === 0 && named.size + attributedErrors > 0)) measured = false;
+  }
+
+  const plannedFiles = new Set<string>();
+  const roots = names.filter((name) => /^pod-\d+\.json$/.test(name));
+  const allMetadata = names.filter((name) => /^pod-\d+(?:-[\w-]+)?\.json$/.test(name)).map(metadata);
+  if (allMetadata.some((shard) => !shard || (expectedCommit && shard.commit !== expectedCommit))) measured = false;
+  const rootMetadata = roots.map(metadata);
+  for (const shard of rootMetadata) {
+    if (!shard || (expectedCommit && shard.commit !== expectedCommit)
+      || !Array.isArray(shard.files) || !shard.files.every((file): file is string => typeof file === 'string')) measured = false;
+    else for (const file of shard.files) plannedFiles.add(file);
+  }
+  const count = rootMetadata[0]?.shardCount;
+  const complete = measured && rootMetadata.every((shard) => shard?.shardCount === count)
+    && roots.length === count
+    && plannedFiles.size > 0 && plannedFiles.size === measuredFiles.size
+    && [...plannedFiles].every((file) => measuredFiles.has(file))
+    && files.size === measuredFiles.size && [...measuredFiles].every((file) => files.has(file))
+    && typeof count === 'number' && Number.isSafeInteger(count) && count > 0
+    && Array.from({ length: count }, (_, index) => index).every((index) => names.includes(`pod-${index}.json`)
+      && leaves.some((name) => name.startsWith(`pod-${index}.`) || name.startsWith(`pod-${index}-`)));
+  return { failures: [...failures].sort(), errors: [...errors].sort(), files: files.size, complete };
+}

package/scripts/release-loop/checklist-gate-node.ts

@@ -0,0 +1,35 @@
+#!/usr/bin/env bun
+import { addItem, checklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
+import { emitNodeResult, errorResult, readGraphContext, type GraphContext } from './node-verdict.js';
+
+export function runChecklistGate(context: GraphContext = readGraphContext()) {
+  const version = context.input.version;
+  const data = listChecklist(version);
+  const gate = checklistGate(version);
+  const counts = summarizeChecklist(data);
+  const summary = `확인표 🟢${counts.green} 🟡${counts.yellow}(이동 ${gate.moved.length} · 알려진 문제 ${gate.knownIssues.length} · 막음 ${gate.blocked.length} · 판정 없음 ${gate.undecided.length}) 🔴${counts.red}${gate.red.length ? ` (${gate.red.join(', ')})` : ''}`;
+  if (gate.ok && gate.moved.length) {
+    const [major, minor, patch] = version.split('.').map(Number);
+    const next = `${major}.${minor}.${patch! + 1}`;
+    for (const id of gate.moved) {
+      const item = data.items.find((candidate) => candidate.id === id)!;
+      if (listChecklist(next).items.some((candidate) => candidate.id === id)) continue;
+      try { addItem(next, { id, title: item.title, ...(item.owner !== undefined ? { owner: item.owner } : {}) }); }
+      catch (error) {
+        if (!listChecklist(next).items.some((candidate) => candidate.id === id)) throw error;
+      }
+    }
+  }
+  return { outcome: gate.ok ? 'ok' as const : 'fail' as const, verdict: gate.ok ? 'pass' as const : 'fail' as const, summary, ...gate };
+}
+
+if (import.meta.main) {
+  try {
+    const result = runChecklistGate();
+    emitNodeResult(result);
+    process.exitCode = result.outcome === 'ok' ? 0 : 1;
+  } catch (error) {
+    emitNodeResult(errorResult(error));
+    process.exitCode = 2;
+  }
+}

package/scripts/release-loop/env-known-failures.ts

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** The identity is the complete Bun failure id, not its containing test file. */
+export function loadEnvKnownFailures(repoRoot: string): Set<string> {
+  const path = join(repoRoot, 'test/env-known-failures.json');
+  if (!existsSync(path)) return new Set();
+  let data: unknown;
+  try { data = JSON.parse(readFileSync(path, 'utf8')); }
+  catch (error) { throw new Error(`invalid environment known failures: ${path}`, { cause: error }); }
+  if (!data || typeof data !== 'object' || Array.isArray(data)
+    || !('env' in data) || data.env !== 'linux-pod'
+    || !('measuredAt' in data) || typeof data.measuredAt !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(data.measuredAt)
+    || !('tests' in data) || !Array.isArray(data.tests)
+    || !data.tests.every((entry: unknown) => entry && typeof entry === 'object' && !Array.isArray(entry)
+      && 'id' in entry && typeof entry.id === 'string'
+      && /^(?:[\w.-]+\/)+[\w.-]+\.test\.tsx? > \S.*$/.test(entry.id)
+      && 'reason' in entry && typeof entry.reason === 'string' && entry.reason.trim().length > 0)) {
+    throw new Error(`invalid environment known failures: ${path}`);
+  }
+  const ids = data.tests.map((entry: { id: string }) => entry.id);
+  if (new Set(ids).size !== ids.length) throw new Error(`invalid environment known failures: duplicate id in ${path}`);
+  return new Set(ids);
+}
+
+export function splitKnownEnv(failures: string[], known: Set<string>): { counted: string[]; knownEnv: string[] } {
+  return {
+    counted: failures.filter((id) => !known.has(id)),
+    knownEnv: failures.filter((id) => known.has(id)),
+  };
+}

package/scripts/release-loop/gate-diff.ts

@@ -18,6 +18,35 @@ export function parseFailures(output: string): string[] {
   return [...failures].sort();
 }
 
+const xmlText = (value: string): string => value
+  .replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+  .replace(/&#(\d+);/g, (_, code: string) => String.fromCodePoint(Number(code))).replace(/&amp;/g, '&');
+
+/** Failed test names from a bun junit report, in the same `<file> > <describe> > <name>` shape as {@link parseFailures}.
+ *  Used when the console summary counts a failure but prints no `(fail)` line for it (09-30 0.2.6 gate: `--dots`). */
+export function junitFailures(xml: string): string[] {
+  const failures = new Set<string>();
+  const suites: string[] = [];
+  let file: string | undefined;
+  let open: string | undefined;
+  for (const match of xml.matchAll(/<(\/?)(testsuite|testcase|failure)\b([^>]*?)(\/?)>/g)) {
+    const [, closing, tag, attrs, selfClosing] = match;
+    const attr = (name: string) => { const m = new RegExp(`\\b${name}="([^"]*)"`).exec(attrs!); return m ? xmlText(m[1]!) : undefined; };
+    if (tag === 'testsuite') {
+      if (closing) { suites.pop(); continue; }
+      suites.push(attr('name') ?? '');
+      if (suites.length === 1) file = attr('file') ?? attr('name');
+    } else if (tag === 'testcase') {
+      if (closing) { open = undefined; continue; }
+      const name = [...suites.slice(1), attr('name') ?? ''].join(' > ');
+      open = selfClosing ? undefined : `${attr('file') ?? file} > ${name}`;
+    } else if (tag === 'failure' && !closing && open) {
+      failures.add(open);
+    }
+  }
+  return [...failures].sort();
+}
+
 export function diffFailures(cut: Iterable<string>, baseline: Iterable<string>): FailureDiff {
   const c = new Set(cut);
   const b = new Set(baseline);