elanous 0.2.42 → 0.2.44

package/scripts/release-loop/preflight.ts

@@ -5,8 +5,8 @@
 // ⛔ 읽기 전용 — 칸을 옮기지도, 동결을 바꾸지도, push 하지도 않는다. 옮길 것은 «명령»으로 제안만 한다.
 // ⛔ 게이트 규칙을 다시 쓰지 않는다 — checklist-gate 노드 · release run 진입 검사 · 예약 시작 준비 검사(releaseReadiness, #24557)가
 //    함께 쓰는 단 하나의 판정 cutChecklistGate 를 그대로 부르고, 예약 시작 경로는 releaseReadiness 를 CLI 와 같은 인자로 부른다.
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, mkdtempSync } from 'node:fs';
-import { join } from 'node:path';
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, mkdtempSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { cutChecklistGate, listChecklist, type ChecklistItem } from '../../src/release-loop/checklist.js';
@@ -16,10 +16,13 @@ import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
 import { debug } from '../../src/debug/log.js';
 import { releaseReadiness } from './release-readiness.js';
 import { latestPublishedPreviousVersion, runUnattendedRelease, type UnattendedReleaseDeps } from './unattended-release.js';
-import { loadExportConfig, run as runPublicExport, selectExportFiles } from '../public-export.js';
+import { gitIgnoredExportFiles, loadExportConfig, run as runPublicExport, selectExportFiles } from '../public-export.js';
+import { SPAWN_SYNC_MAX_BUFFER } from '../../src/util/spawn-sync-output.js';
+import { NODE_REGISTRY, parsePodPool } from '../../src/task-orchestrator/surfaces/pod-pool.js';
 
 export type PreflightLevel = 'ok' | 'warn' | 'block';
-export type PreflightCheck = 'checklist' | 'postpub' | 'run-input' | 'freeze' | 'schedule' | 'export';
+export type PreflightCheck = 'checklist' | 'postpub' | 'run-input' | 'freeze' | 'schedule' | 'export' | 'notes' | 'cut-tree' | 'gate-slot' | 'release-notes'
+  | 'cutoff-notes' | 'gitignored-export' | 'pwa-build' | 'gate-image';
 export interface PreflightFinding { level: PreflightLevel; check: PreflightCheck; id?: string; message: string; suggestion?: string }
 export interface GateMeasure { version: string; runId: string; gateSeconds: number; toPublishSeconds?: number }
 const compareStable = (a: string, b: string) => { const x = a.split('.').map(Number), y = b.split('.').map(Number); return x[0]! - y[0]! || x[1]! - y[1]! || x[2]! - y[2]!; };
@@ -32,6 +35,14 @@ export interface PreflightResult {
   findings: PreflightFinding[];
   schedule: { cutAt: string; landBy: string | null; publishAt: string | null; publishAtSource: 'option' | 'schedule' | 'cadence' | null; exportCheckAt: string } | null;
   exportCheck: { mainSha: string; files: number; leaks: number; codeLiterals: number } | null;
+  cutoffExportCheck: { commit: string; gitIgnoredLeaks: number | null; error?: string } | null;
+  /** Read-only T−120 evidence. It describes checks only; it never means a release stage ran. */
+  countdownReadiness: {
+    status: 'green' | 'red' | 'unmeasured';
+    notes: { status: 'green' | 'red' | 'unmeasured'; addedLines: number | null };
+    export: { status: 'green' | 'red' | 'unmeasured'; leaks: number | null };
+    checklist: { status: 'green' | 'red' | 'unmeasured' };
+  };
   /** The immediately previous release (by version order) whose gate is compared. */
   previousVersion: string | null;
   gateMeasure: GateMeasure | null;
@@ -39,8 +50,76 @@ export interface PreflightResult {
   fallbackGateMeasure: GateMeasure | null;
 }
 
+// ── RELEASE-COUNTDOWN-SEQUENCE — T−120 → T0 발사 시퀀스 ─────────────────────────────────────────
+// 누리호 발사 체계의 사상: H0 전 자동 시퀀스 · 단계별 녹색/빨강 한 화면 · 범위 이탈(빨강)이면 자동 중지 ·
+// 최후 수동 취소 구간 · 실패는 «부적합 보고»로 원장에 남겨 다음 판에 반영한다.
+// 단계 → 검사 묶음은 기존 findings 의 check 분류를 «그대로» 재사용한다(게이트 규칙을 다시 쓰지 않는다).
+export type CountdownStage = 'T-120' | 'T-60' | 'T-30' | 'T0';
+
+/** What `scripts/release-loop/cutoff.ts` pins at T−60 (`<instance>/release/<version>/manifest.json`). */
+export interface CountdownManifest {
+  cutoff?: { sha?: string };
+  fragments?: { byPr: number; byNextMd: number; unlinked: number; unknown: number };
+  escalate?: Array<{ kind?: string }>;
+}
+
+/** The «node-b» gate slot: the dispatcher is paused and the pod target lowered so the gate can take a Pod. */
+export interface CountdownGateSlot { dispatcherPaused?: boolean; podTargetFrom?: number; podTargetTo?: number }
+
+export interface CountdownStep {
+  stage: CountdownStage;
+  /** Minutes before the cut. */
+  offsetMinutes: number;
+  /** Cut − offset (ISO); null when the release has no stored schedule. */
+  at: string | null;
+  label: string;
+  level: PreflightLevel;
+  findings: PreflightFinding[];
+  /** Not judged — an earlier step went red and the sequence stopped. */
+  skipped: boolean;
+}
+
+export interface NonconformanceEntry {
+  version: string;
+  stage: CountdownStage;
+  /** 원인 */
+  cause: string;
+  /** 수리 */
+  repair: string;
+  /** 다음 판 반영 */
+  nextRelease: string;
+  at: string;
+}
+
+export interface CountdownResult {
+  version: string;
+  next: string;
+  cutAt: string | null;
+  verdict: PreflightLevel;
+  steps: CountdownStep[];
+  /** The stage that went red and stopped the sequence. */
+  haltedAt: CountdownStage | null;
+  /** 담당 자리 우편 — sent when the sequence stops. */
+  mail: { from: string; to: string; subject: string; body: string } | null;
+  /** 최후 수동 취소 구간 — the last seconds before T0 in which a human can still abort. */
+  manualCancel: { windowStartAt: string; windowEndAt: string; totalResponsibleSeconds: number; ldSeconds: number } | null;
+  nonconformance: NonconformanceEntry[];
+  /** The target «부적합 보고» ledger (JSON Lines); dry-run does not append. */
+  nonconformanceLedger: string;
+  sideEffectsEnabled: boolean;
+  preflight: PreflightResult;
+}
+export type ReleaseCountdownStep = {
+  id: 'notes-and-readiness' | 'pinned-main-preflight' | 'gate-window' | 'cut';
+  offsetMinutes: number;
+  at: string;
+  action: string;
+  observation: 'not-observed-by-countdown';
+};
+
 export interface PreflightDeps {
   now?: Date;
+  countdown?: boolean;
   /** Planned publish time (ISO). Without it, the October cadence (07:00 · 18:00 KST) after the cut is assumed. */
   publishAt?: string;
   runInput?: (version: string) => Promise<{ input: unknown }>;
@@ -52,14 +131,40 @@ export interface PreflightDeps {
   previousVersion?: string;
   /** Injectable for deterministic preflight tests. Production pins origin/main and scans a disposable checkout. */
   exportCheck?: () => Promise<{ mainSha: string; files: number; leaks: number; codeLiterals: number }>;
+  /** Release cut −60: build the pinned candidate PWA from a disposable checkout. */
+  pwaBuildCheck?: (commit: string) => Promise<{ ok: boolean; detail: string; commit?: string }>;
+  /** Release cut −60: count export-gitignored hits against the exact cutoff tree. */
+  gitIgnoredExportCheck?: (commit: string) => Promise<number | null>;
+  /** Release cut −60: prove the candidate's immutable commit tag exists in at least one configured gate pool. */
+  gateImageTagCheck?: (commit: string, poolSpec: string) => { checked: boolean; pools: string[]; detail?: string };
+  /** Countdown T−120/T−60/T0: the cut manifest `cutoff.ts` pinned (default `<instance>/release/<v>/manifest.json`). */
+  manifest?: (version: string) => CountdownManifest | null;
+  /** Countdown T−60: the «node-b» gate-slot record (default `<instance>/release/<v>/gate-slot.json`). */
+  gateSlot?: (version: string) => CountdownGateSlot | null;
+  /** Countdown seat mail — default posts `eln msg post --from OP --to <담당 자리>`. */
+  postMail?: (mail: { from: string; to: string; subject: string; body: string }) => void;
+  /** Countdown «부적합 보고» ledger (JSON Lines) — default `<instance>/release/nonconformance.jsonl`. */
+  nonconformanceLog?: string;
+  /** Injectable read-only comparison of release/next.md against the previous published tag. */
+  releaseNotesCheck?: (previousVersion: string | undefined, mainSha: string | undefined) => Promise<number>;
+  /** Explicitly enable owner mail and nonconformance ledger append; defaults to dry-run. */
+  allowSideEffects?: boolean;
 }
 
 function runGit(cwd: string, args: string[]): string {
-  const result = spawnSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 16 << 20 });
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 60_000, maxBuffer: 16 << 20 });
   if (result.status !== 0) throw new Error(`git ${args.join(' ')} 실패 rc=${result.status}: ${(result.stderr ?? '').trim().slice(0, 300)}`);
   return (result.stdout ?? '').trim();
 }
 
