elanous 0.2.12 → 0.2.14

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

@@ -5,6 +5,7 @@ import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
+import { landingFreezeMessage, readLandingFreeze } from '../../src/release-loop/landing-freeze.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { getElanousConfigDirOverride } from '../../src/elanous-config-dir.js';
 import { diffFailures, junitFailures, parseFailures } from './gate-diff';
@@ -18,7 +19,7 @@ import { POD_BUN_CACHE_HOST_PATH, parseInstallSeconds, podBunCacheVolume } from
 import { PodPoolScheduler, parsePodPool, checkPodPool } from '../../src/task-orchestrator/surfaces/pod-pool.js';
 import { defaultKubectl } from '../../src/task-orchestrator/surfaces/self-implement-pod.js';
 
-interface CommandResult { rc: number; output: string; passedIds?: string[] }
+interface CommandResult { rc: number; output: string; passedIds?: string[]; stalledEnv?: Array<{ file: string; reason: 'no-output' }> }
 export interface GateRunner {
   command(cmd: string, args: string[], cwd: string): Promise<CommandResult>;
   localCommand(cmd: string, args: string[], cwd: string): Promise<CommandResult>;
@@ -32,6 +33,7 @@ export interface GateRunner {
 }
 export interface GateOptions {
   commit: string;
+  forceFreeze?: boolean;
   version: string;
   baselineVersion?: string;
   baselineCommit?: string;
@@ -50,6 +52,7 @@ export interface GateResult {
   fixed: number;
   knownEnv: number;
   knownEnvCleared: string[];
+  stalledEnv: Array<{ file: string; reason: 'no-output'; local: 'passed' | 'failed' }>;
   baselineSource?: 'ledger' | 'instance' | 'cut-logs' | 'swept';
   durationMs: number;
   error?: string;
@@ -322,13 +325,15 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
       const ran = clean && lastMatch(clean, /Ran (\d+) tests? across (\d+) files?/);
       const passes = clean === undefined ? NaN : summaryCount(clean, 'pass');
       const fails = clean === undefined ? NaN : summaryCount(clean, 'fail');
+      const errors = clean === undefined ? NaN : summaryCount(clean, 'error');
       let reason: ShardReason | undefined;
       let namedFailures: number | undefined;
       let unattributedDetail: string | undefined;
       if (jobFailed || (jobExitCode !== undefined && jobExitCode !== 0) || (rc !== undefined && rc !== 0 && rc !== 1)) reason = 'job-failed';
       else if (!clean || rc === undefined) reason = 'no-output';
       else if (!ran || !Number.isFinite(passes) || !Number.isFinite(fails)
-        || Number(ran[2]) === 0 || Number(ran[2]) > paths.length || Number(ran[1]) === 0) reason = 'incomplete';
+        || Number(ran[2]) === 0 || Number(ran[2]) > paths.length
+        || (Number(ran[1]) === 0 && !(errors > 0))) reason = 'incomplete';
       else {
         try {
           const attributed = failuresOf({ rc, output: clean }, `pod-${shard} shard`);
@@ -400,7 +405,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
         return { runs: children.flatMap((child) => child.runs), stalled: children.flatMap((child) => child.stalled) };
       }
       return { runs: [{ output: clean!, rc: rc!, pass: passes, fail: fails,
-        errors: Number.isNaN(summaryCount(clean!, 'error')) ? 0 : summaryCount(clean!, 'error'),
+        errors: Number.isNaN(errors) ? 0 : errors,
         ran: Number(ran![1]), files: Number(ran![2]), passedIds: junit ? junitPassedIds(junit) : [] }], stalled: [] };
     };
     // 모든 조각이 끝난 뒤 판정한다 — 한 조각의 예외로 먼저 돌아가면 다른 Pod 가 도는 채로 정리가 시작된다(#22002 리뷰 R3).
@@ -413,11 +418,12 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     const total = measured.reduce((sum, run) => ({ pass: sum.pass + run.pass, fail: sum.fail + run.fail,
       errors: sum.errors + run.errors, ran: sum.ran + run.ran, files: sum.files + run.files }),
     { pass: 0, fail: 0, errors: 0, ran: 0, files: 0 });
-    if (stalledShards.length) throw new StalledPodShards(stalledShards, total);
-    if (total.ran === 0 && total.errors === 0) throw new Error('sweep incomplete: no tests ran');
+    if (stalledShards.some((item) => item.reason !== 'no-output' || item.files.length !== 1)) throw new StalledPodShards(stalledShards, total);
+    if (total.ran === 0 && total.errors === 0 && !stalledShards.length) throw new Error('sweep incomplete: no tests ran');
     const outputs = measured.map((run) => run.output.replace(/(?:^|\n)\s*\d+ (?:pass|fail|errors?)\s*(?=\n|$)/g, '\n').replace(/Ran \d+ tests? across \d+ files?\.?/g, ''));
     return { rc: total.fail + total.errors ? 1 : 0, output: outputs.join('\n') + `\n${total.pass} pass\n${total.fail} fail\n${total.errors} errors\nRan ${total.ran} tests across ${total.files} files.\n`,
-      passedIds: [...new Set(measured.flatMap((run) => run.passedIds))].sort() };
+      passedIds: [...new Set(measured.flatMap((run) => run.passedIds))].sort(),
+      stalledEnv: stalledShards.flatMap((item) => item.files.map((file) => ({ file, reason: 'no-output' as const }))) };
   };
   return {
     command,
@@ -533,6 +539,12 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
   const start = Date.now();
   const explicitConfig = getElanousConfigDirOverride();
   const root = explicitConfig ? effectiveInstanceRoot() : (opts.instanceRoot ?? effectiveInstanceRoot());
+  // The freeze is read from the same root the gate runs in (a config-dir override must not move it elsewhere).
+  const frozen = readLandingFreeze(root);
+  if (frozen) {
+    debug.log('release.run', opts.forceFreeze ? 'freeze-forced' : 'frozen', { version: opts.version, reason: frozen.reason, until: frozen.until, node: 'gate' });
+    if (!opts.forceFreeze) throw new Error(landingFreezeMessage(frozen));
+  }
   const ledger = explicitConfig ? root : (opts.ledgerRoot ?? releaseLedgerRoot());
   const roots = [...new Set([ledger, root])];
   const cachedBaseline = (version: string, commit: string) => {
@@ -550,7 +562,7 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     return baselineCommit(root, version);
   };
   const repo = resolve(opts.repo ?? process.cwd());
-  const result: GateResult = { outcome: 'error', commit: opts.commit, introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], durationMs: 0 };
+  const result: GateResult = { outcome: 'error', commit: opts.commit, introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], durationMs: 0 };
   let work: string | undefined;
   let baseSnapshot = false;
   let cutFailures: SweepFailures | undefined;
