elanous 0.2.6 → 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/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/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-node.ts

@@ -8,6 +8,8 @@ import { debug } from '../../src/debug/log.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { getElanousConfigDirOverride } from '../../src/elanous-config-dir.js';
 import { diffFailures, junitFailures, parseFailures } from './gate-diff';
+import { loadEnvKnownFailures, splitKnownEnv } from './env-known-failures';
+import { baselineFromCutLogs } from './baseline-from-logs';
 import { planShards, readFileDurations } from './shard-plan';
 import { deriveCdpTestPatterns } from '../test-deterministic';
 import { emitNodeResult, readGraphContext } from './node-verdict.js';
@@ -16,7 +18,7 @@ import { POD_BUN_CACHE_HOST_PATH, parseInstallSeconds, podBunCacheVolume } from
 import { PodPoolScheduler, parsePodPool, checkPodPool } from '../../src/task-orchestrator/surfaces/pod-pool.js';
 import { defaultKubectl } from '../../src/task-orchestrator/surfaces/self-implement-pod.js';
 
-interface CommandResult { rc: number; output: string }
+interface CommandResult { rc: number; output: string; passedIds?: string[] }
 export interface GateRunner {
   command(cmd: string, args: string[], cwd: string): Promise<CommandResult>;
   localCommand(cmd: string, args: string[], cwd: string): Promise<CommandResult>;
@@ -38,7 +40,7 @@ export interface GateOptions {
   instanceRoot?: string;
   ledgerRoot?: string;
   repo?: string;
-  pod?: { pool: string; shards?: number; shardTimeoutSeconds?: number; durationSource?: string };
+  pod?: { pool: string; shards?: number; shardTimeoutSeconds?: number; durationSource?: string; bunCache?: string };
 }
 export interface GateResult {
   outcome: 'ok' | 'regression' | 'error';
@@ -46,7 +48,9 @@ export interface GateResult {
   introduced: string[];
   preexisting: number;
   fixed: number;
-  baselineSource?: 'ledger' | 'instance' | 'swept';
+  knownEnv: number;
+  knownEnvCleared: string[];
+  baselineSource?: 'ledger' | 'instance' | 'cut-logs' | 'swept';
   durationMs: number;
   error?: string;
   stalledShards?: Array<{ shard: number; files: string[]; reason: 'incomplete' | 'no-output' | 'job-failed' | 'unattributed'; lastFile?: string; summaryFailures?: number; namedFailures?: number; detail?: string }>;
@@ -64,6 +68,38 @@ function check(result: CommandResult, label: string): void {
 }
 
 type SweepFailures = { failures: string[]; errors: string[] };
+
+/** Only named, completed JUnit cases can prove a listed failure passed in this cut. */
+function junitPassedIds(xml: string): string[] {
+  const passed = new Set<string>();
+  const suites: string[] = [];
+  let file: string | undefined;
+  let open: { id: string; passed: boolean } | undefined;
+  const decode = (value: string) => value.replace(/&(?:quot|apos|lt|gt|amp|#\d+|#x[\da-fA-F]+);/g, (entity) => {
+    const named: Record<string, string> = { '&quot;': '"', '&apos;': "'", '&lt;': '<', '&gt;': '>', '&amp;': '&' };
+    if (entity in named) return named[entity]!;
+    const code = entity.startsWith('&#x') ? Number.parseInt(entity.slice(3, -1), 16) : Number(entity.slice(2, -1));
+    return code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : entity;
+  });
+  for (const match of xml.matchAll(/<(\/?)\s*(testsuite|testcase|failure|error|skipped)\b([^>]*?)(\/?)>/g)) {
+    const [, closing, tag, attrs, selfClosing] = match;
+    const attr = (name: string) => { const found = new RegExp(`\\b${name}="([^"]*)"`).exec(attrs!); return found ? decode(found[1]!) : undefined; };
+    if (tag === 'testsuite') {
+      if (closing) { suites.pop(); if (!suites.length) file = undefined; }
+      else if (!selfClosing) { suites.push(attr('name') ?? ''); if (suites.length === 1) file = attr('file') ?? attr('name'); }
+    } else if (tag === 'testcase') {
+      if (closing) { if (open?.passed) passed.add(open.id); open = undefined; }
+      else {
+        const name = [...suites.slice(1), attr('name') ?? ''].join(' > ');
+        const path = attr('file') ?? file;
+        const id = path && name ? `${path} > ${name}` : undefined;
+        if (selfClosing) { if (id) passed.add(id); }
+        else open = id ? { id, passed: true } : undefined;
+      }
+    } else if (!closing && open) open.passed = false;
+  }
+  return [...passed].sort();
+}
 // A test may spawn a nested `bun test` whose own summary lines land earlier in the same output
 // (09-29 0.2.4 gate: «0 fail · Ran 2 tests across 1 file» at line 6765 of a 60064-test sweep) —
 // the sweep's own summary is always the «last» one, so read the last match, never the first.
@@ -76,6 +112,11 @@ const summaryCount = (output: string, label: string) => Number(lastMatch(output,
 /** bun reads a bare positional as a substring filter (`test` matches every *.test.ts); `./` makes it a path. */
 const asPath = (path: string) => path.startsWith('./') || path.startsWith('/') ? path : `./${path}`;
 export const POD_ISOLATION_MEMORY_LIMIT = '32Gi';
+/** Integration tests that the Pod sweep does not run — each is judged by a real run elsewhere at the cut.
+ *  0.2.7 run 5 (10-01): `scripts/install.test.ts` (real `bun pm pack` → `bun add` installs, 301 s alone on node-b)
+ *  sat in a shard of its own past the 1200 s deadline with no output and stopped the whole gate. Judged on the
+ *  mbp at the cut instead (TD1 moves it to the integration line). Keep this list short and explained. */
+export const POD_SWEEP_INTEGRATION_ONLY: readonly string[] = ['scripts/install.test.ts'];
 const tail40 = (output: string) => output.trimEnd().split(/\r?\n/).slice(-40).join('\n');
 const lastStartedTestFile = (output: string, paths: string[]): string | undefined => {
   let last: string | undefined;
@@ -92,10 +133,15 @@ function failuresOf(run: CommandResult, label: string): SweepFailures {
   const reportedErrors = summaryCount(output, 'error');
   const errorCount = Number.isNaN(reportedErrors) ? 0 : reportedErrors;
   const incomplete = (reason: string) => new Error(`${label} incomplete (rc=${run.rc}; Ran=${ran ? ran[0] : 'missing'}; errors=${Number.isNaN(reportedErrors) ? 'missing' : errorCount}; ${reason})\n${tail40(output)}`);
-  if (!ran || (Number(ran[1]) === 0 && errorCount === 0) || (run.rc !== 0 && run.rc !== 1)) throw incomplete('summary/exit');
   const count = summaryCount(output, 'fail');
   const failures = parseFailures(output);
   const occurrences = [...output.matchAll(/\(fail\)\s+.+?(?:\s+\[[\d.]+(?:ms|s)\])?\s*$/gm)].length;
+  // A test that leaves process.exitCode set leaks a non-zero exit into a run whose own summary is complete and clean
+  // (0.2.7 gate: agent-cli at v0.2.6 · 12 pass · 0 fail · rc 2). The summary is the verdict; read that exit as clean.
+  const leakedExit = !!ran && run.rc !== 0 && run.rc !== 1 && count === 0 && errorCount === 0 && occurrences === 0
+    && !/^# Unhandled error between tests/m.test(output);
+  const rc = leakedExit ? 0 : run.rc;
+  if (!ran || (Number(ran[1]) === 0 && errorCount === 0) || (rc !== 0 && rc !== 1)) throw incomplete('summary/exit');
   // Bun reports file-level unhandled errors separately from test failures.
   const errors: string[] = [];
   let file: string | undefined;
@@ -110,7 +156,7 @@ function failuresOf(run: CommandResult, label: string): SweepFailures {
   }
   if (errors.length !== errorCount) throw incomplete(`error attribution identified=${errors.length}`);
   if (!Number.isFinite(count) || count !== occurrences || (count > 0 && failures.length === 0)
-    || (run.rc === 1 && count === 0 && errorCount === 0) || (run.rc === 0 && count + errorCount > 0)) {
+    || (rc === 1 && count === 0 && errorCount === 0) || (rc === 0 && count + errorCount > 0)) {
     throw incomplete(`failure attribution incomplete: summary=${count}, identified=${failures.length}`);
   }
   return { failures, errors: [...new Set(errors)].sort() };
@@ -156,7 +202,10 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     const cdpPatterns = cdp.output.split(/\r?\n/).filter((path) => path.endsWith('.test.ts'));
     // CDP 시험은 `test:deterministic` 이 스스로 뺀다 — 조각에 그것만 남으면 bun «시험 없음» exit 1 을 «불완전»으로 읽었다(09-30 G1d 실측 둘).
     // bun 의 탐색은 숨은 디렉터리(`.x/`)를 안 연다 — 사람의 `bun test` 가 한 번도 안 돌리는 빈 픽스처가 조각에 혼자 남아 «Ran 0 tests» 를 «불완전»으로 읽었다(09-30 G1e 5번 조각).
-    const assignable = files.filter((file) => !cdpPatterns.includes(file) && !file.split('/').some((part) => part.startsWith('.')));
+    const assignable = files.filter((file) => !cdpPatterns.includes(file) && !POD_SWEEP_INTEGRATION_ONLY.includes(file)
+      && !file.split('/').some((part) => part.startsWith('.')));
+    const integrationOnly = files.filter((file) => POD_SWEEP_INTEGRATION_ONLY.includes(file));
+    if (integrationOnly.length) debug.log('release-loop.gate', 'pod-sweep-integration-only', { files: integrationOnly });
     if (!assignable.length) throw new Error('sweep incomplete: no tests ran');
     const durations = pod.durationSource ? readFileDurations(pod.durationSource) : new Map<string, number>();
     const shards = planShards(assignable, durations, shardCount);
@@ -169,7 +218,10 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     const ready = poolOverride ? undefined : checkPodPool(parsePodPool(pod.pool), defaultKubectl);
     if (ready && !ready.ok) throw new Error('pod command: 풀의 노드가 하나도 준비되지 않았다');
     const poolScheduler = poolOverride ?? new PodPoolScheduler(ready!.ready);
-    const bunCache = process.env[POD_BUN_CACHE_HOST_PATH]?.trim() || undefined;
+    const configCache = typeof pod.bunCache === 'string' ? pod.bunCache.trim() : '';
+    const envCache = process.env[POD_BUN_CACHE_HOST_PATH]?.trim();
+    const bunCache = configCache || envCache || undefined;
+    debug.log('release-loop.gate', 'pod-bun-cache', { source: configCache ? 'config' : envCache ? 'env' : 'none' });
     const cachePrefix = bunCache ? `${podBunCacheVolume(bunCache).shellPrefix} ` : '';
     const jobLogTail = (job: PodCommandResult): string => {
       if (podLogTail) return podLogTail(job);
@@ -179,7 +231,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
       }
       return '';
     };
-    type ShardRun = { output: string; rc: number; pass: number; fail: number; errors: number; ran: number; files: number };
+    type ShardRun = { output: string; rc: number; pass: number; fail: number; errors: number; ran: number; files: number; passedIds: string[] };
     type ShardReason = NonNullable<GateResult['stalledShards']>[number]['reason'];
     // 깊이 끝 OOM 조각은 «조각 전체»를 파일 하나씩 격리한다 — 상한 40 이면 나머지가 못 잰 채 남았다(09-30 ① 7번 조각 110 파일).
     const isolationRemaining = shards.map((item) => item.files.length);
@@ -233,7 +285,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
         const destination = join(logDir, `pod-${shard}${branch}.log`);
         if (output !== undefined) writeFileSync(destination, output, { mode: 0o600 });
         else rmSync(destination, { force: true });
-        writeFileSync(join(logDir, `pod-${shard}${branch}.json`), JSON.stringify({ durationMs, rc: rc ?? null, files: paths, plannedSeconds: estimated(paths) }) + '\n', { mode: 0o600 });
+        writeFileSync(join(logDir, `pod-${shard}${branch}.json`), JSON.stringify({ durationMs, rc: rc ?? null, files: paths, plannedSeconds: estimated(paths), shardCount: shards.length, commit }) + '\n', { mode: 0o600 });
         const junitDestination = join(logDir, `pod-${shard}${branch}.junit.xml`);
         if (junit !== undefined) writeFileSync(junitDestination, junit, { mode: 0o600 });
         else rmSync(junitDestination, { force: true });
@@ -308,7 +360,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
       }
       return { runs: [{ output: clean!, rc: rc!, pass: passes, fail: fails,
         errors: Number.isNaN(summaryCount(clean!, 'error')) ? 0 : summaryCount(clean!, 'error'),
-        ran: Number(ran![1]), files: Number(ran![2]) }], stalled: [] };
+        ran: Number(ran![1]), files: Number(ran![2]), passedIds: junit ? junitPassedIds(junit) : [] }], stalled: [] };
     };
     // 모든 조각이 끝난 뒤 판정한다 — 한 조각의 예외로 먼저 돌아가면 다른 Pod 가 도는 채로 정리가 시작된다(#22002 리뷰 R3).
     const settled = await Promise.allSettled(shards.map((item, shard) => runShard(item.files, shard)));
@@ -323,7 +375,8 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     if (stalledShards.length) throw new StalledPodShards(stalledShards, total);
     if (total.ran === 0 && total.errors === 0) throw new Error('sweep incomplete: no tests ran');
     const outputs = measured.map((run) => run.output.replace(/(?:^|\n)\s*\d+ (?:pass|fail|errors?)\s*(?=\n|$)/g, '\n').replace(/Ran \d+ tests? across \d+ files?\.?/g, ''));
-    return { rc: total.fail + total.errors ? 1 : 0, output: outputs.join('\n') + `\n${total.pass} pass\n${total.fail} fail\n${total.errors} errors\nRan ${total.ran} tests across ${total.files} files.\n` };
+    return { rc: total.fail + total.errors ? 1 : 0, output: outputs.join('\n') + `\n${total.pass} pass\n${total.fail} fail\n${total.errors} errors\nRan ${total.ran} tests across ${total.files} files.\n`,
+      passedIds: [...new Set(measured.flatMap((run) => run.passedIds))].sort() };
   };
   return {
     command,
@@ -455,7 +508,7 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     return baselineCommit(root, version);
   };
   const repo = resolve(opts.repo ?? process.cwd());
