elanous 0.2.13 → 0.2.15

package/scripts/marketing/generate-feature-map.ts

@@ -0,0 +1,118 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { FEATURE_MATURITY, type Maturity } from '../../src/maturity/feature-maturity.js';
+import type { ChecklistItem } from '../../src/release-loop/checklist.js';
+
+const DEFAULT_MAP = resolve(import.meta.dir, '../../docs/marketing/MAP-value-props-to-features.md');
+const HELD = /특허\s*(?:보류|후보)|GOAL-CASCADE/i;
+const PR = /(?:^|[^\w])#(\d+)\b|\/pull\/(\d+)\b/g;
+type Grade = '된다' | '베타' | '로드맵';
+type Row = { feature: string; grade: Grade; id: string; pr: string };
+type Registry = typeof FEATURE_MATURITY;
+
+function cells(line: string): string[] {
+  return line.slice(1, -1).split(/(?<!\\)\|/).map((cell) => cell.trim().replace(/\\\|/g, '|'));
+}
+
+function clean(text: string): string {
+  return text.replace(/\*\*/g, '').replace(/\s+/g, ' ').trim();
+}
+
+function gradeFor(feature: string, hint: string, registry: Registry): Maturity | undefined {
+  // A surface alone ("cli", "telegram") does not identify a feature in the registry.
+  const key = /\/(?:[\w-]+)(?:\/[\w-]+)*/.exec(hint)?.[0];
+  if (key && Object.prototype.hasOwnProperty.call(registry.pwaRoute, key))
+    return registry.pwaRoute[key as keyof Registry['pwaRoute']].pwa;
+  const named = /\b(cliRoot|tuiSlash|telegramCommand|discordCommand):([\w:-]+)/.exec(hint);
+  if (named) {
+    const group = registry[named[1] as Exclude<keyof Registry, 'pwaRoute'>] as Record<string, Maturity>;
+    return Object.prototype.hasOwnProperty.call(group, named[2]!) ? group[named[2]!] : undefined;
+  }
+  // Explicit command spelling in a feature name is unambiguous; a prose word is not.
+  const command = /`(?:elanous )?([\w:-]+)`/.exec(feature)?.[1];
+  if (command && Object.prototype.hasOwnProperty.call(registry.cliRoot, command))
+    return registry.cliRoot[command as keyof Registry['cliRoot']];
+  return undefined;
+}
+
+function prs(text: string): string[] {
+  return [...new Set([...text.matchAll(PR)].map((m) => `#${m[1] ?? m[2]}`))];
+}
+
+function escapeCell(text: string): string {
+  return text.replace(/\|/g, '\\|').replace(/[\r\n]+/g, ' ');
+}
+
+/** Checklist cells require green status; rows without checklist cells use the map's maturity and public marker. */
+export function generateFeatureMap(input: { map: string; items: readonly ChecklistItem[]; registry: Registry; version: string }): string {
+  const checklist = new Map(input.items.map((item) => [item.id, item]));
+  const green = new Map(input.items.filter((item) => item.status === 'green').map((item) => [item.id, item]));
+  const rows: Row[] = [];
+  let section = '';
+  for (const line of input.map.split(/\r?\n/)) {
+    if (/^#{2,3} /.test(line)) section = line;
+    if (!section.startsWith('## 2. 기능 배치표 ') || !line.startsWith('|')) continue;
+    const columns = cells(line);
+    if (columns.length !== 8 || !/^P\d+(?:[·⊕]P\d+)*$/.test(clean(columns[0]!))) continue;
+    const [_, rawFeature, rawId, , hint, publication, evidence] = columns;
+    const feature = clean(rawFeature!);
+    if (!feature || feature === '—') continue;
+    const id = clean(rawId!);
+    const ids = id.split(/[·⊕]/).map((part) => part.trim()).filter(Boolean);
+    const hasChecklistCell = ids.some((part) => checklist.has(part));
+    const matched = ids.map((part) => green.get(part)).filter((item): item is ChecklistItem => !!item);
+    const complete = ids.length > 0 && ids.every((part) => green.has(part));
+    const maturity = hasChecklistCell ? gradeFor(feature, hint!, input.registry) : undefined;
+    const mapMaturity = /^(?:\/\S+\s+)?(stable|beta)\b/i.exec(clean(hint!))?.[1]?.toLowerCase();
+    const grade: Grade = hasChecklistCell
+      ? complete && maturity === 'stable' ? '된다' : complete && maturity === 'beta' ? '베타' : '로드맵'
+      : !clean(publication!).startsWith('✅') ? '로드맵'
+        : mapMaturity === 'stable' ? '된다' : mapMaturity === 'beta' ? '베타' : '로드맵';
+    const evidencePrs = hasChecklistCell
+      ? [...new Set(matched.flatMap((item) => prs(item.evidence ?? '')))] : prs(evidence!);
+    const held = HELD.test([...columns, ...ids.map((part) => {
+      const item = checklist.get(part);
+      return item ? `${item.title} ${item.evidence ?? ''}` : '';
+    })].join(' '));
+    rows.push({ feature: held ? '개념' : feature, grade: held ? '로드맵' : grade,
+      id: held ? '—' : hasChecklistCell ? id : '지도 판정', pr: held || !evidencePrs.length ? '근거 없음'
+        : !hasChecklistCell || complete ? evidencePrs.join(', ') : `부분: ${evidencePrs.join(', ')} · 나머지 칸 미완` });
+  }
+  const lines = [
+    '# FEATURE-MAP — 엘라누스가 할 수 있는 것',
+    '',
+    `판: ${escapeCell(input.version)} · 원천: src/maturity/feature-maturity.ts + 릴리스 체크리스트 green + docs/marketing/MAP-value-props-to-features.md §2`,
+    `재생성: \`bun scripts/marketing/generate-feature-map.ts --version ${escapeCell(input.version)} --out docs/marketing/FEATURE-MAP.md\``,
+    '내부 배치용: 로드맵은 현재 기능이 아니며, 된다/베타도 공개 판정·컷의 조상 PR 확인을 대신하지 않는다.',
+    '',
+    '| 기능 | 성숙도 | 칸 id | 근거 PR |',
+    '|---|---|---|---|',
+    ...rows.map((row) => `| ${escapeCell(row.feature)} | ${row.grade} | ${escapeCell(row.id)} | ${escapeCell(row.pr)} |`),
+    '',
+  ];
+  return lines.join('\n');
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const option = (name: string) => {
+    const index = args.indexOf(name);
+    if (index < 0) return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${name} 값이 필요하다`);
+    args.splice(index, 2);
+    return value;
+  };
+  const version = option('--version');
+  const mapFile = option('--map') ?? DEFAULT_MAP;
+  const checklistFile = option('--checklist');
+  const out = option('--out');
+  if (!version || args.length) throw new Error('Usage: bun scripts/marketing/generate-feature-map.ts --version <v> [--map <file>] [--checklist <snapshot.json>] [--out <file>]');
+  const items = checklistFile
+    ? (JSON.parse(readFileSync(checklistFile, 'utf8')) as { items: ChecklistItem[] }).items
+    : (await import('../../src/release-loop/checklist.js')).listChecklist(version).items;
+  if (!Array.isArray(items)) throw new Error('체크리스트 items 배열이 없다');
+  const body = generateFeatureMap({ map: readFileSync(mapFile, 'utf8'), items, registry: FEATURE_MATURITY, version });
+  if (out) writeFileSync(out, body);
+  else process.stdout.write(body);
+}

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

@@ -1,27 +1,66 @@
 #!/usr/bin/env bun
-import { addItem, checklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
+import { checklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
+import * as store from '../../src/release-loop/feature-store.js';
+import { getSchedule } from '../../src/release-loop/release-schedule.js';
+import { debug } from '../../src/debug/log.js';
 import { emitNodeResult, errorResult, readGraphContext, type GraphContext } from './node-verdict.js';
 
-export function runChecklistGate(context: GraphContext = readGraphContext()) {
+export function runChecklistGate(context: GraphContext = readGraphContext(), now: Date = new Date()) {
   const version = context.input.version;
   const data = listChecklist(version);
+  const schedule = getSchedule(version);
+  const deadline = schedule?.landBy;
+  const overdue = deadline !== null && deadline !== undefined && now.getTime() > Date.parse(deadline);
+  const autoMoved = overdue ? data.items.filter((item) => item.status === 'yellow' && item.priority !== 'P0' && item.disposition === undefined).map((item) => item.id) : [];
   const gate = checklistGate(version);
-  const counts = summarizeChecklist(data);
-  const summary = `확인표 🟢${counts.green} 🟡${counts.yellow}(이동 ${gate.moved.length} · 알려진 문제 ${gate.knownIssues.length} · 막음 ${gate.blocked.length} · 판정 없음 ${gate.undecided.length}) 🔴${counts.red}${gate.red.length ? ` (${gate.red.join(', ')})` : ''}${gate.parity?.length ? ` · ⚠ 짝 경고 ${gate.parity.length}(${gate.parity.map((p) => p.id).join(', ')})` : ''}`;
-  if (gate.ok && gate.moved.length) {
-    const [major, minor, patch] = version.split('.').map(Number);
-    const next = `${major}.${minor}.${patch! + 1}`;
-    // 이월은 «같은 칸»을 다음 판으로 옮기는 것 — 다른 판 id 충돌 검사(CKID #23407)의 대상이 아니다.
+  const p0 = data.items.filter((item) => item.status === 'yellow' && item.priority === 'P0').map((item) => item.id);
+  gate.undecided = gate.undecided.filter((id) => !autoMoved.includes(id) && !p0.includes(id));
+  gate.moved = gate.moved.filter((id) => !p0.includes(id)).concat(autoMoved);
+  gate.knownIssues = gate.knownIssues.filter((item) => !p0.includes(item.id));
+  gate.blocked.push(...p0.filter((id) => !gate.blocked.includes(id)));
+  gate.ok = gate.red.length === 0 && gate.undecided.length === 0 && gate.blocked.length === 0;
+  const [major, minor, patch] = version.split('.').map(Number);
+  const next = `${major}.${minor}.${patch! + 1}`;
+  const carried: string[] = [];
+  let carryFailure: string | undefined;
+  if (gate.moved.length) {
+    const nextChecklist = listChecklist(next);
+    const existing = new Map(nextChecklist.items.map((item) => [item.id, item]));
+    const movedFromHere = new Set(nextChecklist.history.filter((entry) => entry.field === 'move' && entry.from === version).map((entry) => entry.id));
+    const sameCarry = new Set<string>();
     for (const id of gate.moved) {
-      const item = data.items.find((candidate) => candidate.id === id)!;
-      if (listChecklist(next).items.some((candidate) => candidate.id === id)) continue;
-      try { addItem(next, { id, title: item.title, ...(item.owner !== undefined ? { owner: item.owner } : {}), ...(item.kind !== undefined ? { kind: item.kind } : {}) }, { allowDuplicateId: true }); }
-      catch (error) {
-        if (!listChecklist(next).items.some((candidate) => candidate.id === id)) throw error;
+      const original = data.items.find((item) => item.id === id)!;
+      const destination = existing.get(id);
+      if (!destination) continue;
+      if (destination.title === original.title && destination.owner === original.owner && (movedFromHere.has(id) || destination.evidence?.split('\n').some((line) => line.startsWith(`${version}에서 이월`)))) {
+        sameCarry.add(id);
+      } else {
+        carryFailure = `이월 충돌: ${id} — 다음 판에 다른 칸이 같은 ID`;
+        debug.log('release-loop.checklist-gate', 'carry-collision', { id, from: version, to: next });
+        break;
+      }
+    }
+    if (!carryFailure) for (const id of gate.moved) {
+      try {
+        if (sameCarry.has(id)) {
+          store.remove(version, id, 'release-loop.checklist-gate');
+          debug.log('release-loop.checklist-gate', 'carry-closed', { id, from: version, to: next });
+        } else {
+          const reason = autoMoved.includes(id) ? `컷 자동 이월 · 마감 ${new Intl.DateTimeFormat('en-GB', { timeZone: 'Asia/Seoul', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).format(new Date(deadline!))}` : '컷 자동 이월 · 처분 move';
+          store.move(id, version, next, 'release-loop.checklist-gate', undefined, undefined, reason, { clearDisposition: true });
+          carried.push(id);
+          debug.log('release-loop.checklist-gate', 'carried', { id, from: version, to: next });
+        }
+      } catch (error) {
+        carryFailure = `이월 실패: ${id} — ${error instanceof Error ? error.message : String(error)}`;
+        break;
       }
     }
   }
-  return { outcome: gate.ok ? 'ok' as const : 'fail' as const, verdict: gate.ok ? 'pass' as const : 'fail' as const, summary, ...gate };
+  if (carryFailure) gate.ok = false;
+  const counts = summarizeChecklist(data);
+  const summary = `${carryFailure ? `${carryFailure} · ` : ''}확인표 🟢${counts.green} 🟡${counts.yellow}(이동 ${gate.moved.length} · 알려진 문제 ${gate.knownIssues.length} · 막음 ${gate.blocked.length} · 판정 없음 ${gate.undecided.length}) 🔴${counts.red}${gate.red.length ? ` (${gate.red.join(', ')})` : ''}${gate.parity?.length ? ` · ⚠ 짝 경고 ${gate.parity.length}(${gate.parity.map((p) => p.id).join(', ')})` : ''} · 이월 ${carried.length}(${carried.join(', ') || '-'})`;
+  return { outcome: gate.ok ? 'ok' as const : 'fail' as const, verdict: gate.ok ? 'pass' as const : 'fail' as const, summary, ...gate, carried };
 }
 
 if (import.meta.main) {

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

@@ -1,10 +1,11 @@
 #!/usr/bin/env bun
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 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,10 +19,10 @@ 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[]; stalledEnv?: Array<{ file: string; reason: 'no-output' }> }
+interface CommandResult { rc: number; output: string; passedIds?: string[]; stalledEnv?: Array<{ file: string; reason: 'no-output' }>; timedOut?: boolean }
 export interface GateRunner {
-  command(cmd: string, args: string[], cwd: string): Promise<CommandResult>;
-  localCommand(cmd: string, args: string[], cwd: string): Promise<CommandResult>;
+  command(cmd: string, args: string[], cwd: string, limitMs?: number): Promise<CommandResult>;
+  localCommand(cmd: string, args: string[], cwd: string, limitMs?: number): Promise<CommandResult>;
   sweep(tree: string, logDir?: string, pod?: GateOptions['pod']): Promise<CommandResult>;
   add(tree: string, commit: string): Promise<void>;
   remove(tree: string): Promise<void>;
@@ -32,6 +33,7 @@ export interface GateRunner {
 }
 export interface GateOptions {
   commit: string;
+  forceFreeze?: boolean;
   version: string;
   baselineVersion?: string;
   baselineCommit?: string;
@@ -50,7 +52,7 @@ export interface GateResult {
   fixed: number;
   knownEnv: number;
   knownEnvCleared: string[];
-  stalledEnv: Array<{ file: string; reason: 'no-output'; local: 'passed' | 'failed' }>;
+  stalledEnv: Array<{ file: string; reason: 'no-output' | 'isolated-timeout'; local: 'passed' | 'failed' | 'timeout' }>;
   baselineSource?: 'ledger' | 'instance' | 'cut-logs' | 'swept';
   durationMs: number;
   error?: string;
@@ -187,17 +189,63 @@ class StalledPodShards extends Error {
   }
 }
 
+/** Isolated re-runs (host stall re-run · cut and baseline re-checks) are time-limited; sweeps and installs keep their full time. */
+export const GATE_ISOLATED_TIMEOUT_MS = 300_000;
+
+/**
+ * Runs a limited local command in its own process group. On timeout: SIGTERM the group (test-deterministic forwards it to its own
+ * `bun test` group — Chrome included), SIGKILL after a grace, and return after a hard deadline even if a foreign-group process still holds the pipe.
+ */
+export function limitedLocalCommand(cmd: string, args: string[], cwd: string, limitMs: number, graceMs = 10_000): Promise<CommandResult> {
+  return new Promise((resolveRun) => {
+    const chunks: string[] = [];
+    let timedOut = false;
+    let done = false;
+    const timers: ReturnType<typeof setTimeout>[] = [];
+    const child = spawn(cmd, args, { cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    let kept = 0;
+    // Same ceiling as the unlimited spawnSync path (maxBuffer 128MB): drop the oldest output beyond it, keep the tail.
+    const keep = (d: string) => { chunks.push(d); kept += d.length; while (kept > 128 * 1024 * 1024 && chunks.length > 1) kept -= chunks.shift()!.length; };
+    child.stdout?.setEncoding('utf8').on('data', keep);
+    child.stderr?.setEncoding('utf8').on('data', keep);
+    const signalGroup = (signal: NodeJS.Signals) => { try { if (child.pid) process.kill(-child.pid, signal); } catch { /* group already gone */ } };
+    const finish = (code: number | null, error?: Error) => {
+      if (done) return;
+      done = true;
+      for (const timer of timers) clearTimeout(timer);
+      child.stdout?.destroy();
+      child.stderr?.destroy();
+      const tail = error ? `\n${error}` : timedOut ? `\nkilled after ${limitMs}ms (process group)` : '';
+      resolveRun({ rc: code ?? 2, output: `${chunks.join('')}${tail}`, ...(timedOut ? { timedOut } : {}) });
+    };
+    timers.push(setTimeout(() => {
+      timedOut = true;
+      signalGroup('SIGTERM');
+      timers.push(setTimeout(() => signalGroup('SIGKILL'), graceMs));
+      timers.push(setTimeout(() => finish(null), graceMs + 5_000));
+    }, limitMs));
+    child.on('error', (error) => finish(null, error));
+    child.on('close', (code) => finish(code));
+  });
+}
+
 export function createGateRunner(repo: string, remote?: string, commandOverride?: GateRunner['command'], podCommand: (options: RunPodCommandOptions) => Promise<PodCommandResult> = runPodCommand, poolOverride?: PodPoolScheduler, podLogTail?: (job: PodCommandResult) => string): GateRunner {
   let remoteMirror: string | undefined;
-  const localCommand: GateRunner['command'] = async (cmd, args, cwd) => {
+  const localCommand: GateRunner['localCommand'] = async (cmd, args, cwd, limitMs) => {
+    if (limitMs) return limitedLocalCommand(cmd, args, cwd, limitMs);
     const run = spawnSync(cmd, args, { cwd, encoding: 'utf8', maxBuffer: 128 * 1024 * 1024 });
     return { rc: run.status ?? 2, output: `${run.stdout ?? ''}\n${run.stderr ?? ''}${run.error ? `\n${run.error}` : ''}` };
   };
   const command: GateRunner['command'] = commandOverride ?? (remote
-    ? async (cmd, args, cwd) => {
-      const run = spawnSync('ssh', [remote, `PATH=$HOME/.bun/bin:/opt/homebrew/bin:$PATH; export PATH; cd ${quote(cwd)} && ${[cmd, ...args].map(quote).join(' ')}`],
-        { encoding: 'utf8', maxBuffer: 128 * 1024 * 1024 });
-      return { rc: run.status ?? 2, output: `${run.stdout ?? ''}\n${run.stderr ?? ''}${run.error ? `\n${run.error}` : ''}` };
+    ? async (cmd, args, cwd, limitMs) => {
+      // A limited remote run is killed on the remote host; the local ssh deadline is a backstop.
+      // GNU timeout signals its own process group: -s KILL would kill timeout too (ssh 255), so TERM first then KILL after 10s (124 / 137).
+      // No coreutils timeout on the remote → run unlimited there and rely on the local ssh deadline.
+      const limitPrefix = limitMs ? `$(command -v timeout >/dev/null 2>&1 && echo 'timeout -k 10 ${Math.ceil(limitMs / 1000)}') ` : '';
+      const run = spawnSync('ssh', [remote, `PATH=$HOME/.bun/bin:/opt/homebrew/bin:$PATH; export PATH; cd ${quote(cwd)} && ${limitPrefix}${[cmd, ...args].map(quote).join(' ')}`],
+        { encoding: 'utf8', maxBuffer: 128 * 1024 * 1024, ...(limitMs ? { timeout: limitMs + 60_000, killSignal: 'SIGKILL' as const } : {}) });
+      const timedOut = !!limitMs && (run.status === 124 || run.status === 137 || (run.error as NodeJS.ErrnoException | undefined)?.code === 'ETIMEDOUT');
+      return { rc: run.status ?? 2, output: `${run.stdout ?? ''}\n${run.stderr ?? ''}${run.error ? `\n${run.error}` : ''}`, ...(timedOut ? { timedOut } : {}) };
     }
     : localCommand);
   const podSweep = async (tree: string, logDir: string | undefined, pod: NonNullable<GateOptions['pod']>): Promise<CommandResult> => {
@@ -537,6 +585,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) => {
@@ -622,7 +676,15 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
         }
         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);
+          // 0.2.15: InsidePage.test.tsx gave no Pod output and then hung on the host with headless Chrome — the run could only fail.
+          const isolated = await runner.localCommand('bun', ['run', 'test:deterministic', asPath(file)], hostTree, GATE_ISOLATED_TIMEOUT_MS);
+          // A file that stalls in its Pod shard and again on the host is an environment stall: record it, measure nothing from it.
+          if (isolated.timedOut) {
+            // Grandchildren (e.g. headless Chrome) can outlive the kill — the event lets the next release see a repeat.
+            debug.log('release-loop.gate', 'isolated-timeout', { file, label, limitMs: GATE_ISOLATED_TIMEOUT_MS });
+            local.push({ file, reason, local: 'timeout' });
+            continue;
+          }
           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);
@@ -680,14 +742,26 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     result.fixed = diff.fixed.length;
     result.preexisting = diff.common.length;
     for (const file of new Set(diff.newFailures.map(fileOf))) {
-      const isolatedCut = cutHostFailed.has(file)
+      // 0.2.15: the cut re-check of a new-failure file (InsidePage.test.tsx · headless Chrome) hung for good — limit it like the host re-run.
+      const cutCheck = cutHostFailed.has(file) ? undefined : await runner.command('bun', ['run', 'test:deterministic', asPath(file)], cutTree, GATE_ISOLATED_TIMEOUT_MS);
+      if (cutCheck?.timedOut) {
+        debug.log('release-loop.gate', 'isolated-timeout', { file, label: 'cut isolated', limitMs: GATE_ISOLATED_TIMEOUT_MS });
+        result.stalledEnv.push({ file, reason: 'isolated-timeout', local: 'timeout' });
+        continue;
+      }
+      const isolatedCut = cutCheck === undefined
         ? { 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}`);
+        : failuresOf(cutCheck, `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;
       const baselineTree = await getBaseTree();
-      const previous = await runner.command('bun', ['run', 'test:deterministic', asPath(file)], baselineTree);
+      const previous = await runner.command('bun', ['run', 'test:deterministic', asPath(file)], baselineTree, GATE_ISOLATED_TIMEOUT_MS);
+      if (previous.timedOut) {
+        debug.log('release-loop.gate', 'isolated-timeout', { file, label: 'baseline isolated', limitMs: GATE_ISOLATED_TIMEOUT_MS });
+        result.stalledEnv.push({ file, reason: 'isolated-timeout', local: 'timeout' });
+        continue;
+      }
       let oldFailures: Set<string>;
       if (/No tests found|had no matches/i.test(previous.output) && previous.rc === 1) {
         const lookup = await runner.command('git', ['ls-tree', '--name-only', baseSha, '--', file], opts.remote ? baselineTree : repo);
@@ -766,6 +840,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,

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 };
 }