@@ -601,7 +613,38 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     for (const dir of [cutTree, join(cutTree, 'apps/pwa')]) check(await runner.command('bun', ['install'], dir), `bun install ${dir}`);
     const cutRun = await runner.sweep(cutTree, join(root, 'release', opts.version, 'gate-logs', 'cut'),
       opts.pod ? { ...opts.pod, durationSource: join(ledger, 'release', opts.baselineVersion, 'gate-logs', 'cut') } : undefined);
-    const cut = failuresOf(cutRun, 'cut sweep');
+    const localStalled = async (run: CommandResult, tree: string, commit: string, label: string) => {
+      const stalled = run.stalledEnv ?? [];
+      const noCompletedShard = stalled.length && run.rc === 0
+        && /(?:^|\n)0 pass\n0 fail\n0 errors\nRan 0 tests across 0 files\./.test(run.output);
+      const measured: SweepFailures = noCompletedShard ? { failures: [], errors: [] } : failuresOf(run, `${label} sweep`);
+      if (!stalled.length) return measured;
+      let hostTree = tree;
+      const local: GateResult['stalledEnv'] = [];
+      try {
+        if (opts.remote) {
+          hostTree = join(mkdtempSync(join(tmpdir(), 'release-gate-local-')), 'cut');
+          check(await runner.localCommand('git', ['clone', '--quiet', '--shared', '--no-checkout', repo, hostTree], repo), 'host cut clone');
+          check(await runner.localCommand('git', ['checkout', '--quiet', '--detach', commit], hostTree), 'host cut checkout');
+          for (const dir of [hostTree, join(hostTree, 'apps/pwa')]) check(await runner.localCommand('bun', ['install'], dir), `host bun install ${dir}`);
+        }
+        for (const { file, reason } of stalled) {
+          if (!/^(?:[\w.-]+\/)+[\w.-]+\.test\.tsx?$/.test(file) || file.split('/').includes('..')) throw new Error(`unsafe test path: ${file}`);
+          const isolated = await runner.localCommand('bun', ['run', 'test:deterministic', asPath(file)], hostTree);
+          const parsed = failuresOf(isolated, `${label} host isolated ${file}`);
+          if ([...parsed.failures, ...parsed.errors].some((id) => fileOf(id) !== file)) throw new Error(`host isolated run attributed to another file: ${file}`);
+          measured.failures.push(...parsed.failures);
+          measured.errors.push(...parsed.errors);
+          local.push({ file, reason, local: parsed.failures.length || parsed.errors.length ? 'failed' : 'passed' });
+        }
+      } finally {
+        if (opts.remote && hostTree !== tree) rmSync(dirname(hostTree), { recursive: true, force: true });
+      }
+      result.stalledEnv.push(...local);
+      debug.log('release-loop.gate', 'pod-shard-stalled-env', { files: stalled.map(({ file, reason }) => ({ file, reason })), local });
+      return measured;
+    };
+    const cut = await localStalled(cutRun, cutTree, opts.commit, 'cut');
     cutFailures = cut;
     const baseSha = opts.baselineCommit ?? baselineReleaseCommit(opts.baselineVersion);
     const cached = cachedBaseline(opts.baselineVersion, baseSha);
