elanous 0.2.9 → 0.2.11

package/scripts/release-loop/mac-smoke-node.ts

@@ -0,0 +1,229 @@
+#!/usr/bin/env bun
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join, posix, resolve } from 'node:path';
+import { debug } from '../../src/debug/log.js';
+import { getUserConfig } from '../../src/user-config.js';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
+import { getElanousConfigDirOverride } from '../../src/elanous-config-dir.js';
+import { baselineCommit } from './gate-node.js';
+import { diffFailures, junitFailures } from './gate-diff.js';
+import { finishNode, readGraphContext, runCommand, type CommandResult, type CommandRunner, type GraphContext } from './node-verdict.js';
+
+const sha = /^[a-f0-9]{7,40}$/i;
+const testFile = /\.test\.tsx?$/;
+const hostName = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const quote = (s: string) => `'${s.replaceAll("'", "'\\''")}'`;
+
+export interface MacSmokeDeps {
+  context?: GraphContext;
+  configHost?: () => unknown;
+  baseline?: (version: string) => string;
+  changedFiles?: (baseline: string, commit: string) => string[];
+  findImporters?: (sources: string[], commit: string) => string[];
+  repo?: string;
+}
+
+export interface MacSmokeResult extends Record<string, unknown> {
+  outcome: 'ok' | 'fail' | 'error';
+  verdict: 'pass' | 'fail';
+  summary: string;
+  files: number;
+  newFailures: number;
+  preexisting: number;
+  smoke: 'pass' | 'fail' | 'unmeasured' | 'skipped';
+}
+
+function requireOk(result: CommandResult, stage: string): string {
+  if (result.status !== 0) throw new Error(`${stage} 실패`);
+  return result.stdout;
+}
+
+function names(output: string): string[] {
+  return output.split('\0').filter(Boolean);
+}
+
+function safeFile(file: string): boolean {
+  return !file.startsWith('/') && !file.split('/').includes('..') && /^[\w./@+-]+$/.test(file);
+}
+
+function changedTests(run: CommandRunner, repo: string, base: string, cut: string): string[] {
+  return names(requireOk(run('git', ['diff', '--name-only', '-z', `${base}..${cut}`], repo), '변경 파일 조회'));
+}
+
+function importers(run: CommandRunner, repo: string, sources: string[], commit: string): string[] {
+  const picked = new Set<string>();
+  for (const source of sources) {
+    const stem = source.replace(/\.(?:tsx?|jsx?|mjs|cjs)$/, '');
+    const directoryIndex = basename(stem) === 'index' ? posix.dirname(stem) : undefined;
+    const search = run('git', ['grep', '-l', '-z', '-F', '-e', basename(stem), '-e', source, '-e', stem, ...(directoryIndex ? ['-e', directoryIndex] : []), commit, '--', '*.test.ts', '*.test.tsx'], repo);
+    // git grep returns 1 for no matches; other errors mean the selection could not be measured.
+    if (search.status !== 0 && search.status !== 1) throw new Error('시험 import 검색 실패');
+    for (const entry of names(search.stdout)) {
+      if (!entry.startsWith(`${commit}:`)) throw new Error('시험 import 경로 측정 불가');
+      const file = entry.slice(commit.length + 1);
+      if (!safeFile(file) || !testFile.test(file)) throw new Error('시험 import 경로 측정 불가');
+      const contents = requireOk(run('git', ['show', `${commit}:${file}`], repo), '컷 시험 읽기');
+      if (contents.includes(source)) { picked.add(file); continue; }
+      for (const match of contents.matchAll(/(?:\bfrom\s*|\bimport\s*(?:\(\s*)?|\brequire\s*\()\s*['"]([^'"]+)['"]/g)) {
+        const spec = match[1]!;
+        const target = spec.startsWith('.') ? posix.normalize(posix.join(posix.dirname(file), spec)) : spec.replace(/^@\//, '');
+        const targetStem = target.replace(/\.(?:tsx?|jsx?|mjs|cjs)$/, '');
+        if (target === source || targetStem === stem || (directoryIndex && targetStem === directoryIndex)) { picked.add(file); break; }
+      }
+    }
+  }
+  return [...picked];
+}
+
+// Collection proof comes from bun's junit file (one top-level <testsuite file=…> per collected file):
+// non-TTY bun prints no per-file headers when everything passes, so stdout cannot prove which files ran (10-03 real run).
+export function testFailures(result: CommandResult, junit: string | null, selected: string[]): string[] {
+  const output = `${result.stdout}\n${result.stderr}`.replace(/\x1b\[[0-9;]*[A-Za-z]/g, '');
+  const summary = /Ran \d+ tests? across (\d+) files?/.exec(output);
+  if (junit === null || result.status === null || !summary || Number(summary[1]) !== selected.length) throw new Error('시험 결과 측정 불가');
+  const observed = new Set<string>();
+  let depth = 0;
+  for (const match of junit.matchAll(/<(\/?)testsuite\b([^>]*?)(\/?)>/g)) {
+    const [, closing, attrs, selfClosing] = match;
+    if (closing) { depth = Math.max(0, depth - 1); continue; }
+    if (depth === 0) {
+      const file = /\bfile="([^"]*)"/.exec(attrs!)?.[1] ?? /\bname="([^"]*)"/.exec(attrs!)?.[1];
+      if (file) observed.add(file.replace(/^\.\//, ''));
+    }
+    if (!selfClosing) depth += 1;
+  }
+  const failures = junitFailures(junit);
+  if (observed.size !== selected.length || selected.some((file) => !observed.has(file))
+    || (result.status !== 0 && failures.length === 0)) {
+    throw new Error('시험 결과 측정 불가');
+  }
+  return failures;
+}
+
+export function runMacSmoke(run: CommandRunner = runCommand, deps: MacSmokeDeps = {}): MacSmokeResult {
+  const start = Date.now();
+  let version = '';
+  let host = '';
+  let files = 0;
+  let newFailures = 0;
+  let preexisting = 0;
+  let smoke: MacSmokeResult['smoke'] = 'unmeasured';
+  let result: MacSmokeResult;
+  let work: string | undefined;
+  let cutCreated = false;
+  let baseCreated = false;
+  let remote = '';
+  let remoteAttempt = false;
+  const repo = resolve(deps.repo ?? process.cwd());
+  const command = (cmd: string, args: string[], cwd: string, timeoutMs?: number): CommandResult => host === 'local'
+    ? run(cmd, args, cwd, timeoutMs)
+    : run('ssh', [host, `PATH="$HOME/.bun/bin:$HOME/.local/bin:$PATH"; export PATH; cd ${quote(cwd)} && ${[cmd, ...args].map(quote).join(' ')}`], undefined, timeoutMs);
+  try {
+    const context = deps.context ?? readGraphContext();
+    version = context.input.version;
+    const configured = context.input.macSmokeHost ?? (deps.configHost ?? (() => (getUserConfig().raw.release as { macSmoke?: { host?: unknown } } | undefined)?.macSmoke?.host))();
+    if (configured === undefined || configured === null || configured === '') {
+      smoke = 'skipped';
+      result = { outcome: 'ok', verdict: 'pass', summary: 'macOS 대상 없음 — 건너뜀', files, newFailures, preexisting, smoke };
+    } else {
+      if (typeof configured !== 'string' || !hostName.test(configured)) throw new Error('macSmokeHost 호스트 이름이 유효하지 않음');
+      host = configured;
+      const commit = context.input.commit ?? context.outputs['version-release']?.commit;
+      if (typeof commit !== 'string' || !sha.test(commit)) throw new Error('컷 커밋 없음 또는 유효하지 않음 — 측정 불가');
+      const platform = host === 'local' ? run('uname', ['-s'], repo) : run('ssh', [host, 'uname -s'], repo);
+      if (requireOk(platform, '호스트 플랫폼 확인').trim() !== 'Darwin') throw new Error('macOS 호스트 아님 — 측정 불가');
+      const instance = effectiveInstanceRoot();
+      const root = getElanousConfigDirOverride() ? instance : releaseLedgerRoot();
+      const base = (deps.baseline ?? ((v) => baselineCommit(existsSync(join(root, 'release', v, 'release.json')) ? root : instance, v)))(context.input.previousVersion);
+      if (!sha.test(base)) throw new Error('지난 판 커밋 측정 불가');
+      const changed = (deps.changedFiles ?? ((b, c) => changedTests(run, repo, b, c)))(base, commit);
+      if (!changed.every(safeFile)) throw new Error('변경 파일 경로 측정 불가');
+      const sources = changed.filter((file) => /\.(?:tsx?|jsx?|mjs|cjs)$/.test(file) && !testFile.test(file));
+      const candidates = [...new Set([...changed.filter((file) => testFile.test(file)), ...(deps.findImporters ?? ((paths, revision) => importers(run, repo, paths, revision)))(sources, commit)])].sort();
+      if (!candidates.every(safeFile)) throw new Error('시험 파일 경로 측정 불가');
+      const cutFiles = new Set(requireOk(run('git', ['ls-tree', '-r', '--name-only', '-z', commit], repo), '컷 파일 조회').split('\0'));
+      const selected = candidates.filter((file) => cutFiles.has(file));
+      const clipped = Math.max(0, selected.length - 200);
+      const tests = selected.slice(0, 200);
+      files = tests.length;
+      const baseFiles = new Set(requireOk(run('git', ['ls-tree', '-r', '--name-only', '-z', base], repo), '기준 파일 조회').split('\0'));
+      work = mkdtempSync(join(tmpdir(), 'release-mac-smoke-'));
+      let source = repo;
+      if (host !== 'local') {
+        remoteAttempt = true;
+        remote = requireOk(run('ssh', [host, 'mktemp -d /tmp/release-mac-smoke-XXXXXXXX'], repo), '호스트 연결').trim();
+        if (!/^\/tmp\/release-mac-smoke-[\w-]+$/.test(remote)) throw new Error('원격 임시 경로 측정 불가');
+        requireOk(command('git', ['init', '--bare', `${remote}/mirror.git`], remote), '원격 저장소 생성');
+        for (const revision of new Set([commit, base])) {
+          requireOk(run('git', ['push', `${host}:${remote}/mirror.git`, `${revision}:refs/heads/mac-smoke-${revision}`], repo), '원격 커밋 전송');
+        }
+        requireOk(command('git', ['clone', '-q', '--no-checkout', `${remote}/mirror.git`, `${remote}/repo`], remote), '원격 복제');
+        source = `${remote}/repo`;
+      }
+      const cutTree = host === 'local' ? join(work, 'cut') : `${remote}/cut`;
+      requireOk(command('git', ['-C', source, 'worktree', 'add', '--detach', cutTree, commit], source), '체크아웃');
+      cutCreated = true;
+      requireOk(command('bun', ['install'], cutTree), '설치');
+      const execute = (tree: string, paths: string[]): string[] => {
+        const failures: string[] = [];
+        for (let i = 0; i < paths.length; i += 50) {
+          const batch = paths.slice(i, i + 50);
+          const report = `.mac-smoke-junit-${i}.xml`;
+          // `./` makes each path exact — bare paths are substring filters and also run same-named copies (10-03 nested worktrees).
+          const tested = command('bun', ['test', '--reporter=junit', `--reporter-outfile=${report}`, ...batch.map((file) => `./${file}`)], tree, 1_200_000);
+          const xml = command('cat', [report], tree);
+          failures.push(...testFailures(tested, xml.status === 0 ? xml.stdout : null, batch));
+        }
+        return failures;
+      };
+      const cutFailures = execute(cutTree, tests);
+      const versionSmoke = command('bun', ['bin/elanous.mjs', '--test', '--version'], cutTree);
+      const scheduleSmoke = command('bun', ['bin/elanous.mjs', '--test', 'release', 'schedule', 'list', '--json'], cutTree);
+      smoke = versionSmoke.status === 0 && scheduleSmoke.status === 0 ? 'pass' : 'fail';
+      let baselineFailures: string[] = [];
+      if (cutFailures.length) {
+        const baseTree = host === 'local' ? join(work, 'base') : `${remote}/base`;
+        requireOk(command('git', ['-C', source, 'worktree', 'add', '--detach', baseTree, base], source), '기준 체크아웃');
+        baseCreated = true;
+        requireOk(command('bun', ['install'], baseTree), '기준 설치');
+        baselineFailures = execute(baseTree, tests.filter((file) => baseFiles.has(file)));
+      }
+      const delta = diffFailures(cutFailures, baselineFailures);
+      newFailures = delta.newFailures.length;
+      preexisting = delta.common.length;
+      const outcome = newFailures || smoke !== 'pass' ? 'fail' : 'ok';
+      result = { outcome, verdict: outcome === 'ok' ? 'pass' : 'fail', files, newFailures, preexisting, smoke,
+        summary: `macOS ${outcome} · 새 실패 ${newFailures} · 기존 실패 ${preexisting} · 스모크 ${smoke}${clipped ? ` · 잘림 ${clipped}` : ''}${newFailures ? ` · ${delta.newFailures.slice(0, 5).map((id) => id.split(' > ')[0]).join(', ')}` : ''}` };
+    }
+  } catch {
+    result = { outcome: 'error', verdict: 'fail', summary: 'macOS 측정 불가 (연결·체크아웃·설치·시험 결과 확인 필요)', files, newFailures, preexisting, smoke };
+  } finally {
+    if (remoteAttempt && remote) {
+      try {
+        const cleanup = run('ssh', [host, `rm -rf -- ${quote(remote)}`]);
+        if (cleanup.status !== 0) result = { outcome: 'error', verdict: 'fail', summary: 'macOS 측정 불가 (임시 작업 정리 실패)', files, newFailures, preexisting, smoke };
+      } catch { result = { outcome: 'error', verdict: 'fail', summary: 'macOS 측정 불가 (임시 작업 정리 실패)', files, newFailures, preexisting, smoke }; }
+    }
+    if (work) {
+      if (host === 'local') {
+        for (const tree of [cutCreated && 'cut', baseCreated && 'base'].filter((name): name is string => Boolean(name))) {
+          try {
+            const removed = run('git', ['worktree', 'remove', '--force', join(work, tree)], repo);
+            if (removed.status !== 0) result = { outcome: 'error', verdict: 'fail', summary: 'macOS 측정 불가 (임시 작업 정리 실패)', files, newFailures, preexisting, smoke };
+          } catch { result = { outcome: 'error', verdict: 'fail', summary: 'macOS 측정 불가 (임시 작업 정리 실패)', files, newFailures, preexisting, smoke }; }
+        }
+      }
+      try { rmSync(work, { recursive: true, force: true }); }
+      catch { result = { outcome: 'error', verdict: 'fail', summary: 'macOS 측정 불가 (임시 작업 정리 실패)', files, newFailures, preexisting, smoke }; }
+    }
+    debug.log('release-loop.mac-smoke', 'judged', { version, host, files, newFailures, smoke, outcome: result!.outcome, ms: Date.now() - start });
+  }
+  return result!;
+}
+
+if (import.meta.main) {
+  let version = '';
+  try { version = readGraphContext().input.version; process.exitCode = finishNode('mac-smoke', version, runMacSmoke()); }
+  catch { process.exitCode = finishNode('mac-smoke', version, { outcome: 'error', verdict: 'fail', summary: 'macOS 측정 불가' }); }
+}

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

@@ -33,9 +33,9 @@ export function emitNodeResult<T extends Record<string, unknown>>(result: T & {
 }
 
 export interface CommandResult { status: number | null; stdout: string; stderr: string }
-export type CommandRunner = (command: string, args: string[], cwd?: string) => CommandResult;
-export const runCommand: CommandRunner = (command, args, cwd) => {
-  const result = spawnSync(command, args, { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+export type CommandRunner = (command: string, args: string[], cwd?: string, timeoutMs?: number) => CommandResult;
+export const runCommand: CommandRunner = (command, args, cwd, timeoutMs) => {
+  const result = spawnSync(command, args, { cwd, timeout: timeoutMs, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
   return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr || (result.error ? String(result.error) : '') };
 };
 

package/scripts/release-loop/ops-upgrade-node.ts

@@ -1,8 +1,29 @@
 #!/usr/bin/env bun
+import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
+import { join, isAbsolute } from 'node:path';
+import { debug } from '../../src/debug/log.js';
 import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandResult, type CommandRunner } from './node-verdict.js';
 
-interface HostResult { host: string; ok: boolean; before: string; after: string; error?: string; skipped?: string; hooks?: string }
+interface HostResult { host: string; ok: boolean; before: string; after: string; error?: string; skipped?: string; hooks?: string; restart?: 'no-service' }
+interface OpsUpgradeDeps { exists?: (path: string) => boolean; installSource?: () => string | null }
+
+function localInstallSource(): string | null {
+  try {
+    const data: unknown = JSON.parse(readFileSync(join(homedir(), '.local/share/elanous/install.json'), 'utf8'));
+    return data && typeof data === 'object' && 'source' in data && typeof data.source === 'string' ? data.source : null;
+  } catch { return null; }
+}
+
+function installedMatches(installed: unknown, version: string, checkout: boolean): boolean {
+  return installed === version || checkout && typeof installed === 'string'
+    && installed.startsWith(`${version}-`) && /^[0-9a-f]{12}$/.test(installed.slice(version.length + 1));
+}
+
+function missingService(data: Record<string, unknown> | undefined): boolean {
+  return typeof data?.reason === 'string'
+    && /^재시작 실패:\s*(?:Could not find service\s+"?com\.elanous\.nexus\b|(?:Failed to restart elanous-nexus\.service:\s*)?Unit elanous-nexus(?:\.service)? not found\b)/i.test(data.reason);
+}
 
 function firstLine(text: string): string { return text.trim().split(/\r?\n/)[0]?.trim() ?? ''; }
 
@@ -15,7 +36,7 @@ function reason(result: CommandResult): string {
 
 function quote(value: string): string { return `'${value.replaceAll("'", "'\\''")}'`; }
 
-export function runOpsUpgrade(run: CommandRunner = runCommand) {
+export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeDeps = {}) {
   const context = readGraphContext();
   const hosts = context.input.opsHosts;
   if (hosts === undefined || (Array.isArray(hosts) && hosts.length === 0)) {
@@ -27,9 +48,12 @@ export function runOpsUpgrade(run: CommandRunner = runCommand) {
   if (nodeOutput(context, 'publish', 'tag') !== `v${version}`) throw new Error('published tag/version mismatch');
   const internalDist = context.input.internalDist;
   if (internalDist !== undefined && (typeof internalDist !== 'string' || !internalDist.trim())) throw new Error('input.internalDist must be a path string');
-  const feedPath = typeof internalDist === 'string' && internalDist.startsWith('~/') ? `${homedir()}/${internalDist.slice(2)}` : internalDist;
+  const defaultFeed = join(homedir(), '.local/share/elanous-ops/internal-dist');
+  const feedPath = typeof internalDist === 'string'
+    ? internalDist.startsWith('~/') ? `${homedir()}/${internalDist.slice(2)}` : internalDist
+    : (deps.exists ?? existsSync)(defaultFeed) ? defaultFeed : undefined;
   let feedError = '';
-  if (typeof feedPath === 'string') {
+  if (feedPath !== undefined) {
     try {
       const feed = run('bun', ['scripts/publish-internal-dist.ts', '--checkout', process.cwd(), '--out', feedPath]);
       const data = lastResult(feed);
@@ -38,8 +62,15 @@ export function runOpsUpgrade(run: CommandRunner = runCommand) {
   }
   const results: HostResult[] = [];
   for (const host of hosts as string[]) {
+    const source = host === 'local' ? (deps.installSource ?? localInstallSource)() : null;
+    const checkout = host === 'local' && source !== null && isAbsolute(source);
+    const path = checkout ? 'checkout' as const : 'release' as const;
+    const record = (result: HostResult) => {
+      results.push(result);
+      debug.log('release-loop.ops-upgrade', 'host', { host, path, restart: result.restart ?? (context.input.opsRestart === true ? result.ok ? 'ok' : 'failed' : 'skipped'), ok: result.ok });
+    };
     if (host !== 'local' && feedError) {
-      results.push({ host, ok: false, before: '', after: '', skipped: '내부 피드 발행 실패', error: feedError });
+      record({ host, ok: false, before: '', after: '', skipped: '내부 피드 발행 실패', error: feedError });
       continue;
     }
     const command = (args: string[]): CommandResult => host === 'local'
@@ -51,22 +82,46 @@ export function runOpsUpgrade(run: CommandRunner = runCommand) {
     try {
       const previous = command(['--version']);
       if (previous.status === 0) before = firstLine(previous.stdout);
-      const updated = command(['update', '--version', version, '--json', ...(context.input.opsRestart === true ? ['--restart'] : [])]);
+      if (checkout) {
+        const git = (args: string[]) => run('git', args, source!);
+        const dirty = git(['status', '--porcelain', '--untracked-files=all']);
+        if (dirty.status !== 0 || dirty.stdout.trim()) {
+          record({ host, ok: false, before, after, error: dirty.status === 0 ? '체크아웃 변경 있음' : `체크아웃 상태 확인 실패: ${reason(dirty)}` });
+          continue;
+        }
+        const fetched = git(['fetch', '--tags']);
+        if (fetched.status !== 0) {
+          record({ host, ok: false, before, after, error: `태그 가져오기 실패: ${reason(fetched)}` });
+          continue;
+        }
+        const tag = git(['rev-parse', '--verify', `refs/tags/v${version}^{commit}`]);
+        if (tag.status !== 0 || !tag.stdout.trim()) {
+          record({ host, ok: false, before, after, error: `태그 없음: v${version}` });
+          continue;
+        }
+        const moved = git(['checkout', '--detach', `v${version}`]);
+        if (moved.status !== 0) {
+          record({ host, ok: false, before, after, error: `체크아웃 전환 실패: ${reason(moved)}` });
+          continue;
+        }
+      }
+      const updated = command(['update', ...(checkout || host !== 'local' && feedPath !== undefined ? [] : ['--version', version]), '--json', ...(context.input.opsRestart === true ? ['--restart'] : [])]);
       const updateResult = lastResult(updated);
-      if (updated.status !== 0 || updateResult?.exitCode !== 0 || updateResult.installedVersion !== version) {
-        const error = updated.status === 0 && updateResult?.exitCode === 0
-          ? `설치판 불일치 (기대 ${version}, 실제 ${String(updateResult.installedVersion)})` : reason(updated);
-        results.push({ host, ok: false, before, after, error });
+      const noService = host !== 'local' && context.input.opsRestart === true && updateResult?.exitCode === 1 && missingService(updateResult);
+      if ((!noService && (updated.status !== 0 || updateResult?.exitCode !== 0)) || !installedMatches(updateResult?.installedVersion, version, checkout)) {
+        const error = (updated.status === 0 && updateResult?.exitCode === 0 || noService)
+          ? `설치판 불일치 (기대 ${version}, 실제 ${String(updateResult?.installedVersion)})` : reason(updated);
+        record({ host, ok: false, before, after, error });
         continue;
       }
       const current = command(['--version']);
       if (current.status !== 0) {
-        results.push({ host, ok: false, before, after, error: reason(current) });
+        record({ host, ok: false, before, after, error: reason(current) });
         continue;
       }
       after = firstLine(current.stdout);
-      if (after.split(/\s+/)[0] !== version) {
-        results.push({ host, ok: false, before, after, error: `올렸는데 판이 그대로 (기대 ${version}, 실제 ${after || '없음'})` });
+      if (!installedMatches(after.split(/\s+/)[0], version, checkout)) {
+        record({ host, ok: false, before, after, error: `올렸는데 판이 그대로 (기대 ${version}, 실제 ${after || '없음'})` });
         continue;
       }
       // The webhook receiver (`elanous hooks serve`, a user systemd unit on the bot VM) keeps the old code until it
@@ -76,16 +131,17 @@ export function runOpsUpgrade(run: CommandRunner = runCommand) {
         const restarted = run('ssh', [host, 'systemctl --user try-restart elanous-hooks.service 2>/dev/null && systemctl --user is-active elanous-hooks.service 2>/dev/null || echo absent']);
         hooks = firstLine(restarted.stdout) || 'absent';
       }
-      results.push({ host, ok: true, before, after, ...(hooks ? { hooks } : {}) });
+      record({ host, ok: true, before, after, ...(hooks ? { hooks } : {}), ...(noService ? { restart: 'no-service' as const } : {}) });
     } catch (error) {
-      results.push({ host, ok: false, before, after, error: firstLine(String(error)) });
+      record({ host, ok: false, before, after, error: firstLine(String(error)) });
     }
   }
   const failures = results.filter((result) => !result.ok);
   return { outcome: failures.length || feedError ? 'fail' as const : 'ok' as const,
     verdict: failures.length || feedError ? 'fail' as const : 'pass' as const,
     summary: failures.length ? `운영 판올림 실패: ${failures.map(({ host, error }) => `${host}: ${error}`).join('; ')}${feedError && !failures.some((item) => item.skipped) ? `; ${feedError}` : ''}`
-      : feedError || `운영 판올림 ${version} · ${results.length}대 확인`, hosts: results };
+      : feedError || `운영 판올림 ${version} · ${results.length}대 확인`,
+    feed: feedError ? 'failed' as const : feedPath === undefined ? 'skipped-no-path' as const : 'published' as const, hosts: results };
 }
 
 if (import.meta.main) {

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

@@ -2,10 +2,13 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { checklistGate, type ChecklistGate } from '../../src/release-loop/checklist.js';
+import { getSchedule, formatKst } from '../../src/release-loop/release-schedule.js';
+import { debug } from '../../src/debug/log.js';
 
 export type ReleaseReadiness =
   | { ready: false; reason: 'already-published'; details: string }
   | { ready: false; reason: 'already-running'; details: string }
+  | { ready: false; reason: 'before-cut'; details: string }
   | { ready: false; reason: 'checklist-blocked'; details: ChecklistGate }
   | { ready: true; reason: 'ready'; details: ChecklistGate };
 
@@ -13,6 +16,7 @@ export interface ReleaseReadinessDeps {
   ledgerRoot?: string;
   checklist?: typeof checklistGate;
   isPidAlive?: (pid: number) => boolean;
+  now?: () => Date;
 }
 
 function readIfPresent(path: string): string | undefined {
@@ -52,6 +56,11 @@ export function releaseReadiness(version: string, deps: ReleaseReadinessDeps = {
       return { ready: false, reason: 'already-running', details: String(pid) };
     }
   }
+  const schedule = getSchedule(version, deps.ledgerRoot);
+  if (schedule && (deps.now ?? (() => new Date()))().getTime() < Date.parse(schedule.cutAt)) {
+    debug.log('release.schedule', 'before-cut', { version, cutAt: schedule.cutAt, landBy: schedule.landBy });
+    return { ready: false, reason: 'before-cut', details: `before-cut (${formatKst(schedule.cutAt)})` };
+  }
   const gate = (deps.checklist ?? checklistGate)(version);
   if (!gate.ok) return { ready: false, reason: 'checklist-blocked', details: gate };
   return { ready: true, reason: 'ready', details: gate };

package/scripts/release-loop/tui-node-checks.ts

@@ -27,3 +27,45 @@ export function tuiChecks(s: TuiScreens, readyLimitMs = 60_000): TuiCheck[] {
 export function tuiVerdict(checks: readonly TuiCheck[]): 'pass' | 'fail' {
   return checks.every((c) => c.pass) ? 'pass' : 'fail';
 }
+
+export type TuiRegress = {
+  pass: number;
+  fail: number;
+  results: Array<{ id: string; title: string; ok: boolean; reason: string }>;
+} | { unmeasured: string };
+
+export function validatedTuiRegress(data: unknown): TuiRegress {
+  const invalid = { unmeasured: 'tui.regress 결과 없음' };
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return invalid;
+  const value = data as Record<string, unknown>;
+  if (typeof value.unmeasured === 'string' && value.unmeasured.trim()) return { unmeasured: value.unmeasured };
+  if (!Array.isArray(value.results) || value.results.length !== 7
+    || !Number.isInteger(value.pass) || !Number.isInteger(value.fail)
+    || (value.pass as number) < 0 || (value.fail as number) < 0
+    || (value.pass as number) + (value.fail as number) !== 7
+    || value.results.some((r: unknown) => !r || typeof r !== 'object'
+      || typeof (r as Record<string, unknown>).id !== 'string'
+      || !/^R[1-7]$/.test((r as Record<string, unknown>).id as string)
+      || typeof (r as Record<string, unknown>).title !== 'string'
+      || typeof (r as Record<string, unknown>).ok !== 'boolean'
+      || typeof (r as Record<string, unknown>).reason !== 'string')
+    || value.pass !== value.results.filter((r: { ok: boolean }) => r.ok).length
+    || value.fail !== value.results.filter((r: { ok: boolean }) => !r.ok).length
+    || new Set(value.results.map((r: { id: string }) => r.id)).size !== 7) return invalid;
+  return value as { pass: number; fail: number; results: Array<{ id: string; title: string; ok: boolean; reason: string }> };
+}
+
+export function parseTuiRegress(stdout: string): TuiRegress {
+  const lines = stdout.trim().split('\n');
+  if (lines.length !== 1) return { unmeasured: 'JSON 한 줄이 아니다' };
+  try { return validatedTuiRegress(JSON.parse(lines[0]!)); }
+  catch { return { unmeasured: 'JSON 결과를 읽을 수 없다' }; }
+}
+
+export function regressWarning(regress: TuiRegress): { level: 'ok' | 'warn' | 'unmeasured'; line: string } {
+  if ('unmeasured' in regress) return { level: 'unmeasured', line: `tui-regress: unmeasured — ${regress.unmeasured}` };
+  const failed = regress.results.filter((result) => !result.ok).map((result) => result.id);
+  return failed.length
+    ? { level: 'warn', line: `tui-regress: warn — ${failed.join(', ')}` }
+    : { level: 'ok', line: `tui-regress: ok — ${regress.pass} pass · 0 fail` };
+}

package/scripts/release-loop/tui-sim-node.ts

@@ -6,7 +6,7 @@
  *
  * Steps: temp worktree at <sha> → `scripts/tui-sim.ts start --test` (that commit's code, the
  * repo's `.elanous-test` config so no first-run wizard) → first screen → `/help` → Esc → dump PNG
- * → stop, clean, remove worktree. Never touches the production daemon or ~/.elanous.
+ * → stop, clean → run seven PTY regression checks → remove worktree. Never touches the production daemon or ~/.elanous.
  * macOS only (the TUI PTY checks run on the mbp). One retry of the whole session → «flaky».
  *
  * Exit: 0 = pass or flaky · 1 = fail · 2 = could not run (not macOS, worktree).
@@ -15,7 +15,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { copyFileSync, existsSync, mkdtempSync, openSync, symlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
-import { tuiChecks, tuiVerdict, type TuiCheck } from './tui-node-checks';
+import { parseTuiRegress, regressWarning, tuiChecks, tuiVerdict, type TuiCheck, type TuiRegress } from './tui-node-checks';
 
 const log = (msg: string) => process.stderr.write(`[tui-node] ${msg}\n`);
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
@@ -64,6 +64,27 @@ async function session(worktree: string, stateDir: string, id: string, work: str
   }
 }
 
+export function measureTuiRegress(worktree: string, runner: typeof spawnSync = spawnSync): TuiRegress {
+  try {
+    const measured = runner('bun', ['scripts/tui-regress.ts', '--json'], {
+      cwd: worktree, encoding: 'utf8', timeout: 180_000, maxBuffer: 16 * 1024 * 1024,
+    });
+    if (measured.error) return { unmeasured: measured.error.message };
+    if (measured.status !== 0 && measured.status !== 1) {
+      return { unmeasured: `실행 종료 코드 ${measured.status ?? measured.signal ?? '없음'}: ${(measured.stderr ?? '').trim().slice(0, 200)}` };
+    }
+    return parseTuiRegress(measured.stdout ?? '');
+  } catch (error) {
+    return { unmeasured: String(error) };
+  }
+}
+
+export function tuiNodeOutput(commit: string, attempts: Array<{ checks: TuiCheck[]; png?: string }>, regress: TuiRegress, failure?: string) {
+  const last = attempts.at(-1);
+  const verdict = !last ? 'error' : tuiVerdict(last.checks) === 'fail' ? 'fail' : attempts.length > 1 ? 'flaky' : 'pass';
+  return { verdict, commit, attempts: attempts.length, checks: last?.checks ?? [], png: last?.png, regress, ...(failure ? { error: failure } : {}) };
+}
+
 async function main(): Promise<number> {
   const argv = process.argv.slice(2);
   const commit = argv[argv.indexOf('--commit') + 1] ?? '';
@@ -77,9 +98,12 @@ async function main(): Promise<number> {
   const worktree = join(work, 'tree');
   let attempts: Array<{ checks: TuiCheck[]; png?: string }> = [];
   let failure: string | undefined;
+  let regress: TuiRegress = { unmeasured: 'worktree를 만들지 못했다' };
+  let worktreeReady = false;
   try {
     const add = spawnSync('git', ['worktree', 'add', '--detach', worktree, commit], { cwd: repo, encoding: 'utf8' });
     if (add.status !== 0) throw new Error(`worktree add failed: ${(add.stderr ?? '').trim()}`);
+    worktreeReady = true;
     symlinkSync(join(repo, 'node_modules'), join(worktree, 'node_modules'));
     if (!existsSync(join(stateDir, 'config.json'))) log(`⚠ ${stateDir}/config.json missing — the TUI may open the first-run wizard`);
     const id = `rl-${commit.slice(0, 8)}-${Date.now().toString(36)}`;
@@ -94,20 +118,20 @@ async function main(): Promise<number> {
     log(`could not run: ${failure}`);
     attempts = [];
   } finally {
+    if (worktreeReady) regress = measureTuiRegress(worktree);
     spawnSync('git', ['worktree', 'remove', '--force', worktree], { cwd: repo });
   }
 
-  const last = attempts.at(-1);
-  const verdict = !last ? 'error' : tuiVerdict(last.checks) === 'fail' ? 'fail' : attempts.length > 1 ? 'flaky' : 'pass';
-  const out = { verdict, commit, attempts: attempts.length, checks: last?.checks ?? [], png: last?.png, ...(failure ? { error: failure } : {}) };
+  const out = tuiNodeOutput(commit, attempts, regress, failure);
   if (json) console.log(JSON.stringify(out));
   else {
-    console.log(`tui-node: ${verdict} · ${commit.slice(0, 10)} · attempts ${attempts.length}`);
+    console.log(`tui-node: ${out.verdict} · ${commit.slice(0, 10)} · attempts ${attempts.length}`);
     for (const c of out.checks) console.log(`  ${c.pass ? '✓' : '✗'} ${c.id} — ${c.detail}`);
     if (out.png) console.log(`  screen: ${out.png}`);
+    console.log(`  ${regressWarning(regress).line}`);
     if (failure) console.log(`  error: ${failure}`);
   }
-  return verdict === 'error' ? 2 : verdict === 'fail' ? 1 : 0;
+  return out.verdict === 'error' ? 2 : out.verdict === 'fail' ? 1 : 0;
 }
 
-process.exit(await main());
+if (import.meta.main) process.exit(await main());

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

@@ -24,6 +24,7 @@ export interface ReleaseLoopConfig {
 export interface ReleaseRunInput extends ReleaseLoopConfig {
   version: string;
   previousVersion: string;
+  cutCommit?: string;
   gatePodPool: string;
 }
 
@@ -67,7 +68,7 @@ export function releaseLoopConfig(configPath = getElanousConfigDirOverride() ? j
   return raw.release?.loop ?? {};
 }
 
-export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDeps = {}): ReleaseRunInput {
+export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDeps = {}, cutCommit?: string): ReleaseRunInput {
   const config = deps.config ?? releaseLoopConfig(deps.configPath);
   const pool = config.gatePodPool;
   if (typeof pool !== 'string' || !pool.trim()) throw new Error('release.loop.gatePodPool is required before graph execution');
@@ -75,16 +76,17 @@ export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDep
   return {
     ...config,
     version, previousVersion,
+    ...(cutCommit !== undefined ? { cutCommit } : {}),
     gatePodPool: pool.trim(),
   };
 }
 
 /** Fail closed at the entry boundary, before any graph node can change a release. */
 export async function runUnattendedRelease(
-  opts: { version: string; dryRun?: boolean },
+  opts: { version: string; dryRun?: boolean; cutCommit?: string },
   deps: UnattendedReleaseDeps = {},
 ): Promise<{ input: ReleaseRunInput; dryRun: boolean; state?: GraphRunState }> {
-  const input = buildReleaseRunInput(opts.version, deps);
+  const input = buildReleaseRunInput(opts.version, deps, opts.cutCommit);
   if (opts.dryRun) return { input, dryRun: true };
   const gate = (deps.checklist ?? checklistGate)(opts.version);
   if (!gate.ok) throw new Error(`release checklist blocked: ${[...gate.red, ...gate.undecided, ...gate.blocked].join(', ')}`);