elanous 0.2.19 → 0.2.21

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

@@ -2,9 +2,15 @@
 // 입력 = 게이트 로그 디렉토리(`<ledger>/release/<version>/gate-logs/cut`)의 `pod-*.json`.
 //   첫 판 샤드 = `pod-<n>.json` · 재시도 = 그 밖의 모든 `pod-*.json`(`-c<k>`·`-c<k>-file-<m>`·`-retry` …).
 // ⛔ 측정이 없으면 `measured:false` 로 표시한다 — 0 을 «잰 값»처럼 내지 않는다.
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+// ⭐ 기본 = 전 우주(LOGS-DEFAULT-ALL · 0.2.20) — 게이트는 실행 트리의 시험 우주(예: ⟨test:wt-release⟩
+//   `<tree>/.elanous-test/release/<v>/gate-logs/cut`)에 쌓인다. 운영 원장만 보면 0.2.19 판처럼
+//   «측정 없음»으로 오판한다. 그래서 버전 인자는 운영 원장 ⊕ 등록된 모든 우주(시험·파생 시험 포함)를
+//   본다 — 우주 열거는 `eln logs --all --include-test` 와 같은 레지스트리(`readLogInstanceScope`)다.
+//   좁히기는 opt-in `--prod-only`(종전 동작: `releaseLedgerRoot()` 하나).
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { releaseLedgerRoot } from '../../src/instance/resolve.js';
+import { readLogInstanceScope } from '../../src/mss/logging/instance-registry.js';
 
 export interface ShardTiming { name: string; min: number; files: number; plannedMin: number | null }
 
@@ -82,12 +88,94 @@ export function gateTiming(dir: string): GateTimingReport {
   };
 }
 
+/** 인자가 버전이 아니라 디렉토리인가 — 경로처럼 보이거나 실제로 있으면. */
+export function isGateLogDirArg(arg: string): boolean {
+  return arg.includes('/') || arg.startsWith('.') || existsSync(arg);
+}
+
 /** `<version>` 이면 원장 루트(`releaseLedgerRoot()`)의 `release/<version>/gate-logs/cut`, 경로처럼 보이면 그대로. */
 export function resolveGateLogDir(arg: string, ledgerRoot: string = releaseLedgerRoot()): string {
-  if (arg.includes('/') || arg.startsWith('.') || existsSync(arg)) return arg;
+  if (isGateLogDirArg(arg)) return arg;
   return join(ledgerRoot, 'release', arg, 'gate-logs', 'cut');
 }
 
