elanous 0.2.34 → 0.2.36

package/src/release-loop/checklist.ts

@@ -13,6 +13,15 @@ export type ChecklistKind = 'screen' | 'postpub';
 const CHECKLIST_KINDS: readonly ChecklistKind[] = ['screen', 'postpub'];
 export type ChecklistDispatchKind = 'code' | 'ops' | 'measure' | 'decision' | 'umbrella';
 const CHECKLIST_DISPATCH_KINDS: readonly ChecklistDispatchKind[] = ['code', 'ops', 'measure', 'decision', 'umbrella'];
+/** MUST 지정 — 이 칸이 지켜야 하는 조건과 그 효과. 원장에는 `must` 이벤트(전체 값)로만 실린다. */
+export interface ChecklistMust {
+  version: string;
+  reason: string;
+  setBy: string;
+  setAt: string;
+  effect: string;
+}
+const MUST_FIELDS = ['version', 'reason', 'setBy', 'setAt', 'effect'] as const;
 export interface ChecklistItem {
   id: string;
   title: string;
@@ -32,6 +41,8 @@ export interface ChecklistItem {
   kind?: ChecklistKind;
   /** Whether the seat dispatcher should launch a coding task. Missing in old rows means code. */
   dispatchKind?: ChecklistDispatchKind;
+  /** MUST 지정(있으면 이 칸은 MUST 다). 원장 스키마에 must 컬럼이 없어 `must` 이벤트에서 복원한다. */
+  must?: ChecklistMust;
   updatedAt: string;
   updatedBy: string;
 }
@@ -92,13 +103,51 @@ function decodeClaimHistory(data: Checklist): Checklist {
   return { ...data, history: data.history.map(decodeClaimHistoryEntry) };
 }
 
+/** A `must` event carries the whole MUST value in `to`; anything that is not five strings is not a MUST. */
+function mustValue(value: unknown): ChecklistMust | null {
+  if (!value || typeof value !== 'object') return null;
+  const record = value as Record<string, unknown>;
+  if (!MUST_FIELDS.every((field) => typeof record[field] === 'string')) return null;
+  return { version: record.version as string, reason: record.reason as string, setBy: record.setBy as string, setAt: record.setAt as string, effect: record.effect as string };
+}
+
+function decodeMustEntry<T extends ChecklistHistory>(entry: T): T {
+  if (entry.field !== 'must') return entry;
+  const must = mustValue(entry.to);
+  return must ? { ...entry, to: must } as T : entry;
+}
+
+/** The ledger event schema has no must column either; the last `must` event is this cell's MUST. */
+function decodeMustHistory(data: Checklist): Checklist {
+  const latest = new Map<string, ChecklistMust>();
+  for (const entry of data.history) {
+    if (entry.field !== 'must') continue;
+    const must = mustValue(entry.to);
+    if (must) latest.set(entry.id, must);
+  }
+  if (!latest.size) return data;
+  return { ...data, items: data.items.map((item) => {
+    const must = latest.get(item.id);
+    return must ? { ...item, must } : item;
+  }) };
+}
+
+function latestMust(history: readonly ChecklistHistory[], id: string): ChecklistMust | null {
+  for (let index = history.length - 1; index >= 0; index--) {
+    const entry = history[index]!;
+    if (entry.id !== id || entry.field !== 'must') continue;
+    return mustValue(entry.to);
+  }
+  return null;
+}
+
 export function listChecklist(v: string, root?: string): Checklist {
-  return decodeClaimHistory(root === undefined ? store.list(v) : store.list(v, undefined, undefined, root));
+  return decodeMustHistory(decodeClaimHistory(root === undefined ? store.list(v) : store.list(v, undefined, undefined, root)));
 }
 
 /** Events for this id across every release, ordered by event time (then ledger sequence). */
 export function checklistHistory(id: string): Array<ChecklistHistory & { version: string; seq: number }> {
-  return store.history(id).map(decodeClaimHistoryEntry);
+  return store.history(id).map((entry) => decodeMustEntry(decodeClaimHistoryEntry(entry)));
 }
 
 /** Status events in the requested window; other ledger fields never become status changes. */
@@ -116,8 +165,8 @@ function assertPredecessorsExist(predecessors: readonly string[] | undefined, da
 }
 
 function mutate(v: string, apply: (data: Checklist, otherItems: (id: string) => store.ChecklistCollision[]) => boolean): Checklist {
-  // addItem/setItem/claimItem/removeItem/seedFromRoadmap reach the generation-fenced ledger write here.
-  return decodeClaimHistory(store.mutate(v, store.releasedVersion(), devVersion(), apply));
+  // addItem/setItem/claimItem/removeItem/seedFromRoadmap/setMust reach the generation-fenced ledger write here.
+  return decodeMustHistory(decodeClaimHistory(store.mutate(v, store.releasedVersion(), devVersion(), apply)));
 }
 
 function change(data: Checklist, id: string, field: string, from: unknown, to: unknown, by: string, at: string): void {
@@ -132,6 +181,28 @@ function mentionedPaths(text: string): string[] {
   return [...text.matchAll(PATH_TOKEN)].map((match) => match[1]!).filter((path) => !path.split('/').includes('..'));
 }
 
+/** `docs/goal-context/03-verification-menu.md` §선택 원칙: merge SHA·타입검사는 수용선이 아니다. */
+export const MERGE_OR_TYPECHECK_ONLY_REAL_WARNING = '- 완료 경계 실물: merge sha·타입검사만으로는 실물이 아니다 — docs/goal-context/03-verification-menu.md 에서 동작을 재는 방법을 고른다';
+/** 통합 이력·정적 타입 상태만 말하는 낱말(조사 뗀 꼴). 이 밖의 낱말이 하나라도 있으면 실물 주장으로 본다. */
+const MERGE_OR_TYPECHECK_WORD = /^(?:pr|merge|merged|머지|병합|착지|landed|land|sha|merge-sha|commit|커밋|origin|main|tsc|typecheck|type-check|typecheck-changed|타입검사|타입|검사|type|check|changed|통과|pass|passed|green|clean|errors?|error|오류|에러|없음|후|뒤|완료|확인|and|및|만|됨|된다)$/i;
+const MERGE_OR_TYPECHECK_SIGNAL = /^(?:merge|merged|머지|병합|착지|landed|land|sha|merge-sha|tsc|typecheck|type-check|타입검사)$/i;
+const KOREAN_PARTICLE_TAIL = /(?:했다|했음|하였다|했고|함|으로|로|이|가|은|는|을|를|와|과|에|의|만|됨|된|된다)$/u;
+
+/** 「완료 경계 실물」 값이 merge sha·PR 착지·타입검사 낱말로만 이뤄졌나(동작 관측이 하나도 없나). */
+export function isMergeOrTypecheckOnlyEvidence(value: string): boolean {
+  const words = value.split(/[\s.!?。…~`'"·,⊕+()[\]:;/=|→-]+/u).map((word) => word.replace(/^#/, '')).filter(Boolean);
+  if (!words.length) return false;
+  let signal = false;
+  for (const raw of words) {
+    if (/^\d+$/.test(raw) || /^[0-9a-f]{7,40}$/i.test(raw)) continue;
+    let word = raw;
+    for (let strip = 0; strip < 3 && !MERGE_OR_TYPECHECK_WORD.test(word); strip++) word = word.replace(KOREAN_PARTICLE_TAIL, '');
+    if (!MERGE_OR_TYPECHECK_WORD.test(word)) return false;
+    if (MERGE_OR_TYPECHECK_SIGNAL.test(word)) signal = true;
+  }
+  return signal;
+}
+
 /** Shadow check at checklist authorship. Callers supply the origin/main file probe and merged-PR file reader. */
 export function inspectChecklistTargetPaths(input: {
   title: string; evidence?: string; refs?: readonly string[]; dispatchKind?: ChecklistDispatchKind;
@@ -179,6 +250,8 @@ export function inspectChecklistTargetPaths(input: {
       if (!lines.some((line) => line.startsWith(`- 완료 경계 ${label}:`) && line.slice(`- 완료 경계 ${label}:`.length).trim()))
         warnings.push(`- 완료 경계 ${label}: 줄이 없다`);
     }
+    const real = lines.find((line) => line.startsWith('- 완료 경계 실물:'))?.slice('- 완료 경계 실물:'.length).trim();
+    if (real && isMergeOrTypecheckOnlyEvidence(real)) warnings.push(MERGE_OR_TYPECHECK_ONLY_REAL_WARNING);
   }
   if (!warnings.length) return { targets, warnings, candidates: [] };
   const sources = [input.title, input.evidence ?? '', ...(input.refs ?? [])].join('\n');
@@ -336,6 +409,29 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
   return setItemGuarded(v, id, patch, by);
 }
 
+/** 효과 없는 MUST 는 게이트가 판단할 근거가 없다 — 거부한다. */
+function validateMust(must: ChecklistMust): ChecklistMust {
+  if (!must.effect.trim()) throw new CliUserError('MUST 효과가 비었다', "release checklist must <id> --effect '<게이트에 미치는 효과>'");
+  return must;
+}
+
+/** 이 칸의 MUST 를 세운다. 저장은 `must` 이벤트(from = 이전 전체 값, to = 새 전체 값)로만 하고, 다른 칸 행은 건드리지 않는다. */
+export function setMust(v: string, id: string, input: { version: string; reason: string; effect: string }, by: string): Checklist {
+  if (!by.trim()) throw new CliUserError('MUST 기록 주체가 비었다');
+  const at = new Date().toISOString();
+  const must = validateMust({ version: input.version, reason: input.reason, setBy: by, setAt: at, effect: input.effect });
+  return mutate(v, (data) => {
+    const item = data.items.find((entry) => entry.id === id);
+    if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
+    const previous = latestMust(data.history, id);
+    if (previous && JSON.stringify(previous) === JSON.stringify(must)) return false;
+    item.updatedAt = at;
+    item.updatedBy = by;
+    change(data, id, 'must', previous, must, by, at);
+    return true;
+  });
+}
+
 /** Remove only the exact machine-authored line; preserve all other evidence bytes and blank lines. */
 export function withoutDispatchSkipLine(evidence: string, line: string | null): string {
   if (!line) return evidence;

package/src/release-loop/landed-but-yellow.ts

@@ -23,9 +23,64 @@ export function evidencePlan(rows: readonly LandedButYellowRow[]): Array<{ id: s
   }));
 }
 
+interface PrIndex {
+  /** Shape of the list when indexed — a mismatch means the caller changed the array in place. */
+  length: number;
+  firstNumber: number | undefined;
+  lastNumber: number | undefined;
+  /** PR positions per body `칸:` line id — the whole-line label the matcher accepts. */
+  cellIds: Map<string, number[]>;
+  /** PR positions per maximal ASCII-alphanumeric run in the title or body. */
+  runs: Map<string, number[]>;
+}
+
+const ALNUM_RUN = /[A-Za-z0-9]+/g;
+const CELL_LINE = /^[ \t]*칸(?:[ \t]*:[ \t]*|[ \t]+)([A-Za-z0-9_-]+(?:[ \t]*,[ \t]*[A-Za-z0-9_-]+)*)[ \t]*$/;
+const prIndexes = new WeakMap<readonly MergedChecklistPr[], PrIndex>();
+
+function push(map: Map<string, number[]>, key: string, position: number): void {
+  const list = map.get(key);
+  if (!list) map.set(key, [position]);
+  else if (list[list.length - 1] !== position) list.push(position);
+}
+
+/**
+ * Built once per PR list (the open audit reuses one list across every version). Contract: callers treat the list as
+ * read-only after passing it. A cheap guard still re-indexes when the length or the first/last PR number changed;
+ * an in-place edit that keeps all three is not detected.
+ */
+function prIndex(prs: readonly MergedChecklistPr[]): PrIndex {
+  const cached = prIndexes.get(prs);
+  if (cached && cached.length === prs.length && cached.firstNumber === prs[0]?.number && cached.lastNumber === prs[prs.length - 1]?.number) return cached;
+  const index: PrIndex = { length: prs.length, firstNumber: prs[0]?.number, lastNumber: prs[prs.length - 1]?.number, cellIds: new Map(), runs: new Map() };
+  prs.forEach((pr, position) => {
+    const body = pr.body ?? '';
+    for (const line of body.split('\n')) {
+      const match = CELL_LINE.exec(line.endsWith('\r') ? line.slice(0, -1) : line);
+      for (const candidate of match?.[1]?.split(',') ?? []) push(index.cellIds, candidate.trim(), position);
+    }
+    for (const text of [pr.title, body]) for (const [run] of text.matchAll(ALNUM_RUN)) push(index.runs, run, position);
+  });
+  prIndexes.set(prs, index);
+  return index;
+}
+
+/**
+ * PRs that can match `id` at all — a necessary condition, never a verdict. Every non-cell-line basis needs `id`
+ * in the title or body with no ASCII letter/digit on either side, so its leading alphanumeric run appears there
+ * as a maximal run. Ids that do not start with a letter or digit fall back to every PR.
+ */
+function candidatePositions(index: PrIndex, id: string, total: number): number[] {
+  const lead = /^[A-Za-z0-9]+/.exec(id)?.[0];
+  if (!lead) return Array.from({ length: total }, (_, position) => position);
+  const merged = new Set([...(index.cellIds.get(id) ?? []), ...(index.runs.get(lead) ?? [])]);
+  return [...merged].sort((a, b) => a - b);
+}
+
 /** Prefer a dedicated body cell line over title evidence; incidental mentions only qualify for long ids. */
 export function landedButYellow(items: readonly ChecklistItem[], prs: readonly MergedChecklistPr[], { owner }: { owner?: string } = {}): LandedButYellowRow[] {
   const rows: LandedButYellowRow[] = [];
+  const index = prIndex(prs);
   for (const item of items) {
     if (item.status !== 'yellow' && item.status !== 'red') continue;
     if (owner !== undefined && !ownerMatches(item.owner, owner)) continue;
@@ -37,11 +92,10 @@ export function landedButYellow(items: readonly ChecklistItem[], prs: readonly M
       : new RegExp(`^${id}(?:\\s|$)`);
     const explicitTitle = new RegExp(`(?<![A-Za-z0-9])${id}\\s+(?:수확|(?:첫|둘째|셋째)\\s*조각)(?![A-Za-z0-9가-힣])|\\(${id}\\)`);
     const rank: Record<PrMatchBasis, number> = { 'cell-line': 0, 'title-strong': 1, mention: 2 };
-    const matched = prs.flatMap((pr) => {
-      const cellLine = (pr.body ?? '').split('\n').some((line) => {
-        const match = /^[ \t]*칸(?:[ \t]*:[ \t]*|[ \t]+)([A-Za-z0-9_-]+(?:[ \t]*,[ \t]*[A-Za-z0-9_-]+)*)[ \t]*$/.exec(line.endsWith('\r') ? line.slice(0, -1) : line);
-        return match?.[1]?.split(',').some((candidate) => candidate.trim() === item.id) ?? false;
-      });
+    const cellLines = new Set(index.cellIds.get(item.id) ?? []);
+    const matched = candidatePositions(index, item.id, prs.length).flatMap((position) => {
+      const pr = prs[position]!;
+      const cellLine = cellLines.has(position);
       const basis: PrMatchBasis | undefined = cellLine ? 'cell-line'
         : titleStart.test(pr.title) || explicitTitle.test(pr.title) ? 'title-strong'
           : !shortId && (word.test(pr.title) || word.test(pr.body ?? '')) ? 'mention' : undefined;
@@ -58,3 +112,73 @@ export function landedButYellow(items: readonly ChecklistItem[], prs: readonly M
   }
   return rows.sort((a, b) => Number(b.newer) - Number(a.newer));
 }
+
+export interface MergedPrRunResult { status: number | null; stdout: string; stderr: string }
+/** One `gh` invocation; resolves when the process exits. */
+export type MergedPrRunner = (command: string, args: readonly string[], cwd: string) => Promise<MergedPrRunResult>;
+
+export const MERGED_PR_LIMIT = 400;
+/** Concurrent `gh pr list` calls once the first page is full (LANDED-YELLOW-FAST · 10-21 prod: 24 sequential calls ≈ 145s). */
+export const MERGED_PR_CONCURRENCY = 6;
+const DAY_MS = 86_400_000;
+
+/**
+ * Merged PRs since `since` (UTC date). One call answers when it returns fewer than the cap. Otherwise the range
+ * splits into UTC-day windows fetched with a concurrency cap; a full window is halved down to one second as before,
+ * and a full one-second window probes one extra row to tell exactly 400 from truncation.
+ * The returned set and the truncation flag match the former sequential bisection; only call shape and time differ.
+ */
+export async function fetchMergedChecklistPrs(since: string, now: Date, run: MergedPrRunner, cwd: string,
+  { concurrency = MERGED_PR_CONCURRENCY }: { concurrency?: number } = {}): Promise<{ prs: MergedChecklistPr[]; truncated: boolean; calls: number }> {
+  let calls = 0;
+  const fetch = async (lower: string, upper?: string, limit = MERGED_PR_LIMIT): Promise<MergedChecklistPr[]> => {
+    const search = `merged:>=${lower}${upper ? ` merged:<${upper}` : ''}`;
+    calls++;
+    const r = await run('gh', ['pr', 'list', '--state', 'merged', '--search', search, '--limit', String(limit), '--json', 'number,title,body,mergedAt'], cwd);
+    if (r.status !== 0) throw new Error(`병합 PR 조회(gh) 실패 rc=${r.status}: ${(r.stderr || r.stdout).trim().slice(0, 400)}`);
+    const page = JSON.parse(r.stdout.trim()) as MergedChecklistPr[];
+    if (!Array.isArray(page)) throw new Error('병합 PR 조회(gh): 배열이 아니다');
+    return page;
+  };
+  const first = await fetch(since);
+  if (first.length < MERGED_PR_LIMIT) return { prs: first, truncated: false, calls };
+  // Bounded pool: at most `concurrency` gh processes at once; a failure stops new calls and rejects.
+  let active = 0;
+  let failed: unknown;
+  const waiting: Array<() => void> = [];
+  const limited = async <T>(task: () => Promise<T>): Promise<T> => {
+    while (active >= Math.max(1, concurrency) && failed === undefined) await new Promise<void>((resolve) => waiting.push(resolve));
+    if (failed !== undefined) throw failed;
+    active++;
+    try { return await task(); }
+    catch (error) { failed ??= error; throw error; }
+    finally { active--; if (failed !== undefined) for (const wake of waiting.splice(0)) wake(); else waiting.shift()?.(); }
+  };
+  let truncated = false;
+  const visit = async (start: number, end: number): Promise<MergedChecklistPr[]> => {
+    const from = new Date(start).toISOString();
+    const to = new Date(end).toISOString();
+    const page = await limited(() => fetch(from, to));
+    if (page.length < MERGED_PR_LIMIT) return page;
+    if (end - start <= 1000) {
+      // The second-precision search cannot be subdivided; probe one extra row to distinguish exactly 400 from a real truncation.
+      const probe = await limited(() => fetch(from, to, MERGED_PR_LIMIT + 1));
+      if (probe.length > MERGED_PR_LIMIT) truncated = true;
+      return probe.slice(0, MERGED_PR_LIMIT);
+    }
+    const middle = start + Math.floor((end - start) / 2000) * 1000;
+    const [left, right] = await Promise.all([visit(start, middle), visit(middle, end)]);
+    return [...left, ...right];
+  };
+  const lower = Date.parse(`${since}T00:00:00Z`);
+  const upper = Math.max(lower + 1000, Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + 1));
+  const windows: Array<[number, number]> = [];
+  for (let start = lower; start < upper; start += DAY_MS) windows.push([start, Math.min(start + DAY_MS, upper)]);
+  const settled = await Promise.allSettled(windows.map(([start, end]) => visit(start, end)));
+  const rejected = settled.find((result): result is PromiseRejectedResult => result.status === 'rejected');
+  if (rejected) throw failed ?? rejected.reason;
+  // Chronological window order, first occurrence wins — the same de-duplication as before.
+  const unique = new Map<number, MergedChecklistPr>();
+  for (const result of settled) for (const pr of (result as PromiseFulfilledResult<MergedChecklistPr[]>).value) if (!unique.has(pr.number)) unique.set(pr.number, pr);
+  return { prs: [...unique.values()], truncated, calls };
+}

package/src/release-loop/light-rc.ts

@@ -209,6 +209,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   };
   const captured: Buffer[] = [];
   const rc = await (deps.dispatch ?? dispatchHeavyCheck)({
+    // Keep the self-gate contract: an unavailable remote leaves this release check unmeasured; do not start a heavy gate locally.
     tool: 'self-gate', repo: cwd, installPwa: true, refs: [base], json: true, commit: measuredCommit,
     // The host re-runs this command with --local (and ELANOUS_GATE_REMOTE_CHILD=1), so it never recurses.
     remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],

package/src/release-loop/rehearsal.ts

@@ -15,6 +15,7 @@ import { LIGHT_RC_UNKNOWN_HOST, runLightRc, type LightRcResult } from './light-r
 import { planRehearsalShards, type RehearsalShardPlan, type RehearsalShardPlanDeps } from './rehearsal-shard-plan.js';
 import { listSchedules, type ReleaseSchedule } from './release-schedule.js';
 import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
+import { hardRehearsalGateArgs } from '../../scripts/release-loop/gate-radius-live.js';
 
 export type StepId = 'hard-mid' | 'rc-7h' | 'hard-5h' | 'rc-150m';
 export type RehearsalOutcome = 'ok' | 'regression' | 'unmeasured' | 'error' | 'no-checkout' | 'checkout-dirty' | 'superseded' | 'interrupted';
@@ -185,27 +186,23 @@ export function runRehearsalLeakCheck(checkout: string): { status: number | null
   } finally { rmSync(out, { recursive: true, force: true }); }
 }
 
-/** The hard rehearsal uses the release gate itself, pinned to the fetched main SHA and node-b Pod member. */
-async function runHardGate(version: string, checkout: string, sha: string, ledgerRoot: string, runId: string): Promise<HardGateResult> {
-  const configuredPool = releaseLoopConfig().gatePodPool;
-  if (!configuredPool) throw new Error('hard rehearsal requires release.loop.gatePodPool');
-  const members = parsePodPool(configuredPool);
-  const gateMember = members.find(member => member.sshHost === 'node-b');
-  if (!gateMember) throw new Error('hard rehearsal requires a live node-b Pod member');
-  const pool = configuredPool.split(',').map(part => part.trim())
-    .find(part => part.split(/[#:]/, 1)[0] === `${gateMember.context}@${gateMember.sshHost}`);
-  if (!pool) throw new Error('hard rehearsal cannot isolate the node-b Pod member');
-  const previous = latestPublishedPreviousVersion(version, ledgerRoot);
-  const logPath = join(ledgerRoot, 'release', version, 'rehearsal', `${runId}.log`);
-  mkdirSync(dirname(logPath), { recursive: true });
-  const run = (() => {
-    const log = openSync(logPath, 'wx', 0o600);
-    try { return spawnSync('bun', ['scripts/release-loop/gate-node.ts', '--commit', sha, '--version', version,
-      '--baseline-version', previous, '--executor', 'pod', '--pod-pool', pool, '--pod-shards', '12', '--json'], {
-      cwd: checkout, encoding: 'utf8', stdio: ['ignore', log, log], timeout: 4 * 60 * 60_000,
-      env: { ...process.env, ELANOUS_STATE_DIR: ledgerRoot, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(ledgerRoot) },
-    }); } finally { closeSync(log); }
-  })();
+/** Run the exact hard-gate subprocess with an isolated clock budget for timeout replay. */
+export function spawnHardRehearsalGate(opts: {
+  binary: string; args: string[]; checkout: string; ledgerRoot: string; logPath: string; timeoutMs: number; sha: string;
+}): HardGateResult {
+  mkdirSync(dirname(opts.logPath), { recursive: true });
+  const log = openSync(opts.logPath, 'wx', 0o600);
+  let run: ReturnType<typeof spawnSync>;
+  try {
+    run = spawnSync(opts.binary, opts.args, {
+      cwd: opts.checkout, encoding: 'utf8', stdio: ['ignore', log, log], timeout: opts.timeoutMs,
+      env: { ...process.env, ELANOUS_STATE_DIR: opts.ledgerRoot, ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(opts.ledgerRoot) },
+    });
+  } finally { closeSync(log); }
+  return parseHardRehearsalGateResult(run, opts.logPath, opts.sha);
+}
+
+function parseHardRehearsalGateResult(run: ReturnType<typeof spawnSync>, logPath: string, sha: string): HardGateResult {
   // stdout and stderr stream to the claim's durable evidence while the child is still running.
   const output = readFileSync(logPath, 'utf8');
   const line = output.split(/\r?\n/).reverse().find(value => value.trim().startsWith('{'));
@@ -225,6 +222,25 @@ async function runHardGate(version: string, checkout: string, sha: string, ledge
   throw new Error(`hard rehearsal gate rc=${run.status ?? 'spawn'} disagrees with outcome=${result.outcome}`);
 }
 
+/** The hard rehearsal uses the release gate itself, pinned to the fetched main SHA and node-b Pod member. */
+async function runHardGate(version: string, checkout: string, sha: string, ledgerRoot: string, runId: string): Promise<HardGateResult> {
+  const configuredPool = releaseLoopConfig().gatePodPool;
+  if (!configuredPool) throw new Error('hard rehearsal requires release.loop.gatePodPool');
+  const members = parsePodPool(configuredPool);
+  const gateMember = members.find(member => member.sshHost === 'node-b');
+  if (!gateMember) throw new Error('hard rehearsal requires a live node-b Pod member');
+  const pool = configuredPool.split(',').map(part => part.trim())
+    .find(part => part.split(/[#:]/, 1)[0] === `${gateMember.context}@${gateMember.sshHost}`);
+  if (!pool) throw new Error('hard rehearsal cannot isolate the node-b Pod member');
+  const previous = latestPublishedPreviousVersion(version, ledgerRoot);
+  const logPath = join(ledgerRoot, 'release', version, 'rehearsal', `${runId}.log`);
+  mkdirSync(dirname(logPath), { recursive: true });
+  return spawnHardRehearsalGate({
+    binary: 'bun', args: hardRehearsalGateArgs(version, runId, sha, previous, pool),
+    checkout, ledgerRoot, logPath, timeoutMs: 4 * 60 * 60_000, sha,
+  });
+}
+
 function oneLine(text: string): string { return text.replace(/\s+/g, ' ').trim(); }
 
 function outcomeLine(stamp: RehearsalStamp): string {