elanous 0.2.42 → 0.2.43

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';
@@ -17,9 +17,10 @@ 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 { SPAWN_SYNC_MAX_BUFFER } from '../../src/util/spawn-sync-output.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';
 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 +33,13 @@ 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;
+  /** 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 +47,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,10 +128,22 @@ 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 }>;
+  /** 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();
 }
@@ -76,7 +164,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 +182,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 +204,27 @@ 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;
+}
+
 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 +252,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
@@ -273,6 +407,18 @@ export async function releasePreflight(version: string, deps: PreflightDeps = {}
     findings.push({ level: 'block', check: 'run-input', message: `release run --dry-run 입력 오류 — ${error instanceof Error ? error.message : String(error)}` });
   }
 
+  let notesAddedLines: number | null = 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) {
+      findings.push({ level: 'warn', check: 'release-notes', message: `release/next.md 변경을 측정하지 못했다 — ${error instanceof Error ? error.message : String(error)}` });
+    }
+  }
+
   // 4. Landing freeze (emergency switch since RELEASE-BRANCH): when on, `release run` refuses.
   try {
     const frozen = (deps.freeze ?? (() => readLandingFreeze(deps.releaseRunDeps?.freezeRoot)))();
@@ -320,10 +466,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, countdownReadiness, previousVersion, gateMeasure, fallbackGateMeasure };
 }
 
 const ICON: Record<PreflightLevel, string> = { ok: '✅', warn: '⚠️', block: '⛔' };
@@ -336,3 +501,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'],
+  'T-30': ['schedule'],
+  T0: [],
+};
+const COUNTDOWN_LABELS: Record<CountdownStage, string> = {
+  'T-120': '노트(next.md 새 줄) · 공개 export 누수 · 체크리스트 게이트 모의',
+  'T-60': 'preflight(컷 트리 고정) ⊕ node-b 게이트 자리(디스패처 정지 · podTarget 감축)',
+  '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;
+}

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

@@ -15,6 +15,7 @@ import { releaseRunUniverse } from './release-universe.js';
 import { baseVersion, isStableVersion, nextPrereleaseVersion, type PrereleaseKind } from './release-version.js';
 import { publishAtError } from './publish-at.js';
 import { checkGateExecutorChoice, type GateExecutor } from './gate-executor.js';
+import { readReleaseGateRehearsal, readReleaseOpsPolicy, selectReleaseGateMethod } from './gate-method.js';
 
 const VERSION = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
 const GRAPH = join(import.meta.dir, '../../graphs/release/release-loop.yaml');
@@ -55,6 +56,8 @@ export interface ReleaseRunInput extends ReleaseLoopConfig {
   gatePodPool?: string;
   /** GATE-HOST-EXECUTOR — absent = pod (today's input, byte-identical); `host` sweeps on `gateRemote`. */
   gateExecutor?: GateExecutor;
+  /** RELEASE-POLICY-PACK — gate source/image identity follows the selected cut commit. */
+  gateImagePin?: 'cut-commit';
   forceFreeze?: boolean;
   publishAt?: string;
   /** RELEASE-BRANCH: version-release cuts release/<v> from main HEAD and bumps only the branch. */