-  const result: GateResult = { outcome: 'error', commit: opts.commit, introduced: [], preexisting: 0, fixed: 0, durationMs: 0 };
+  const result: GateResult = { outcome: 'error', commit: opts.commit, introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], durationMs: 0 };
   let work: string | undefined;
   let baseSnapshot = false;
   let cutFailures: SweepFailures | undefined;
@@ -510,8 +563,9 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     cutFailures = cut;
     const baseSha = opts.baselineCommit ?? baselineReleaseCommit(opts.baselineVersion);
     const cached = cachedBaseline(opts.baselineVersion, baseSha);
-    const trusted = cached?.saved;
-    result.baselineSource = trusted ? cached!.source : 'swept';
+    const recorded = cached ? undefined : baselineFromCutLogs(join(ledger, 'release', opts.baselineVersion, 'gate-logs', 'cut'), baseSha);
+    const trusted = cached?.saved ?? (recorded?.complete ? recorded : undefined);
+    result.baselineSource = cached ? cached.source : recorded?.complete ? 'cut-logs' : 'swept';
     debug.log('release-loop.gate', 'baseline', { version: opts.baselineVersion, source: result.baselineSource, commit: baseSha });
     let baseTree: string | undefined;
     const getBaseTree = async () => {
@@ -534,7 +588,14 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
       baseline = failuresOf(baseRun, 'baseline sweep');
     }
     for (const id of [...baseline.failures, ...baseline.errors, ...cut.failures, ...cut.errors]) fileOf(id);
