elanous 0.2.21 → 0.2.23

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

@@ -21,7 +21,7 @@ import { POD_BUN_CACHE_HOST_PATH, parseInstallSeconds, podBunCacheVolume } from
 import { PodPoolScheduler, parsePodPool, checkPodPool } from '../../src/task-orchestrator/surfaces/pod-pool.js';
 import { POD_INSTALL_SLOTS_DEFAULT, POD_INSTALL_SLOTS_HOST_PATH, installSlotScript } from '../../src/task-orchestrator/surfaces/pod-install-slots.js';
 import { gateDepsInstallScript, parseGateDeps } from '../../src/task-orchestrator/surfaces/pod-gate-deps.js';
-import { gateShardsPath, writeGateShards, type GateShard } from '../../src/release-loop/gate-shards.js';
+import { gateShardsPath, recordGateShardsVerdict, writeGateShards, type GateShard } from '../../src/release-loop/gate-shards.js';
 import { defaultKubectl } from '../../src/task-orchestrator/surfaces/self-implement-pod.js';
 
 interface CommandResult { rc: number; output: string; passedIds?: string[]; stalledEnv?: Array<{ file: string; reason: 'no-output' }>; timedOut?: boolean }
@@ -75,6 +75,7 @@ export interface GateResult {
   knownEnv: number;
   knownEnvCleared: string[];
   stalledEnv: Array<{ file: string; reason: 'no-output' | 'isolated-timeout'; local: 'passed' | 'failed' | 'timeout' }>;
+  rcNonzeroNoFailures: Array<{ file: string; rc: number; pass: number; baseline: 'same' | 'clean' | 'missing' }>;
   baselineSource?: 'ledger' | 'instance' | 'cut-logs' | 'swept';
   /** GATE-BASELINE-CACHE — isolated baseline files answered from the ledger (hits) or run now (misses). */
   baselineCache?: { hits: number; misses: number };
@@ -460,6 +461,47 @@ function failuresOf(run: CommandResult, label: string): SweepFailures {
   return { failures, errors: [...new Set(errors)].sort() };
 }
 
+/**
+ * «N pass · 0 fail · rc=1» from an isolated run is read as `rc-nonzero-no-failures` only when the summary is a complete,
+ * clean, single-file summary for the requested file (`Ran N≥1 tests across 1 file` · 0 fail · 0 error · no `(fail)` ·
+ * no unhandled error · pass = N · no other test-file header). Every other run is read exactly as before (`failuresOf`,
+ * which throws on the incomplete shapes, plus a failure-count/identified-name check).
+ */
+export function readIsolatedRun(run: CommandResult, label: string, file: string):
+  | { kind: 'read'; failures: string[]; errors: string[] }
+  | { kind: 'rc-nonzero-no-failures'; rc: number; pass: number } {
+  const output = stripPodRepoRoot(run.output.replace(/\x1b\[[0-9;]*[A-Za-z]/g, ''));
+  const ran = lastMatch(output, /Ran (\d+) tests? across (\d+) files?/);
+  // rc 1 only: other non-zero exits with a clean summary keep the established leaked-exit reading (clean) in failuresOf.
+  const cleanNonzero = run.rc === 1 && !!ran && Number(ran[1]) >= 1 && Number(ran[2]) === 1
+    && summaryCount(output, 'fail') === 0
+    && (Number.isNaN(summaryCount(output, 'error')) || summaryCount(output, 'error') === 0)
+    && parseFailures(output).length === 0 && !/\(fail\)/.test(output)
+    && !/Unhandled error between tests/.test(output);
+  if (!cleanNonzero) {
+    const read = failuresOf(run, label);
+    // Two (fail) lines folding into one id would undercount the file's failures: unreadable, not fewer.
+    const failCount = summaryCount(output, 'fail');
+    if (Number.isFinite(failCount) && read.failures.length !== failCount)
+      throw new Error(`${label} incomplete (rc=${run.rc}; failure attribution summary=${failCount}, identified=${read.failures.length})`);
+    return { kind: 'read', ...read };
+  }
+  // Bun's file headers, when present, must identify the requested file before the result is recorded or cached.
+  // Any test-file path counts: root-level (`other.test.ts:`), nested, or absolute (outside the stripped Pod root).
+  for (const raw of output.split(/\r?\n/)) {
+    // Any characters but `:` (unicode, spaces, @, +, …) — a header is `<path ending in .test/.spec.ts>:`.
+    const header = /^(?:\.\/)?([^\s:][^:]*?\.(?:test|spec)\.[cm]?[jt]sx?):/.exec(raw.trim());
+    if (header && header[1] !== file)
+      throw new Error(`${label} incomplete (rc=${run.rc}; isolated run attributed to another file: ${header[1]})`);
+  }
+  const pass = summaryCount(output, 'pass');
+  if (pass !== Number(ran![1]))
+    throw new Error(`${label} incomplete (rc=${run.rc}; pass=${Number.isNaN(pass) ? 'missing' : pass}; Ran=${ran![1]})`);
+  // Validate the requested file as well as the summary; only this one file can own the synthetic id.
+  fileOf(`${file} > [rc-nonzero]`);
+  return { kind: 'rc-nonzero-no-failures', rc: run.rc, pass };
+}
+
 class StalledPodShards extends Error {
   constructor(readonly stalledShards: NonNullable<GateResult['stalledShards']>, readonly partialSummary: NonNullable<GateResult['partialSummary']>) {
     super(`pod sweep incomplete: stalled shards ${stalledShards.map(({ shard }) => shard).join(', ')}`);
@@ -1149,7 +1191,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, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], durationMs: 0 };
+  const result: GateResult = { outcome: 'error', commit: opts.commit, introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], rcNonzeroNoFailures: [], durationMs: 0 };
   let work: string | undefined;
   let baseSnapshot = false;
   let cutFailures: SweepFailures | undefined;
@@ -1345,12 +1387,15 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
         result.stalledEnv.push({ file, reason: 'isolated-timeout', local: 'timeout' });
         continue;
       }