@@ -65,6 +68,7 @@ export interface UnattendedReleaseDeps {
   ledgerRoot?: string;
   config?: ReleaseLoopConfig;
   configPath?: string;
+  policyPath?: string;
   graph?: (path: string, options: { input: ReleaseRunInput; pinChildUniverse?: boolean; deps?: { root?: string } }) => Promise<GraphRunState>;
   checklist?: (version: string) => Pick<ReturnType<typeof cutChecklistGate>, 'ok' | 'red' | 'undecided' | 'blocked'>;
   freezeRoot?: string;
@@ -125,20 +129,27 @@ export interface GateExecutorRequest { executor?: string; host?: string }
 export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDeps = {}, cutCommit?: string, gate: GateExecutorRequest = {}): ReleaseRunInput {
   const config = deps.config ?? releaseLoopConfig(deps.configPath);
   if (gate.executor === undefined && gate.host !== undefined) throw new Error('--gate-host requires --gate-executor host');
-  const choice = gate.executor === undefined ? undefined
-    : checkGateExecutorChoice(gate.executor, gate.executor === 'host' ? gate.host ?? config.gateRemote : gate.host);
-  const pool = config.gatePodPool;
-  const hasPool = typeof pool === 'string' && !!pool.trim();
-  // The pod executor (the default) stays fail-closed on a missing pool; an explicit host executor does not need one.
-  if (choice?.executor !== 'host' && !hasPool) throw new Error('release.loop.gatePodPool is required before graph execution');
   const previousVersion = latestPublishedPreviousVersion(baseVersion(version), deps.ledgerRoot);
+  const rehearsal = readReleaseGateRehearsal(deps.ledgerRoot ?? releaseLedgerRoot(), previousVersion);
+  const method = selectReleaseGateMethod({ policy: readReleaseOpsPolicy(deps.policyPath), targetVersion: baseVersion(version),
+    configuredPool: config.gatePodPool, rehearsal });
+  debug.log('release.run', 'gate-method-selected', { version, previousVersion, ...method });
+  const requested = gate.executor === undefined ? undefined
+    : checkGateExecutorChoice(gate.executor, gate.executor === 'host' ? gate.host ?? config.gateRemote : gate.host);
+  if (requested && requested.executor !== method.executor) {
+    debug.log('release.run', 'gate-method-override-rejected', { version, requested: requested.executor, selected: method.executor, decision: method.decision });
+    throw new Error(`gate executor ${requested.executor} conflicts with release policy ${method.executor}`);
+  }
+  if (method.executor === 'pod' && !method.pool) throw new Error('release.loop.gatePodPool is required by release ops policy');
   return {
     ...config,
     version, previousVersion,
     ...(cutCommit !== undefined ? { cutCommit } : {}),
-    ...(hasPool ? { gatePodPool: pool.trim() } : {}),
-    ...(choice ? { gateExecutor: choice.executor } : {}),
-    ...(choice?.host ? { gateRemote: choice.host } : {}),
+    ...(method.executor === 'pod' ? { gatePodPool: method.pool } : {}),
+    gateExecutor: method.executor,
+    gateImagePin: method.imagePin,
+    // A future policy may select host; only then can its validated host request reach this input.
+    ...(requested?.host ? { gateRemote: requested.host } : {}),
   };
 }
 

package/scripts/rhythm/daily.ts

@@ -5,7 +5,7 @@ import { Database } from 'bun:sqlite';
 import { dirname, join } from 'node:path';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
 import { listSchedules } from '../../src/release-loop/release-schedule.js';
-import { devVersion, listChecklist } from '../../src/release-loop/checklist.js';
+import { checklistDevVersion, devVersion, listChecklist } from '../../src/release-loop/checklist.js';
 import { DecisionLedger } from '../../src/decisions/decision-ledger.js';
 import { selectProact1Lite, type ProactSignals } from '../../src/decisions/proact1-lite.js';
 import { trafficTick, seatOfTree } from '../../src/loops/orchestrator/traffic.js';
@@ -21,6 +21,7 @@ import { BriefItemsLedger } from '../../src/briefing/brief-items.js';
 import { debug } from '../../src/debug/log.js';
 import { retroBriefingLines } from '../../src/retro/daily.js';
 import { dispatchCooAdmin } from '../../src/domains/coo-admin-tool.js';
+import { runLinearProgressSync, type ProgressSyncResult } from './linear-progress-sync.js';
 
 export type Section<T> = { status: 'ok'; value: T } | { status: 'unreadable'; reason: string };
 export type Landing = { title: string; seat: string; mergedAt: string; prNumber?: number };