+/** Avoid partial-clone promisor remotes turning a missing fixture/cut SHA into an implicit network fetch. */
+function hasLocalCommit(repoRoot: string, commit: string): boolean {
+  const result = spawnSync('git', ['cat-file', '-e', `${commit}^{commit}`], {
+    cwd: repoRoot, env: { ...process.env, GIT_NO_LAZY_FETCH: '1' }, encoding: 'utf8', timeout: 5_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER,
+  });
+  return result.status === 0;
+}
+
 /** Read-only main snapshot: all checkout and cleanup writes are contained in a disposable temp directory. */
 export async function scanOriginMainExport(): Promise<{ mainSha: string; files: number; leaks: number; codeLiterals: number }> {
   const repoRoot = runGit(process.cwd(), ['rev-parse', '--show-toplevel']);
@@ -76,7 +181,7 @@ export async function scanOriginMainExport(): Promise<{ mainSha: string; files:
     needed.add('release/public-export.yaml');
     // Read only the paths the pinned manifest can inspect; the full tracked-path index stays at mainSha.
     const manifestPath = join(snapshot, 'release/public-export.yaml');
-    const manifest = spawnSync('git', ['-C', snapshot, 'show', `${mainSha}:release/public-export.yaml`], { encoding: 'utf8', maxBuffer: 4 << 20 });
+    const manifest = spawnSync('git', ['-C', snapshot, 'show', `${mainSha}:release/public-export.yaml`], { encoding: 'utf8', timeout: 60_000, maxBuffer: 4 << 20 });
     if (manifest.status !== 0) throw new Error(`origin/main public export manifest 읽기 실패: ${(manifest.stderr ?? '').trim()}`);
     mkdirSync(join(snapshot, 'release'), { recursive: true });
     writeFileSync(manifestPath, manifest.stdout ?? '');
@@ -94,7 +199,7 @@ export async function scanOriginMainExport(): Promise<{ mainSha: string; files:
       }
     }
     const checkout = spawnSync('git', ['-C', snapshot, 'checkout-index', '--stdin', '-z', '-f'], {
-      input: `${[...needed].filter((file) => trackedSet.has(file)).join('\0')}\0`, encoding: 'utf8', maxBuffer: 16 << 20,
+      input: `${[...needed].filter((file) => trackedSet.has(file)).join('\0')}\0`, encoding: 'utf8', timeout: 60_000, maxBuffer: 16 << 20,
     });
     if (checkout.status !== 0) throw new Error(`origin/main export 입력 파일 준비 실패 rc=${checkout.status}: ${(checkout.stderr ?? '').trim().slice(0, 300)}`);
     let output = '';
@@ -116,12 +221,121 @@ export async function scanOriginMainExport(): Promise<{ mainSha: string; files:
     }
     if (typeof report.files !== 'number' || typeof report.leaks !== 'number') throw new Error('public-export 검사 결과가 완전하지 않다');
     if (code !== (report.leaks > 0 ? 1 : 0)) throw new Error(`public-export 종료 코드와 누수 결과 불일치: rc=${code} leaks=${report.leaks}`);
-    return { mainSha, files: report.files, leaks: report.leaks, codeLiterals: report.codeLiterals?.hits ?? 0 };
+    const codeLiterals = report.codeLiterals?.hits ?? 0;
+    return { mainSha, files: report.files, leaks: Math.max(0, report.leaks - codeLiterals), codeLiterals };
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+/** Count added release-note lines from the last published tag to the exact pinned main commit. */
+export async function scanReleaseNotesAddedLines(previousVersion: string | undefined, mainSha: string | undefined): Promise<number> {
+  if (!previousVersion || !STABLE.test(previousVersion)) throw new Error('직전 발행 판 버전이 없어 release/next.md 변경을 비교할 수 없다');
+  const repoRoot = runGit(process.cwd(), ['rev-parse', '--show-toplevel']);
+  const pinnedMainSha = mainSha && /^[0-9a-f]{40}$/u.test(mainSha)
+    ? mainSha : runGit(repoRoot, ['rev-parse', '--verify', 'origin/main^{commit}']);
+  const previousTag = runGit(repoRoot, ['rev-parse', '--verify', `v${previousVersion}^{commit}`]);
+  const numstat = runGit(repoRoot, ['diff', '--numstat', `${previousTag}...${pinnedMainSha}`, '--', 'release/next.md']);
+  if (!numstat) return 0;
+  const added = Number(numstat.split('\t', 1)[0]);
+  if (!Number.isSafeInteger(added) || added < 0) throw new Error(`release/next.md diff 결과를 읽을 수 없다: ${numstat}`);
+  return added;
+}
+
+/** Count files selected by the cutoff commit's public-export manifest that its own .gitignore would hide. */
+export async function scanGitIgnoredExportAtCommit(commit: string): Promise<number | null> {
+  if (!/^[0-9a-f]{40}$/i.test(commit)) return null;
+  const repoRoot = runGit(process.cwd(), ['rev-parse', '--show-toplevel']);
+  if (!hasLocalCommit(repoRoot, commit)) return null;
+  const temp = mkdtempSync(join(tmpdir(), 'release-preflight-gitignored-'));
+  const snapshot = join(temp, 'checkout');
+  try {
+    runGit(temp, ['clone', '--shared', '--no-checkout', '--quiet', repoRoot, snapshot]);
+    runGit(snapshot, ['read-tree', commit]);
+    runGit(snapshot, ['checkout-index', '--all', '--force']);
+    const tracked = runGit(snapshot, ['ls-files', '-z']).split('\0').filter(Boolean);
+    const config = loadExportConfig(snapshot);
+    return gitIgnoredExportFiles(snapshot, selectExportFiles(tracked, config)).length;
   } finally {
     rmSync(temp, { recursive: true, force: true });
   }
 }
 
+/** Build the PWA from an exact candidate commit in a disposable snapshot; never build the caller's dirty tree. */
+export async function scanPwaBuildAtCommit(commit: string): Promise<{ ok: boolean; detail: string; commit: string }> {
+  if (!/^[0-9a-f]{40}$/i.test(commit)) return { ok: false, detail: `candidate commit is not pinned: ${commit || '(missing)'}`, commit };
+  const repoRoot = runGit(process.cwd(), ['rev-parse', '--show-toplevel']);
+  if (!hasLocalCommit(repoRoot, commit)) return { ok: false, detail: `candidate commit is unavailable locally: ${commit}`, commit };
+  const temp = mkdtempSync(join(tmpdir(), 'release-preflight-pwa-'));
+  const snapshot = join(temp, 'checkout');
+  const run = (cmd: string, args: string[], cwd: string, timeout = 60_000) => spawnSync(cmd, args, {
+    cwd, encoding: 'utf8', timeout, maxBuffer: SPAWN_SYNC_MAX_BUFFER,
+  });
+  const failureDetail = (result: ReturnType<typeof run>): string =>
+    (result.stderr || result.stdout || (result.error instanceof Error ? result.error.message : '') || `exit ${result.status}`).trim();
+  try {
+    const clone = run('git', ['clone', '--shared', '--no-checkout', '--quiet', repoRoot, snapshot], temp);
+    if (clone.status !== 0) return { ok: false, detail: `candidate checkout failed: ${failureDetail(clone)}`, commit };
+    const tree = run('git', ['read-tree', commit], snapshot);
+    if (tree.status !== 0) return { ok: false, detail: `candidate tree unavailable: ${failureDetail(tree)}`, commit };
+    const checkout = run('git', ['checkout-index', '--all', '--force'], snapshot);
+    if (checkout.status !== 0) return { ok: false, detail: `candidate files unavailable: ${failureDetail(checkout)}`, commit };
+    const rootInstall = run('bun', ['install', '--frozen-lockfile'], snapshot, 300_000);
+    if (rootInstall.status !== 0) return { ok: false, detail: `candidate dependency install failed: ${failureDetail(rootInstall).slice(-500)}`, commit };
+    const pwaInstall = run('bun', ['install', '--frozen-lockfile'], join(snapshot, 'apps/pwa'), 300_000);
+    if (pwaInstall.status !== 0) return { ok: false, detail: `PWA dependency install failed: ${failureDetail(pwaInstall).slice(-500)}`, commit };
+    const build = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], snapshot, 15 * 60_000);
+    const detail = (build.status === 0 ? build.stdout : failureDetail(build)).trim().slice(-800);
+    // The snapshot was checked out at `commit`; echo that pin so injected evidence still has to match it.
+    return { ok: build.status === 0 && !build.error, detail: detail || `nexus build exit ${build.status}`, commit };
+  } catch (error) {
+    return { ok: false, detail: error instanceof Error ? error.message : String(error), commit };
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+/** Read pool tags with a bounded SSH timeout; local pools use the image's immutable commit label. */
+export function scanGateImageTag(commit: string, poolSpec: string): { checked: boolean; pools: string[]; detail?: string } {
+  if (!/^[0-9a-f]{40}$/i.test(commit)) return { checked: false, pools: [], detail: 'cutoff commit is not pinned' };
+  try {
+    const members = parsePodPool(poolSpec);
+    if (!members.length) return { checked: false, pools: [], detail: 'gate pool is empty' };
+    const pools: string[] = [];
+    const errors: string[] = [];
+    for (const member of members) {
+      if (!member.sshHost) {
+        const local = spawnSync('docker', ['image', 'inspect', 'elanous-harness:local', '--format', '{{index .Config.Labels "elanous.commit"}}'], { encoding: 'utf8', timeout: 10_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+        if (local.status === 0 && local.stdout.trim() === commit) pools.push(member.context);
+        else if (local.error || local.status === null) errors.push(`${member.context}: ${local.error?.message ?? 'docker inspection unavailable'}`);
+        continue;
+      }
+      const registry = member.registry ?? NODE_REGISTRY;
+      const portMatch = /:(\d+)$/.exec(registry);
+      if (!portMatch) {
+        errors.push(`${member.context}: registry port is missing (${registry})`);
+        continue;
+      }
+      // Remote registry tags use the 12-character prefix per pod-pool.ts; local elanous.commit labels are full SHAs.
+      const port = portMatch[1]!;
+      const image = 'elanous-harness';
+      const remote = spawnSync('ssh', ['-o', 'BatchMode=yes', '-o', 'ConnectTimeout=5', member.sshHost,
+        `curl -fsS --max-time 5 http://localhost:${port}/v2/${image}/tags/list 2>/dev/null`], { encoding: 'utf8', timeout: 12_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+      if (remote.status !== 0) {
+        errors.push(`${member.context}: registry query failed${remote.error ? ` (${remote.error.message})` : ` (rc=${remote.status})`}`);
+        continue;
+      }
+      try {
+        const tags = (JSON.parse(remote.stdout) as { tags?: string[] }).tags ?? [];
+        if (tags.includes(commit.slice(0, 12))) pools.push(member.context);
+      } catch { errors.push(`${member.context}: registry tag response was not valid JSON`); }
+    }
+    return { checked: errors.length === 0, pools, ...(errors.length ? { detail: errors.join('; ') } : {}) };
+  } catch (error) {
+    return { checked: false, pools: [], detail: error instanceof Error ? error.message : String(error) };
+  }
+}
+
 const POSTPUB_ID = /^POSTPUB-/i;
 // Only a title that «starts» with the marker: a pre-publish cell often mentions «발행 뒤» in its body (a slot, a plan).
 const POSTPUB_TITLE = /^[«"'(]?\s*(발행\s*(뒤|후)|post-?publish)/i;
@@ -149,6 +363,37 @@ export function cadencePublishAt(cutAt: string): string {
   return new Date(cut).toISOString();
 }
 
+/** A read-only timeline; timestamps never imply that a human or automation completed a step. */
+export function releaseCountdown(cutAt: string): ReleaseCountdownStep[] {
+  const cut = Date.parse(cutAt);
+  if (!Number.isFinite(cut)) throw new Error(`invalid release cut time: ${cutAt}`);
+  const phases = [
+    { id: 'notes-and-readiness', offsetMinutes: -120, action: 'release/next.md 새 줄 ≥1 · 공개 export 누수 0 · 체크리스트 게이트 모의' },
+    { id: 'pinned-main-preflight', offsetMinutes: -60, action: '컷 트리를 고정하고 origin/main export 및 release preflight 실행' },
+    { id: 'gate-window', offsetMinutes: -30, action: 'gate 모드 · node-b 자리 확보 · 디스패처 정지 · podTarget 감축 확인' },
+    { id: 'cut', offsetMinutes: 0, action: 'release 컷 실행' },
+  ] as const;
+  return phases.map((phase) => ({
+    ...phase,
+    at: new Date(cut + phase.offsetMinutes * 60_000).toISOString(),
+    observation: 'not-observed-by-countdown',
+  }));
+}
+
+export function formatReleaseCountdown(cutAt: string, now = new Date(), readiness?: PreflightResult['countdownReadiness']): string[] {
+  return [
+    `발행 카운트다운 · 컷 ${formatKst(cutAt)} · 이 명령은 단계 완료를 관측하거나 실행하지 않는다`,
+    ...releaseCountdown(cutAt).map((step) => {
+      const label = step.offsetMinutes === 0 ? 'T0' : `T${step.offsetMinutes}`;
+      const timing = now.getTime() < Date.parse(step.at) ? '예정' : '시각 도달 · 완료 미관측';
+      const t120 = readiness && step.id === 'notes-and-readiness'
+        ? ` · read-only 판정 ${readiness.status} (notes +${readiness.notes.addedLines ?? '?'} · export 누수 ${readiness.export.leaks ?? '?'} · checklist ${readiness.checklist.status})`
+        : '';
+      return `· ${label} ${formatKst(step.at)} · ${timing} · ${step.action}${t120}`;
+    }),
+  ];
+}
+
 /**
  * A release's measured gate: the newest finished release-loop run of «that» version (`{ version }`) or, with
  * `{ below }`, the most recently measured run of any version under it. Node timings are not stored in the run state, so the gate time is the start of the gate node's context file to
@@ -209,6 +454,9 @@ export async function releasePreflight(version: string, deps: PreflightDeps = {}
   // Always the stored cut (before or after it): the preflight simulates «the cut», not the moment it is run.
   const judgeAt = schedule ? new Date(Date.parse(schedule.cutAt)) : now;
   const data = listChecklist(version);
+  const cutoffManifest = deps.countdown
+    ? (deps.manifest ?? ((v: string) => readReleaseJson<CountdownManifest>(v, 'manifest.json')))(version)
+    : null;
   const { autoMoved, ...gate } = cutChecklistGate(version, schedule?.landBy, judgeAt);
   const p0 = data.items.filter((item) => item.status === 'yellow' && item.priority === 'P0').map((item) => item.id);
   const byId = new Map(data.items.map((item) => [item.id, item]));
@@ -253,7 +501,8 @@ export async function releasePreflight(version: string, deps: PreflightDeps = {}
 
   // 3a. Public export leakage is measured against one pinned origin/main commit, never this possibly dirty branch.
   try {
-    exportCheck = await (deps.exportCheck ?? scanOriginMainExport)();
+    const scanned = await (deps.exportCheck ?? scanOriginMainExport)();
+    exportCheck = scanned;
     findings.push(exportCheck.leaks
       ? { level: 'block', check: 'export', message: `origin/main ${exportCheck.mainSha.slice(0, 12)} 공개 export 누수 ${exportCheck.leaks}건 · ${exportCheck.files} 파일 검사` }
       : { level: 'ok', check: 'export', message: `origin/main ${exportCheck.mainSha.slice(0, 12)} 공개 export 누수 0건 · ${exportCheck.files} 파일 검사` });
@@ -264,15 +513,92 @@ export async function releasePreflight(version: string, deps: PreflightDeps = {}
 
   // 3. The same input check `release run --dry-run` makes.
   let runPrevious: string | undefined;
+  let gatePodPool: string | undefined;
   try {
     const result = await (deps.runInput ?? ((v: string) => runUnattendedRelease({ version: v, dryRun: true }, deps.releaseRunDeps ?? {})))(version);
     const input = result.input as { previousVersion?: string; gatePodPool?: string };
     runPrevious = input.previousVersion;
+    gatePodPool = input.gatePodPool;
     findings.push({ level: 'ok', check: 'run-input', message: `release run --dry-run 입력 OK — 직전 판 ${input.previousVersion ?? '-'} · 게이트 풀 ${input.gatePodPool ?? '-'}` });
   } catch (error) {
     findings.push({ level: 'block', check: 'run-input', message: `release run --dry-run 입력 오류 — ${error instanceof Error ? error.message : String(error)}` });
   }
 
+  let notesAddedLines: number | null = null;
+  let cutoffExportCheck: PreflightResult['cutoffExportCheck'] = null;
+  const manifestNotesEmpty = cutoffManifest?.escalate?.some((item) => item.kind === 'notes-empty') === true;
+  const fragments = cutoffManifest?.fragments;
+  const manifestNoteSummary = fragments
+    && [fragments.byPr, fragments.byNextMd, fragments.unlinked, fragments.unknown].every(Number.isFinite)
+    ? `PR ${fragments.byPr} · next.md ${fragments.byNextMd} · unlinked ${fragments.unlinked} · unknown ${fragments.unknown}`
+    : null;
+  if (deps.countdown) {
+    try {
+      notesAddedLines = await (deps.releaseNotesCheck ?? scanReleaseNotesAddedLines)(runPrevious, exportCheck?.mainSha);
+      findings.push(notesAddedLines > 0
+        ? { level: 'ok', check: 'release-notes', message: `직전 발행 ${runPrevious ?? '-'} 이후 고정 main의 release/next.md 추가 ${notesAddedLines}줄` }
+        : { level: 'block', check: 'release-notes', message: `직전 발행 ${runPrevious ?? '-'} 이후 고정 main의 release/next.md 추가 줄이 없다` });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      findings.push({ level: 'warn', check: 'release-notes', message: `release/next.md 변경을 측정하지 못했다 — ${message}` });
+    }
+
+    const candidateCommit = cutoffManifest?.cutoff?.sha ?? '';
+    // cutoff.ts already classifies all public note sources (PR fragments and next.md lines) and emits
+    // notes-empty only when the manifest contains no user-visible feat/fix/security line.
+    const notesEmpty = manifestNotesEmpty;
+    const notesDetail = notesEmpty
+      ? 'notes-empty — 컷 manifest가 공개용 feat/fix/security 노트가 없다고 판정했다'
+      : `컷 manifest 노트 분류: ${manifestNoteSummary ?? '확인 불가'}`;
+    const emptyManifestNotes = fragments !== undefined
+      && fragments.byPr === 0 && fragments.byNextMd === 0 && fragments.unlinked === 0 && fragments.unknown === 0;
+    const cutoffNotesMissing = !candidateCommit || manifestNoteSummary === null || notesEmpty || emptyManifestNotes;
+    findings.push({
+      level: cutoffNotesMissing ? 'block' : 'ok', check: 'cutoff-notes',
+      message: notesDetail,
+      ...(cutoffNotesMissing ? { suggestion: 'cutoff manifest를 만들고 고정 후보 트리의 release/next.md 에 사용자용 feat/fix 줄을 더한 뒤 다시 검사한다' } : {}),
+    });
+
+    let ignoredLeaks: number | null = null;
+    let ignoredLeaksError: string | undefined;
+    try { ignoredLeaks = await (deps.gitIgnoredExportCheck ?? scanGitIgnoredExportAtCommit)(candidateCommit); }
+    catch (error) {
+      ignoredLeaks = null;
+      ignoredLeaksError = error instanceof Error ? error.message : String(error);
+    }
+    cutoffExportCheck = { commit: candidateCommit, gitIgnoredLeaks: ignoredLeaks, ...(ignoredLeaksError ? { error: ignoredLeaksError } : {}) };
+    findings.push(ignoredLeaks === 0
+      ? { level: 'ok', check: 'gitignored-export', message: `컷 후보 ${candidateCommit.slice(0, 12) || '(SHA 없음)'} public-export export-gitignored 0건` }
+      : { level: 'block', check: 'gitignored-export', message: ignoredLeaks === null || ignoredLeaks === undefined
+        ? `컷 후보 ${candidateCommit.slice(0, 12) || '(SHA 없음)'} public-export export-gitignored 결과를 확인하지 못했다${ignoredLeaksError ? ` — ${ignoredLeaksError}` : ''}`
+        : `컷 후보 ${candidateCommit.slice(0, 12) || '(SHA 없음)'} public-export export-gitignored ${ignoredLeaks}건`,
+        suggestion: '공개 export 입력 중 .gitignore 에 걸리는 파일을 제거하거나 공개 정책을 고치고 검사를 다시 실행한다' });
+
+    let pwa: { ok: boolean; detail: string; commit?: string };
+    try {
+      pwa = await (deps.pwaBuildCheck ?? scanPwaBuildAtCommit)(candidateCommit);
+      const pwaOk = pwa.ok && pwa.commit === candidateCommit;
+      findings.push(pwaOk
+        ? { level: 'ok', check: 'pwa-build', message: `PWA 빌드 통과 · ${candidateCommit.slice(0, 12)}` }
+      : { level: 'block', check: 'pwa-build', message: `PWA 빌드 실패 또는 SHA 불일치(${pwa.commit ?? '미기록'} ≠ ${candidateCommit}) · ${pwa.detail}`,
+          suggestion: `고정 후보 ${candidateCommit.slice(0, 12) || '(SHA 없음)'}에서 apps/pwa 빌드를 통과시킨다` });
+    } catch (error) {
+      pwa = { ok: false, detail: error instanceof Error ? error.message : String(error) };
+      findings.push({ level: 'block', check: 'pwa-build', message: `PWA 빌드 증거를 확인하지 못했다 · ${pwa.detail}`,
+        suggestion: `고정 후보 ${candidateCommit.slice(0, 12) || '(SHA 없음)'}에서 apps/pwa 빌드를 통과시킨다` });
+    }
+
+    const imageCheck = gatePodPool
+      ? (deps.gateImageTagCheck ?? scanGateImageTag)(candidateCommit, gatePodPool)
+      : { checked: false, pools: [], detail: 'release run 입력에서 gatePodPool을 얻지 못했다' };
+    findings.push(imageCheck.checked && imageCheck.pools.length > 0
+      ? { level: 'ok', check: 'gate-image', message: `컷 후보 gate 이미지 태그 ${candidateCommit.slice(0, 12)} 확인 · 풀 ${imageCheck.pools.join(', ')}` }
+      : { level: 'block', check: 'gate-image', message: imageCheck.checked
+        ? `컷 후보 gate 이미지 태그 ${candidateCommit.slice(0, 12) || '(SHA 없음)'}가 어느 풀에도 없다`
+        : `컷 후보 gate 이미지 태그를 확인하지 못했다 · ${imageCheck.detail ?? '원인 미상'}`,
+        suggestion: `컷 후보 ${candidateCommit.slice(0, 12) || '(SHA 없음)'}의 gate 이미지를 하나 이상의 풀에 빌드·반입한 뒤 preflight 를 다시 실행한다` });
+  }
+
   // 4. Landing freeze (emergency switch since RELEASE-BRANCH): when on, `release run` refuses.
   try {
     const frozen = (deps.freeze ?? (() => readLandingFreeze(deps.releaseRunDeps?.freezeRoot)))();
@@ -320,10 +646,29 @@ export async function releasePreflight(version: string, deps: PreflightDeps = {}
     }
   }
 
+  const checklistHasResult = findings.some((f) => f.check === 'checklist' && f.level === 'ok');
+  const countdownReadiness: PreflightResult['countdownReadiness'] = !deps.countdown ? {
+    status: 'unmeasured', notes: { status: 'unmeasured', addedLines: null },
+    export: { status: 'unmeasured', leaks: null }, checklist: { status: 'unmeasured' },
+  } : (() => {
+    const notesFinding = findings.find((f) => f.check === 'release-notes');
+    const exportFinding = findings.find((f) => f.check === 'export');
+    const checklistBlocked = findings.some((f) => f.check === 'checklist' && f.level === 'block');
+    const notesStatus = notesFinding?.level === 'ok' ? 'green' : notesFinding?.level === 'block' ? 'red' : 'unmeasured';
+    const exportStatus = exportFinding?.level === 'ok' ? 'green' : exportFinding?.level === 'block' ? 'red' : 'unmeasured';
+    const checklistStatus = checklistBlocked ? 'red' : checklistHasResult ? 'green' : 'unmeasured';
+    const statuses = [notesStatus, exportStatus, checklistStatus];
+    return {
+      status: statuses.includes('red') ? 'red' : statuses.every((status) => status === 'green') ? 'green' : 'unmeasured',
+      notes: { status: notesStatus, addedLines: notesAddedLines },
+      export: { status: exportStatus, leaks: exportCheck?.leaks ?? null },
+      checklist: { status: checklistStatus },
+    };
+  })();
   const blockers = findings.filter((f) => f.level === 'block').length;
   const warnings = findings.filter((f) => f.level === 'warn').length;
   debug.log('release.preflight', 'checked', { version, blockers, warnings });
-  return { version, next, verdict: blockers ? 'block' : warnings ? 'warn' : 'ok', blockers, warnings, findings, schedule: scheduleOut, exportCheck, previousVersion, gateMeasure, fallbackGateMeasure };
+  return { version, next, verdict: blockers ? 'block' : warnings ? 'warn' : 'ok', blockers, warnings, findings, schedule: scheduleOut, exportCheck, cutoffExportCheck, countdownReadiness, previousVersion, gateMeasure, fallbackGateMeasure };
 }
 
 const ICON: Record<PreflightLevel, string> = { ok: '✅', warn: '⚠️', block: '⛔' };
@@ -336,3 +681,192 @@ export function formatPreflight(result: PreflightResult): string[] {
     : result.verdict === 'warn' ? `⚠️ 판정: 통과(경고 ${result.warnings})` : '✅ 판정: 통과';
   return [`release preflight ${result.version} (다음 판 ${result.next})`, ...lines, verdict];
 }
+
+const COUNTDOWN_ORDER: CountdownStage[] = ['T-120', 'T-60', 'T-30', 'T0'];
+const COUNTDOWN_OFFSET_MINUTES: Record<CountdownStage, number> = { 'T-120': 120, 'T-60': 60, 'T-30': 30, T0: 0 };
+/** Which existing finding group each stage judges — the check vocabulary of `releasePreflight`, not a new rule set. */
+const COUNTDOWN_CHECKS: Record<CountdownStage, PreflightCheck[]> = {
+  'T-120': ['checklist', 'postpub', 'notes', 'release-notes', 'export'],
+  'T-60': ['run-input', 'freeze', 'cut-tree', 'gate-slot', 'cutoff-notes', 'gitignored-export', 'pwa-build', 'gate-image'],
+  'T-30': ['schedule'],
+  T0: [],
+};
+const COUNTDOWN_LABELS: Record<CountdownStage, string> = {
+  'T-120': '노트(next.md 새 줄) · 공개 export 누수 · 체크리스트 게이트 모의',
+  'T-60': '컷 후보 P0 네 항목(노트 · gitignore export · PWA · gate 이미지) ⊕ node-b 게이트 자리',
+  'T-30': 'gate window 준비(컷→발행 창 ≥ 직전 실측 게이트)',
+  T0: '컷 트리 확인(실제 컷 실행은 별도)',
+};
+/** 담당 자리 — who is mailed when that stage goes red. */
+const COUNTDOWN_OWNER: Record<CountdownStage, string> = { 'T-120': 'TC', 'T-60': 'OP', 'T-30': 'OP', T0: 'OP' };
+/** 최후 수동 취소 구간(누리호 사상): 총책임자 8초 · LD 5초. */
+const MANUAL_CANCEL_SECONDS = { totalResponsibleSeconds: 8, ldSeconds: 5 };
+
+const worstLevel = (findings: PreflightFinding[]): PreflightLevel =>
+  findings.some((finding) => finding.level === 'block') ? 'block' : findings.some((finding) => finding.level === 'warn') ? 'warn' : 'ok';
+
+function readReleaseJson<T>(version: string, file: string): T | null {
+  try { return JSON.parse(readFileSync(join(effectiveInstanceRoot(), 'release', version, file), 'utf8')) as T; } catch { return null; }
+}
+
+/** T−120 — `next.md` got at least one new line for this release (0.2.39 found notes-empty only after the cut). */
+function countdownNotes(manifest: CountdownManifest | null): PreflightFinding {
+  if (!manifest) return { level: 'warn', check: 'notes', message: 'next.md 새 줄 판정 없음 — 컷 manifest 없음(T−60 의 cutoff.ts 가 만든다)' };
+  const lines = (manifest.fragments?.byNextMd ?? 0) + (manifest.fragments?.unlinked ?? 0);
+  if ((manifest.escalate ?? []).some((item) => item.kind === 'notes-empty') || lines < 1) {
+    return {
+      level: 'block', check: 'notes', message: 'next.md 새 줄 0 — notes-empty(이 판 공개 노트가 비어 있다 · 컷 뒤에 드러나면 발행이 늦어진다)',
+      suggestion: 'release/next.md 에 이 판 feat/fix 줄을 더하고 cutoff.ts 로 manifest 를 다시 만든다',
+    };
+  }
+  return { level: 'ok', check: 'notes', message: `next.md 새 줄 ${lines}줄` };
+}
+
+/** T−60 — the cut tree is pinned: the manifest names one cutoff sha (cutoff.ts output, its format unchanged). */
+function countdownCutTree(manifest: CountdownManifest | null): PreflightFinding {
+  const sha = manifest?.cutoff?.sha;
+  return sha
+    ? { level: 'ok', check: 'cut-tree', message: `컷 트리 고정 ${sha.slice(0, 12)}` }
+    : { level: 'warn', check: 'cut-tree', message: '컷 트리 고정 없음 — T−60 에 `bun scripts/release-loop/cutoff.ts --version <v>` 로 manifest 를 만든다' };
+}
+
+/** T−60 — the «node-b» gate slot: dispatcher stopped and the pod target lowered so the gate can take a Pod. */
+function countdownGateSlot(slot: CountdownGateSlot | null): PreflightFinding[] {
+  if (!slot) return [{ level: 'warn', check: 'gate-slot', message: 'node-b 게이트 자리 기록 없음 — release/<v>/gate-slot.json(디스패처 정지 · podTarget 감축)' }];
+  const findings: PreflightFinding[] = [];
+  if (slot.dispatcherPaused !== true) {
+    findings.push({
+      level: 'block', check: 'gate-slot', message: 'node-b 게이트 자리 — 디스패처가 멈추지 않았다(게이트가 Pod 를 잡지 못한다)',
+      suggestion: '디스패처를 정지하고 release/<v>/gate-slot.json 에 dispatcherPaused: true 를 남긴다',
+    });
+  }
+  if (slot.podTargetFrom !== undefined && slot.podTargetTo !== undefined && slot.podTargetTo >= slot.podTargetFrom) {
+    findings.push({
+      level: 'block', check: 'gate-slot', message: `node-b 게이트 자리 — podTarget 감축 없음(${slot.podTargetFrom}→${slot.podTargetTo})`,
+      suggestion: 'podTarget 을 게이트 몫만큼 줄이고 gate-slot.json 에 from/to 를 기록한다',
+    });
+  }
+  if (!findings.length) {
+    const target = slot.podTargetFrom !== undefined ? ` · podTarget ${slot.podTargetFrom}→${slot.podTargetTo ?? slot.podTargetFrom}` : '';
+    findings.push({ level: 'ok', check: 'gate-slot', message: `node-b 게이트 자리 확보 — 디스패처 정지${target}` });
+  }
+  return findings;
+}
+
+/** T0 — model readiness only: this command never executes the cut. */
+function countdownCut(manifest: CountdownManifest | null): PreflightFinding {
+  const sha = manifest?.cutoff?.sha;
+  return sha
+    ? { level: 'ok', check: 'cut-tree', message: `T0 컷 준비 — 고정 트리 ${sha.slice(0, 12)}(실제 컷 실행은 별도 명령)` }
+    : { level: 'block', check: 'cut-tree', message: 'T0 컷 불가 — 컷 트리 고정(manifest cutoff.sha)이 없다', suggestion: 'T−60 에 cutoff.ts 로 컷 트리를 고정한다' };
+}
+
+function postSeatMail(mail: { from: string; to: string; subject: string; body: string }): void {
+  const result = spawnSync('eln', ['msg', 'post', '--from', mail.from, '--to', mail.to, '--kind', 'report', '--body', `${mail.subject}\n${mail.body}`], {
+    encoding: 'utf8', timeout: 60_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER,
+  });
+  if (result.status !== 0 || result.error) process.stderr.write(`release countdown 좌석 우편 실패: ${(result.stderr || String(result.error ?? result.status)).trim()}\n`);
+}
+
+/**
+ * `release preflight --countdown` — the launch sequence from T−120 to T0 over the same `releasePreflight` findings.
+ * A red stage stops every later stage, mails the owning seat and appends one «부적합 보고» per failure to the ledger.
+ * Read-only apart from that ledger append and the seat mail — the cut and the checklist are never changed.
+ */
+export async function runReleaseCountdown(version: string, deps: PreflightDeps = {}): Promise<CountdownResult> {
+  const preflight = await releasePreflight(version, { ...deps, countdown: true });
+  const now = deps.now ?? new Date();
+  const manifest = (deps.manifest ?? ((v: string) => readReleaseJson<CountdownManifest>(v, 'manifest.json')))(version);
+  const slot = (deps.gateSlot ?? ((v: string) => readReleaseJson<CountdownGateSlot>(v, 'gate-slot.json')))(version);
+  const cutAt = preflight.schedule?.cutAt ?? null;
+
+  const grouped = new Map<PreflightCheck, PreflightFinding[]>();
+  for (const finding of preflight.findings) grouped.set(finding.check, [...(grouped.get(finding.check) ?? []), finding]);
+  const own: Record<CountdownStage, PreflightFinding[]> = {
+    'T-120': [countdownNotes(manifest)],
+    'T-60': [countdownCutTree(manifest), ...countdownGateSlot(slot)],
+    'T-30': [],
+    T0: [countdownCut(manifest)],
+  };
+
+  const steps: CountdownStep[] = [];
+  let haltedAt: CountdownStage | null = null;
+  for (const stage of COUNTDOWN_ORDER) {
+    const offsetMinutes = COUNTDOWN_OFFSET_MINUTES[stage];
+    const at = cutAt ? new Date(Date.parse(cutAt) - offsetMinutes * 60_000).toISOString() : null;
+    if (haltedAt) {
+      steps.push({ stage, offsetMinutes, at, label: COUNTDOWN_LABELS[stage], level: 'ok', findings: [], skipped: true });
+      continue;
+    }
+    const findings = [...COUNTDOWN_CHECKS[stage].flatMap((check) => grouped.get(check) ?? []), ...own[stage]];
+    const level = worstLevel(findings);
+    steps.push({ stage, offsetMinutes, at, label: COUNTDOWN_LABELS[stage], level, findings, skipped: false });
+    if (level === 'block') haltedAt = stage;
+  }
+
+  const nonconformance: NonconformanceEntry[] = steps.flatMap((step) => step.findings
+    .filter((finding) => finding.level === 'block')
+    .map((finding) => ({
+      version, stage: step.stage, cause: finding.message,
+      repair: finding.suggestion ?? `${step.stage} 담당 자리가 원인을 확인해 고친다`,
+      nextRelease: preflight.next, at: now.toISOString(),
+    })));
+  const nonconformanceLedger = deps.nonconformanceLog ?? join(effectiveInstanceRoot(), 'release', 'nonconformance.jsonl');
+  if (deps.allowSideEffects && nonconformance.length) {
+    mkdirSync(dirname(nonconformanceLedger), { recursive: true });
+    appendFileSync(nonconformanceLedger, `${nonconformance.map((entry) => JSON.stringify(entry)).join('\n')}\n`);
+  }
+
+  const mail = haltedAt ? countdownMail(version, haltedAt, steps, nonconformance.length) : null;
+  if (deps.allowSideEffects && mail) (deps.postMail ?? postSeatMail)(mail);
+
+  const cancelSeconds = MANUAL_CANCEL_SECONDS.totalResponsibleSeconds + MANUAL_CANCEL_SECONDS.ldSeconds;
+  const manualCancel = cutAt ? {
+    windowStartAt: new Date(Date.parse(cutAt) - cancelSeconds * 1000).toISOString(),
+    windowEndAt: cutAt, ...MANUAL_CANCEL_SECONDS,
+  } : null;
+  const verdict = haltedAt ? 'block' : steps.some((step) => step.level === 'warn') ? 'warn' : 'ok';
+  debug.log('release.preflight', 'countdown', { version, haltedAt, verdict, nonconformance: nonconformance.length });
+  return {
+    version, next: preflight.next, cutAt, verdict, steps, haltedAt, mail, manualCancel, nonconformance, nonconformanceLedger,
+    sideEffectsEnabled: deps.allowSideEffects === true, preflight,
+  };
+}
+
+function countdownMail(version: string, stage: CountdownStage, steps: CountdownStep[], failures: number): CountdownResult['mail'] {
+  const step = steps.find((entry) => entry.stage === stage)!;
+  const reasons = step.findings.filter((finding) => finding.level === 'block');
+  const repairs = reasons.filter((finding) => finding.suggestion).map((finding) => `· ${finding.message} → ${finding.suggestion}`);
+  return {
+    from: 'OP', to: COUNTDOWN_OWNER[stage], subject: `RELEASE-COUNTDOWN ${version} ${stage}`,
+    body: [
+      `RELEASE-COUNTDOWN ${version} ${stage} 빨강 — 발사 시퀀스를 자동 중지했다.`,
+      ...reasons.map((finding) => `· ${finding.message}`),
+      ...(repairs.length ? ['수리:', ...repairs] : []),
+      `«부적합 보고» ${failures}건을 원장에 넣었다(원인·수리·다음 판 ${nextPatch(version)} 반영).`,
+    ].join('\n'),
+  };
+}
+
+/** The one screen of the launch sequence: every stage green/red, the manual-cancel window and one «판정:» line. */
+export function formatCountdown(result: CountdownResult): string[] {
+  const lines = [`release countdown ${result.version} (다음 판 ${result.next})${result.cutAt ? ` · 컷 ${formatKst(result.cutAt)}` : ''} · 검사 상태만 표시(단계 실행은 미관측)`];
+  for (const step of result.steps) {
+    const when = step.at ? ` · ${formatKst(step.at)}` : '';
+    if (step.skipped) { lines.push(`⏸ ${step.stage} — 미진행(${result.haltedAt} 빨강 — 자동 중지)${when}`); continue; }
+    lines.push(`${ICON[step.level]} ${step.stage} ${step.label}${when}`);
+    for (const finding of step.findings) {
+      lines.push(`    ${ICON[finding.level]} ${finding.message}`);
+      if (finding.suggestion) lines.push(`      → ${finding.suggestion}`);
+    }
+  }
+  if (result.manualCancel) {
+    const seconds = Math.round((Date.parse(result.manualCancel.windowEndAt) - Date.parse(result.manualCancel.windowStartAt)) / 1000);
+    lines.push(`⏱ 최후 수동 취소 구간 T0−${seconds}초 ~ T0 (${formatKst(result.manualCancel.windowEndAt)}) — 총책임자 ${result.manualCancel.totalResponsibleSeconds}초 · LD ${result.manualCancel.ldSeconds}초`);
+  }
+  if (result.mail) lines.push(`${result.sideEffectsEnabled ? '📮 담당 자리 우편' : '📮 담당 자리 우편 계획(미발송 · 기본 dry-run)'} → ${result.mail.to} · ${result.mail.subject}`);
+  lines.push(result.verdict === 'block'
+    ? `⛔ 판정: 평가 중지 — ${result.haltedAt} 빨강 · 부적합 보고 ${result.nonconformance.length}건 ${result.sideEffectsEnabled ? `원장 기록(${result.nonconformanceLedger})` : `원장 기록 계획(미기록 · 기본 dry-run: ${result.nonconformanceLedger})`}`
+    : result.verdict === 'warn' ? '⚠️ 판정: 통과(경고) — 경고 단계는 기록만 한다' : '✅ 판정: 통과');
+  return lines;
+}