-      const isolatedCut = cutCheck === undefined
+      const cutReading = cutCheck === undefined ? undefined : readIsolatedRun(cutCheck, `cut isolated ${file}`, file);
+      const rcOnly = cutReading?.kind === 'rc-nonzero-no-failures' ? cutReading : undefined;
+      const rcOnlyId = `${file} > [rc-nonzero]`;
+      const isolatedCut: SweepFailures = cutReading === undefined
         ? { failures: cut.failures.filter((id) => fileOf(id) === file), errors: cut.errors.filter((id) => fileOf(id) === file) }
-        : failuresOf(cutCheck, `cut isolated ${file}`);
+        : cutReading.kind === 'read' ? cutReading : { failures: [], errors: [rcOnlyId] };
       if (cutCheck !== undefined) remember({ commit: opts.commit, file, host: cacheHost, failures: isolatedCut.failures, errors: isolatedCut.errors, missing: false });
       const reproduced = new Set([...isolatedCut.failures, ...isolatedCut.errors]);
-      let candidates = diff.newFailures.filter((id) => fileOf(id) === file && reproduced.has(id));
+      let candidates = rcOnly ? [rcOnlyId] : diff.newFailures.filter((id) => fileOf(id) === file && reproduced.has(id));
       // GATE-INTRO-RECHECK — a new failure that is only bun's «timed out» shape gets one more isolated run with a generous
       // per-test limit, on the same runner (node-b when the gate is remote). Passing there = flaky under load (warning);
       // an assertion failure, a failure again, or a run that cannot be read stays introduced.
@@ -1382,7 +1427,9 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
       }
       if (candidates.length === 0) continue;
       let oldFailures: Set<string>;
+      let baselineMissing = false;
       const hit = baseCache.get(`${file}\0${cacheHost}`);
+      if (hit?.missing) baselineMissing = true;
       if (hit) {
         cacheStats.hits++;
         oldFailures = new Set([...hit.failures, ...hit.errors]);
@@ -1399,13 +1446,22 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
           const lookup = await runner.command('git', ['ls-tree', '--name-only', baseSha, '--', file], opts.remote ? baselineTree : repo);
           if (lookup.rc !== 0 || lookup.output.trim()) throw new Error(`baseline isolated run incomplete: ${file}`);
           oldFailures = new Set();
+          baselineMissing = true;
           remember({ commit: baseSha, file, host: cacheHost, failures: [], errors: [], missing: true });
         } else {
-          const prior = failuresOf(previous, `baseline isolated ${file}`);
+          const reading = readIsolatedRun(previous, `baseline isolated ${file}`, file);
+          const prior: SweepFailures = reading.kind === 'read' ? reading : { failures: [], errors: [rcOnlyId] };
+          if (reading.kind === 'rc-nonzero-no-failures') debug.log('release-loop.gate', 'isolated-rc-nonzero-no-failures',
+            { file, label: 'baseline isolated', rc: reading.rc, pass: reading.pass, baseline: 'same' });
           oldFailures = new Set([...prior.failures, ...prior.errors]);
           remember({ commit: baseSha, file, host: cacheHost, failures: prior.failures, errors: prior.errors, missing: false });
         }
       }
+      if (rcOnly) {
+        const baseline = oldFailures.has(rcOnlyId) ? 'same' : baselineMissing ? 'missing' : 'clean';
+        result.rcNonzeroNoFailures.push({ file, rc: rcOnly.rc, pass: rcOnly.pass, baseline });
+        debug.log('release-loop.gate', 'isolated-rc-nonzero-no-failures', { file, label: 'cut isolated', rc: rcOnly.rc, pass: rcOnly.pass, baseline });
+      }
       for (const id of candidates) {
         if (oldFailures.has(id)) result.preexisting++;
         else result.introduced.push(id);
@@ -1456,6 +1512,15 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     }
   }
   if (result.outcome !== 'error') debug.log('release-loop.gate', 'judged', { version: opts.version, commit: opts.commit, introduced: result.introduced.length, preexisting: result.preexisting });
+  // GATE-LIVE-OBS-RC-WORDING ⓒ — the shards board says «판정 전» until this lands; then «새 실패 N» only (UX · gate-shards.ts).
+  // Same ledger as the board's own writes (sweep's shardsFile). A write failure is logged and never changes the verdict.
+  if (result.outcome !== 'error' && opts.pod) {
+    const path = opts.ledgerRoot ? gateShardsPath(opts.version, opts.ledgerRoot) : gateShardsPath(opts.version);
+    try {
+      const written = recordGateShardsVerdict(path, { introduced: result.introduced.length, preexisting: result.preexisting });
+      debug.log('release-loop.gate', 'shards-verdict', { version: opts.version, path, written, introduced: result.introduced.length, preexisting: result.preexisting });
+    } catch (error) { debug.log('release-loop.gate', 'shards-verdict-write-failed', { path, error: String(error) }); }
+  }
   return result;
 }
 