@@ -630,22 +673,24 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
       // hour of local baseline after a 23-minute Pod cut).
       const baseRun = await runner.sweep(await getBaseTree(), join(root, 'release', opts.version, 'gate-logs', 'baseline'),
         opts.pod ? { ...opts.pod, durationSource: join(ledger, 'release', opts.baselineVersion, 'gate-logs', 'cut') } : undefined);
-      baseline = failuresOf(baseRun, 'baseline sweep');
+      baseline = await localStalled(baseRun, baseTree!, baseSha, 'baseline');
     }
     for (const id of [...baseline.failures, ...baseline.errors, ...cut.failures, ...cut.errors]) fileOf(id);
     const known = opts.pod ? loadEnvKnownFailures(repo) : new Set<string>();
     const cutIds = [...cut.failures, ...cut.errors];
+    const cutHostFailed = new Set(cutRun.stalledEnv?.map(({ file }) => file) ?? []);
     const baselineIds = [...baseline.failures, ...baseline.errors];
     const countedCut = splitKnownEnv(cutIds, known);
     const countedBaseline = splitKnownEnv(baselineIds, known);
     result.knownEnv = countedCut.knownEnv.length;
-    result.knownEnvCleared = [...new Set(cutRun.passedIds ?? [])].filter((id) => known.has(id) && !cutIds.includes(id)).sort();
+    result.knownEnvCleared = [...new Set(cutRun.passedIds ?? [])].filter((id) => known.has(id) && !cutIds.includes(id) && !cutRun.stalledEnv?.some(({ file }) => fileOf(id) === file)).sort();
     const diff = diffFailures(countedCut.counted, countedBaseline.counted);
     result.fixed = diff.fixed.length;
     result.preexisting = diff.common.length;
     for (const file of new Set(diff.newFailures.map(fileOf))) {
-      const isolated = await runner.command('bun', ['run', 'test:deterministic', asPath(file)], cutTree);
-      const isolatedCut = failuresOf(isolated, `cut isolated ${file}`);
+      const isolatedCut = cutHostFailed.has(file)
+        ? { failures: cut.failures.filter((id) => fileOf(id) === file), errors: cut.errors.filter((id) => fileOf(id) === file) }
+        : failuresOf(await runner.command('bun', ['run', 'test:deterministic', asPath(file)], cutTree), `cut isolated ${file}`);
       const reproduced = new Set([...isolatedCut.failures, ...isolatedCut.errors]);
       const candidates = diff.newFailures.filter((id) => fileOf(id) === file && reproduced.has(id));
       if (candidates.length === 0) continue;
@@ -690,7 +735,7 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     if (opts.remote) runner.remoteMirror = undefined;
     result.durationMs = Date.now() - start;
   }
