elanous 0.2.16 → 0.2.18

package/scripts/landing-heal/run-mission.ts

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from 'node:path';
 import { githubAutomationToken } from '../../src/auth/github-app-token.js';
 import { debug } from '../../src/debug/log.js';
 import { emitDecision } from '../../src/live/detail-switch.js';
-import { parse } from '../../src/agent-substrate/pr-comment-meta.js';
+import { expandRecords, parse } from '../../src/agent-substrate/pr-comment-meta.js';
 import { classifyReviewRounds, matchMustFix, type MustFixVerdict } from './must-fix-match.js';
 import { verifyCleanCheckout, type CheckoutResult } from './clean-checkout.js';
 
@@ -116,7 +116,8 @@ export function runMission(mission: string, ctx: GraphContext, run: RunCommand =
         const pages = JSON.parse(run(['api', `repos/{owner}/{repo}/pulls/${pr.number}/comments`, '--paginate', '--slurp'])) as Array<Array<{ body?: string }>>;
         if (!Array.isArray(pages) || !pages.every(Array.isArray)) throw new Error(`invalid review comments for PR #${pr.number}`);
         const inline = pages.flat();
-        const comments = [...(details.reviews ?? []), ...(details.comments ?? []), ...inline];
+        const comments = [...(details.reviews ?? []), ...(details.comments ?? []), ...inline]
+          .flatMap((comment) => comment.body ? expandRecords(comment.body).map((body) => ({ ...comment, body })) : [comment]);
         const reviewRounds = comments.filter(({ body }) => {
           const meta = body ? parse(body) : null;
           return meta?.role === 'reviewer' && !!meta.run && meta.round !== undefined;

package/scripts/public-export-test-run.ts

@@ -4,7 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { run as exportRun } from './public-export.js';
+import { privateRedactionsPath, run as exportRun } from './public-export.js';
 
 export interface Comparison {
   exportOnly: string[];
@@ -118,4 +118,39 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
   }
 }
 
-if (import.meta.main) process.exit(run(process.argv.slice(2)));
+// GATE-REMOTE (10-06): `--remote [host]` runs the same commit on that host and prints its result (JSON gains host · remote:true);
+//   `--local` forces this machine. Without either, a busy machine (1-min load > gateRemote.loadThreshold) dispatches on its own.
+if (import.meta.main) void (async () => {
+  const { extractGateRemoteFlags, dispatchHeavyCheck, unreproducibleArgs, relativizeArgs } = await import('../src/self-implement/gate-remote.js');
+  const flags = extractGateRemoteFlags(process.argv.slice(2));
+  if (flags.error) { console.error(flags.error); process.exit(2); }
+  const repo = resolve(import.meta.dir, '..');
+  // The private redaction table changes exported file contents — the remote export must use the same one or the comparison differs.
+  const table = privateRedactionsPath();
+  const payloadFiles = existsSync(table) ? [{ env: 'ELANOUS_EXPORT_REDACTIONS', content: readFileSync(table, 'utf8') }] : [];
+  // File arguments, the --files list and its entries resolve against the repository root (as run() does).
+  const paths = flags.rest.filter((arg) => !arg.startsWith('--'));
+  const listIndex = flags.rest.indexOf('--files');
+  const list = listIndex >= 0 ? flags.rest[listIndex + 1] : undefined;
+  // List entries reach the host verbatim (only positional arguments are rewritten), so an absolute entry is not portable.
+  const absoluteEntries: string[] = [];
+  if (list) {
+    try {
+      const entries = readFileSync(resolve(repo, list), 'utf8').split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+      absoluteEntries.push(...entries.filter((entry) => isAbsolute(entry)));
+      paths.push(...entries);
+    } catch { /* run() reports it */ }
+  }
+  process.exitCode = await dispatchHeavyCheck({
+    payloadFiles,
+    localOnlyReason: (() => {
+      // Each must be a tracked file inside the repository, or the remote checkout would measure something else.
+      const bad = [...new Set([...absoluteEntries, ...unreproducibleArgs(paths, repo)])];
+      return bad.length ? `file argument not reproducible on the host (outside the repository or not tracked at HEAD): ${bad.join(' ')}` : undefined;
+    })(),
+    tool: 'public-export-test-run', repo, flags, json: flags.rest.includes('--json'),
+    installPwa: paths.some((arg) => arg.includes('apps/pwa')),
+    remoteArgv: ['bun', 'scripts/public-export-test-run.ts', '--local', ...relativizeArgs(flags.rest, repo)],
+    runLocal: () => run(flags.rest),
+  });
+})();

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

@@ -1,24 +1,25 @@
 #!/usr/bin/env bun
-import { checklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
+import { cutChecklistGate, 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 { prereleaseKind } from './release-version.js';
 import { emitNodeResult, errorResult, readGraphContext, type GraphContext } from './node-verdict.js';
 
+/** RELEASE-REHEARSAL-RC: a prerelease rehearses the pipeline; it must not judge or carry the stable version's cells. */
+export function prereleaseChecklistSkip(context: GraphContext) {
+  const version = context.input.version;
+  if (prereleaseKind(version) === null) return null;
+  debug.log('release-loop.checklist-gate', 'skipped', { version, reason: 'prerelease' });
+  return { outcome: 'ok' as const, verdict: 'pass' as const, summary: `checklist gate skipped — ${version} is a prerelease rehearsal`, skipped: 'prerelease' };
+}
+
 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 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 { autoMoved, ...gate } = cutChecklistGate(version, deadline, now);
   const [major, minor, patch] = version.split('.').map(Number);
   const next = `${major}.${minor}.${patch! + 1}`;
   const carried: string[] = [];
@@ -65,7 +66,8 @@ export function runChecklistGate(context: GraphContext = readGraphContext(), now
 
 if (import.meta.main) {
   try {
-    const result = runChecklistGate();
+    const context = readGraphContext();
+    const result = prereleaseChecklistSkip(context) ?? runChecklistGate(context);
     emitNodeResult(result);
     process.exitCode = result.outcome === 'ok' ? 0 : 1;
   } catch (error) {

package/scripts/release-loop/cut-branch.ts

@@ -3,6 +3,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
+import { isReleaseVersion } from './release-version.js';
 
 export interface CutBranchOptions { version: string; base: string; pick: string[]; append?: boolean; dryRun?: boolean; repoRoot?: string; log?: (line: string) => void }
 
@@ -26,7 +27,7 @@ export function cutReleaseBranch(opts: CutBranchOptions): { branch: string; comm
   const report = (event: 'created' | 'refused' | 'conflict' | 'appended', reason?: string, commit?: string, extra?: Record<string, string | string[]>) =>
     debug.log('release-loop.cut-branch', event, { version: opts.version, branch, ...(commit ? { commit } : {}), ...(reason ? { reason } : {}), ...extra });
   try {
-    if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(opts.version)) throw new Error(`invalid release version: ${opts.version}`);
+    if (!isReleaseVersion(opts.version)) throw new Error(`invalid release version: ${opts.version}`);
     if (!opts.pick.length) throw new Error('at least one --pick commit is required');
     for (const sha of [opts.base, ...opts.pick]) if (!/^[0-9a-f]{7,40}$/i.test(sha)) throw new Error(`invalid commit SHA: ${sha}`);
     git(repo, ['fetch', 'origin', 'main']);

package/scripts/release-loop/cutoff.ts

@@ -25,8 +25,10 @@ function requiredGit(args: string[]): string {
 }
 
 function versionParts(value: string): number[] | null {
-  if (!/^\d+\.\d+\.\d+$/.test(value)) return null;
-  return value.split('.').map(Number);
+  // A prerelease (0.2.18-rc.0) is placed by its base version — earlier stable tags are its baseline.
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-(?:rc|alpha|beta)\.\d+)?$/.exec(value);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
 }
 
 function compareVersions(a: number[], b: number[]): number {

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

@@ -1,10 +1,15 @@
 #!/usr/bin/env bun
-import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../../src/instance/resolve.js';
+import { listChecklist } from '../../src/release-loop/checklist.js';
+import type { ReleaseManifest } from '../../src/release-loop/manifest.js';
+import { recordDocsFollow, type DocsFollowItem } from './release-docs.js';
 import { dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { errorResult, finishNode, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
+import { prereleaseKind } from './release-version.js';
 
-export function runDocsLand(run: CommandRunner = runCommand) {
+export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effectiveInstanceRoot(), ledgerRoot = releaseLedgerRoot()) {
   const context = readGraphContext();
   const version = context.input.version;
   if (context.outputs.publish?.outcome !== 'ok') throw new Error('publish must succeed before docs land');
@@ -14,6 +19,37 @@ export function runDocsLand(run: CommandRunner = runCommand) {
   const worktree = nodeOutput(context, 'docs', 'worktree');
   const scratch = dirname(worktree);
   if (dirname(scratch) !== tmpdir() || !/^release-docs-[A-Za-z0-9]+$/.test(scratch.split('/').at(-1) ?? '') || worktree !== join(scratch, 'tree')) throw new Error('invalid docs worktree');
+  const recordFollow = (deployed: boolean) => {
+    const releaseDir = join(stateRoot, 'release', version);
+    const manifest: ReleaseManifest = JSON.parse(readFileSync(join(releaseDir, 'manifest.json'), 'utf8'));
+    if (manifest.version !== version || !Array.isArray(manifest.in)) throw new Error('docs-follow manifest/version mismatch');
+    // MK attestations are independent of generated notes; missing proof is unmeasured.
+    const evidencePath = join(releaseDir, 'docs-follow-evidence.json');
+    // 증거 파일이 깨졌으면 «증거 없음»으로 센다 — 보고서·MK 대기열은 그래도 남긴다(미측정으로).
+    let raw: unknown = { items: [] };
+    try { if (existsSync(evidencePath)) raw = JSON.parse(readFileSync(evidencePath, 'utf8')); }
+    catch (error) { process.stderr.write(`docs-follow evidence unreadable — counted as no evidence: ${String(error)}\n`); }
+    const valid = !!raw && typeof raw === 'object' && 'items' in raw && Array.isArray((raw as { items: unknown }).items);
+    if (!valid) process.stderr.write('docs-follow evidence malformed — counted as no evidence\n');
+    // 항목도 하나씩 본다 — 객체이고 문자열 id 가 있는 것만 증거로 센다(나머지는 «증거 없음»).
+    const evidence: { items: unknown[] } = { items: valid ? (raw as { items: unknown[] }).items
+      .filter((item) => !!item && typeof item === 'object' && typeof (item as { id?: unknown }).id === 'string') : [] };
+    const checklist = listChecklist(version, ledgerRoot);
+    const attestations = new Map((evidence.items as DocsFollowItem[]).map((item) => [item.id, item]));
+    const items = checklist.items.map((item) => ({ ...attestations.get(item.id), id: item.id, status: item.status,
+      ...(deployed ? {} : { docs: undefined }) }));
+    const publicationFile = join(ledgerRoot, 'release', version, 'release.json');
+    const publication: unknown = existsSync(publicationFile) ? JSON.parse(readFileSync(publicationFile, 'utf8')) : null;
+    const publishedAt = publication && typeof publication === 'object' && 'publishedAt' in publication
+      && typeof publication.publishedAt === 'string' ? publication.publishedAt : undefined;
+    const follow = recordDocsFollow(stateRoot, manifest, items, new Date(), publishedAt);
+    return { pending: follow.pending.length, unassessed: follow.unassessed.length, ratio: follow.ratio, verdict: follow.verdict };
+  };
+  // The deployment error is authoritative even if the follow-up ledger cannot be written.
+  const recordFailure = () => {
+    try { return recordFollow(false); }
+    catch (error) { process.stderr.write(`docs-follow recording failed: ${String(error)}\n`); return undefined; }
+  };
   // 재시도 멱등: 노트가 이미 main 에 있으면(앞 판에서 머지됐고 배포만 실패) 착지를 건너뛰고 배포부터.
   const before = run('git', ['fetch', 'origin', 'main']);
   if (before.status !== 0) throw new Error(`docs landing fetch failed: ${before.stderr}`);
@@ -22,16 +58,20 @@ export function runDocsLand(run: CommandRunner = runCommand) {
     if (!existsSync(worktree)) throw new Error(`docs worktree missing and notes not on main: ${worktree}`);
     const land = run('bun', ['bin/elanous.mjs', 'pr', 'land', '--cwd', worktree]);
     if (land.stderr) process.stderr.write(land.stderr);
-    if (land.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `docs land failed: ${land.stderr || land.stdout}` };
+    if (land.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `docs land failed: ${land.stderr || land.stdout}`, docsFollow: recordFailure() };
     if (land.status !== 0 || !land.stdout.includes('✓ merge:')) throw new Error(`docs land incomplete (rc=${land.status}): ${land.stderr || land.stdout}`);
   }
+  // 착지(병합)는 이미 끝났다 — 이 뒤의 모든 실패는 후속 기록을 시도하고 원래 오류를 그대로 던진다.
   const fetch = run('git', ['fetch', 'origin', 'main']);
-  if (fetch.status !== 0) throw new Error(`docs landing fetch failed: ${fetch.stderr}`);
+  if (fetch.status !== 0) { recordFailure(); throw new Error(`docs landing fetch failed: ${fetch.stderr}`); }
   const merged = run('git', ['rev-parse', 'origin/main']);
-  if (merged.status !== 0 || !/^[0-9a-f]{40}\s*$/i.test(merged.stdout)) throw new Error(`merged main commit unavailable: ${merged.stderr}`);
-  const deployDir = mkdtempSync(join(tmpdir(), 'release-docs-deploy-'));
+  if (merged.status !== 0 || !/^[0-9a-f]{40}\s*$/i.test(merged.stdout)) { recordFailure(); throw new Error(`merged main commit unavailable: ${merged.stderr}`); }
+  let deployDir: string;
+  try { deployDir = mkdtempSync(join(tmpdir(), 'release-docs-deploy-')); }
+  catch (error) { recordFailure(); throw error; }
   const deployTree = join(deployDir, 'tree');
   let added = false;
+  let deployed = false;
   try {
     const add = run('git', ['worktree', 'add', '--detach', deployTree, merged.stdout.trim()]);
     if (add.status !== 0) throw new Error(`docs deploy worktree failed: ${add.stderr}`);
@@ -40,26 +80,52 @@ export function runDocsLand(run: CommandRunner = runCommand) {
     if (install.status !== 0) throw new Error(`docs deploy install failed: ${install.stderr}`);
     const deploy = run('bun', ['website/scripts/deploy-pages.ts', '--remote', 'node-b', '--yes'], deployTree);
     if (deploy.stderr) process.stderr.write(deploy.stderr);
-    if (deploy.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const, summary: `docs deploy failed: ${deploy.stderr || deploy.stdout}` };
+    if (deploy.status === 1) return { outcome: 'fail' as const, verdict: 'fail' as const,
+      summary: `docs deploy failed: ${deploy.stderr || deploy.stdout}`, docsFollow: recordFailure() };
     if (deploy.status !== 0) throw new Error(`docs deploy incomplete (rc=${deploy.status}): ${deploy.stderr || deploy.stdout}`);
+    deployed = true;
     if (existsSync(worktree)) {
       const remove = run('git', ['worktree', 'remove', '--force', worktree]);
       if (remove.status !== 0) throw new Error(`docs worktree cleanup failed: ${remove.stderr}`);
     }
     rmSync(scratch, { recursive: true, force: true });
-    return { outcome: 'ok' as const, verdict: 'pass' as const, summary: `docs landed and deployed v${version}` };
+    // 배포 성공 — 후속 기록 실패(manifest 없음 등)는 결과를 «실패»로 바꾸지 않는다. 알리고 넘어간다.
+    let follow: ReturnType<typeof recordFollow> | undefined;
+    try { follow = recordFollow(true); }
+    catch (error) { process.stderr.write(`docs-follow recording failed after deploy: ${String(error)}\n`); }
+    return { outcome: 'ok' as const, verdict: 'pass' as const,
+      summary: `docs landed and deployed v${version}${follow ? ` · docs-follow pending=${follow.pending} unassessed=${follow.unassessed}` : ' · docs-follow not recorded'}`,
+      docsFollow: follow };
+  } catch (error) {
+    if (!deployed) recordFailure();
+    else {
+      // 배포는 됐는데 정리에서 실패 — 보고서·MK 대기열은 «배포됨»으로 남기고 원래 오류를 보존한다.
+      try { recordFollow(true); }
+      catch (recordError) { process.stderr.write(`docs-follow recording failed: ${String(recordError)}\n`); }
+    }
+    throw error;
   } finally {
     try {
       if (added) {
         const remove = run('git', ['worktree', 'remove', '--force', deployTree]);
-        if (remove.status !== 0) throw new Error(`docs deploy cleanup failed: ${remove.stderr}`);
+        // 배포 임시 트리 정리 실패는 앞선 결과(반환·원래 오류)를 덮지 않는다 — 알리고 넘어간다.
+        if (remove.status !== 0) process.stderr.write(`docs deploy cleanup failed (kept the original result): ${remove.stderr}\n`);
       }
-    } finally { rmSync(deployDir, { recursive: true, force: true }); }
+    } finally {
+      try { rmSync(deployDir, { recursive: true, force: true }); }
+      catch (error) { process.stderr.write(`docs deploy temp cleanup failed (kept the original result): ${String(error)}\n`); }
+    }
   }
 }
 
 if (import.meta.main) {
   let version = '';
-  try { version = readGraphContext().input.version; process.exitCode = finishNode('docs-land', version, runDocsLand()); }
+  try {
+    version = readGraphContext().input.version;
+    // RELEASE-REHEARSAL-RC: a prerelease never lands docs on main or upgrades the operating hosts.
+    process.exitCode = finishNode('docs-land', version, prereleaseKind(version) !== null
+      ? { outcome: 'ok', verdict: 'pass', summary: `docs-land skipped — ${version} is a prerelease`, skipped: 'prerelease' }
+      : runDocsLand());
+  }
   catch (error) { process.exitCode = finishNode('docs-land', version, errorResult(error)); }
 }

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

@@ -72,7 +72,7 @@ export function runDocs(
       }
       throw new Error(`unknown argument: ${arg}`);
     }
-    if (!version || !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/.test(version)) {
+    if (!version || !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:rc|alpha|beta)\.(?:0|[1-9]\d*))?$/.test(version)) {
       throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version): x.y.z');
     }
     root = resolve(root);

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

@@ -54,6 +54,8 @@ export interface GateResult {
   knownEnvCleared: string[];
   stalledEnv: Array<{ file: string; reason: 'no-output' | 'isolated-timeout'; local: 'passed' | 'failed' | 'timeout' }>;
   baselineSource?: 'ledger' | 'instance' | 'cut-logs' | 'swept';
+  /** GATE-BASELINE-CACHE — isolated baseline files answered from the ledger (hits) or run now (misses). */
+  baselineCache?: { hits: number; misses: number };
   durationMs: number;
   error?: string;
   stalledShards?: Array<{ shard: number; files: string[]; reason: 'incomplete' | 'no-output' | 'job-failed' | 'unattributed'; lastFile?: string; summaryFailures?: number; namedFailures?: number; detail?: string }>;
@@ -583,6 +585,61 @@ function fileOf(id: string): string {
   return file;
 }
 
+/**
+ * GATE-BASELINE-CACHE (0.2.18) — the isolated `bun run test:deterministic <file>` result of one test file at one commit,
+ * kept in the machine ledger so a later gate does not run it again (0.2.17: the failing files were re-run on the previous
+ * release commit although that release had already measured them). Cache format harvested from draft #24500.
+ * `host` is where the result was measured (`local` or the ssh host) — a result from another host is a miss.
+ * Timeouts are never stored: an environment stall is measured again, not remembered.
+ */
+export interface BaselineFileResult { commit: string; file: string; host: string; failures: string[]; errors: string[]; missing: boolean }
+export const baselineCachePath = (ledger: string, commit: string) => join(ledger, 'gate-baseline-cache', `${commit}.jsonl`);
+function validFileResult(value: unknown, commit: string): value is BaselineFileResult {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const row = value as Partial<BaselineFileResult>;
+  if (row.commit !== commit || typeof row.file !== 'string' || typeof row.host !== 'string' || !row.host.trim()
+    || typeof row.missing !== 'boolean' || !Array.isArray(row.failures) || !Array.isArray(row.errors)
+    || (row.missing && (row.failures.length || row.errors.length))) return false;
+  try {
+    fileOf(`${row.file} > case`);
+    return [...row.failures, ...row.errors].every((id) => typeof id === 'string' && fileOf(id) === row.file);
+  } catch { return false; }
+}
+/** A missing cache file is empty; any unreadable or invalid row discards the whole file — it is never read as a pass. */
+export function readBaselineFileCache(ledger: string, commit: string): Map<string, BaselineFileResult> {
+  const entries = new Map<string, BaselineFileResult>();
+  if (!sha.test(commit)) return entries;
+  const path = baselineCachePath(ledger, commit);
+  if (!existsSync(path)) return entries;
+  try {
+    // The writer always ends with one newline and never writes an empty line — anything else is a damaged file.
+    const text = readFileSync(path, 'utf8');
+    if (!text.endsWith('\n')) throw new Error('missing final newline');
+    for (const line of text.slice(0, -1).split('\n')) {
+      if (!line.trim()) throw new Error('empty line');
+      const row: unknown = JSON.parse(line);
+      if (!validFileResult(row, commit)) throw new Error('invalid row');
+      entries.set(`${row.file}\0${row.host}`, row);
+    }
+  } catch (error) {
+    debug.log('release.gate', 'baseline-cache-corrupt', { path, error: String(error) });
+    entries.clear();
+  }
+  return entries;
+}
+export function saveBaselineFileCache(ledger: string, commit: string, rows: BaselineFileResult[]): void {
+  if (!rows.length || !sha.test(commit)) return;
+  const entries = readBaselineFileCache(ledger, commit);
+  for (const row of rows) entries.set(`${row.file}\0${row.host}`, row);
+  const path = baselineCachePath(ledger, commit);
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = join(dirname(path), `.gate-baseline-${process.pid}-${randomUUID()}.tmp`);
+  try {
+    writeFileSync(temp, [...entries.values()].map((row) => JSON.stringify(row)).join('\n') + '\n', { mode: 0o600 });
+    renameSync(temp, path);
+  } finally { if (existsSync(temp)) rmSync(temp); }
+}
+
 export async function judgeGate(opts: GateOptions, runner: GateRunner = createGateRunner(opts.repo ?? process.cwd(), opts.remote)): Promise<GateResult> {
   const start = Date.now();
   const explicitConfig = getElanousConfigDirOverride();
@@ -743,7 +800,23 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
     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))) {
+    // GATE-BASELINE-CACHE — only the files whose new failures reproduce in isolation reach the baseline, and each
+    // (commit, file, host) is run at most once across gates: this gate's cut results also seed the next gate's baseline.
+    const cacheHost = opts.remote ?? 'local';
+    const newFailureFiles = new Set(diff.newFailures.map(fileOf));
+    const baseCache = newFailureFiles.size ? readBaselineFileCache(ledger, baseSha) : new Map<string, BaselineFileResult>();
+    const cacheStats = { hits: 0, misses: 0 };
+    const remember = (row: BaselineFileResult) => {
+      // Only a row the reader would accept is stored; an unstorable result skips the cache and leaves the verdict alone.
+      const { commit, file } = row;
+      if (!validFileResult(row, commit)) {
+        debug.log('release.gate', 'baseline-cache-skip', { commit, file });
+        return;
+      }
+      try { saveBaselineFileCache(ledger, row.commit, [row]); }
+      catch (error) { debug.log('release.gate', 'baseline-cache-write-failed', { commit: row.commit, file: row.file, error: String(error) }); }
+    };
+    for (const file of newFailureFiles) {
       // 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) {
@@ -754,30 +827,42 @@ export async function judgeGate(opts: GateOptions, runner: GateRunner = createGa
       const isolatedCut = cutCheck === undefined
         ? { failures: cut.failures.filter((id) => fileOf(id) === file), errors: cut.errors.filter((id) => fileOf(id) === file) }
         : failuresOf(cutCheck, `cut isolated ${file}`);
+      if (cutCheck !== undefined) remember({ commit: opts.commit, file, host: cacheHost, failures: isolatedCut.failures, errors: isolatedCut.errors, missing: false });
       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, 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);
-        if (lookup.rc !== 0 || lookup.output.trim()) throw new Error(`baseline isolated run incomplete: ${file}`);
-        oldFailures = new Set();
+      const hit = baseCache.get(`${file}\0${cacheHost}`);
+      if (hit) {
+        cacheStats.hits++;
+        oldFailures = new Set([...hit.failures, ...hit.errors]);
       } else {
-        const prior = failuresOf(previous, `baseline isolated ${file}`);
-        oldFailures = new Set([...prior.failures, ...prior.errors]);
+        cacheStats.misses++;
+        const baselineTree = await getBaseTree();
+        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;
+        }
+        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);
+          if (lookup.rc !== 0 || lookup.output.trim()) throw new Error(`baseline isolated run incomplete: ${file}`);
+          oldFailures = new Set();
+          remember({ commit: baseSha, file, host: cacheHost, failures: [], errors: [], missing: true });
+        } else {
+          const prior = failuresOf(previous, `baseline isolated ${file}`);
+          oldFailures = new Set([...prior.failures, ...prior.errors]);
+          remember({ commit: baseSha, file, host: cacheHost, failures: prior.failures, errors: prior.errors, missing: false });
+        }
       }
       for (const id of candidates) {
         if (oldFailures.has(id)) result.preexisting++;
         else result.introduced.push(id);
       }
     }
+    result.baselineCache = cacheStats;
+    debug.log('release.gate', 'baseline-cache', { hits: cacheStats.hits, misses: cacheStats.misses, commit: baseSha });
     result.outcome = result.introduced.length ? 'regression' : 'ok';
   } catch (error) {
     result.error = error instanceof Error ? error.message : String(error);

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

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import { spawnSync } from 'node:child_process';
+import { isReleaseVersion } from './release-version.js';
 import { readFileSync } from 'node:fs';
 import { debug } from '../../src/debug/log.js';
 
@@ -17,7 +18,7 @@ export function readGraphContext(env: NodeJS.ProcessEnv = process.env): GraphCon
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid graph context');
   const context = value as Record<string, unknown>;
   const input = context.input as Record<string, unknown> | undefined;
-  if (!input || typeof input.version !== 'string' || !/^\d+\.\d+\.\d+$/.test(input.version)
+  if (!input || typeof input.version !== 'string' || !isReleaseVersion(input.version)
     || typeof input.previousVersion !== 'string' || !/^\d+\.\d+\.\d+$/.test(input.previousVersion)) throw new Error('version and previousVersion required');
   return { input: input as GraphContext['input'], outputs: context.outputs && typeof context.outputs === 'object' ? context.outputs as GraphContext['outputs'] : {} };
 }

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

@@ -7,6 +7,7 @@ import { debug } from '../../src/debug/log.js';
 import { sendOutbound } from '../../src/domains/outbound-alert.js';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
 import { emitNodeResult, readGraphContext, type GraphContext } from './node-verdict.js';
+import { prereleaseKind } from './release-version.js';
 
 type Result = { outcome: 'ok' | 'fail'; verdict: 'pass' | 'fail'; summary: string; npm?: 'published' | 'already-published' | 'staged-not-visible'; humanAction?: 'npm-support' };
 type Exec = (command: string, args: string[], env?: NodeJS.ProcessEnv) => { status: number | null; stdout: string; stderr: string };
@@ -47,8 +48,11 @@ function metadata(value: unknown): { name?: string; version?: string } {
 export async function runNpmPublish(context: GraphContext = readGraphContext(), deps: NpmPublishDeps = {}): Promise<Result> {
   const version = context.input.version;
   let token = '';
+  // RELEASE-REHEARSAL-RC: a prerelease goes to `next` so `npm i elanous` never resolves to a rehearsal build.
+  let distTag = 'latest';
   try {
     if (context.outputs.publish?.outcome !== 'ok') throw new Error('publish must succeed before npm publish');
+    distTag = prereleaseKind(version) === null ? 'latest' : 'next';
     const stateDir = deps.stateDir ?? effectiveInstanceRoot();
     // REL3 — the archive prepare actually built (its output) wins over this process's universe: a resumed run can
     // resolve another universe (10-01 0.2.7: prepared in the pilot test universe, resumed in production).
@@ -67,14 +71,14 @@ export async function runNpmPublish(context: GraphContext = readGraphContext(),
       const [manifest, tags] = await Promise.all([readRegistry(`${PACKAGE_URL}/${version}`), readRegistry(PACKAGE_URL)]);
       if (manifest.status !== 200 && manifest.status !== 404) throw new Error(`npm registry version lookup failed (${manifest.status})`);
       if (tags.status !== 200) throw new Error(`npm registry tags lookup failed (${tags.status})`);
-      const latest = tags.body && typeof tags.body === 'object' && 'dist-tags' in tags.body
-        ? (tags.body as { 'dist-tags'?: { latest?: unknown } })['dist-tags']?.latest : undefined;
+      const tagged = tags.body && typeof tags.body === 'object' && 'dist-tags' in tags.body
+        ? (tags.body as { 'dist-tags'?: Record<string, unknown> })['dist-tags']?.[distTag] : undefined;
       if (manifest.status === 200 && (metadata(manifest.body).name !== 'elanous' || metadata(manifest.body).version !== version))
         throw new Error('npm registry version metadata mismatch');
-      return { visible: manifest.status === 200, tagged: manifest.status === 200 && latest === version };
+      return { visible: manifest.status === 200, tagged: manifest.status === 200 && tagged === version };
     };
     const before = await inspect();
-    if (before.tagged) return { outcome: 'ok', verdict: 'pass', npm: 'already-published', summary: `npm ${version} already published with latest tag` };
+    if (before.tagged) return { outcome: 'ok', verdict: 'pass', npm: 'already-published', summary: `npm ${version} already published with ${distTag} tag` };
     if (!before.visible) {
       // The npm token is a machine secret (like the GitHub App key): input → this universe → the production root.
       const tokenFile = context.input.npmTokenFile ?? [join(stateDir, 'secrets', 'npm-token'), join(deps.productionRoot ?? prodInstanceRoot(), 'secrets', 'npm-token')].find((p) => existsSync(p)) ?? join(stateDir, 'secrets', 'npm-token');
@@ -86,7 +90,7 @@ export async function runNpmPublish(context: GraphContext = readGraphContext(),
       try {
         const npmrc = join(dir, 'npmrc');
         writeFileSync(npmrc, `//registry.npmjs.org/:_authToken=${token}\n`, { mode: 0o600, flag: 'wx' });
-        published = run('npm', ['publish', candidate, '--ignore-scripts', '--tag', 'latest', '--access', 'public'], { ...process.env, NPM_CONFIG_USERCONFIG: npmrc });
+        published = run('npm', ['publish', candidate, '--ignore-scripts', '--tag', distTag, '--access', 'public'], { ...process.env, NPM_CONFIG_USERCONFIG: npmrc });
       } finally { rmSync(dir, { recursive: true, force: true }); }
       const output = `${published.stdout}\n${published.stderr}`;
       const staged = published.status !== 0 && /\bE409\b/i.test(output) && /previously staged/i.test(output);
@@ -96,10 +100,10 @@ export async function runNpmPublish(context: GraphContext = readGraphContext(),
     let last = before;
     for (let i = 0; i <= polls; i++) {
       last = await inspect();
-      if (last.tagged) return { outcome: 'ok', verdict: 'pass', npm: before.visible ? 'already-published' : 'published', summary: `npm ${version} visible with latest tag` };
+      if (last.tagged) return { outcome: 'ok', verdict: 'pass', npm: before.visible ? 'already-published' : 'published', summary: `npm ${version} visible with ${distTag} tag` };
       if (i < polls) await wait(Math.min(30_000, waitMinutes * 60_000 - i * 30_000));
     }
-    if (last.visible) throw new Error(`npm ${version} visible but dist-tags.latest did not reach ${version} within ${waitMinutes} minutes`);
+    if (last.visible) throw new Error(`npm ${version} visible but dist-tags.${distTag} did not reach ${version} within ${waitMinutes} minutes`);
     try { (deps.log ?? ((v, minutes) => debug.log('release-loop.npm', 'staged-not-visible', { version: v, waitedMinutes: minutes })))(version, waitMinutes); } catch { /* observation must not mask npm's staged state */ }
     try { (deps.alert ?? sendOutbound)(`npm ${version} 가 스테이징에 멈춤 — 계정 소유자 확인 필요`, 'alert'); } catch { /* alert failure must not block docs */ }
     return { outcome: 'ok', verdict: 'pass', npm: 'staged-not-visible', humanAction: 'npm-support', summary: 'npm 스테이징 — 레지스트리에 아직 없음' };

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

@@ -4,6 +4,7 @@ import { homedir, tmpdir } from 'node:os';
 import { join, isAbsolute } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandResult, type CommandRunner } from './node-verdict.js';
+import { prereleaseKind } from './release-version.js';
 
 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. */
@@ -199,6 +200,12 @@ export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeD
 
 if (import.meta.main) {
   let version = '';
-  try { version = readGraphContext().input.version; process.exitCode = finishNode('ops-upgrade', version, runOpsUpgrade()); }
+  try {
+    version = readGraphContext().input.version;
+    // RELEASE-REHEARSAL-RC: a prerelease never lands docs on main or upgrades the operating hosts.
+    process.exitCode = finishNode('ops-upgrade', version, prereleaseKind(version) !== null
+      ? { outcome: 'ok', verdict: 'pass', summary: `ops-upgrade skipped — ${version} is a prerelease`, skipped: 'prerelease' }
+      : runOpsUpgrade());
+  }
   catch (error) { process.exitCode = finishNode('ops-upgrade', version, errorResult(error)); }
 }