@@ -1464,6 +1529,7 @@ export function graphGateResult(result: GateResult, graph: boolean) {
     verdict: result.outcome === 'ok' ? 'pass' as const : 'fail' as const,
     summary: (result.partial ? `부분 재검 ${result.partial.files}파일(앞 게이트 ${result.partial.priorCommit.slice(0, 9)} 결과 이음) · ` : '')
       + (result.outcome === 'ok' ? `새 회귀 ${result.introduced.length} · 기존 ${result.preexisting} · 고침 ${result.fixed ?? '못 셈(기준선 미루기)'}` : `게이트 ${result.outcome}: ${result.error ?? result.introduced.length + ' new regressions'}`) + ` · 환경 알려진 실패 ${result.knownEnv}`
+      + (result.rcNonzeroNoFailures.length ? ` · ⚠ 종료코드만 비영 ${result.rcNonzeroNoFailures.length}` : '')
       + (result.loadFlaky?.length ? ` · ⚠ 부하 흔들림 ${result.loadFlaky.length}(시간 초과 꼴 · ${GATE_TIMEOUT_RECHECK_MS / 1000}s 재실행 통과 · 막지 않음)` : '')
       + (result.stalledEnv.length ? ` · 환경 멈춤 ${result.stalledEnv.length} (Pod 밖 통과 ${result.stalledEnv.filter((item) => item.local === 'passed').length})` : '') };
 }
@@ -1535,7 +1601,7 @@ if (import.meta.main) {
     version = opts.version;
     result = await judgeGate(opts);
   } catch (error) {
-    result = { outcome: 'error', commit: '', introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], durationMs: Date.now() - start, error: String(error) };
+    result = { outcome: 'error', commit: '', introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], rcNonzeroNoFailures: [], durationMs: Date.now() - start, error: String(error) };
   }
   if (result.error) console.error(result.error);
   debug.log('release-loop.gate', 'result', { version, outcome: result.outcome });

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