+export interface GateLogCandidate { universe: string; dir: string }
+
+export interface GateLogScope {
+  /** 본 후보 원장 루트 수(물리 경로 dedup 뒤). */
+  roots: number;
+  /** 우주 레지스트리 — `read` 읽음 · `unreadable` 못 읽음(«등록 우주 0»이 아니라 «못 셈» — 운영 원장만 봤다)
+   *  · `skipped` `--prod-only` 라 안 읽음. */
+  registry: 'read' | 'unreadable' | 'skipped';
+  /** `--prod-only` 로 좁혔나. */
+  prodOnly: boolean;
+}
+
+export interface GateLogScopeDeps {
+  ledgerRoot?: string;
+  readInstances?: () => { instances: ReadonlyArray<{ name: string; stateDir: string }>; queryStatus: { registeredStores: boolean } };
+}
+
+function physical(path: string): string {
+  try { return realpathSync(path); } catch { return path; }
+}
+
+/** 버전의 게이트 로그 후보 — 운영 원장 루트(`releaseLedgerRoot()`) ⊕ 등록된 모든 우주.
+ *  물리 경로로 dedup 한다(`~/.monad` → `~/.elanous` 심링크가 같은 판을 두 번 세지 않게). */
+export function gateLogCandidates(
+  version: string,
+  opts: { prodOnly?: boolean } = {},
+  deps: GateLogScopeDeps = {},
+): { candidates: GateLogCandidate[]; scope: GateLogScope } {
+  const primary = deps.ledgerRoot ?? releaseLedgerRoot();
+  const roots: Array<{ universe: string; root: string }> = [{ universe: 'prod', root: primary }];
+  let registry: GateLogScope['registry'] = 'skipped';
+  if (!opts.prodOnly) {
+    const scope = (deps.readInstances ?? readLogInstanceScope)();
+    registry = scope.queryStatus.registeredStores ? 'read' : 'unreadable';
+    // 못 읽은 판의 부분 목록은 쓰지 않는다 — «운영만 봤다»는 표시와 실제 본 범위를 일치시킨다.
+    if (registry === 'read') for (const instance of scope.instances) roots.push({ universe: instance.name, root: instance.stateDir });
+  }
+  const seen = new Set<string>();
+  const candidates: GateLogCandidate[] = [];
+  for (const { universe, root } of roots) {
+    const key = physical(root);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    candidates.push({ universe, dir: resolveGateLogDir(version, root) });
+  }
+  return { candidates, scope: { roots: candidates.length, registry, prodOnly: opts.prodOnly === true } };
+}
+
+export interface GateTimingScan {
+  version: string;
+  scope: GateLogScope & { found: number };
+  /** pod-*.json 디렉토리가 «있는» 우주만 — 판마다 따로 낸다(서로 다른 판의 샤드를 섞지 않는다). */
+  reports: Array<GateTimingReport & { universe: string }>;
+}
+
+/** 버전 인자의 기본 동선 — 후보 우주 전부에서 게이트 로그 디렉토리가 있는 것만 보고한다. */
+export function scanGateTiming(version: string, opts: { prodOnly?: boolean } = {}, deps: GateLogScopeDeps = {}): GateTimingScan {
+  const { candidates, scope } = gateLogCandidates(version, opts, deps);
+  const reports = candidates
+    .filter(({ dir }) => existsSync(dir) && statSync(dir).isDirectory())
+    .map(({ universe, dir }) => ({ universe, ...gateTiming(dir) }));
+  return { version, scope: { ...scope, found: reports.length }, reports };
+}
+
+export function formatGateTimingScan(scan: GateTimingScan): string {
+  const s = scan.scope;
+  const head = `게이트 로그 ${scan.version} — ${s.prodOnly ? '운영 원장만(--prod-only)' : '전 우주'} · 본 원장 루트 ${s.roots}개 · 로그 있는 우주 ${s.found}개`
+    + (s.registry === 'unreadable' ? ' · ⚠ 우주 레지스트리를 못 읽었다(운영만 봤다 — «없다»가 아니라 «못 셈»)' : '');
+  if (scan.reports.length === 0) {
+    const where = s.registry === 'read' ? '본 우주 어디에도' : '운영 원장에';
+    const unknown = s.registry === 'unreadable' ? ' · 시험 우주는 못 셌다(있을 수 있다)' : '';
+    return [head, `  게이트 시간 — 측정 없음 · ${where} release/${scan.version}/gate-logs/cut 가 없다${unknown}`,
+      ...(s.prodOnly ? ['  (--prod-only 를 빼면 시험 우주까지 본다)'] : [])].join('\n');
+  }
+  return [head, ...scan.reports.map((r) => `⟨${r.universe}⟩ ${formatGateTiming(r)}`)].join('\n');
+}
+
 export function formatGateTiming(r: GateTimingReport): string {
   if (!r.measured) {
     return [`게이트 시간 — 측정 없음 (${r.dir})`, '  pod-*.json 에 durationMs 가 하나도 없다 · 0 은 «잰 값»이 아니다',
@@ -106,15 +194,36 @@ export function formatGateTiming(r: GateTimingReport): string {
   return lines.join('\n');
 }
 
+export const GATE_TIMING_USAGE = [
+  '기본 = 전 우주 — 운영 원장 ⊕ 시험 우주(⟨test:wt-release⟩ 등)의 게이트 로그를 옵션 없이 함께 읽는다',
+  '사용법: bun scripts/release-loop/gate-timing.ts <version|dir> [--json] [--prod-only]',
+  '  <version>    등록된 모든 우주의 release/<version>/gate-logs/cut 를 우주마다 따로 보고한다(⟨우주⟩ 태그)',
+  '  <dir>        그 디렉토리 하나만 (종전과 같은 단일 보고)',
+  '  --prod-only  운영 원장 루트(releaseLedgerRoot)만 본다 — 종전 기본',
+  '  --json       구조화 출력 (<version> 이면 { version, scope, reports[] })',
+].join('\n');
+
+const KNOWN_FLAGS = new Set(['--json', '--prod-only', '--help', '-h']);
+
 if (import.meta.main) {
   const args = process.argv.slice(2);
+  if (args.includes('--help') || args.includes('-h')) { console.log(GATE_TIMING_USAGE); process.exit(0); }
+  const unknown = args.filter((a) => a.startsWith('-') && !KNOWN_FLAGS.has(a));
+  if (unknown.length) { console.error(`알 수 없는 옵션: ${unknown.join(' ')}\n${GATE_TIMING_USAGE}`); process.exit(2); }
   const json = args.includes('--json');
-  const target = args.find((a) => !a.startsWith('--'));
+  const prodOnly = args.includes('--prod-only');
+  const target = args.find((a) => !a.startsWith('-'));
   if (!target) {
-    console.error('사용법: bun scripts/release-loop/gate-timing.ts <version|dir> [--json]');
+    console.error(GATE_TIMING_USAGE);
     process.exit(2);
   }
-  const report = gateTiming(resolveGateLogDir(target));
-  console.log(json ? JSON.stringify(report, null, 2) : formatGateTiming(report));
-  if (!report.measured) process.exit(1);
+  if (isGateLogDirArg(target)) {
+    const report = gateTiming(target);
+    console.log(json ? JSON.stringify(report, null, 2) : formatGateTiming(report));
+    if (!report.measured) process.exit(1);
+  } else {
+    const scan = scanGateTiming(target, { prodOnly });
+    console.log(json ? JSON.stringify(scan, null, 2) : formatGateTimingScan(scan));
+    if (!scan.reports.some((r) => r.measured)) process.exit(1);
+  }
 }

package/scripts/release-loop/preflight.ts

@@ -27,7 +27,7 @@ export interface PreflightResult {
   blockers: number;
   warnings: number;
   findings: PreflightFinding[];
-  schedule: { cutAt: string; landBy: string | null; publishAt: string | null; publishAtSource: 'option' | 'cadence' | null } | null;
+  schedule: { cutAt: string; landBy: string | null; publishAt: string | null; publishAtSource: 'option' | 'schedule' | 'cadence' | null } | null;
   /** The immediately previous release (by version order) whose gate is compared. */
   previousVersion: string | null;
   gateMeasure: GateMeasure | null;
@@ -206,15 +206,17 @@ export async function releasePreflight(version: string, deps: PreflightDeps = {}
     findings.push({ level: 'warn', check: 'schedule', message: `판 일정 없음 — elanous release schedule set --version ${version} --cut-at <iso> --land-by <iso>` });
   } else {
     const cut = Date.parse(schedule.cutAt);
-    const publishAt = deps.publishAt ? new Date(deps.publishAt).toISOString() : cadencePublishAt(schedule.cutAt);
-    scheduleOut = { cutAt: schedule.cutAt, landBy: schedule.landBy, publishAt, publishAtSource: deps.publishAt ? 'option' : 'cadence' };
+    // --publish-at > the stored schedule publish time (`release schedule set --publish-at`) > the October cadence.
+    const publishAtSource = deps.publishAt ? 'option' : schedule.publishAt ? 'schedule' : 'cadence';
+    const publishAt = deps.publishAt ? new Date(deps.publishAt).toISOString() : schedule.publishAt ?? cadencePublishAt(schedule.cutAt);
+    scheduleOut = { cutAt: schedule.cutAt, landBy: schedule.landBy, publishAt, publishAtSource };
     if (!schedule.landBy) findings.push({ level: 'warn', check: 'schedule', message: `착지 마감 없음 — 컷 ${formatKst(schedule.cutAt)} · 규칙은 컷 − 30분` });
     else if (cut - Date.parse(schedule.landBy) < 30 * 60_000) findings.push({ level: 'warn', check: 'schedule', message: `착지 마감 ${formatKst(schedule.landBy)} 이 컷 − 30분보다 늦다(컷 ${formatKst(schedule.cutAt)})` });
     else findings.push({ level: 'ok', check: 'schedule', message: `일정 — 착지 마감 ${formatKst(schedule.landBy)} · 컷 ${formatKst(schedule.cutAt)}` });
     gateMeasure = previousVersion ? releaseGateMeasure({ version: previousVersion }, deps.graphRunsRoot) : null;
     if (!gateMeasure) fallbackGateMeasure = releaseGateMeasure({ below: version }, deps.graphRunsRoot);
     const windowSeconds = Math.round((Date.parse(publishAt) - cut) / 1000);
-    const publishLabel = `발행 ${formatKst(publishAt)}${deps.publishAt ? '' : '(기본: 판 주기 07·18시 · --publish-at 로 바꾼다)'}`;
+    const publishLabel = `발행 ${formatKst(publishAt)}${publishAtSource === 'cadence' ? '(기본: 판 주기 07·18시 · --publish-at 로 바꾼다)' : publishAtSource === 'schedule' ? '(판 일정)' : ''}`;
     if (!gateMeasure) {
       const fallback = fallbackGateMeasure ? ` · 참고: 가장 최근 실측은 ${fallbackGateMeasure.version} 게이트 ${minutes(fallbackGateMeasure.gateSeconds)}(직전 판 아님)` : ' · 게이트 실측 없음';
       findings.push({ level: 'warn', check: 'schedule', message: `직전 판${previousVersion ? `(${previousVersion})` : ''} 실측 없음 — 컷→${publishLabel} 창 ${minutes(windowSeconds)}${fallback}` });

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

@@ -0,0 +1,141 @@
+// PUBLISH-TIME-FROM-GATE (0.2.20 P1) — 발행 시각을 사람이 고르지 않고 «실측»에서 제안한다.
+//
+// 🩸 계기: 판 일정이 «컷 18:45 → 발행 20:00(75분)»처럼 잡혔는데 게이트 하나가 60분+ · 게이트 뒤 노드가 ~40분이다.
+// ⭐ 자 = 최근 N(기본 3)개 완료된(`status: done` · 안정 버전) release-loop 런마다 «런 시작(≈ 컷) → 발행 노드 끝»을 재고 중앙값을 쓴다.
+//    창은 «최근 N개 완료 런»으로 고정한다 — 못 잰 런 대신 더 옛 런을 끌어오지 않는다(옛 판이 지금 실측인 척 섞이지 않게).
+//    런 시작 = 컷이다(예약 시작이 컷에 런을 띄운다) — preflight 의 «런 시작→발행 노드»와 같은 기점.
+// ⛔ 못 잰 런은 0 으로 세지 않는다 — 건너뛰고 `skipped` 에 이유와 함께 남긴다. 표본이 0 이면 제안도 경고도 «없음»이다.
+//
+// 시각 출처(우선순위):
+//   ① `nodes[]` 의 `startedAt`·`endedAt`(0.2.19~ 원장이 노드 시각을 적는다)
+//   ② 옛 원장 — `<runId>.json.contexts/<n>.json` 의 mtime(노드 n 이 «시작할 때» 쓰인다) ⇒ 발행 노드 끝 ≈ 다음 노드 시작.
+//      (preflight `releaseGateMeasure` 와 같은 근사 · 그 파일의 nodeId 가 path 와 맞을 때만 쓴다)
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { releaseLedgerRoot } from '../../src/instance/resolve.js';
+
+export const DEFAULT_PUBLISH_SAMPLE = 3;
+/** 중앙값 위에 얹는 여유(분). 제안은 그 뒤 5분 단위로 올린다. */
+export const DEFAULT_PUBLISH_MARGIN_MIN = 10;
+
+const STABLE = /^\d+\.\d+\.\d+$/;
+
+export interface PublishDurationSample {
+  version: string;
+  runId: string;
+  startedAt: string;
+  /** 런 시작 → 발행 노드 끝(초). */
+  seconds: number;
+  source: 'nodes' | 'contexts';
+}
+
+export interface PublishWindowMeasure {
+  root: string;
+  /** 중앙값에 쓴 표본(최신 먼저 · 최근 sample 개 완료 런 중 잰 것). */
+  samples: PublishDurationSample[];
+  /** 창 안의 완료 런이었지만 못 잰 것 — «0»이 아니라 «못 셈». */
+  skipped: Array<{ runId: string; version: string; why: string }>;
+  /** 표본이 없으면 null(측정 없음). */
+  medianSeconds: number | null;
+}
+
+interface RunState {
+  runId?: string;
+  status?: string;
+  startedAt?: string;
+  path?: unknown;
+  input?: { version?: string };
+  nodes?: Array<{ nodeId?: string; startedAt?: string; endedAt?: string }>;
+}
+
+export function defaultReleaseGraphRunsRoot(ledgerRoot: string = releaseLedgerRoot()): string {
+  return join(ledgerRoot, 'graph-runs', 'release-loop');
+}
+
+function median(xs: number[]): number {
+  const s = [...xs].sort((a, b) => a - b);
+  const m = s.length >> 1;
+  return s.length % 2 ? s[m]! : (s[m - 1]! + s[m]!) / 2;
+}
+
+function publishEndMs(root: string, file: string, state: RunState, path: string[]): { ms: number; source: PublishDurationSample['source'] } | null {
+  const node = Array.isArray(state.nodes) ? state.nodes.find((n) => n?.nodeId === 'publish') : undefined;
+  const ended = node?.endedAt ? Date.parse(node.endedAt) : NaN;
+  if (Number.isFinite(ended)) return { ms: ended, source: 'nodes' };
+  const index = path.indexOf('publish');
+  const contexts = join(root, `${file}.contexts`);
+  if (index < 0 || index + 1 >= path.length || !existsSync(contexts)) return null;
+  const ctxPath = join(contexts, `${index + 2}.json`); // contexts/<n>.json 은 1부터 — 발행 다음 노드의 시작
+  try {
+    const ctx = JSON.parse(readFileSync(ctxPath, 'utf8')) as { nodeId?: string };
+    return ctx.nodeId === path[index + 1] ? { ms: statSync(ctxPath).mtimeMs, source: 'contexts' } : null;
+  } catch { return null; }
+}
+
+/** 최근 `sample` 개 완료 release-loop 런의 «런 시작 → 발행 노드 끝» 중앙값. */
+export function measurePublishWindow(opts: { root?: string; sample?: number } = {}): PublishWindowMeasure {
+  const root = opts.root ?? defaultReleaseGraphRunsRoot();
+  const sample = Math.max(1, opts.sample ?? DEFAULT_PUBLISH_SAMPLE);
+  const runs: Array<{ file: string; state: RunState; version: string; startedAt: string; startMs: number; path: string[] | null }> = [];
+  if (existsSync(root)) {
+    for (const file of readdirSync(root)) {
+      if (!file.endsWith('.json') || file.includes('.decision')) continue;
+      try {
+        const state = JSON.parse(readFileSync(join(root, file), 'utf8')) as RunState;
+        const v = state.input?.version;
+        if (state.status !== 'done' || typeof v !== 'string' || !STABLE.test(v)) continue;
+        // A completed stable run with a broken start or path is still «a run in the window» — it lands in `skipped`, not nowhere.
+        const startedAt = typeof state.startedAt === 'string' ? state.startedAt : '';
+        runs.push({ file, state, version: v, startedAt, startMs: Date.parse(startedAt), path: Array.isArray(state.path) ? state.path.filter((p): p is string => typeof p === 'string') : null });
+      } catch { /* 못 읽은 원장은 표본이 아니다 */ }
+    }
+  }
+  // Newest first; a run without a readable start sorts by its file mtime so it still takes its place in the window.
+  const order = (run: (typeof runs)[number]) => (Number.isFinite(run.startMs) ? run.startMs : statSync(join(root, run.file)).mtimeMs);
+  runs.sort((a, b) => order(b) - order(a));
+  const samples: PublishDurationSample[] = [];
+  const skipped: PublishWindowMeasure['skipped'] = [];
+  for (const run of runs.slice(0, sample)) {
+    const runId = run.state.runId ?? run.file.slice(0, -5);
+    if (!Number.isFinite(run.startMs)) { skipped.push({ runId, version: run.version, why: 'startedAt 없음·무효' }); continue; }
+    if (!run.path) { skipped.push({ runId, version: run.version, why: 'path 가 배열이 아님' }); continue; }
+    if (!run.path.includes('publish')) { skipped.push({ runId, version: run.version, why: 'path 에 publish 노드 없음' }); continue; }
+    const end = publishEndMs(root, run.file, run.state, run.path);
+    const start = run.startMs;
+    if (!end || end.ms < start) { skipped.push({ runId, version: run.version, why: '발행 노드 끝 시각을 못 읽음' }); continue; }
+    samples.push({ version: run.version, runId, startedAt: run.startedAt, seconds: Math.round((end.ms - start) / 1000), source: end.source });
+  }
+  return { root, samples, skipped, medianSeconds: samples.length ? Math.round(median(samples.map((s) => s.seconds))) : null };
+}
+
+/** 제안 발행 시각 = 컷 + 중앙값 + 여유, 5분 단위로 올림. 측정이 없으면 null. */
+export function proposePublishAt(cutAt: string, measure: PublishWindowMeasure, marginMin = DEFAULT_PUBLISH_MARGIN_MIN): string | null {
+  if (measure.medianSeconds === null) return null;
+  const raw = Date.parse(cutAt) + measure.medianSeconds * 1000 + marginMin * 60_000;
+  const step = 5 * 60_000;
+  return new Date(Math.ceil(raw / step) * step).toISOString();
+}
+
+export function kstHourMinute(iso: string): string {
+  return new Intl.DateTimeFormat('en-GB', { timeZone: 'Asia/Seoul', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).format(new Date(iso));
+}
+
+const mins = (seconds: number) => Math.round(seconds / 60);
+
+/** 발행 시각이 실측 중앙값보다 짧으면 한 줄 경고, 아니면 null(측정 없음도 null — 경고할 자가 없다). */
+export function publishWindowWarning(cutAt: string, publishAt: string, measure: PublishWindowMeasure, marginMin = DEFAULT_PUBLISH_MARGIN_MIN): string | null {
+  if (measure.medianSeconds === null) return null;
+  const windowSeconds = (Date.parse(publishAt) - Date.parse(cutAt)) / 1000;
+  if (windowSeconds >= measure.medianSeconds) return null;
+  const proposed = proposePublishAt(cutAt, measure, marginMin)!;
+  return `⚠️ 발행 시각이 실측 중앙값(${mins(measure.medianSeconds)}분)보다 짧다 — 컷→발행 ${mins(windowSeconds)}분 · 제안: ${kstHourMinute(proposed)} KST (최근 ${measure.samples.length}판 ${measure.samples.map((s) => s.version).join('·')} · +여유 ${marginMin}분)`;
+}
+
+/** `release schedule show` 의 한 줄 — 제안 발행 시각 또는 «측정 없음». */
+export function formatPublishProposal(cutAt: string, measure: PublishWindowMeasure, marginMin = DEFAULT_PUBLISH_MARGIN_MIN): string {
+  const proposed = proposePublishAt(cutAt, measure, marginMin);
+  if (!proposed || measure.medianSeconds === null) {
+    return `발행 제안 — 실측 없음(완료된 release-loop 런에서 발행 노드 시각을 못 읽었다 · 본 곳 ${measure.root}${measure.skipped.length ? ` · 못 잰 런 ${measure.skipped.length}` : ''})`;
+  }
+  return `발행 제안 ${kstHourMinute(proposed)} KST — 컷 + 실측 중앙값 ${mins(measure.medianSeconds)}분(최근 ${measure.samples.length}판 ${measure.samples.map((s) => `${s.version} ${mins(s.seconds)}분`).join(' · ')}) + 여유 ${marginMin}분`;
+}

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

@@ -114,10 +114,7 @@ export function recordDocsFollow(root: string, manifest: ReleaseManifest, items:
   const journal = join(root, 'seat-requests', 'requests.jsonl');
   withSeatRequestLedgerLock(journal, () => {
     const known = new Set(listSeatRequests(root).map((row) => row.key));
-    const missing = [
-      ...report.pending.map((item) => ({ id: item.id, text: `문서 반영 대기 목록 v${manifest.version} · ${item.id}: ${item.missing.join(', ')} — 착지 ${item.sha}; docs·홈 실측 뒤 닫기` })),
-      ...report.unassessed.map((id) => ({ id, text: `문서 반영 대기 목록 v${manifest.version} · ${id}: 착지·green·EXPOSE-RUBRIC 근거 미판정 — 확인 전 공개 문면 금지` })),
-    ];
+    const missing = report.pending.map((item) => ({ id: item.id, text: `문서 반영 대기 목록 v${manifest.version} · ${item.id}: ${item.missing.join(', ')} — 착지 ${item.sha}; docs·홈 실측 뒤 닫기` }));
     const rows = missing.filter((item) => !known.has(`docs-follow:${manifest.version}:${item.id}`)).map((item) => ({
       key: `docs-follow:${manifest.version}:${item.id}`, seat: 'MK', status: 'queued' as const,
       text: item.text, queuedAt: now.toISOString(), ref: `release:${manifest.version}:docs-follow`,

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

@@ -0,0 +1,38 @@
+// RELEASE-LEDGER-UNIVERSE (0.2.20 P0): the release run decides its universe ONCE at the entry and every node
+// subprocess is pinned to it (graph runner `pinChildUniverse` stamps ELANOUS_STATE_DIR = this root). Without it a node
+// launched as `bun scripts/release-loop/*-node.ts` from a non-leader tree (wt-release) re-resolved the tree-derived test
+// universe and wrote manifest·story·gate logs to ⟨test:wt-release⟩ while the run ledger was prod (10-07).
+import { getElanousConfigDirOverride } from '../../src/elanous-config-dir.js';
+import { debug } from '../../src/debug/log.js';
+import { effectiveInstanceRoot, normRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
+
+export interface ReleaseUniverseDeps {
+  /** An injected ledger root (tests, or a caller that already decided) is used as is. */
+  root?: string;
+  override?: () => string | undefined;
+  prodRoot?: () => string;
+  effectiveRoot?: () => string;
+}
+
+/**
+ * The single universe of a release run. An explicit `--config-dir` selects its own universe; otherwise the release
+ * ledger is the machine-wide prod root, and a process that itself resolved elsewhere (a source tree without a stamp)
+ * is refused before any node starts — its own logs would land in a different universe from its nodes.
+ */
+export function releaseRunUniverse(deps: ReleaseUniverseDeps = {}): string {
+  if (deps.root) return deps.root;
+  const override = (deps.override ?? getElanousConfigDirOverride)();
+  if (override) {
+    const root = (deps.effectiveRoot ?? effectiveInstanceRoot)();
+    debug.log('release.run', 'universe', { root, layer: 'explicit-flag' });
+    return root;
+  }
+  const prod = normRoot((deps.prodRoot ?? prodInstanceRoot)());
+  const parent = normRoot((deps.effectiveRoot ?? effectiveInstanceRoot)());
+  if (parent !== prod) {
+    debug.log('release.run', 'universe-refused', { parent, prod });
+    throw new Error(`release run refused: this process resolves to ${parent}, not the release ledger universe ${prod} — its nodes would split ledgers and logs across universes. Run the installed \`elanous\` or pass \`--config-dir ${prod}\``);
+  }
+  debug.log('release.run', 'universe', { root: prod, layer: 'prod' });
+  return prod;
+}

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

@@ -7,6 +7,7 @@ import { join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { lastJsonObject, runGraph, type GraphRunState } from '../../src/graph-runner/runner.js';
+import { releaseRunUniverse } from './release-universe.js';
 import { isReleaseVersion } from './release-version.js';
 import { changedFilesBetween, clearPartialPlan, planPartialRegate, writePartialPlan } from './gate-partial.js';
 
@@ -165,10 +166,12 @@ 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 }> {
   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 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, ...(deps.root || deps.runBash ? { deps: { ...(deps.root ? { root: deps.root } : {}), ...(deps.runBash ? { runBash: deps.runBash } : {}) } } : {}) });
+  const state = await (deps.graph ?? runGraph)(graphPath, { resumeRunId: opts.runId, fromNodeId: opts.from, pinChildUniverse: true, deps: { root: deps.root, ...(deps.runBash ? { runBash: deps.runBash } : {}) } });
   return { tip, partial, state };
 }

package/scripts/release-loop/shard-plan.ts

@@ -1,15 +1,60 @@
-import { readdirSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 
 /** Plan weights for a Pod sweep: wall-scaled when the previous cut recorded shard wall times, junit seconds otherwise. */
-export function planDurations(durationSource: string | undefined): { durations: Map<string, number>; wall?: { shards: number; scaledFiles: number } } {
+export function planDurations(durationSource: string | undefined): { durations: Map<string, number>; wall?: { shards: number; scaledFiles: number }; fallback?: string } {
   if (!durationSource) return { durations: new Map() };
-  const junit = readFileDurations(durationSource);
-  const wall = readFileWallWeights(durationSource, junit);
+  const primary = planDurationsFrom(durationSource);
+  if (primary.durations.size) return primary;
+  // GATE-PLAN-TIMINGS: the baseline cut left no reports (0.2.20: baseline 0.2.19 was gated from another universe, so
+  // all 5,585 files were «unknown», planned 3.9 min, measured 13–20 min). Use the most recent sibling cut instead.
+  const fallback = latestSiblingCutDir(durationSource);
+  if (!fallback) {
+    debug.log('release-loop.gate', 'plan-duration-fallback', { source: durationSource, fallback: null });
+    return primary;
+  }
+  const result = planDurationsFrom(fallback);
+  debug.log('release-loop.gate', 'plan-duration-fallback', { source: durationSource, fallback, files: result.durations.size, wall: !!result.wall });
+  return result.durations.size ? { ...result, fallback } : primary;
+}
+
+function planDurationsFrom(dir: string): { durations: Map<string, number>; wall?: { shards: number; scaledFiles: number } } {
+  const junit = readFileDurations(dir);
+  const wall = readFileWallWeights(dir, junit);
   return wall ? { durations: wall.weights, wall: { shards: wall.shards, scaledFiles: wall.scaledFiles } } : { durations: junit };
 }
 
+/**
+ * For a `<root>/<version>/<a>/<b>` duration source (the gate passes `<ledger>/release/<baseline>/gate-logs/cut`), the
+ * sibling `<root>/<other>/<a>/<b>` directory whose newest `*.junit.xml` is the most recent — «the latest gate». The
+ * source itself is skipped. Undefined when the path is too shallow or no sibling holds a junit report.
+ */
+export function latestSiblingCutDir(durationSource: string): string | undefined {
+  const source = resolve(durationSource);
+  const b = basename(source);
+  const a = basename(dirname(source));
+  const root = dirname(dirname(dirname(source)));
+  if (!a || !b || root === dirname(dirname(source))) return undefined;
+  let versions: string[];
+  try { versions = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name); }
+  catch { return undefined; }
+  let best: { dir: string; mtimeMs: number } | undefined;
+  for (const version of versions.sort()) {
+    const dir = join(root, version, a, b);
+    if (dir === source) continue;
+    let newest = -1;
+    try {
+      for (const name of readdirSync(dir)) {
+        if (!name.endsWith('.junit.xml')) continue;
+        try { newest = Math.max(newest, statSync(join(dir, name)).mtimeMs); } catch { /* vanished mid-scan */ }
+      }
+    } catch { continue; }
+    if (newest >= 0 && (!best || newest > best.mtimeMs)) best = { dir, mtimeMs: newest };
+  }
+  return best?.dir;
+}
+
 /** Observation for GATE-PLAN-WALLTIME, emitted once the shards are planned so `maxPlannedMin` is the heaviest shard. */
 export function logPlanWalltime(wall: { shards: number; scaledFiles: number } | undefined, shards: ReadonlyArray<{ plannedSeconds: number }>): void {
   if (!wall) return;

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

@@ -9,6 +9,7 @@ import { getSchedule } from '../../src/release-loop/release-schedule.js';
 import { isLandingFreezeRefusal, readLandingFreeze, LandingFrozenError } from '../../src/release-loop/landing-freeze.js';
 import { debug } from '../../src/debug/log.js';
 import { runGraph, type GraphRunState } from '../../src/graph-runner/runner.js';
+import { releaseRunUniverse } from './release-universe.js';
 import { baseVersion, isStableVersion, nextPrereleaseVersion, type PrereleaseKind } from './release-version.js';
 
 const VERSION = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
@@ -18,7 +19,12 @@ export interface ReleaseLoopConfig {
   gatePodPool?: string;
   gatePodBunCache?: string;
   gatePodShards?: number;
+  /** GATE-TIMEOUT-HEAL — the per-shard deadline floor; each shard gets planned × 1.5 above it (capped). */
   gatePodShardTimeoutSeconds?: number;
+  /** GATE-INSTALL-CACHE — concurrent `bun install`s per gate node (default 4 · 0 = off). */
+  gatePodInstallSlots?: number;
+  /** GATE-MEM-ADMIT — seconds a gate shard waits for pool admission (memory headroom) before launching anyway with `admission-timeout` (default 300 · 0 = off). */
+  gatePodAdmissionWaitSeconds?: number;
   /** GATE-SPEED A3①: gate shard Pod CPU — `2` (request = limit) or `{ request, limit }`. Omitted = request 1 / limit 4. */
   gatePodCpu?: number | string | { request?: number | string; limit?: number | string };
   gateRemote?: string;
@@ -42,7 +48,7 @@ export interface UnattendedReleaseDeps {
   ledgerRoot?: string;
   config?: ReleaseLoopConfig;
   configPath?: string;
-  graph?: (path: string, options: { input: ReleaseRunInput }) => Promise<GraphRunState>;
+  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;
   /** Names already taken for prerelease numbering (remote release branches and tags). */
@@ -142,7 +148,9 @@ export async function runUnattendedRelease(
   }
   const beforeGraph = readLandingFreeze(deps.freezeRoot);
   if (beforeGraph && !opts.forceFreeze) throw new LandingFrozenError(beforeGraph);
-  const state = await (deps.graph ?? runGraph)(GRAPH, { input });
+  // RELEASE-LEDGER-UNIVERSE: one universe for the run ledger, the release ledger and every node subprocess.
+  const root = releaseRunUniverse({ root: deps.ledgerRoot });
+  const state = await (deps.graph ?? runGraph)(GRAPH, { input, pinChildUniverse: true, deps: { root } });
   // A freeze switched on while the graph ran stops gate or publish inside it. Only a failed gate/publish node whose own
   // record is the freeze refusal is reported as the freeze; any other failure keeps its own reason.
   if (state.status === 'failed' && !opts.forceFreeze) {

package/scripts/release-story/draft.ts

@@ -55,7 +55,7 @@ function userFacingLines(markdown: string): { lines: string[]; internalDropped:
 }
 
 function firstPhrase(title: string): string {
-  let quote: '»' | '"' | '`' | undefined;
+  let quote: '»' | '"' | '`' | '”' | '’' | '」' | undefined;
   let angleStart = -1;
   for (let i = 0; i < title.length; i++) {
     const char = title[i]!;
@@ -64,6 +64,10 @@ function firstPhrase(title: string): string {
       continue;
     }
     if (char === '«') { quote = '»'; angleStart = i; continue; }
+    if (char === '“') { quote = '”'; continue; }
+    // 여는 ‘ 는 생략 부호로 안 쓰이니 짝을 기다린다 — ASCII ' 는 한국어 생략 부호라 짝으로 보지 않는다.
+    if (char === '‘') { quote = '’'; continue; }
+    if (char === '「') { quote = '」'; continue; }
     if (char === '"' || char === '`') { quote = char; continue; }
     if (/[:：]/.test(char) || (/[—·–]/.test(char) && /\s/.test(title[i - 1] ?? '') && /\s/.test(title[i + 1] ?? ''))) {
       return title.slice(0, i).trim();

package/scripts/retro/shadow-compare.ts

@@ -0,0 +1,71 @@
+#!/usr/bin/env bun
+/**
+ * RETRO-DAILY 그림자 대조 — 매일 회고 그래프를 «정답지»(RFC §0 다섯 반복 문제) 위에서 돌려 맞혔는지 본다.
+ *
+ *   bun scripts/retro/shadow-compare.ts [--facts <facts.json>] [--key <answer-key.json>] [--json]
+ *
+ * 기본 입력 = test/fixtures/retro/ 의 10-07 사실 ⊕ 정답지. 그래프는 임시 우주(mkdtemp)에서 shadow 로만 돈다 —
+ * 운영 회고 파일·체크리스트·메시지 어느 것도 건드리지 않는다. 놓친 주제가 있으면 exit 1.
+ */
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { runGraph } from '../../src/graph-runner/runner.js';
+import { retroDayFile } from '../../src/retro/daily.js';
+
+const repo = resolve(import.meta.dir, '..', '..');
+export const RETRO_DAILY_GRAPH = join(repo, 'graphs', 'retro', 'daily.yaml');
+export const DEFAULT_FACTS = join(repo, 'test', 'fixtures', 'retro', 'rfc0-2026-10-07-facts.json');
+export const DEFAULT_KEY = join(repo, 'test', 'fixtures', 'retro', 'rfc0-answer-key.json');
+
+type Theme = { theme: string; title: string; recurring: boolean; reBrokeAfterGreen: boolean; rank: number };
+type Key = { day: string; greenCells?: unknown[]; expected: { theme: string; title: string; reBrokeAfterGreen?: boolean }[]; notRecurring?: string[] };
+export type ShadowComparison = {
+  ok: boolean; status: string; day: string; detected: string[]; missed: string[]; falsePositives: string[];
+  reBrokeMismatch: string[]; firstRank: string | null; actions: number; summary: string[]; wroteChecklist: boolean; mode: string;
+};
+
+export function compareWithKey(dayFile: { themes: Theme[]; actions: unknown[]; summary: string[]; mode: string }, key: Key, status = 'done'): Omit<ShadowComparison, 'wroteChecklist'> {
+  const recurring = dayFile.themes.filter(t => t.recurring);
+  const detected = recurring.map(t => t.theme);
+  const missed = key.expected.filter(e => !detected.includes(e.theme)).map(e => e.theme);
+  // 정답지 밖의 반복 주제는 전부 오탐이다(목록에 적은 것만 보지 않는다).
+  const expected = new Set(key.expected.map(e => e.theme));
+  const falsePositives = [...new Set([...detected.filter(t => !expected.has(t)), ...(key.notRecurring ?? []).filter(t => detected.includes(t))])];
+  const reBrokeMismatch = key.expected.filter(e => e.reBrokeAfterGreen !== undefined
+    && recurring.find(t => t.theme === e.theme)?.reBrokeAfterGreen !== e.reBrokeAfterGreen).map(e => e.theme);
+  const firstRank = recurring.sort((a, b) => a.rank - b.rank)[0]?.theme ?? null;
+  // «초록 뒤 재발»이 정답지에 있으면 그것이 1순위여야 한다(RFC §1 recur).
+  const mustLead = key.expected.find(e => e.reBrokeAfterGreen)?.theme;
+  const ok = status === 'done' && !missed.length && !falsePositives.length && !reBrokeMismatch.length
+    && (!mustLead || firstRank === mustLead) && dayFile.actions.length <= 3 && dayFile.summary.length === 3;
+  return { ok, status, day: key.day, detected, missed, falsePositives, reBrokeMismatch, firstRank, actions: dayFile.actions.length, summary: dayFile.summary, mode: dayFile.mode };
+}
+
+export async function runShadowComparison(factsFile = DEFAULT_FACTS, keyFile = DEFAULT_KEY): Promise<ShadowComparison> {
+  const key = JSON.parse(readFileSync(keyFile, 'utf8')) as Key;
+  const root = mkdtempSync(join(tmpdir(), 'retro-shadow-'));
+  try {
+    const run = await runGraph(RETRO_DAILY_GRAPH, { input: { factsFile: resolve(factsFile), day: key.day, greenCells: key.greenCells ?? [], mode: 'shadow' }, deps: { root } });
+    if (run.status !== 'done') return { ok: false, status: run.status, day: key.day, detected: [], missed: key.expected.map(e => e.theme), falsePositives: [], reBrokeMismatch: [], firstRank: null, actions: 0, summary: [], wroteChecklist: false, mode: 'shadow' };
+    const dayFile = JSON.parse(readFileSync(retroDayFile(root, key.day), 'utf8'));
+    const act = run.nodes.find(n => n.nodeId === 'act');
+    const wroteChecklist = typeof act?.output === 'string' && /"wroteChecklist":true/.test(act.output);
+    const result = compareWithKey(dayFile, key, run.status);
+    return { ...result, ok: result.ok && !wroteChecklist && dayFile.mode === 'shadow', wroteChecklist };
+  } finally { rmSync(root, { recursive: true, force: true }); }
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const flag = (name: string) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined; };
+  const result = await runShadowComparison(flag('--facts'), flag('--key'));
+  console.log(args.includes('--json') ? JSON.stringify(result) : [
+    `retro-daily 그림자 대조 ${result.ok ? 'OK' : 'MISS'} · ${result.day} · status=${result.status} · mode=${result.mode}`,
+    `잡음: ${result.detected.join(', ') || '없음'}`,
+    `놓침: ${result.missed.join(', ') || '없음'} · 오탐: ${result.falsePositives.join(', ') || '없음'} · 초록뒤재발 불일치: ${result.reBrokeMismatch.join(', ') || '없음'}`,
+    `1순위: ${result.firstRank ?? '없음'} · 조치 초안 ${result.actions} · 체크리스트 쓰기 ${result.wroteChecklist}`,
+    ...result.summary.map(line => `  ${line}`),
+  ].join('\n'));
+  if (!result.ok) process.exitCode = 1;
+}