elanous 0.2.27 → 0.2.29

package/scripts/lib/morning-report-options.ts

@@ -0,0 +1,41 @@
+// ── morning-report 스크립트 CLI 인자 — 명시 서사 모델(--narrative-model) ────────
+//
+// scripts/morning-report.ts 는 지금 인자를 process.argv.includes(...) 인라인으로 읽는다
+// (--dry · --no-narrate · --no-upload). 이 파일은 그 스크립트의 인자 계약을 일반 파서
+// scripts/lib/argv.ts#parseArgv 위에 정의한다. 계약이 스크립트의 네 플래그를 «전부» 아는
+// 것은, 이 헬퍼가 «스크립트 CLI 인자» 전체를 받아 모델 값만 뽑는 목적이어서다 —
+// 다른 플래그가 섞인 실제 argv 가 들어와도 모델 값에 오염이 없다.
+//
+// 반환 계약 — src/domains/morning-report.ts#MorningReportOpts.model 에 그대로 꽂힌다:
+//   · '--narrative-model X' / '--narrative-model=X' 두 철자를 «같게» 읽어 값 문자열 반환.
+//   · 플래그가 없으면 undefined — src/domains/morning-essential.ts 의 기본 provider
+//     경로(model 미지정 ⇒ providerFor(cfg))를 그대로 보존한다. 값이 없거나 빈 값이면
+//     parseArgv 오류를 던져 기본 모델로 조용히 실행되지 않도록 한다.
+//
+// ⛔ 의도된 경계(비연결 선언): 이 유닛은 «정의 + 단위시험» 에서 멈춘다.
+//   scripts/morning-report.ts 탑레벨(CLI 진입) → composeMorningReport(..., { model }) 배선은
+//   의존 형제 샤드(task:d0183079b142)의 몫이다. 지금 이 유닛을 실행 경로에서 부르는 곳은
+//   scripts/lib/morning-report-options.test.ts(bun test, in-process) 다.
+
+import { parseArgv, type ArgvContract } from './argv.js';
+
+/** morning-report 스크립트의 전체 CLI 플래그 — 파서 계약(여기 없는 플래그는 거부된다). */
+const MORNING_REPORT_ARGV: ArgvContract = {
+  known: {
+    '--dry': 'bool',
+    '--no-narrate': 'bool',
+    '--no-upload': 'bool',
+    '--narrative-model': 'value',
+  },
+  label: 'morning-report',
+};
+
+/**
+ * 아침 브리핑 시장서사의 명시 LLM 모델(--narrative-model)을 argv 에서 뽑는다.
+ * 플래그가 없으면 undefined — undefined 자체가 «기본 provider 경로» 값이다.
+ */
+export function parseNarrativeModelArg(argv: string[]): string | undefined {
+  const parsed = parseArgv(argv, MORNING_REPORT_ARGV);
+  if (parsed.errors.length > 0) throw new Error(parsed.errors.join('\n'));
+  return parsed.values['narrative-model'];
+}

package/scripts/pr-land-extra-remote-gates.ts