@@ -0,0 +1,208 @@
+// GATE-SPEED-P2 — measure one commit's gate wall clock without folding earlier attempts into retries.
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { readJunitFileSeconds } from './gate-method.js';
+import { resolveGateLogDir } from './gate-timing.js';
+
+type TimedPod = { name: string; start: number; end: number; durationMs: number; root: boolean };
+export interface GateWallAttempt {
+  commit: string;
+  records: number;
+  roots: number;
+  retries: number;
+  wallMin: number;
+  rootWallMin: number | null;
+  retryTailMin: number | null;
+  overhead: { medianMin: number | null; p90Min: number | null; unmeasuredRoots: number };
+}
+export interface GateWallReport {
+  dir: string;
+  targetMin: number;
+  measured: boolean;
+  commit: string | null;
+  records: number;
+  roots: number;
+  retries: number;
+  wallMin: number | null;
+  wallSource: 'pod-records' | null;
+  rootWallMin: number | null;
+  retryTailMin: number | null;
+  overhead: GateWallAttempt['overhead'];
+  retryOnlyAttempts: number;
+  attempts: GateWallAttempt[];
+  shardsWallMin: number | null;
+  disagree: boolean;
+  unreadable: string[];
+  /** ✓ only when every pod record was read; a slower verdict is already certain. */
+  verdict: 'pass' | 'fail' | 'undetermined' | null;
+  /** Why shards.json was not compared although present (it carries no attempt identity). */
+  shardsSkipped: 'not-latest-attempt' | 'outside-attempt-window' | null;
+}
+
+const POD_JSON = /^pod-.+\.json$/;
+const ROOT = /^pod-\d+\.json$/;
+function median(values: number[]): number {
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid]! : (sorted[mid - 1]! + sorted[mid]!) / 2;
+}
+function spanMin(pods: TimedPod[]): number {
+  return (Math.max(...pods.map((p) => p.end)) - Math.min(...pods.map((p) => p.start))) / 60_000;
+}
+function attempt(dir: string, commit: string, pods: TimedPod[]): GateWallAttempt {
+  const roots = pods.filter((p) => p.root);
+  const overhead: number[] = [];
+  let unmeasuredRoots = 0;
+  for (const pod of roots) {
+    try {
+      const xml = readFileSync(join(dir, pod.name.replace(/\.json$/, '.junit.xml')), 'utf8');
+      const seconds = [...readJunitFileSeconds(xml).values()];
+      if (!seconds.length) { unmeasuredRoots++; continue; }
+      overhead.push((pod.durationMs - seconds.reduce((sum, s) => sum + s, 0) * 1000) / 60_000);
+    } catch { unmeasuredRoots++; }
+  }
+  const wall = spanMin(pods);
+  const rootWall = roots.length ? spanMin(roots) : null;
+  const sorted = overhead.sort((a, b) => a - b);
+  return {
+    commit, records: pods.length, roots: roots.length, retries: pods.length - roots.length,
+    wallMin: wall, rootWallMin: rootWall,
+    retryTailMin: rootWall === null ? null : wall - rootWall,
+    overhead: {
+      medianMin: sorted.length ? median(sorted) : null,
+      p90Min: sorted.length ? sorted[Math.ceil(sorted.length * 0.9) - 1]! : null,
+      unmeasuredRoots,
+    },
+  };
+}
+
+const SHARDS_WINDOW_SLACK_MS = 5 * 60_000;
+/**
+ * shards.json is a snapshot of the latest attempt, not an archive of every commit, and has no attempt identity.
+ * A row is attributed to the attempt only when its root id is one of the attempt's roots AND
+ * a row starts inside the attempt's pod-record window (from 5 min before its first start to its last end) — a
+ * previous attempt's snapshot reusing `pod-0` started earlier and is rejected. The end is free: a longer
+ * snapshot is exactly the disagreement this report keeps.
+ */
+function shardsSpan(dir: string, rootNames: Set<string>, window: { start: number; end: number }): number | 'outside-attempt-window' | null {
+  try {
+    const file: unknown = JSON.parse(readFileSync(join(dir, 'shards.json'), 'utf8'));
+    if (!file || typeof file !== 'object' || !('shards' in file) || !Array.isArray(file.shards)) return null;
+    const rows = file.shards as unknown[];
+    if (!rows.length) return null;
+    const starts: number[] = [];
+    const ends: number[] = [];
+    for (const row of rows) {
+      if (!row || typeof row !== 'object' || !('id' in row) || typeof row.id !== 'string'
+        || !rootNames.has(`${row.id}.json`)) return null;
+      const start = 'startedAt' in row && typeof row.startedAt === 'string' ? Date.parse(row.startedAt) : NaN;
+      const end = 'endedAt' in row && typeof row.endedAt === 'string' ? Date.parse(row.endedAt) : NaN;
+      if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) return null;
+      if (start < window.start - SHARDS_WINDOW_SLACK_MS || start > window.end) return 'outside-attempt-window';
+      starts.push(start);
+      ends.push(end);
+    }
+    if (Math.max(...ends) < Math.min(...starts)) return null;
+    return (Math.max(...ends) - Math.min(...starts)) / 60_000;
+  } catch { return null; }
+}
+
+export function gateWall(dir: string, opts: { commit?: string; targetMin?: number } = {}): GateWallReport {
+  const targetMin = opts.targetMin ?? 30;
+  if (!Number.isFinite(targetMin) || targetMin <= 0) throw new Error('target-min 은 양수여야 합니다');
+  const groups = new Map<string, TimedPod[]>();
+  const unreadable: string[] = [];
+  const names = existsSync(dir) && statSync(dir).isDirectory() ? readdirSync(dir).filter((n) => POD_JSON.test(n)).sort() : [];
+  for (const name of names) {
+    try {
+      const pod: unknown = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+      if (!pod || typeof pod !== 'object' || !('commit' in pod) || !('durationMs' in pod)
+        || typeof pod.commit !== 'string' || !pod.commit.trim()
+        || typeof pod.durationMs !== 'number' || !Number.isFinite(pod.durationMs) || pod.durationMs < 0) {
+        unreadable.push(name); continue;
+      }
+      const end = statSync(join(dir, name)).mtimeMs;
+      if (!Number.isFinite(end)) { unreadable.push(name); continue; }
+      const group = groups.get(pod.commit) ?? [];
+      group.push({ name, start: end - pod.durationMs, end, durationMs: pod.durationMs, root: ROOT.test(name) });
+      groups.set(pod.commit, group);
+    } catch { unreadable.push(name); }
+  }
+  const ordered = [...groups].sort((a, b) => Math.max(...b[1].map((p) => p.end)) - Math.max(...a[1].map((p) => p.end)));
+  const matching = opts.commit === undefined ? ordered : ordered.filter(([commit]) => commit.startsWith(opts.commit!));
+  if (opts.commit !== undefined && matching.length > 1) throw new Error(`모호한 커밋 앞자리: ${opts.commit}`);
+  const chosen = matching.find(([, pods]) => pods.some((p) => p.root));
+  const attempts = ordered.map(([commit, pods]) => attempt(dir, commit, pods));
+  const selected = chosen && attempts.find((a) => a.commit === chosen[0]);
+  // The snapshot has no commit field. Only the latest recorded attempt can own it; require its root row IDs too.
+  const latest = chosen !== undefined && ordered[0]?.[0] === chosen[0];
+  const span = chosen && latest
+    ? shardsSpan(dir, new Set(chosen[1].filter((p) => p.root).map((p) => p.name)),
+      { start: Math.min(...chosen[1].map((p) => p.start)), end: Math.max(...chosen[1].map((p) => p.end)) }) : null;
+  const snapshot = typeof span === 'number' ? span : null;
+  const shardsWallMin = snapshot;
+  const hasShards = existsSync(join(dir, 'shards.json'));
+  const shardsSkipped = !hasShards || !chosen ? null : !latest ? 'not-latest-attempt' as const : span === 'outside-attempt-window' ? span : null;
+  const wallMin = selected?.wallMin ?? null;
+  const verdict = wallMin === null ? null : wallMin > targetMin ? 'fail' as const : unreadable.length ? 'undetermined' as const : 'pass' as const;
+  return {
+    dir, targetMin, measured: selected !== undefined, commit: selected?.commit ?? null,
+    records: selected?.records ?? 0, roots: selected?.roots ?? 0, retries: selected?.retries ?? 0,
+    wallMin: selected?.wallMin ?? null, wallSource: selected ? 'pod-records' : null,
+    rootWallMin: selected?.rootWallMin ?? null, retryTailMin: selected?.retryTailMin ?? null,
+    overhead: selected?.overhead ?? { medianMin: null, p90Min: null, unmeasuredRoots: 0 },
+    retryOnlyAttempts: attempts.filter((a) => a.roots === 0).length,
+    attempts, shardsWallMin,
+    disagree: snapshot !== null && chosen !== undefined && Math.abs(snapshot - spanMin(chosen[1])) > 5,
+    unreadable, verdict, shardsSkipped,
+  };
+}
+
+export function formatGateWall(report: GateWallReport): string {
+  const number = (value: number | null) => value === null ? '못 잼' : `${value.toFixed(1)}분`;
+  if (!report.measured) return `게이트 벽시계 못 잼 · 목표 ≤${report.targetMin}분 판정 못 잼 · 루트 못 잼 · 재시도 꼬리 못 잼 · 조각 준비 중앙 못 잼`;
+  return [
+    `게이트 벽시계 ${number(report.wallMin)}(pod-records · 커밋 ${report.commit!.slice(0, 8)}) · 목표 ≤${report.targetMin}분 ${report.verdict === 'pass' ? '✓' : report.verdict === 'fail' ? '✗' : `판정 보류(못 읽은 기록 ${report.unreadable.length})`} · 루트 ${number(report.rootWallMin)} · 재시도 꼬리 ${number(report.retryTailMin)} · 조각 준비 중앙 ${number(report.overhead.medianMin)}`,
+    `커밋 ${report.commit} · 기록 ${report.records} · 루트 ${report.roots} · 재시도 ${report.retries} · 루트 없는 시도 ${report.retryOnlyAttempts} · 준비 p90 ${number(report.overhead.p90Min)} · 준비 못 잰 루트 ${report.overhead.unmeasuredRoots}`,
+    ...(report.shardsWallMin === null ? [] : [`shards.json 벽시계 ${number(report.shardsWallMin)} · 기록 추정 ${number(report.wallMin)}${report.disagree ? ' · ⚠ 5분 초과 불일치' : ''}`]),
+    ...(report.shardsSkipped ? [`shards.json 대조 생략 — 이 시도의 것인지 확인 못 함(${report.shardsSkipped})`] : []),
+    ...(report.unreadable.length ? [`⚠ 못 읽은 기록 ${report.unreadable.length}: ${report.unreadable.slice(0, 3).join(', ')}`] : []),
+  ].join('\n');
+}
+
+export const GATE_WALL_USAGE = '사용법: bun scripts/release-loop/gate-wall.ts <version|dir> [--commit <sha>] [--target-min <n>] [--json]';
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  let target: string | undefined;
+  let commit: string | undefined;
+  let targetMin: number | undefined;
+  let json = false;
+  let error: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === '--json') { json = true; continue; }
+    if (arg === '--commit' || arg === '--target-min') {
+      const value = args[++i];
+      if (!value || value.startsWith('-')) { error = `값이 없는 옵션: ${arg}`; break; }
+      if (arg === '--commit') commit = value;
+      else {
+        targetMin = Number(value);
+        if (!Number.isFinite(targetMin) || targetMin <= 0) { error = `잘못된 목표 분: ${value}`; break; }
+      }
+      continue;
+    }
+    if (arg.startsWith('-')) { error = `알 수 없는 옵션: ${arg}`; break; }
+    if (target) { error = `예상치 못한 인자: ${arg}`; break; }
+    target = arg;
+  }
+  if (error || !target) { console.error(`${error ?? '대상 경로 또는 버전이 필요합니다'}\n${GATE_WALL_USAGE}`); process.exit(2); }
+  try {
+    const report = gateWall(resolveGateLogDir(target), { commit, targetMin });
+    console.log(json ? JSON.stringify(report, null, 2) : formatGateWall(report));
+    if (!report.measured) process.exitCode = 1;
+  } catch (e) {
+    console.error(`${e instanceof Error ? e.message : String(e)}\n${GATE_WALL_USAGE}`);
+    process.exitCode = 2;
+  }
+}

