elanous 0.2.10 → 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/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(', ')}`);

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

@@ -49,9 +49,9 @@ function fetchMain(repo: string): void {
   }
 }
 
-function versionAt(repo: string): string {
-  const pkg = JSON.parse(git(repo, 'show', 'origin/main:package.json')) as { version?: unknown };
-  if (typeof pkg.version !== 'string') throw new Error('origin/main package.json has no version');
+function versionAt(repo: string, ref = 'origin/main'): string {
+  const pkg = JSON.parse(git(repo, 'show', `${ref}:package.json`)) as { version?: unknown };
+  if (typeof pkg.version !== 'string') throw new Error(`${ref} package.json has no version`);
   return pkg.version;
 }
 
@@ -64,13 +64,49 @@ function shippedNextMdLines(repo: string, cut: string | undefined): { lines: Set
   return { lines: new Set(shown.stdout.split('\n').map((line) => line.trim()).filter((line) => line.startsWith('- '))) };
 }
 
-function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string): Output {
+function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string, cutCommit?: string): Output {
   const target = kind === 'release' ? releaseVersion : nextDevVersion(releaseVersion);
   const source = kind === 'release' ? `${releaseVersion}-dev.N` : releaseVersion;
   fetchMain(repo);
+  if (kind === 'release' && cutCommit !== undefined) {
+    if (!/^[0-9a-f]{7,40}$/i.test(cutCommit)) throw new Error(`invalid cut commit SHA: ${cutCommit}`);
+    const local = spawnSync('git', ['rev-parse', '--verify', `${cutCommit}^{commit}`], { cwd: repo, encoding: 'utf8' });
+    let chosen = local.status === 0 ? local.stdout.trim() : '';
+    const onMain = chosen ? spawnSync('git', ['merge-base', '--is-ancestor', chosen, 'origin/main'], { cwd: repo }) : null;
+    if (onMain && onMain.status !== 0 && onMain.status !== 1) throw new Error(`git merge-base failed: ${onMain.error || onMain.stderr || 'unknown'}`);
+    if (onMain?.status !== 0) {
+      const remote = git(repo, 'ls-remote', '--heads', 'origin', `refs/heads/release/${releaseVersion}`);
+      const branchTip = remote.split(/\s+/)[0];
+      if (!chosen && branchTip?.toLowerCase().startsWith(cutCommit.toLowerCase())) {
+        git(repo, 'fetch', 'origin', `refs/heads/release/${releaseVersion}`);
+        chosen = git(repo, 'rev-parse', '--verify', `${cutCommit}^{commit}`);
+      }
+      if (!chosen) chosen = git(repo, 'rev-parse', '--verify', `${cutCommit}^{commit}`);
+      if (branchTip !== chosen) {
+        throw new Error(`cut commit ${chosen} is neither an ancestor of origin/main nor the tip of release/${releaseVersion}`);
+      }
+    }
+    const current = versionAt(repo, chosen);
+    if (current !== target) throw new Error(`cut commit ${chosen} package.json version ${current} is not ${target}`);
+    debug.log('release-loop.cut', 'chosen', { version: releaseVersion, source: 'cut-commit', commit: chosen });
+    return { outcome: 'ok', kind, version: target, commit: chosen, pr: null };
+  }
   const current = versionAt(repo);
   const before = git(repo, 'rev-parse', 'origin/main');
-  if (current === target) return { outcome: 'ok', kind, version: target, commit: before, pr: null };
+  if (current === target) {
+    if (kind === 'release') debug.log('release-loop.cut', 'chosen', { version: releaseVersion, source: 'main', commit: before });
+    return { outcome: 'ok', kind, version: target, commit: before, pr: null };
+  }
+  // An older chosen cut may finish after main has already advanced to the next stable release.
+  // Keep that newer main untouched; a -dev.N mismatch is not evidence of a later release.
+  if (kind === 'dev-bump' && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(current)) {
+    const mainParts = current.split('.').map(BigInt);
+    const nextParts = target.slice(0, -'-dev.0'.length).split('.').map(BigInt);
+    const firstDifference = mainParts.findIndex((part, index) => part !== nextParts[index]);
+    if (firstDifference === -1 || mainParts[firstDifference]! > nextParts[firstDifference]!) {
+      return { outcome: 'ok', kind, version: current, commit: before, pr: null };
+    }
+  }
   if (kind === 'release' ? !new RegExp(`^${releaseVersion.replaceAll('.', '\\.')}\\-dev\\.(0|[1-9][0-9]*)$`).test(current) : current !== source) {
     throw new Error(`origin/main version ${current} is not ${source} (target ${target})`);
   }
@@ -84,6 +120,13 @@ function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string)
     const old = `"version": "${current}"`;
     if (!text.includes(old)) throw new Error(`package.json version field not found: ${current}`);
     writeFileSync(path, text.replace(old, `"version": "${target}"`));
+    const serverPath = join(worktree, 'server.json');
+    if (existsSync(serverPath)) {
+      const server = JSON.parse(readFileSync(serverPath, 'utf8')) as { version: string; packages: Array<{ version: string }> };
+      server.version = target;
+      server.packages[0]!.version = target;
+      writeFileSync(serverPath, `${JSON.stringify(server, null, 2)}\n`);
+    }
     const lockPath = join(worktree, 'bun.lock');
     const lock = readFileSync(lockPath, 'utf8');
     const root = /"workspaces"\s*:\s*\{\s*""\s*:\s*\{([\s\S]*?)(?=\s*"(?:dependencies|devDependencies|optionalDependencies)"\s*:)/.exec(lock);
@@ -143,6 +186,7 @@ function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string)
     const commit = git(repo, 'rev-parse', 'origin/main');
     if (versionAt(repo) !== target || commit === before) throw new Error(`origin/main did not advance to ${target} after merge`);
     const output: Output = { outcome: 'ok', kind, version: target, commit, pr: pr ? Number(pr[1]) : null };
+    if (kind === 'release') debug.log('release-loop.cut', 'chosen', { version: releaseVersion, source: 'main', commit });
     git(repo, 'worktree', 'remove', '--force', worktree);
     rmSync(temp, { recursive: true, force: true });
     return output;
@@ -156,27 +200,34 @@ function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Out
   let kind: Kind | null = null;
   let version: string | null = null;
   let cut: string | undefined;
+  let cutCommit: string | undefined;
   try {
-    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] [--cut <sha>] --json');
+    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] [--cut <sha>] [--cut-commit <sha>] --json');
     kind = args[0];
     for (let i = 1; i < args.length; i++) {
       if (args[i] === '--json') continue;
       if (args[i] === '--version' && args[i + 1]) { version = args[++i]!; continue; }
       if (args[i] === '--cut' && args[i + 1]) { cut = args[++i]!; continue; }
+      if (args[i] === '--cut-commit' && args[i + 1]) { cutCommit = args[++i]!; continue; }
       throw new Error(`unknown or incomplete argument: ${args[i]}`);
     }
     if (process.env.ELANOUS_GRAPH_CONTEXT) {
       const location = process.env.ELANOUS_GRAPH_CONTEXT;
       const context = JSON.parse(location.trimStart().startsWith('{') ? location : readFileSync(location, 'utf8')) as {
-        input?: { version?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
+        input?: { version?: unknown; cutCommit?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
       if (!version && typeof context.input?.version === 'string') version = context.input.version;
+      if (kind === 'release' && cutCommit === undefined && context.input?.cutCommit !== undefined) {
+        if (typeof context.input.cutCommit !== 'string') throw new Error('cutCommit must be a commit SHA');
+        cutCommit = context.input.cutCommit;
+      }
       // The cut = the commit version-release landed (what cutoff and the gate measured).
-      const cutCommit = context.outputs?.['version-release']?.commit;
-      if (!cut && typeof cutCommit === 'string' && cutCommit) cut = cutCommit;
+      const releasedCommit = context.outputs?.['version-release']?.commit;
+      if (!cut && typeof releasedCommit === 'string' && releasedCommit) cut = releasedCommit;
     }
     if (!version) throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version)');
     nextDevVersion(version);
-    return landing(resolve(repo), kind, version, cut);
+    if (kind === 'dev-bump' && cutCommit !== undefined) throw new Error('--cut-commit is only valid for release');
+    return landing(resolve(repo), kind, version, cut, cutCommit);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const worktree = /\[worktree: ([^\]]+)\]$/.exec(message)?.[1];

package/scripts/signal-digest-cycle.ts

@@ -13,8 +13,7 @@ import { appendFileSync } from 'node:fs';
 import { SignalPool } from '../src/domains/signal-pool.js';
 import { runDigest, runCommunityBuzzDigest } from '../src/domains/signal-router.js';
 import { sendOutbound } from '../src/domains/outbound-alert.js';
-import { sendReportPhotoBuffer } from '../src/telegram-report.js';
-import { getUserConfig } from '../src/user-config.js';
+import { createDigestPhotoSender } from './signal-digest-photo.js';
 import { ensureCronNodePath } from '../src/domains/cron-path.js';
 import { unknownCronFlag } from '../src/domains/cron-flag-contract.js';
 
@@ -35,14 +34,10 @@ function log(msg: string): void {
   try { appendFileSync(LOG, line + '\n'); } catch { /* fail-soft */ }
 }
 
-async function sendDigestPhoto(png: Buffer, opts?: { caption?: string }): Promise<boolean> {
-  return sendReportPhotoBuffer(getUserConfig(), png, opts);
-}
-
 async function main(): Promise<void> {
   const pool = new SignalPool();
   try {
-    const d = await runDigest(pool, LIVE ? { send: sendOutbound, sendPhoto: sendDigestPhoto } : {});
+    const d = await runDigest(pool, LIVE ? { send: sendOutbound, sendPhoto: createDigestPhotoSender() } : {});
     log(`[${d.mode}] 다이제스트 대기 ${d.count} · 발송 ${d.sent}`);
     if (!LIVE && d.count > 0) {
       log(`  ▶ [digest shadow]\n${d.preview}`);

package/scripts/signal-digest-photo.ts

@@ -0,0 +1,11 @@
+import type { UserConfig } from '../src/user-config.js';
+import { getUserConfig } from '../src/user-config.js';
+import { sendReportPhotoBuffer } from '../src/telegram-report.js';
+
+/** The callback passed to runDigest for trading signal images. */
+export function createDigestPhotoSender(
+  config: () => UserConfig = getUserConfig,
+  sendPhoto: typeof sendReportPhotoBuffer = sendReportPhotoBuffer,
+): (png: Buffer, opts?: { caption?: string }) => Promise<boolean> {
+  return (png, opts) => sendPhoto(config(), png, { ...opts, kind: 'digest' });
+}