-    const diff = diffFailures([...cut.failures, ...cut.errors], [...baseline.failures, ...baseline.errors]);
+    const known = opts.pod ? loadEnvKnownFailures(repo) : new Set<string>();
+    const cutIds = [...cut.failures, ...cut.errors];
+    const baselineIds = [...baseline.failures, ...baseline.errors];
+    const countedCut = splitKnownEnv(cutIds, known);
+    const countedBaseline = splitKnownEnv(baselineIds, known);
+    result.knownEnv = countedCut.knownEnv.length;
+    result.knownEnvCleared = [...new Set(cutRun.passedIds ?? [])].filter((id) => known.has(id) && !cutIds.includes(id)).sort();
+    const diff = diffFailures(countedCut.counted, countedBaseline.counted);
     result.fixed = diff.fixed.length;
     result.preexisting = diff.common.length;
     for (const file of new Set(diff.newFailures.map(fileOf))) {
@@ -584,7 +645,7 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     if (opts.remote) runner.remoteMirror = undefined;
     result.durationMs = Date.now() - start;
   }
-  if (result.outcome !== 'error' && cutFailures) {
+  if (cutFailures && !result.stalledShards?.length) {
     try {
       for (const location of roots) {
         const path = failureFile(location, opts.version);
@@ -608,10 +669,10 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
 export function graphGateResult(result: GateResult, graph: boolean) {
   return { ...result, ...(graph && result.outcome === 'regression' ? { outcome: 'fail' as const } : {}),
     verdict: result.outcome === 'ok' ? 'pass' as const : 'fail' as const,
-    summary: result.outcome === 'ok' ? `새 회귀 ${result.introduced.length} · 기존 ${result.preexisting} · 고침 ${result.fixed}` : `게이트 ${result.outcome}: ${result.error ?? result.introduced.length + ' new regressions'}` };
+    summary: (result.outcome === 'ok' ? `새 회귀 ${result.introduced.length} · 기존 ${result.preexisting} · 고침 ${result.fixed}` : `게이트 ${result.outcome}: ${result.error ?? result.introduced.length + ' new regressions'}`) + ` · 환경 알려진 실패 ${result.knownEnv}` };
 }
 
-function parseOptions(args: string[], env: NodeJS.ProcessEnv): GateOptions | 'help' {
+export function parseOptions(args: string[], env: NodeJS.ProcessEnv): GateOptions | 'help' {
   const context = env.ELANOUS_GRAPH_CONTEXT && args.every((arg) => arg === '--json') ? readGraphContext(env) : undefined;
   const fromGraph: Record<string, unknown> = context?.input ?? {};
   const graphCommit = context?.outputs['version-release']?.commit;
@@ -629,6 +690,7 @@ function parseOptions(args: string[], env: NodeJS.ProcessEnv): GateOptions | 'he
       pool: fromGraph.gatePodPool,
       ...(fromGraph.gatePodShards !== undefined ? { shards: Number(fromGraph.gatePodShards) } : {}),
       ...(fromGraph.gatePodShardTimeoutSeconds !== undefined ? { shardTimeoutSeconds: Number(fromGraph.gatePodShardTimeoutSeconds) } : {}),
+      ...(typeof fromGraph.gatePodBunCache === 'string' && fromGraph.gatePodBunCache.trim() ? { bunCache: fromGraph.gatePodBunCache } : {}),
     } : undefined,
   };
   for (let i = 0; i < args.length; i++) {
@@ -665,7 +727,7 @@ if (import.meta.main) {
     version = opts.version;
     result = await judgeGate(opts);
   } catch (error) {
-    result = { outcome: 'error', commit: '', introduced: [], preexisting: 0, fixed: 0, durationMs: Date.now() - start, error: String(error) };
+    result = { outcome: 'error', commit: '', introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], durationMs: Date.now() - start, error: String(error) };
   }
   if (result.error) console.error(result.error);
   debug.log('release-loop.gate', 'result', { version, outcome: result.outcome });