@@ -542,6 +543,7 @@ export type DailyDeps = { now?: () => Date; root?: string; vaultRoot?: string |
   target?: { chatId: number; botToken: string };
   send?: (request: DailySendRequest) => DailySendConfirmation | null; receipt?: (key: string) => DeliveryReceipt;
   recordDelivery?: (text: string, kind: 'ops-report') => void;
+  linearProgressSync?: typeof runLinearProgressSync;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
   proactSignals?: () => Promise<ProactSignals>;
   proactPreviouslySuggested?: ReadonlySet<string>;
@@ -593,6 +595,8 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
     let sendError: string | null = null;
     let recordError: string | null = null;
     let newsState: string | null = null;
+    let linearProgress: ProgressSyncResult | undefined;
+    let linearProgressError: string | null = null;
     let enabled = deps.sendEnabled === true;
     if (deps.sendEnabled === undefined && options.stage === 'deliver' && !options.dryRun) {
       try { enabled = record(record(record(getUserConfig().raw.loops).rhythm).daily).send === true; }
@@ -613,11 +617,39 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
       deliveryState = delivery.deliveryState;
       if (resolved) newsState = sendNewsAfterReview(delivery, file, markdown, resolved, deps);
     }
+    if (options.stage === 'deliver' && !options.dryRun) {
+      try {
+        const dailyConfig = record(record(record(getUserConfig().raw.loops).rhythm).daily);
+        if (dailyConfig.linearProgressSync === true) {
+          const allowIssueIdentifiers = Array.isArray(dailyConfig.linearProgressIssueAllowlist)
+            ? dailyConfig.linearProgressIssueAllowlist.filter((value): value is string => typeof value === 'string') : [];
+          if (!allowIssueIdentifiers.length) {
+            linearProgressError = 'issue allowlist missing; no Linear comments sent';
+            if (deps.log) deps.log('loop.rhythm-daily', 'linear-progress-config-blocked', { reason: 'issue-allowlist-missing' });
+            else loopEvent('rhythm-daily', 'linear-progress-config-blocked', { reason: 'issue-allowlist-missing' });
+          } else {
+            linearProgress = await (deps.linearProgressSync ?? runLinearProgressSync)({ version: checklistDevVersion(devVersion()), now, root: deps.root,
+              apply: true, allowIssueIdentifiers,
+              log: (event, data) => deps.log ? deps.log('loop.rhythm-daily.linear-progress', event, data)
+                : loopEvent('rhythm-daily.linear-progress', event, data) });
+            if (linearProgress.failures.length) {
+              linearProgressError = `${linearProgress.failures.length} Linear summary failure(s); see loop.rhythm-daily.linear-progress logs`;
+            }
+          }
+        }
+      } catch (error) {
+        linearProgressError = shortReason(reasonOf(error));
+        if (deps.log) deps.log('loop.rhythm-daily', 'linear-progress-failed', { reason: linearProgressError });
+        else loopEvent('rhythm-daily', 'linear-progress-failed', { reason: linearProgressError });
+      }
+    }
     tick.sent = sent;
-    const status = vault.vaultFatal || Object.values(sections).includes('unreadable') ? 'degraded'
+    if (linearProgress) tick.linearProgress = linearProgress;
+    if (linearProgressError) tick.linearProgressError = linearProgressError;
+    const status = vault.vaultFatal || Object.values(sections).includes('unreadable') || !!linearProgressError ? 'degraded'
       : deliveryState === 'pending' ? 'pending'
       : ['sent', 'already-sent', 'receipt-sent'].includes(deliveryState) ? 'ok' : 'degraded';
-    const deliveryLine = `${options.stage} ${status} · target=${target} · ${deliveryState} · sent=${sent} · chars=${chars} · receipt=${receiptKey}${recordError ? ` · ${recordError}` : ''}${newsState ? ` · news=${newsState}` : ''}`;
+    const deliveryLine = `${options.stage} ${status} · target=${target} · ${deliveryState} · sent=${sent} · chars=${chars} · receipt=${receiptKey}${recordError ? ` · ${recordError}` : ''}${newsState ? ` · news=${newsState}` : ''}${linearProgressError ? ` · linear=${linearProgressError}` : ''}`;
     if (options.stage === 'deliver') {
       Object.assign(tick, { status, deliveryState, target, chars, receiptKey, deliveryLine, recordError });
       if (!options.dryRun) {
@@ -625,7 +657,7 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
         else loopEvent('rhythm-daily', 'tick', tick);
       }
     }
-    return { file, markdown, header, risks, sections, sent, ...vault, sendError, recordError, status, deliveryState, deliveryLine,
+    return { file, markdown, header, risks, sections, sent, ...vault, sendError, recordError, status, deliveryState, deliveryLine, linearProgress, linearProgressError,
       draftCloseSummary: undefined };
   }
   const safe = async <T>(fetch: () => Promise<T>): Promise<Section<T>> => {