-  if (cutFailures && !result.stalledShards?.length) {
+  if (cutFailures && !result.stalledShards?.length && !result.stalledEnv.length) {
     try {
       for (const location of roots) {
         const path = failureFile(location, opts.version);
@@ -714,7 +759,8 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
 export function graphGateResult(result: GateResult, graph: boolean) {
   return { ...result, ...(graph && result.outcome === 'regression' ? { outcome: 'fail' as const } : {}),
     verdict: result.outcome === 'ok' ? 'pass' as const : 'fail' as const,
-    summary: (result.outcome === 'ok' ? `새 회귀 ${result.introduced.length} · 기존 ${result.preexisting} · 고침 ${result.fixed}` : `게이트 ${result.outcome}: ${result.error ?? result.introduced.length + ' new regressions'}`) + ` · 환경 알려진 실패 ${result.knownEnv}` };
+    summary: (result.outcome === 'ok' ? `새 회귀 ${result.introduced.length} · 기존 ${result.preexisting} · 고침 ${result.fixed}` : `게이트 ${result.outcome}: ${result.error ?? result.introduced.length + ' new regressions'}`) + ` · 환경 알려진 실패 ${result.knownEnv}`
+      + (result.stalledEnv.length ? ` · 환경 멈춤 ${result.stalledEnv.length} (Pod 밖 통과 ${result.stalledEnv.filter((item) => item.local === 'passed').length})` : '') };
 }
 
 export function parseOptions(args: string[], env: NodeJS.ProcessEnv): GateOptions | 'help' {
@@ -728,6 +774,7 @@ export function parseOptions(args: string[], env: NodeJS.ProcessEnv): GateOption
     commit: typeof fromGraph.commit === 'string' ? fromGraph.commit : '',
     version: typeof fromGraph.version === 'string' ? fromGraph.version : '',
     baselineVersion: typeof fromGraph.previousVersion === 'string' ? fromGraph.previousVersion : undefined,
+    forceFreeze: fromGraph.forceFreeze === true,
     baselineCommit: typeof fromGraph.previousCommit === 'string' ? fromGraph.previousCommit : undefined,
     remote: typeof fromGraph.gateRemote === 'string' ? fromGraph.gateRemote : undefined,
     remoteMirror: typeof fromGraph.gateRemoteMirror === 'string' ? fromGraph.gateRemoteMirror : undefined,
@@ -772,7 +819,7 @@ if (import.meta.main) {
     version = opts.version;
     result = await judgeGate(opts);
   } catch (error) {
-    result = { outcome: 'error', commit: '', introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], durationMs: Date.now() - start, error: String(error) };
+    result = { outcome: 'error', commit: '', introduced: [], preexisting: 0, fixed: 0, knownEnv: 0, knownEnvCleared: [], stalledEnv: [], durationMs: Date.now() - start, error: String(error) };
   }
   if (result.error) console.error(result.error);
   debug.log('release-loop.gate', 'result', { version, outcome: result.outcome });

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

@@ -7,7 +7,7 @@ import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runC
 
 interface HostResult { host: string; ok: boolean; before: string; after: string; error?: string; skipped?: string; hooks?: string; restart?: 'no-service' }
 /** Where the internal feed is packed from: a checkout of the release tag, never the run's working tree. */
-export interface FeedSource { checkout: string; commit: string; cleanup: () => void }
+export interface FeedSource { checkout: string; commit: string; deps: 'linked' | 'installed'; cleanup: () => void }
 interface OpsUpgradeDeps { exists?: (path: string) => boolean; installSource?: () => string | null; feedSource?: (version: string) => FeedSource }
 
 /** Detached worktree at refs/tags/v<version> with the PWA built — the feed ships what was released (10-04 0.2.11:
@@ -26,16 +26,28 @@ export function tagFeedSource(run: CommandRunner, repo: string = process.cwd()):
     try {
       const added = run('git', ['worktree', 'add', '--detach', tree, commit], repo);
       if (added.status !== 0) throw new Error(`태그 체크아웃 실패: ${reason(added)}`);
-      symlinkSync(join(repo, 'node_modules'), join(tree, 'node_modules'));
-      if (existsSync(join(repo, 'apps/pwa/node_modules'))) symlinkSync(join(repo, 'apps/pwa/node_modules'), join(tree, 'apps/pwa/node_modules'));
+      const sameDeps = ['bun.lock', 'apps/pwa/bun.lock', 'package.json', 'apps/pwa/package.json'].every((file) => {
+        try { return readFileSync(join(repo, file), 'utf8') === readFileSync(join(tree, file), 'utf8'); }
+        catch { return false; }
+      });
+      const deps: FeedSource['deps'] = sameDeps ? 'linked' : 'installed';
+      if (sameDeps) {
+        symlinkSync(join(repo, 'node_modules'), join(tree, 'node_modules'));
+        if (existsSync(join(repo, 'apps/pwa/node_modules'))) symlinkSync(join(repo, 'apps/pwa/node_modules'), join(tree, 'apps/pwa/node_modules'));
+      } else {
+        for (const cwd of [tree, join(tree, 'apps/pwa')]) {
+          const installed = run('bun', ['install', '--frozen-lockfile'], cwd, 900_000);
+          if (installed.status !== 0) throw new Error(`태그 의존성 설치 실패: ${reason(installed)}`);
+        }
+      }
       // The feed carries the PWA build (apps/pwa/out is ignored, so a fresh tag checkout has none until built).
       const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], tree, 900_000);
       if (built.status !== 0) throw new Error(`태그 PWA 빌드 실패: ${reason(built)}`);
+      return { checkout: tree, commit, deps, cleanup };
     } catch (error) {
       cleanup();
       throw error;
     }
-    return { checkout: tree, commit, cleanup };
   };
 }
 
@@ -96,7 +108,7 @@ export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeD
         const data = lastResult(feed);
         if (feed.status !== 0 || data?.ok !== true || data.version !== version) feedError = `내부 피드 발행 실패: ${feed.status === 0 && data?.ok === true ? `판 불일치 (${String(data.version)})` : reason(feed)}`;
         else if (data.commit !== source.commit) feedError = `내부 피드 발행 실패: 묶은 커밋 ${String(data.commit).slice(0, 12)} ≠ 태그 ${source.commit.slice(0, 12)}`;
-        debug.log('release-loop.ops-upgrade', 'feed-source', { version, commit: source.commit, source: `refs/tags/v${version}`, packed: data?.commit, pwaBuild: data?.pwaBuild });
+        debug.log('release-loop.ops-upgrade', 'feed-source', { version, commit: source.commit, source: `refs/tags/v${version}`, deps: source.deps, packed: data?.commit, pwaBuild: data?.pwaBuild });
       }
     } catch (error) { feedError = `내부 피드 발행 실패: ${firstLine(String(error))}`; }
     finally { source?.cleanup(); }

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

@@ -3,6 +3,8 @@ import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { WARNING_ONLY } from './auto-approve-node.js';
+import { beginLandingMerge, landingFreezeMessage } from '../../src/release-loop/landing-freeze.js';
+import { debug } from '../../src/debug/log.js';
 import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
 
 export function publicNotes(markdown: string, pages: { pages: Array<{ id: string; slug?: string; source?: string }> }): string {
@@ -64,7 +66,18 @@ export function runPublish(run: CommandRunner = runCommand) {
   try {
     const file = join(dir, 'notes.md');
     writeFileSync(file, body);
-    const published = run('bun', ['bin/elanous.mjs', 'release', 'publish', '--dir', out, '--notes-file', file, '--yes', '--json']);
+    // Same in-flight marker as merges: `freeze on` waits for a publication that already passed this check.
+    // Unlike a merge, a frozen publication is not queued: it fails, and the release run is run again after `freeze off`.
+    const landing = beginLandingMerge();
+    const frozen = landing.frozen;
+    if (frozen) {
+      landing.end(); // already released by beginLandingMerge when frozen; kept explicit so no path leaves a marker
+      debug.log('release.run', context.input.forceFreeze === true ? 'freeze-forced' : 'frozen', { version, reason: frozen.reason, until: frozen.until, node: 'publish' });
+      if (context.input.forceFreeze !== true) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `publish blocked: ${landingFreezeMessage(frozen)}` };
+    }
+    let published: ReturnType<typeof run>;
+    try { published = run('bun', ['bin/elanous.mjs', 'release', 'publish', '--dir', out, '--notes-file', file, '--yes', '--json']); }
+    finally { landing.end(); }
     if (published.stderr) process.stderr.write(published.stderr);
     const result = lastResult(published);
     if (published.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `release publish failed: ${result?.error ?? published.stderr.trim()}` };

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

@@ -4,6 +4,8 @@ import { getElanousConfigDirOverride } from '../../src/elanous-config-dir.js';
 import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
 import { userConfigPath } from '../../src/user-config.js';
 import { checklistGate } from '../../src/release-loop/checklist.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';
 
 const VERSION = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
@@ -26,6 +28,7 @@ export interface ReleaseRunInput extends ReleaseLoopConfig {
   previousVersion: string;
   cutCommit?: string;
   gatePodPool: string;
+  forceFreeze?: boolean;
 }
 
 export interface UnattendedReleaseDeps {
@@ -34,6 +37,7 @@ export interface UnattendedReleaseDeps {
   configPath?: string;
   graph?: (path: string, options: { input: ReleaseRunInput }) => Promise<GraphRunState>;
   checklist?: typeof checklistGate;
+  freezeRoot?: string;
 }
 
 function compareVersions(a: string, b: string): number {
@@ -83,13 +87,31 @@ export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDep
 
 /** Fail closed at the entry boundary, before any graph node can change a release. */
 export async function runUnattendedRelease(
-  opts: { version: string; dryRun?: boolean; cutCommit?: string },
+  opts: { version: string; dryRun?: boolean; cutCommit?: string; forceFreeze?: boolean },
   deps: UnattendedReleaseDeps = {},
 ): Promise<{ input: ReleaseRunInput; dryRun: boolean; state?: GraphRunState }> {
+  if (!opts.dryRun) {
+    const frozen = readLandingFreeze(deps.freezeRoot);
+    if (frozen) {
+      debug.log('release.run', opts.forceFreeze ? 'freeze-forced' : 'frozen', { version: opts.version, reason: frozen.reason, until: frozen.until });
+      if (!opts.forceFreeze) throw new LandingFrozenError(frozen);
+    }
+  }
   const input = buildReleaseRunInput(opts.version, deps, opts.cutCommit);
+  if (opts.forceFreeze) input.forceFreeze = true;
   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(', ')}`);
+  const beforeGraph = readLandingFreeze(deps.freezeRoot);
+  if (beforeGraph && !opts.forceFreeze) throw new LandingFrozenError(beforeGraph);
   const state = await (deps.graph ?? runGraph)(GRAPH, { input });
+  // 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) {
+    const refused = (state.nodes ?? []).find((node) => (node.nodeId === 'gate' || node.nodeId === 'publish') && !node.ok
+      && isLandingFreezeRefusal(`${typeof node.output === 'string' ? node.output : JSON.stringify(node.output ?? '')} ${node.error ?? ''}`));
+    const during = refused ? readLandingFreeze(deps.freezeRoot) : null;
+    if (refused) throw new LandingFrozenError(during ?? { reason: 'frozen during the run', startedAt: new Date().toISOString(), until: null, by: 'release-run' });
+  }
   return { input, dryRun: false, state };
 }

package/scripts/release-loop/vault-note-node.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env bun
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../../src/debug/log.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
+import { listChecklist, type ChecklistItem } from '../../src/release-loop/checklist.js';
+import { userConfigPath } from '../../src/user-config.js';
+import { finishNode, readGraphContext, type GraphContext } from './node-verdict.js';
+
+const directory = '40. Project/엘라누스 릴리스';
+const indexName = '_색인 — 엘라누스 릴리스.md';
+const kst = new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' });
+
+function publishedTime(value: string): { date: string; short: string; full: string } {
+  const instant = new Date(value);
+  if (Number.isNaN(instant.getTime())) throw new Error(`invalid publishedAt: ${value}`);
+  const parts = Object.fromEntries(kst.formatToParts(instant).map(({ type, value: part }) => [type, part]));
+  const date = `${parts.year}-${parts.month}-${parts.day}`;
+  return { date, short: `${parts.month}-${parts.day} ${parts.hour}:${parts.minute}`, full: `${date} ${parts.hour}:${parts.minute} KST` };
+}
+
+function firstClause(title: string): string {
+  return title.split(/\s+[—–·]\s+|[\n。]/, 1)[0]!.trim().replace(/\s+/g, ' ');
+}
+
+function changeCount(draft: string): number {
+  return draft.split(/\r?\n/).filter((line) => /^\s*(?:[-*] |\d+\. )/.test(line)).length;
+}
+
+function configuredVaultRoot(configPath: string): string | undefined {
+  if (!existsSync(configPath)) return undefined;
+  const raw = JSON.parse(readFileSync(configPath, 'utf8')) as { obsidian?: { vaultRoot?: unknown; vault?: unknown } };
+  const value = raw.obsidian?.vaultRoot ?? raw.obsidian?.vault;
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function releaseHistory(context: GraphContext, root: string): string[] {
+  const identity = context as GraphContext & { graphId?: string; runId?: string };
+  if (identity.graphId !== 'release-loop' || !identity.runId || !/^[\w.-]+$/.test(identity.runId)) return [];
+  const dir = join(root, 'graph-runs', 'release-loop');
+  type Run = { graphId: string; runId: string; startedAt?: string; input?: { version?: string };
+    nodes?: Array<{ nodeId: string; ok: boolean; output?: string; error?: string }> };
+  const current = JSON.parse(readFileSync(join(dir, `${identity.runId}.json`), 'utf8')) as Run;
+  if (current.graphId !== 'release-loop' || current.runId !== identity.runId || current.input?.version !== context.input.version || !Array.isArray(current.nodes)) {
+    throw new Error('release graph run identity mismatch');
+  }
+  const runs = readdirSync(dir).filter((file) => file.endsWith('.json') && !file.includes('.decision.json') && /^[\w.-]+\.json$/.test(file))
+    .map((file) => {
+      try { return JSON.parse(readFileSync(join(dir, file), 'utf8')) as Run; }
+      catch { return undefined; }
+    }).filter((run): run is Run => !!run && run.graphId === 'release-loop' && run.input?.version === context.input.version
+      && Array.isArray(run.nodes) && (run.runId === identity.runId || !!current.startedAt && !!run.startedAt && run.startedAt <= current.startedAt));
+  const history: string[] = [];
+  for (const nodeId of ['gate', 'cutoff']) {
+    const attempts = runs.flatMap((run) => run.nodes!.filter((node) => node.nodeId === nodeId));
+    if (attempts.length < 2 || !current.nodes.some((node) => node.nodeId === nodeId && node.ok)) continue;
+    const failed = attempts.find((node) => !node.ok);
+    if (!failed) continue;
+    let reason = failed.error;
+    if (failed.output) {
+      try {
+        const data = JSON.parse(failed.output.trim().split('\n').at(-1)!) as { reason?: string; summary?: string };
+        reason = data.reason ?? data.summary ?? reason;
+      } catch { /* The graph retained an unstructured command failure. */ }
+    }
+    history.push(`- ${nodeId === 'gate' ? '게이트 재시도' : '재컷'}: ${reason ?? '사유 기록 없음'}`);
+  }
+  return history;
+}
+
+interface ReleaseRecord { version: string; tag: string; sourceCommit: string; publishedAt: string; publicRepo?: string }
+export interface VaultNoteDeps {
+  instanceRoot?: string;
+  productionRoot?: string;
+  vaultRoot?: string;
+  configPath?: string;
+  checklist?: (version: string) => Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status'>[];
+}
+
+export function featureFamily(id: string): string {
+  const stem = id.replace(/[-_]?\d+[a-z]?$/i, '');
+  return (stem.split('-')[0] || id).toUpperCase();
+}
+
+export function runVaultNote(context: GraphContext = readGraphContext(), deps: VaultNoteDeps = {}) {
+  const version = context.input.version;
+  try {
+    if ((deps.instanceRoot ?? effectiveInstanceRoot()) !== (deps.productionRoot ?? prodInstanceRoot())) {
+      debug.log('release.vault-note', 'skipped', { version, reason: 'isolated' });
+      return { outcome: 'ok' as const, verdict: 'pass' as const, summary: 'skipped: isolated', skipped: 'isolated' };
+    }
+    const vault = deps.vaultRoot ?? configuredVaultRoot(deps.configPath ?? userConfigPath());
+    if (!vault) {
+      // OP 10-04 19:10 ③: no vault configured is not a failure — skip and say so.
+      debug.log('release.vault-note', 'skipped', { version, reason: 'no-vault' });
+      return { outcome: 'ok' as const, verdict: 'pass' as const, summary: 'skipped: no-vault', skipped: 'no-vault' };
+    }
+    const root = deps.instanceRoot ?? effectiveInstanceRoot();
+    const record: ReleaseRecord = JSON.parse(readFileSync(join(root, 'release', version, 'release.json'), 'utf8'));
+    if (record.version !== version || record.tag !== `v${version}` || !/^[0-9a-f]{8,40}$/i.test(record.sourceCommit))
+      throw new Error('invalid release.json version, tag or sourceCommit');
+    const publicRepo = record.publicRepo;
+    if (typeof publicRepo !== 'string' || !/^[\w.-]+\/[\w.-]+$/.test(publicRepo)) throw new Error('release.json publicRepo missing or invalid');
+    const published = publishedTime(record.publishedAt);
+    const draft = readFileSync(join(root, 'release', version, 'prepared', 'notes-draft.md'), 'utf8');
+    const items = (deps.checklist ?? ((v) => listChecklist(v).items))(version).filter((item) => item.status === 'green');
+    const oneLine = items.slice(0, 3).map((item) => firstClause(item.title)).join(' · ');
+    const location = process.env.ELANOUS_GRAPH_CONTEXT;
+    const identity = location && !('runId' in context)
+      ? JSON.parse(location.trimStart().startsWith('{') ? location : readFileSync(location, 'utf8')) as { graphId?: string; runId?: string }
+      : {};
+    const history = releaseHistory({ ...identity, ...context }, root);
+    // OP 10-04 19:10 ①: group by feature family (cell id family: HQ-FENCE2 → HQ · LOOP-OBS1 → LOOP · K10i → K), not by seat.
+    const groups = new Map<string, typeof items>();
+    for (const item of items) {
+      const heading = featureFamily(item.id);
+      if (!groups.has(heading)) groups.set(heading, []);
+      groups.get(heading)!.push(item);
+    }
+    const abilities = [...groups].flatMap(([heading, group]) => [
+      `### ${heading}`, '',
+      ...group.flatMap((item) => [
+        `- ${item.id} — ${firstClause(item.title)}`,
+        ...[...item.title.matchAll(/`([^`]+)`/g)].map((match) => `  - 명령: \`${match[1]}\``),
+        '',
+      ]),
+    ]);
+    const target = join(vault, directory);
+    const name = `엘라누스 v${version} (${published.date})`;
+    // 대표 10-04 19:25: notes live under <major>.x/<major>.<minor>/ · the index stays at the top.
+    const [major, minor] = version.split('.');
+    const noteDir = join(target, `${major}.x`, `${major}.${minor}`);
+    const note = join(noteDir, `${name}.md`);
+    const indexPath = join(target, indexName);
+    const current = existsSync(indexPath) ? readFileSync(indexPath, 'utf8') : '# 엘라누스 릴리스\n\n| 판 | 발행 | 한 줄 |\n|---|---|---|\n';
+    const row = `| [[${name}\\|v${version}]] | ${published.short} | ${oneLine.replace(/\|/g, '\\|')} |`;
+    const rowExists = current.split(/\r?\n/).some((line) => line.startsWith('| [[') && line.includes(`|v${version}]]`));
+    const header = /\| 판 \| 발행 \| 한 줄 \|\r?\n\|[- :|]+\|\r?\n/;
+    if (!rowExists && !header.test(current)) throw new Error(`index table header missing: ${indexPath}`);
+    mkdirSync(noteDir, { recursive: true });
+    const content = [
+      '---', `title: "엘라누스 v${version} — ${oneLine.replace(/"/g, '\\"')}"`,
+      `version: ${version}`, `published: ${published.full}`, `cut: ${record.sourceCommit.slice(0, 8)}`,
+      'tags: [elanous, release]', 'links:', `  github: https://github.com/${publicRepo}/releases/tag/${record.tag}`,
+      `  npm: elanous@${version}`, '---', '', `# 엘라누스 v${version} — ${oneLine}`, '',
+      '## 한 줄', '', oneLine, '',
+      '## 발행 경과', '', `- ${published.full} 발행`, ...history, '',
+      '## 이제 할 수 있는 것', '', ...abilities, '## 숫자', '',
+      `- 변경 ${changeCount(draft)}건`, `- green 칸 ${items.length}개`, '',
+    ].join('\n');
+    // A handwritten note at the old flat location (e.g. OP's v0.2.13 sample) counts as existing — never duplicate it.
+    let existed = existsSync(join(target, `${name}.md`));
+    if (!existed) {
+      try { writeFileSync(note, content, { flag: 'wx' }); }
+      catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+        existed = true;
+      }
+    }
+    if (!rowExists) {
+      const tableHeader = header.exec(current)!;
+      const tableStart = tableHeader.index + tableHeader[0].length;
+      let insertAt = tableStart;
+      const publishedKey = `${published.date} ${published.short.slice(6)}`;
+      const rows = current.slice(tableStart).matchAll(/^\| \[\[.*?\((\d{4}-\d{2}-\d{2})\)\\?\|v([^\]]+)\]\] \| (\d{2}-\d{2} \d{2}:\d{2}) \|[^\r\n]*(?:\r?\n|$)/gm);
+      for (const existing of rows) {
+        if (existing.index !== insertAt - tableStart) break;
+        const existingKey = `${existing[1]} ${existing[3]!.slice(6)}`;
+        if (existingKey < publishedKey || (existingKey === publishedKey && existing[2]!.localeCompare(version, 'en', { numeric: true }) < 0)) break;
+        insertAt += existing[0].length;
+      }
+      const newline = tableHeader[0].includes('\r\n') ? '\r\n' : '\n';
+      const separator = insertAt === current.length && !current.endsWith('\n') ? newline : '';
+      writeFileSync(indexPath, `${current.slice(0, insertAt)}${separator}${row}${newline}${current.slice(insertAt)}`);
+    }
+    debug.log('release.vault-note', existed ? 'skipped' : 'written', { version, reason: existed ? 'exists' : 'created' });
+    return { outcome: 'ok' as const, verdict: 'pass' as const, summary: existed ? 'skipped: exists' : `vault note written: ${name}`, ...(existed ? { skipped: 'exists' } : {}) };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    debug.log('release.vault-note', 'failed', { version, reason });
+    return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `vault note failed: ${reason}`, reason };
+  }
+}
+
+if (import.meta.main) {
+  let version = '';
+  try {
+    const context = readGraphContext();
+    version = context.input.version;
+    process.exitCode = finishNode('vault-note', version, runVaultNote(context));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    debug.log('release.vault-note', 'failed', { version, reason });
+    process.exitCode = finishNode('vault-note', version, { outcome: 'fail', verdict: 'fail', summary: `vault note failed: ${reason}`, reason });
+  }
+}