package/scripts/release-loop/known-issues-node.ts

@@ -1,5 +1,7 @@
 #!/usr/bin/env bun
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import type { GraphRunState } from '../../src/graph-runner/runner.js';
 import { join } from 'node:path';
 import { emitNodeResult, readGraphContext, runCommand, type CommandRunner, type GraphContext } from './node-verdict.js';
 
@@ -64,6 +66,37 @@ function cleanBullet(text: string): string | null {
   return line;
 }
 
+/** A waiver is copied verbatim into public notes, so reject internal or resolved claims before resuming. */
+export function publicWaiverReason(text: string): string {
+  const bullet = cleanBullet(text);
+  if (!bullet || resolved.test(bullet) || !/[a-z]{3}/i.test(bullet)) throw new Error('unsafe public waiver reason');
+  return bullet;
+}
+
+function recordedWaivers(context: GraphContext, accepted: Issue[]): Issue[] {
+  const contextPath = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (!contextPath || !/\.json\.contexts\/[1-9]\d*\.json$/.test(contextPath)) return [];
+  const raw = JSON.parse(readFileSync(contextPath, 'utf8')) as { graphId?: string; runId?: string; nodeId?: string };
+  if (raw.graphId !== 'release-loop' || raw.nodeId !== 'known-issues' || !raw.runId || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(raw.runId)) return [];
+  const statePath = join(effectiveInstanceRoot(), 'graph-runs', 'release-loop', `${raw.runId}.json`);
+  const visit = Number(contextPath.slice(contextPath.lastIndexOf('/') + 1, -'.json'.length));
+  if (contextPath !== join(`${statePath}.contexts`, `${visit}.json`)) return [];
+  const state = JSON.parse(readFileSync(statePath, 'utf8')) as GraphRunState;
+  if (state.graphId !== 'release-loop' || state.runId !== raw.runId || state.path[visit - 1] !== 'known-issues' ||
+    JSON.stringify((state.input as { acceptedRegressions?: unknown })?.acceptedRegressions ?? []) !== JSON.stringify(context.input.acceptedRegressions ?? [])) return [];
+  return accepted.filter((issue) => {
+    if (!issue.id.startsWith('waive:')) return false;
+    const node = issue.id.slice('waive:'.length);
+    const index = state.path.indexOf(node);
+    const record = state.nodes[index];
+    const waiver = record?.waiver;
+    return index >= 0 && index < visit - 1 && record?.nodeId === node && waiver !== undefined && waiver.reason === issue.note &&
+      // The runner writes a waiver only over a failed executed node (releaseResumeWaiver); its exit may be 0 (outcome fail) or null (timeout).
+      record.ok === true && record.executed === false &&
+      context.outputs[node]?.verdict === 'waived' && context.outputs[node]?.reason === issue.note;
+  });
+}
+
 function command(run: CommandRunner, program: string, args: string[], cwd?: string): string {
   const result = run(program, args, cwd);
   if (result.status !== 0) throw new Error(`${program} ${args[0]} failed: ${result.stderr || result.stdout}`);
@@ -85,13 +118,18 @@ export function runKnownIssues(context: GraphContext = readGraphContext(), run:
   let bullets: string[];
   let fallbackUsed = false;
   const allIssues = [...checklist, ...accepted];
-  const sourceIds = allIssues.map((issue) => issue.id);
-  const prompt = `Write public English release-note bullets for these known issues. Describe only user-visible impact; include a one-line workaround when available. No internal names, test paths, track names, PR numbers, or people. Each bullet must have at most two sentences. Return ONLY a JSON array with exactly one object {"id":"input ID","bullet":"English public sentence"} for each input, using each input ID exactly once. Do not include IDs in bullet text. Input: ${JSON.stringify({ checklist, acceptedRegressions: accepted })}`;
-  let response: ReturnType<CommandRunner>;
-  try {
-    response = run('elanous', ['--test', 'ask', '--json', prompt]);
-  } catch {
-    response = { status: 1, stdout: '', stderr: '' };
+  // The persisted failed-node waiver, not a claimed output or an ID prefix, is the public-note provenance.
+  const waiverIssues = recordedWaivers(context, accepted);
+  const modelIssues = allIssues.filter((issue) => !waiverIssues.includes(issue));
+  const sourceIds = modelIssues.map((issue) => issue.id);
+  const prompt = `Write public English release-note bullets for these known issues. Describe only user-visible impact; include a one-line workaround when available. No internal names, test paths, track names, PR numbers, or people. Each bullet must have at most two sentences. Return ONLY a JSON array with exactly one object {"id":"input ID","bullet":"English public sentence"} for each input, using each input ID exactly once. Do not include IDs in bullet text. Input: ${JSON.stringify({ checklist, acceptedRegressions: accepted.filter((issue) => !waiverIssues.includes(issue)) })}`;
+  let response: ReturnType<CommandRunner> = { status: 0, stdout: JSON.stringify({ reply: '[]' }), stderr: '' };
+  if (modelIssues.length) {
+    try {
+      response = run('elanous', ['--test', 'ask', '--json', prompt]);
+    } catch {
+      response = { status: 1, stdout: '', stderr: '' };
+    }
   }
   if (response.status !== 0) {
     bullets = [FALLBACK];
@@ -105,7 +143,7 @@ export function runKnownIssues(context: GraphContext = readGraphContext(), run:
           return FALLBACK;
         }
         if (resolved.test(safe)) throw new Error(`bullet for ${sourceIds[index]} claims the issue is resolved`);
-        if (!coversIssue(safe, allIssues[index]!, allIssues.filter((_, otherIndex) => otherIndex !== index))) {
+        if (!coversIssue(safe, modelIssues[index]!, modelIssues.filter((_, otherIndex) => otherIndex !== index))) {
           throw new Error(`bullet does not identify input ${sourceIds[index]}`);
         }
         return safe;
@@ -118,6 +156,13 @@ export function runKnownIssues(context: GraphContext = readGraphContext(), run:
       throw new Error(`known issues coverage not verified: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  // A waiver's supplied public impact must survive even when the model omits it or is unavailable.
+  for (const issue of waiverIssues) {
+    const bullet = cleanBullet(issue.note ?? '');
+    if (!bullet || resolved.test(bullet)) throw new Error(`unsafe public waiver reason for ${issue.id}`);
+    const publicBullet = /[.!?]$/.test(bullet) ? bullet : `${bullet}.`;
+    if (!bullets.includes(publicBullet)) bullets.push(publicBullet);
+  }
   const original = readFileSync(notes, 'utf8');
   const heading = /^## Known issues\s*$/m;
   const match = heading.exec(original);

package/scripts/release-loop/publish-at.ts

@@ -0,0 +1,14 @@
+// RELEASE-PUBLISH-AT — the one validator for a promised publish time (CLI entry and the publish node share it).
+
+/** `--publish-at` must be an offset-bearing ISO datetime; returns the refusal message, or null when valid. */
+export function publishAtError(value: string): string | null {
+  const refused = '--publish-at requires an offset-bearing ISO datetime on a real calendar date';
+  const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:Z|[+-](\d{2}):(\d{2}))$/.exec(value);
+  if (!m || !Number.isFinite(Date.parse(value))) return refused;
+  const [y, mo, d, h, mi, sec = '0', oh = '0', om = '0'] = m.slice(1) as string[];
+  // Date.parse rolls 02-30 over into March; a promised publish day must be the day that was written.
+  const day = new Date(Date.UTC(Number(y), Number(mo) - 1, Number(d)));
+  if (day.getUTCFullYear() !== Number(y) || day.getUTCMonth() !== Number(mo) - 1 || day.getUTCDate() !== Number(d)) return refused;
+  if (Number(h) > 23 || Number(mi) > 59 || Number(sec) > 59 || Number(oh) > 23 || Number(om) > 59) return refused;
+  return null;
+}

package/scripts/release-loop/publish-node.ts

@@ -6,6 +6,7 @@ import { WARNING_ONLY } from './auto-approve-node.js';
 import { beginLandingMerge, landingFreezeMessage } from '../../src/release-loop/landing-freeze.js';
 import { debug } from '../../src/debug/log.js';
 import { prereleaseKind } from './release-version.js';
+import { publishAtError } from './publish-at.js';
 import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
 
 export function publicNotes(markdown: string, pages: { pages: Array<{ id: string; slug?: string; source?: string }> }): string {
@@ -43,7 +44,8 @@ export function waitForAssets(run: CommandRunner, repo: string, tag: string, nam
   }
 }
 
-export function runPublish(run: CommandRunner = runCommand, prodFreezeRoot?: string) {
+export function runPublish(run: CommandRunner = runCommand, prodFreezeRoot?: string,
+  clock: { now: () => number; sleep: (ms: number) => void } = { now: Date.now, sleep: Bun.sleepSync }) {
   const context = readGraphContext();
   const version = context.input.version;
   // A measured automatic decision or the existing human approval must authorize publication.
@@ -69,6 +71,17 @@ export function runPublish(run: CommandRunner = runCommand, prodFreezeRoot?: str
   if (doc.status !== 0 || registry.status !== 0) throw new Error(`docs branch missing notes or pages: ${branch}`);
   if (!doc.stdout.startsWith(`# ${version}\n`)) throw new Error('release notes version mismatch');
   const body = labelPrerelease(version, publicNotes(doc.stdout, JSON.parse(registry.stdout)));
+  if (context.input.publishAt !== undefined) {
+    const at = context.input.publishAt;
+    if (typeof at !== 'string' || publishAtError(at) !== null) {
+      throw new Error('invalid publishAt in release run input');
+    }
+    const deadline = Date.parse(at);
+    while (clock.now() < deadline) {
+      const remaining = deadline - clock.now();
+      clock.sleep(Math.min(remaining, 60_000));
+    }
+  }
   const dir = mkdtempSync(join(tmpdir(), 'release-publish-notes-'));
   try {
     const file = join(dir, 'notes.md');
@@ -83,7 +96,9 @@ export function runPublish(run: CommandRunner = runCommand, prodFreezeRoot?: str
       if (context.input.forceFreeze !== true) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `publish blocked: ${landingFreezeMessage(frozen)}` };
     }
     let published: ReturnType<typeof run>;
-    try { published = run('bun', ['bin/elanous.mjs', 'release', 'publish', '--dir', out, '--notes-file', file, '--yes', '--json']); }
+    // The graph recipe no longer bounds this node (it may wait for publishAt), so the irreversible publication itself
+    // keeps the former 30-minute bound on every run — with or without publishAt.
+    try { published = run('bun', ['bin/elanous.mjs', 'release', 'publish', '--dir', out, '--notes-file', file, '--yes', '--json'], undefined, 1_800_000); }
     finally { landing.end(); }
     if (published.stderr) process.stderr.write(published.stderr);
     const result = lastResult(published);

package/scripts/release-loop/resume-release.ts

@@ -10,6 +10,7 @@ import { lastJsonObject, runGraph, type GraphRunState } from '../../src/graph-ru
 import { releaseRunUniverse } from './release-universe.js';
 import { isReleaseVersion } from './release-version.js';
 import { changedFilesBetween, clearPartialPlan, planPartialRegate, writePartialPlan } from './gate-partial.js';
+import { releaseResumeAcceptedRegressions, releaseResumeWaiver, type AcceptedRegression } from './resume.js';
 
 const GRAPH = join(import.meta.dir, '../../graphs/release/release-loop.yaml');
 
@@ -55,7 +56,7 @@ function safeRunId(runId: string): string {
 }
 
 /** Point the saved version-release output at the current release/<v> tip (fast-forward of the recorded commit only). */
-export function refreshReleaseBranchTip(runId: string, deps: ResumeReleaseDeps = {}, from?: string): TipRefresh {
+export function refreshReleaseBranchTip(runId: string, deps: ResumeReleaseDeps = {}, from?: string, waiverCommit?: string): TipRefresh {
   const root = deps.root ?? effectiveInstanceRoot();
   const statePath = join(root, 'graph-runs', 'release-loop', `${safeRunId(runId)}.json`);
   const state = JSON.parse(readFileSync(statePath, 'utf8')) as GraphRunState;
@@ -81,6 +82,9 @@ export function refreshReleaseBranchTip(runId: string, deps: ResumeReleaseDeps =
   if (!/^[0-9a-f]{40}$/i.test(advertised)) throw new Error(`${branch} is not on origin — this run was not cut as a release branch`);
   git(['fetch', 'origin', `+refs/heads/${branch}:refs/remotes/origin/${branch}`]);
   const to = git(['rev-parse', '--verify', `refs/remotes/origin/${branch}^{commit}`]);
+  if (waiverCommit && (recorded.toLowerCase() !== waiverCommit.toLowerCase() || to.toLowerCase() !== waiverCommit.toLowerCase() || advertised.toLowerCase() !== waiverCommit.toLowerCase())) {
+    throw new Error('release branch moved — re-gate the new tip before waiving a node');
+  }
   if (to !== advertised) throw new Error(`${branch} moved while it was read (${advertised} → ${to})`);
   if (to === recorded) {
     debug.log('release-loop.resume', 'tip-unchanged', { runId, version, commit: to });
@@ -164,14 +168,40 @@ function savedGraphPath(statePath: string): string | undefined {
 }
 
 /** Refresh the branch tip, then restart the failed run at `from` with the saved graph snapshot. */
-export async function resumeReleaseRun(opts: { runId: string; from: string; partial?: boolean }, deps: ResumeReleaseDeps = {}): Promise<{ tip: TipRefresh; partial: PartialOutcome; state: GraphRunState }> {
+export async function resumeReleaseRun(opts: { runId: string; from: string; partial?: boolean; waive?: string; reason?: string; acceptedRegressions?: AcceptedRegression[] }, deps: ResumeReleaseDeps = {}): Promise<{ tip: TipRefresh; partial: PartialOutcome; state: GraphRunState }> {
   if (opts.from === 'version-release') throw new Error('--from version-release would cut again — resume at a later node');
   // RELEASE-LEDGER-UNIVERSE: decide the universe once; the run lookup and every resumed node use it.
   deps = { ...deps, root: releaseRunUniverse({ root: deps.root }) };
-  const tip = refreshReleaseBranchTip(opts.runId, deps, opts.from);
+  const statePath = join(deps.root!, 'graph-runs', 'release-loop', `${safeRunId(opts.runId)}.json`);
+  let waiverCommit: string | undefined;
+  const original = opts.waive !== undefined || opts.reason !== undefined || opts.acceptedRegressions !== undefined
+    ? JSON.parse(readFileSync(statePath, 'utf8')) as GraphRunState : undefined;
+  const waiver = original && (opts.waive !== undefined || opts.reason !== undefined)
+    ? releaseResumeWaiver(original, opts) : undefined;
+  const acceptedRegressions = original && opts.acceptedRegressions !== undefined && !waiver
+    ? releaseResumeAcceptedRegressions(original, opts.acceptedRegressions, opts.from) : undefined;
+  // A waived verdict may reuse its original commit. A moved tip still requires a full re-gate.
+  if (waiver) {
+    const saved = JSON.parse(readFileSync(statePath, 'utf8')) as GraphRunState;
+    const versionRecord = saved.nodes.find((node) => node.nodeId === 'version-release');
+    const output = lastJsonObject(versionRecord?.output);
+    const version = output?.version;
+    const recorded = output?.commit;
+    if (typeof version !== 'string' || typeof recorded !== 'string' || !isReleaseVersion(version) || !/^[0-9a-f]{40}$/i.test(recorded)) throw new Error('release waiver requires a recorded release commit');
+    const git = deps.git ?? gitRunner(deps.repo ?? process.cwd());
+    const branch = `release/${version}`;
+    const advertised = git(['ls-remote', '--heads', 'origin', `refs/heads/${branch}`]).split(/\s+/)[0];
+    if (advertised?.toLowerCase() !== recorded.toLowerCase()) throw new Error('release branch moved — re-gate the new tip before waiving a node');
+    waiverCommit = recorded;
+  }
+  // Check the refreshed tip before refresh writes a new version-release record or backup.
+  const tip = refreshReleaseBranchTip(opts.runId, deps, opts.from, waiverCommit);
   const partial = preparePartial(tip, opts, deps);
   // Resume the graph at the path it was started from (its snapshot is used); only tests inject another path.
   const graphPath = deps.graphPath ?? savedGraphPath(tip.statePath) ?? GRAPH;
-  const state = await (deps.graph ?? runGraph)(graphPath, { resumeRunId: opts.runId, fromNodeId: opts.from, pinChildUniverse: true, deps: { root: deps.root, ...(deps.runBash ? { runBash: deps.runBash } : {}) } });
+  const state = await (deps.graph ?? runGraph)(graphPath, { resumeRunId: opts.runId, fromNodeId: opts.from, pinChildUniverse: true,
+    ...(waiver ? { releaseWaiver: { ...waiver, requestedRegressions: opts.acceptedRegressions ?? [] } } : {}),
+    ...(acceptedRegressions ? { releaseAcceptedRegressions: { requested: opts.acceptedRegressions!, acceptedRegressions } } : {}),
+    deps: { root: deps.root, ...(deps.runBash ? { runBash: deps.runBash } : {}) } });
   return { tip, partial, state };
 }