@@ -0,0 +1,49 @@
+#!/usr/bin/env bun
+/** Extra landing gates on the pinned head/main integration tree. */
+import { spawnSync } from 'node:child_process';
+import { runLandGlobalChecksGate } from './land-global-checks.js';
+import { runTestInterferenceGate } from './ci-test-interference-gate.js';
+
+export interface PrLandExtraGateDeps {
+  changedFiles?: (base: string, cwd: string) => string[];
+  runGlobal?: (files: readonly string[], cwd: string) => boolean;
+  runInterference?: (files: readonly string[], cwd: string, log: (message: string) => void) => Promise<number>;
+}
+
+function changedFiles(base: string, cwd: string): string[] {
+  if (!/^[a-f0-9]{40}$/i.test(base)) throw new Error('invalid pinned base');
+  const diff = spawnSync('git', ['diff', '--name-only', '-z', `${base}...HEAD`], { cwd, encoding: 'buffer' });
+  if (diff.error || diff.status !== 0 || !Buffer.isBuffer(diff.stdout)) {
+    throw new Error(`changed files unmeasured: ${diff.error?.message ?? diff.stderr?.toString('utf8') ?? diff.status}`);
+  }
+  return diff.stdout.toString('utf8').split('\0').filter(Boolean);
+}
+
+export async function runPrLandExtraRemoteGates(base: string, cwd = process.cwd(), deps: PrLandExtraGateDeps = {}): Promise<number> {
+  if (!/^[a-f0-9]{40}$/i.test(base)) throw new Error('invalid pinned base');
+  const files = (deps.changedFiles ?? changedFiles)(base, cwd);
+  const globalOk = (deps.runGlobal ?? ((paths, root) => runLandGlobalChecksGate({ changedFiles: paths, cwd: root, log: console.log, error: console.error })))(files, cwd);
+  if (!globalOk) return 1;
+  let interferenceMeasured = true;
+  const interferenceLog = (message: string): void => {
+    console.log(message);
+    if (message.includes('[test-interference-gate] 경고: 측정 불가')) interferenceMeasured = false;
+  };
+  try {
+    const rc = await (deps.runInterference ?? ((paths, root, log) => runTestInterferenceGate({ args: ['--changed-files', ...paths], cwd: root, log })))(files, cwd, interferenceLog);
+    if (rc !== 0) interferenceMeasured = false;
+  } catch (error) {
+    interferenceMeasured = false;
+    console.warn(`[test-interference-gate] 경고: 측정 불가 — ${error instanceof Error ? error.message : String(error)}; 간섭 없음으로 처리하지 않음.`);
+  }
+  console.log(`[pr-land-extra-gates] pass global=measured interference=${interferenceMeasured ? 'measured' : 'unmeasured'} files=${files.length}`);
+  return 0;
+}
+
+if (import.meta.main) {
+  try { process.exitCode = await runPrLandExtraRemoteGates(process.argv[2] ?? ''); }
+  catch (error) {
+    console.error(`[pr-land-extra-gates] unmeasured: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  }
+}

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

@@ -130,7 +130,11 @@ export function runDocs(
 const SHA = /^[0-9a-f]{40}$/i;
 const PREFETCH_DEADLINE_MS = 15 * 60_000;
 type Cut = { version: string; commit: string; manifestHash: string };
-type PrefetchCache = Cut & { main: string; tree: string; docs: DocsResult; tui: Record<string, unknown> | null };
+// Two separately published cache files: a finished TUI must survive a docs failure or delay,
+// so it never lives inside the same file as the docs result (should-fix ②).
+type TuiCache = Cut & { tui: Record<string, unknown> };
+type DocsCache = Cut & { main: string; tree: string; docs: DocsResult };
+type PrefetchCache = DocsCache & { tui: Record<string, unknown> | null };
 type Runner = (command: string, args: string[], cwd?: string, timeout?: number, env?: NodeJS.ProcessEnv) => string;
 export const commandRunner: Runner = (command, args, cwd, timeout, env) => {
   const output = spawnSync(command, args, { cwd, env: env ?? process.env, timeout: timeout ?? 15 * 60_000, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
@@ -162,11 +166,27 @@ function claimPrefetch(dir: string, owner: 'worker' | 'docs'): boolean {
 function cacheFile(dir: string, cut: Cut): string {
   return join(dir, `${cut.commit}-${cut.manifestHash}.json`);
 }
-function loadCache(dir: string, cut: Cut): PrefetchCache | null {
+function tuiCacheFile(dir: string, cut: Cut): string {
+  return join(dir, `${cut.commit}-${cut.manifestHash}.tui.json`);
+}
+function loadTuiCache(dir: string, cut: Cut): TuiCache | null {
+  try {
+    const value = JSON.parse(readFileSync(tuiCacheFile(dir, cut), 'utf8')) as TuiCache;
+    if (value.version !== cut.version || value.commit !== cut.commit || value.manifestHash !== cut.manifestHash) return null;
+    return value;
+  } catch { return null; }
+}
+/** Publish `data` to `path` atomically (temp + rename), so a reader never sees a partial file. */
+function publish(path: string, data: unknown): void {
+  const staged = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(staged, JSON.stringify(data) + '\n');
+  try { renameSync(staged, path); } catch (error) { rmSync(staged, { force: true }); throw error; }
+}
+function loadCache(dir: string, cut: Cut): DocsCache | null {
   try {
-    const value = JSON.parse(readFileSync(cacheFile(dir, cut), 'utf8')) as PrefetchCache;
+    const value = JSON.parse(readFileSync(cacheFile(dir, cut), 'utf8')) as DocsCache;
     if (value.version !== cut.version || value.commit !== cut.commit || value.manifestHash !== cut.manifestHash
-      || !SHA.test(value.main) || value.tree !== join(dir, 'tree') || !existsSync(value.tree)
+      || !SHA.test(value.main) || dirname(value.tree) !== dir || !/^tree-[0-9a-f-]{36}$/.test(basename(value.tree)) || !existsSync(value.tree)
       || value.docs?.outcome !== 'ok' || value.docs.version !== cut.version
       || value.docs.notes !== join(value.tree, 'release/public/docs/releases', `${cut.version}.md`)
       || value.docs.pages !== join(value.tree, 'website/pages.json')
@@ -191,21 +211,34 @@ export function stagePrefetch(context: GraphContext, env: NodeJS.ProcessEnv = pr
   const cut = cutFor(context, stateRoot);
   mkdirSync(dir, { recursive: true });
   const already = loadCache(dir, cut);
-  if (already) return already;
-  const tree = join(dir, 'tree');
+  if (already) return { ...already, tui: loadTuiCache(dir, cut)?.tui ?? null };
+  // An attempt gets its own path. A failed add can only remove a tree belonging to this attempt,
+  // even when an earlier cut or a concurrent worker has a checkout in the same run directory.
+  const tree = join(dir, `tree-${randomUUID()}`);
   let added = false;
+  // `git worktree add` can fail AFTER creating the tree directory (e.g. a failed checkout): clean up
+  // whenever the add succeeded OR the tree is on disk, so a retry of this run is never blocked (should-fix ①).
+  const removeTree = () => {
+    if (!(added || existsSync(tree))) return;
+    try { runner('git', ['worktree', 'remove', '--force', tree], repo, 60_000); } catch { /* preserve original failure */ }
+    // A remove that failed (or could not unregister the tree) must still leave no blocking directory behind.
+    if (existsSync(tree)) rmSync(tree, { recursive: true, force: true });
+  };
   try {
     const main = run('git', ['rev-parse', '--verify', 'origin/main^{commit}'], repo);
     if (!SHA.test(main)) throw new Error('invalid origin/main commit');
-    // TUI runs against the cut, on its own isolated worktree, before touching the docs checkout.
+    const cachedTui = loadTuiCache(dir, cut);
+    // TUI runs against the cut, on its own isolated session, before touching the docs checkout.
     // tui-sim-node.ts prints the RAW result (no `outcome`); judge it the way node-verdict.ts tui would before reuse.
-    const tuiData = deps.tui ? deps.tui(cut.commit) : (() => {
+    // Publish the reusable TUI in its OWN file the moment it is confirmed — a later docs failure or
+    // delay must not throw away a finished TUI (should-fix ②).
+    const tui = cachedTui ? cachedTui.tui : reusableTui(withTuiOutcome(0, deps.tui ? deps.tui(cut.commit) : (() => {
       const tuiRun = spawnSync('bun', ['scripts/release-loop/tui-sim-node.ts', '--commit', cut.commit, '--json'], {
         cwd: repo, timeout: Math.min(6 * 60_000, left()), encoding: 'utf8', maxBuffer: 16 * 1024 * 1024,
       });
       return tuiRun.status === 0 ? lastResult({ status: tuiRun.status, stdout: tuiRun.stdout ?? '', stderr: tuiRun.stderr ?? '' }) ?? null : null;
-    })();
-    const tui = reusableTui(withTuiOutcome(0, tuiData), cut.commit);
+    })()), cut.commit);
+    if (tui && !cachedTui) publish(tuiCacheFile(dir, cut), { ...cut, tui });
     run('git', ['worktree', 'add', '--detach', tree, main], repo);
     added = true;
     run('bun', ['install', '--frozen-lockfile'], tree);
@@ -220,19 +253,14 @@ export function stagePrefetch(context: GraphContext, env: NodeJS.ProcessEnv = pr
     const finalCut = cutFor(context, stateRoot);
     if (finalCut.manifestHash !== cut.manifestHash) throw new Error('manifest changed during prefetch');
     const result: PrefetchCache = { ...cut, main, tree, docs, tui };
-    const final = cacheFile(dir, cut);
-    const staged = `${final}.${process.pid}.${randomUUID()}.tmp`;
-    writeFileSync(staged, JSON.stringify(result) + '\n');
+    const docsCache: DocsCache = { ...cut, main, tree, docs };
     // Publication handshake: whoever creates `claim` first (O_EXCL) wins. The docs node claims before it reads,
     // so a worker that loses can never publish a cache that a docs attempt would consume.
-    if (!claimPrefetch(dir, 'worker')) {
-      rmSync(staged, { force: true });
-      throw new Error('docs node already ran; late prefetch is discarded');
-    }
-    renameSync(staged, final);
+    if (!claimPrefetch(dir, 'worker')) throw new Error('docs node already ran; late prefetch is discarded');
+    publish(cacheFile(dir, cut), docsCache);
     return result;
   } catch (error) {
-    if (added) { try { runner('git', ['worktree', 'remove', '--force', tree], repo, 60_000); } catch { /* preserve original failure */ } }
+    removeTree();
     throw error;
   }
 }
@@ -247,9 +275,10 @@ export function joinTui(context: GraphContext, env: NodeJS.ProcessEnv, repo: str
   }, stateRoot = effectiveInstanceRoot()): Record<string, unknown> {
   if (context.outputs.upgrade?.outcome !== 'ok') throw new Error('upgrade did not pass');
   // Any failure to key the cache (no manifest, cutoff mismatch, no run dir) is a cache miss → original TUI path.
+  // The TUI cache file is independent of docs (should-fix ②): a docs failure or delay never blocks this read.
   let cut: Cut | null = null;
-  let cached: PrefetchCache | null = null;
-  try { cut = cutFor(context, stateRoot); cached = loadCache(runCacheDir(env), cut); } catch { /* cache miss */ }
+  let cached: TuiCache | null = null;
+  try { cut = cutFor(context, stateRoot); cached = loadTuiCache(runCacheDir(env), cut); } catch { /* cache miss */ }
   const reused = cut && cached?.tui && reusableTui(cached.tui, cut.commit);
   if (reused) return { ...reused, outcome: 'ok', summary: `tui ${reused.verdict}` };
   // Preserve node-verdict.ts's exit convention and last-JSON output on a cache miss.
@@ -287,7 +316,7 @@ export function graphDocs(context: GraphContext, env: NodeJS.ProcessEnv, repo: s
   try {
     // No fetch (nor any write to remote) until every gate is verified.
     for (const node of ['gate', 'prepare', 'upgrade', 'tui']) if (context.outputs[node]?.outcome !== 'ok') throw new Error(`${node} did not pass`);
-    let cached: PrefetchCache | null = null;
+    let cached: DocsCache | null = null;
     // A cache key that cannot be computed is a miss — the original fresh-worktree path runs.
     if (mayConsume && cacheDir) { try { const cut = cutFor(context, stateRoot); cached = loadCache(cacheDir, cut); } catch { cached = null; } }
     const branch = `release-docs/${version}`;

package/scripts/release-loop/gate-batch-safe.ts

@@ -0,0 +1,23 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** Explicit opt-in only. A test enters a shared Pod after its own-Pod and batch verdicts have been compared. */
+export function loadGateBatchSafe(repoRoot: string): Set<string> {
+  const path = join(repoRoot, 'release/gate-batch-safe.json');
+  if (!existsSync(path)) return new Set();
+  let data: unknown;
+  try { data = JSON.parse(readFileSync(path, 'utf8')); }
+  catch (error) { throw new Error(`invalid gate batch safe list: ${path}`, { cause: error }); }
+  if (!data || typeof data !== 'object' || Array.isArray(data)
+    || !('env' in data) || data.env !== 'linux-pod'
+    || !('tests' in data) || !Array.isArray(data.tests)
+    || !data.tests.every((entry: unknown) => entry && typeof entry === 'object' && !Array.isArray(entry)
+      && 'file' in entry && typeof entry.file === 'string'
+      && /^(?:[\w.-]+\/)+[\w.-]+\.test\.tsx?$/.test(entry.file)
+      && 'evidence' in entry && typeof entry.evidence === 'string' && entry.evidence.trim().length > 0)) {
+    throw new Error(`invalid gate batch safe list: ${path}`);
+  }
+  const files = data.tests.map((entry: { file: string }) => entry.file);
+  if (new Set(files).size !== files.length) throw new Error(`invalid gate batch safe list: duplicate file in ${path}`);
+  return new Set(files);
+}