elanous 0.2.29 → 0.2.31

package/src/self-implement/run-ledger.ts

@@ -1,4 +1,4 @@
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { refuseProductionLedgerWriteInTest } from '../harness/ledger-write-guard.js';
 import { tracedPathReferences, verbatimOriginalAsk } from './goal-author.js';
@@ -20,6 +20,7 @@ export interface RunLedgerEntry {
   event: string;
   data: Record<string, unknown>;
   goalId?: string;
+  devProject?: string;
   orchestrationId?: string;
   shardId?: string;
   siblingShardIds?: string[];
@@ -412,8 +413,12 @@ export function appendRunLedgerEntry(entry: RunLedgerEntry, dir = runLedgerDir()
   if (refuseProductionLedgerWriteInTest(dir, 'run-ledger')) return;
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   const live = runLedgerPath(entry.runId, dir);
+  const devProject = process.env.ELANOUS_DEV_PROJECT;
+  const row = entry.devProject === undefined && typeof devProject === 'string' && devProject.startsWith('prj-')
+    ? { ...entry, devProject }
+    : entry;
   withRunLedgerLock(dir, entry.runId, () => {
-    const line = `${JSON.stringify(entry)}\n`;
+    const line = `${JSON.stringify(row)}\n`;
     if (!restoreArchivedRunLedger(dir, entry.runId, line)) appendFileSync(live, line, 'utf8');
   });
 }
@@ -1315,6 +1320,10 @@ export interface UnfinishedRunLedgerQuery {
   terminalByTrailingRunStatus?: number;
   cacheHits?: number;
   cacheMisses?: number;
+  /** Hits served by the persisted cross-process scan index (subset of cacheHits). */
+  indexHits?: number;
+  /** Whether that index was loaded from disk, started fresh, or was bypassed. */
+  indexOrigin?: RunLedgerScanIndexOrigin;
   pathFilter?: string;
   matchingPathCount?: number;
   unknownPathCount?: number;
@@ -1674,6 +1683,96 @@ function unfinishedLedgerCacheKey(path: string, read?: RunLedgerReader): string
   return `${path}\u0000reader:${id}`;
 }
 
+// ⭐ 프로세스 간 유효 스캔 색인(칸 CONTEXT-NOW-RUN-SCAN-INDEX).
+//   `/now`(contextNowInWorker)는 요청마다 «새 워커 프로세스»를 띄우므로 위 프로세스 캐시는 매번 빈 채로 시작한다
+//   (실측 2026-10-14: scanned=7893, cacheHits=0, 조회 6.3~8.9초). 색인은 파싱된 파일별 facts 를
+//   원장 옆에 (size, mtimeMs) 스탬프로 저장하고, 스탬프가 같으면 재사용한다. 원장에 무엇이 «붙으면»
+//   스탬프가 바뀌므로 무효화는 자동이다. 읽기 실패는 전부 fail-soft: 색인이 없으면 그냥 새로 읽는다.
+const RUN_LEDGER_SCAN_INDEX_FILE = '.unfinished-scan-index.json';
+const RUN_LEDGER_SCAN_INDEX_VERSION = 1;
+const RUN_LEDGER_SCAN_INDEX_LIMIT = 32_768;
+
+/** Where the persisted scan index lives: beside its ledgers, never mistaken for one (readdir filters canonical names). */
+export function runLedgerScanIndexPath(dir: string): string {
+  return join(dir, RUN_LEDGER_SCAN_INDEX_FILE);
+}
+
+export interface RunLedgerScanIndexRecord {
+  size: number;
+  mtimeMs: number;
+  facts: UnfinishedLedgerFacts;
+}
+
+/** Whether the persisted index was loaded, started fresh, or was bypassed (noCache or an injected reader). */
+export type RunLedgerScanIndexOrigin = 'loaded' | 'fresh' | 'bypassed';
+
+const UNFINISHED_LIFECYCLE_WORDS = new Set<string>([
+  'live', 'orphaned', 'human-stopped', 'terminal-other-vocabulary', 'terminal-run-status-superseded', 'unjudgeable',
+]);
+
+function isScanIndexFacts(value: unknown): value is UnfinishedLedgerFacts {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const facts = value as Record<string, unknown>;
+  return typeof facts.terminal === 'boolean'
+    && typeof facts.terminalByTrailingRunStatus === 'boolean'
+    && (facts.branch === null || typeof facts.branch === 'string')
+    && (facts.lastActivityTimestamp === null || typeof facts.lastActivityTimestamp === 'string')
+    && typeof facts.lastActivityStatus === 'string'
+    && (facts.targetRoot === null || typeof facts.targetRoot === 'string')
+    && (facts.goalFile === null || typeof facts.goalFile === 'string')
+    && typeof facts.fixedLifecycle === 'string' && UNFINISHED_LIFECYCLE_WORDS.has(facts.fixedLifecycle);
+}
+
+function isScanIndexRecord(value: unknown): value is RunLedgerScanIndexRecord {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const record = value as Record<string, unknown>;
+  return Number.isFinite(record.size) && Number.isFinite(record.mtimeMs) && isScanIndexFacts(record.facts);
+}
+
+const scanIndexCache = new Map<string, { stamp: string; entries: Map<string, RunLedgerScanIndexRecord> }>();
+
+function scanIndexFileStamp(path: string): string {
+  try { const stat = statSync(path); return `${stat.size}:${stat.mtimeMs}`; } catch { return 'missing'; }
+}
+
+/** Load (memoized by index-file stamp) the persisted per-directory scan index; malformed or absent behaves as fresh. */
+export function loadRunLedgerScanIndex(dir: string): Map<string, RunLedgerScanIndexRecord> {
+  const path = runLedgerScanIndexPath(dir);
+  const stamp = scanIndexFileStamp(path);
+  const cached = scanIndexCache.get(dir);
+  if (cached && cached.stamp === stamp) return cached.entries;
+  const entries = new Map<string, RunLedgerScanIndexRecord>();
+  if (stamp !== 'missing') {
+    try {
+      const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'));
+      const raw = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        && (parsed as Record<string, unknown>).version === RUN_LEDGER_SCAN_INDEX_VERSION
+        && typeof (parsed as Record<string, unknown>).entries === 'object'
+        && (parsed as Record<string, unknown>).entries !== null && !Array.isArray((parsed as Record<string, unknown>).entries)
+        ? (parsed as { entries: Record<string, unknown> }).entries : null;
+      if (raw) for (const [runId, record] of Object.entries(raw)) {
+        if (isScanIndexRecord(record)) entries.set(runId, record);
+      }
+    } catch { /* a malformed index behaves as absent */ }
+  }
+  scanIndexCache.set(dir, { stamp, entries });
+  return entries;
+}
+
+/** Persist the index beside its ledgers, best-effort: any failure just leaves the next scan reading fresh. */
+function persistRunLedgerScanIndex(dir: string, entries: ReadonlyMap<string, RunLedgerScanIndexRecord>): boolean {
+  if (refuseProductionLedgerWriteInTest(dir, 'run-ledger-scan-index')) return false;
+  const bounded = entries.size > RUN_LEDGER_SCAN_INDEX_LIMIT
+    ? new Map([...entries].slice(entries.size - RUN_LEDGER_SCAN_INDEX_LIMIT))
+    : entries;
+  try {
+    writeFileSync(runLedgerScanIndexPath(dir), JSON.stringify({ version: RUN_LEDGER_SCAN_INDEX_VERSION, entries: Object.fromEntries(bounded) }), 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 function unfinishedLedgerFacts(ledger: readonly RunLedgerEntry[]): UnfinishedLedgerFacts {
   const last = ledger.at(-1)?.timestamp;
   const lastActivityTimestamp = last !== undefined && Number.isFinite(Date.parse(last)) ? last : null;
@@ -1690,7 +1789,13 @@ function unfinishedLedgerFacts(ledger: readonly RunLedgerEntry[]): UnfinishedLed
   };
 }
 
-function readUnfinishedLedgerFacts(runId: string, dir: string, read?: RunLedgerReader, noCache?: boolean): { facts: UnfinishedLedgerFacts; hit: boolean } {
+function readUnfinishedLedgerFacts(
+  runId: string,
+  dir: string,
+  read?: RunLedgerReader,
+  noCache?: boolean,
+  index?: Map<string, RunLedgerScanIndexRecord>,
+): { facts: UnfinishedLedgerFacts; hit: boolean; source: 'process' | 'index' | 'read' } {
   const path = runLedgerPath(runId, dir);
   const key = noCache ? null : unfinishedLedgerCacheKey(path, read);
   const stamp = noCache ? null : statSync(path);
@@ -1698,9 +1803,18 @@ function readUnfinishedLedgerFacts(runId: string, dir: string, read?: RunLedgerR
   if (cached && stamp && key !== null && cached.size === stamp.size && cached.mtimeMs === stamp.mtimeMs) {
     unfinishedLedgerCache.delete(key);
     unfinishedLedgerCache.set(key, cached);
-    return { facts: cached.facts, hit: true };
+    return { facts: cached.facts, hit: true, source: 'process' };
   }
   if (key !== null) unfinishedLedgerCache.delete(key);
+  // ⭐ 프로세스 캐시가 비었어도(새 워커) 디스크 색인의 스탬프가 같으면 재사용한다.
+  //   주입된 reader 는 실제 파일 내용과 무관한 대역이라 색인에 넣지 «도», 색인에서 읽지 «도» 않는다.
+  if (index !== undefined && stamp && read === undefined) {
+    const record = index.get(runId);
+    if (record && record.size === stamp.size && record.mtimeMs === stamp.mtimeMs) {
+      if (key !== null) unfinishedLedgerCache.set(key, { size: stamp.size, mtimeMs: stamp.mtimeMs, facts: record.facts });
+      return { facts: record.facts, hit: true, source: 'index' };
+    }
+  }
   try {
     const ledger = loadRunLedger(runId, dir, read);
     if (ledger === null && stamp !== null) throw new Error(`run ledger disappeared after stat: ${path}`);
@@ -1712,9 +1826,14 @@ function readUnfinishedLedgerFacts(runId: string, dir: string, read?: RunLedgerR
         if (unfinishedLedgerCache.size > UNFINISHED_LEDGER_CACHE_LIMIT) unfinishedLedgerCache.delete(unfinishedLedgerCache.keys().next().value!);
       }
     }
-    return { facts, hit: false };
+    if (index !== undefined && stamp !== null && read === undefined) {
+      index.set(runId, { size: stamp.size, mtimeMs: stamp.mtimeMs, facts });
+    }
+    return { facts, hit: false, source: 'read' };
   } catch (error) {
     if (key !== null) unfinishedLedgerCache.delete(key);
+    // 원장이 사라졌거나 바뀐 사이에 읽었다 — 색인의 스탬프는 이미 무효이므로 치운다(무효화).
+    index?.delete(runId);
     throw error;
   }
 }
@@ -1734,6 +1853,11 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
   const goalsDir = resolve(options.goalsDir ?? resolveGoalDocumentsDir(process.cwd()).directory);
   const list = options.list ?? readdirSync;
   const liveWindowMs = options.liveWindowMs ?? DEFAULT_UNFINISHED_LIVE_WINDOW_MS;
+  // ⭐ 색인은 noCache 나 주입된 reader 가 아니어야만 켠다 — 그 둘은 «정직한 재읽기» 계약을 지켜야 한다.
+  const scanIndex = !options.noCache && options.read === undefined ? loadRunLedgerScanIndex(dir) : undefined;
+  const indexOrigin: RunLedgerScanIndexOrigin = scanIndex === undefined ? 'bypassed' : scanIndex.size > 0 ? 'loaded' : 'fresh';
+  let indexHits = 0;
+  let indexChanged = false;
   let fileNames: string[];
   try {
     fileNames = list(dir);
@@ -1748,6 +1872,8 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
         terminalByTrailingRunStatus: 0,
         cacheHits: 0,
         cacheMisses: 0,
+        indexHits: 0,
+        indexOrigin,
         ...(options.path === undefined ? {} : { pathFilter: options.path, matchingPathCount: 0, unknownPathCount: 0 }),
         scope: 'self-implement-run-ledger',
         note: UNFINISHED_RUN_LEDGER_NOTE,
@@ -1760,6 +1886,8 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
         terminalByTrailingRunStatus: 0,
         cacheHits: 0,
         cacheMisses: 0,
+        indexOrigin,
+        indexHits: 0,
         ms: Date.now() - startedAt,
       });
       return missing;
@@ -1782,12 +1910,18 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
     scanned += 1;
     let facts: UnfinishedLedgerFacts;
     try {
-      const observed = readUnfinishedLedgerFacts(runId, dir, options.read, options.noCache);
+      const observed = readUnfinishedLedgerFacts(runId, dir, options.read, options.noCache, scanIndex);
       facts = observed.facts;
-      if (observed.hit) cacheHits += 1;
-      else cacheMisses += 1;
+      if (observed.hit) {
+        cacheHits += 1;
+        if (observed.source === 'index') indexHits += 1;
+      } else {
+        cacheMisses += 1;
+        if (scanIndex !== undefined) indexChanged = true;
+      }
     } catch {
       cacheMisses += 1;
+      if (scanIndex?.delete(runId)) indexChanged = true;
       unreadableLedgerCount += 1;
       entries.push({ runId, branch: null, status: 'ledger-unreadable', plannedPaths: [], plannedPathStatus: 'unknown', ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalLookupBasis: 'caller-cwd', goalDocumentSearchDirectory: null, lastActivityTimestamp: null, lastActivityAgeMs: null, lastActivityStatus: 'ledger-unreadable', lifecycle: 'unjudgeable' });
       callerCwdCount += 1;
@@ -1840,6 +1974,7 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
     }
   }
   entries.sort((left, right) => left.runId.localeCompare(right.runId));
+  if (scanIndex !== undefined && indexChanged) persistRunLedgerScanIndex(dir, scanIndex);
   debug.log('self-implement.run-ledger', 'goal-lookup-basis', { ledgerTarget: ledgerTargetCount, callerCwd: callerCwdCount });
   debug.log('self-implement.run-ledger', 'unfinished-query', {
     scanned,
@@ -1848,10 +1983,12 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
     terminalByTrailingRunStatus,
     cacheHits,
     cacheMisses,
+    indexOrigin,
+    indexHits,
     ms: Date.now() - startedAt,
   });
   if (options.path === undefined) {
-    return { entries, ledgerDirectory: dir, goalsDirectory: goalsDir, unreadableLedgerCount, ledgerDirectoryMissing: false, terminalByTrailingRunStatus, cacheHits, cacheMisses, scope: 'self-implement-run-ledger', note: UNFINISHED_RUN_LEDGER_NOTE };
+    return { entries, ledgerDirectory: dir, goalsDirectory: goalsDir, unreadableLedgerCount, ledgerDirectoryMissing: false, terminalByTrailingRunStatus, cacheHits, cacheMisses, indexHits, indexOrigin, scope: 'self-implement-run-ledger', note: UNFINISHED_RUN_LEDGER_NOTE };
   }
   const pathFilter = options.path;
   const unknownPathStatus = (entry: UnfinishedRunLedgerEntry): boolean => entry.plannedPathStatus !== 'found-ledger-goal-file'
@@ -1871,6 +2008,8 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
     terminalByTrailingRunStatus,
     cacheHits,
     cacheMisses,
+    indexHits,
+    indexOrigin,
     pathFilter,
     matchingPathCount: matchingEntries.length,
     unknownPathCount: unknownEntries.length,
@@ -1908,6 +2047,8 @@ export interface FederatedUnfinishedRunLedgerQuery {
   reconciledTerminatedElsewhereCount: number;
   cacheHits?: number;
   cacheMisses?: number;
+  /** Hits served by the persisted cross-process scan index (subset of cacheHits). */
+  indexHits?: number;
   pathFilter?: string;
   matchingPathCount?: number;
   unknownPathCount?: number;
@@ -1947,6 +2088,7 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
   let unknownPathCount = 0;
   let cacheHits = 0;
   let cacheMisses = 0;
+  let indexHits = 0;
   const recordDirectoryFailure = (kind: FederatedLedgerDirectoryFailureKind): void => {
     if (kind === 'missing') missingLedgerDirectoryCount += 1;
     else if (kind === 'unreadable') unreadableLedgerDirectoryAccessCount += 1;
@@ -1972,6 +2114,7 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
       unknownPathCount += result.unknownPathCount ?? 0;
       cacheHits += result.cacheHits ?? 0;
       cacheMisses += result.cacheMisses ?? 0;
+      indexHits += result.indexHits ?? 0;
       entries.push(...result.entries.map((entry) => ({ ...entry, ledgerDirectory })));
     } catch (error) {
       recordDirectoryFailure(classifyFederatedLedgerDirectoryReadFailure(error));
@@ -1993,7 +2136,8 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
   for (const runId of unfinishedRunIds) {
     for (const ledgerDirectory of ledgerDirectories) {
       try {
-        if (readUnfinishedLedgerFacts(runId, ledgerDirectory, undefined, options.noCache).facts.terminal) { terminatedElsewhere.add(runId); break; }
+        const reconciliationIndex = options.noCache ? undefined : loadRunLedgerScanIndex(ledgerDirectory);
+        if (readUnfinishedLedgerFacts(runId, ledgerDirectory, undefined, options.noCache, reconciliationIndex).facts.terminal) { terminatedElsewhere.add(runId); break; }
       } catch { /* An absent or unreadable sibling cannot establish termination. */ }
     }
   }
@@ -2014,6 +2158,7 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
     reconciledTerminatedElsewhereCount,
     cacheHits,
     cacheMisses,
+    indexHits,
     ...(options.path === undefined ? {} : { pathFilter: options.path, matchingPathCount, unknownPathCount }),
     scope: 'self-implement-run-ledger-federated',
     note: FEDERATED_UNFINISHED_RUN_LEDGER_NOTE,

package/src/self-implement/run-stop.ts

@@ -15,7 +15,7 @@ import { appendRunLedgerEntry, type RunLedgerEntry, type RunLedgerWriter, type R
 /** 닫힌 목록 — 못 고르면 `unclassified`. */
 export const RUN_STOP_CLASSES = [
   'env-unrelated', 'main-sync', 'pod-died', 'review-repeat',
-  'review-out-of-scope', 'evidence-uncovered', 'fabric', 'launch-failed', 'unclassified',
+  'review-out-of-scope', 'evidence-uncovered', 'fabric', 'launch-failed', 'gate-failed', 'unclassified',
 ] as const;
 export type RunStopClass = typeof RUN_STOP_CLASSES[number];
 
@@ -68,8 +68,9 @@ export function classifyMergeHoldStop(mergeReason: string | undefined): RunStopC
   return 'unclassified';
 }
 
-/** Pod exit 분류 사유 → 닫힌 목록. */
-export function classifyPodExitStop(reason: string | undefined): RunStopClass {
+/** Pod exit 분류 사유 → 닫힌 목록. `stage` 가 호스트 재게이트 실패(`host-regate-failed`)면 `gate-failed`, 인자가 없으면 지금과 똑같이. */
+export function classifyPodExitStop(reason: string | undefined, stage?: string): RunStopClass {
+  if (stage === 'host-regate-failed') return 'gate-failed';
   switch (reason) {
     case 'pod-failure': case 'pod-error': case 'OOMKilled': case 'ENOBUFS': case 'signal': return 'pod-died';
     case 'no-launch': return 'launch-failed';

package/src/self-implement/run-ttl.ts

@@ -5,7 +5,9 @@
  * Past `tools.selfImplement.runTtlHours` (default 24) since its last commit, the sweep makes one pre-emptive move:
  *   · live owning run → one resync memo in its control inbox (same path as SIBLING-RESYNC #24893/#24899),
  *                       at most once per (PR, head sha) — a rebase moves the head and re-arms it
- *   · no live run     → the registered `elanous:needs-rebase` label, once (QUIET-PR-COMMENTS: never a comment)
+ *   · no live run     → the registered `elanous:needs-rebase` label, once (QUIET-PR-COMMENTS: never a comment);
+ *                       when `requestRegate` is supplied, at most one of those stale PRs is also selected
+ *                       for a re-gate request (shadow: would-regate observation only; live: one call)
  *
  * Mode `tools.selfImplement.runTtl.mode`: `shadow` (default) only logs what it would do; `live` writes.
  * Cost bound: a PR opened inside the TTL is still inside its own time-to-landing and is never fetched
@@ -63,6 +65,8 @@ export interface RunTtlResult {
   readonly memo: readonly number[];
   /** Label added (live) or would be added (shadow). */
   readonly label: readonly number[];
+  /** Re-gate requested (live) or would be requested (shadow). Empty when the adapter is omitted. */
+  readonly regate: readonly number[];
   readonly alreadyMarked: readonly number[];
   readonly alreadyMemoed: readonly number[];
   /** Owning run lookup failed — left alone (a failed lookup is not a dead run). */
@@ -109,6 +113,8 @@ export async function runRunTtlSweep(input: {
   concurrency?: number;
   now?: () => number;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  /** Optional: among stale PRs with no live run, request a re-gate for at most one per sweep. */
+  requestRegate?: (pr: RunTtlCandidate) => Promise<void> | void;
 }): Promise<RunTtlResult> {
   const { adapters } = input;
   const now = input.now ?? Date.now;
@@ -132,6 +138,7 @@ export async function runRunTtlSweep(input: {
   const stale: number[] = [];
   const memo: number[] = [];
   const label: number[] = [];
+  const regate: number[] = [];
   const alreadyMarked: number[] = [];
   const alreadyMemoed: number[] = [];
   const unresolved: number[] = [];
@@ -139,17 +146,17 @@ export async function runRunTtlSweep(input: {
   const skippedFetchCap: number[] = [];
   const failed: number[] = [];
   const result = (reason?: string): RunTtlResult => ({
-    mode, ttlHours, considered, freshByCreation, fetched, fresh, unknown, stale, memo, label, alreadyMarked,
+    mode, ttlHours, considered, freshByCreation, fetched, fresh, unknown, stale, memo, label, regate, alreadyMarked,
     alreadyMemoed, unresolved, skippedOverCap, skippedFetchCap, failed, durationMs: Math.max(0, now() - startedAt),
     ...(reason ? { reason } : {}),
   });
   const summary = (out: RunTtlResult): RunTtlResult => {
     emit('summary', {
       ttlHours, cap, maxFetch, concurrency, considered, freshByCreation, fetched, fresh,
-      unknown: unknown.length, stale: stale.length, memo: memo.length, label: label.length,
+      unknown: unknown.length, stale: stale.length, memo: memo.length, label: label.length, regate: regate.length,
       alreadyMarked: alreadyMarked.length, alreadyMemoed: alreadyMemoed.length, unresolved: unresolved.length,
       skippedOverCap: skippedOverCap.length, skippedFetchCap: skippedFetchCap.length, failed: failed.length,
-      memoPrs: memo, labelPrs: label, durationMs: out.durationMs, ...(out.reason ? { reason: out.reason } : {}),
+      memoPrs: memo, labelPrs: label, regatePrs: regate, durationMs: out.durationMs, ...(out.reason ? { reason: out.reason } : {}),
     });
     return out;
   };
@@ -200,6 +207,7 @@ export async function runRunTtlSweep(input: {
   }
   stalePrs.sort((a, b) => b.ageMs - a.ageMs || a.pr.number - b.pr.number);
   let actions = 0;
+  let selectedRegate = false;
   for (const { pr, target, ageMs } of stalePrs) {
     const ageHours = ageMs / 3_600_000;
     const key = `${pr.number}:${pr.headSha}`;
@@ -240,9 +248,15 @@ export async function runRunTtlSweep(input: {
       }
     }
     const reason = target.alive ? 'memo-failed' : target.reason;
+    const canRegate = Boolean(input.requestRegate) && !target.alive && !selectedRegate;
     if (mode === 'shadow') {
       label.push(pr.number);
       emit('would-label', { pr: pr.number, label: RUN_TTL_MARKER_LABEL, reason, ageHours: Math.floor(ageHours) });
+      if (canRegate) {
+        selectedRegate = true;
+        regate.push(pr.number);
+        emit('would-regate', { pr: pr.number, reason, ageHours: Math.floor(ageHours) });
+      }
       continue;
     }
     try {
@@ -253,6 +267,16 @@ export async function runRunTtlSweep(input: {
       failed.push(pr.number);
       emit('label-failed', { pr: pr.number, error: String(error) });
     }
+    if (canRegate) {
+      selectedRegate = true;
+      try {
+        await input.requestRegate!(pr);
+        regate.push(pr.number);
+        emit('regate-requested', { pr: pr.number, reason, ageHours: Math.floor(ageHours) });
+      } catch (error) {
+        emit('regate-failed', { pr: pr.number, error: String(error) });
+      }
+    }
   }
   return summary(result());
 }

package/src/self-implement/seams.ts

@@ -2493,6 +2493,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
 
     openPr: async ({ title, body, head, base, draft, labels, cwd }) => {
       const resolvedBase = assertBaseBranchOnOrigin(cwd, base);
+      const harnessSeat = process.env.ELANOUS_HARNESS_SEAT;
       const outcome = (o.prManager ?? makePrManager()).upsertPr({
         branch: head,
         worktreePath: cwd,
@@ -2501,6 +2502,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         commitMessage: title,
         ...(resolvedBase ? { base: resolvedBase } : {}),
         ...(draft !== undefined ? { draft } : {}),
+        ...(harnessSeat === 'OP' || harnessSeat === 'TC' || harnessSeat === 'MK' || harnessSeat === 'UX' ? { seat: harnessSeat } : {}),
         // BENCH-ISOLATED-ARMS ② — base 가 `bench/<id>/base` 면 라벨 `elanous:bench` 를 더한다.
         ...(() => {
           const all = benchIdFromBase(resolvedBase) && !labels?.includes(BENCH_LABEL) ? [...(labels ?? []), BENCH_LABEL] : labels;

package/src/self-implement/shadow-stage.ts

@@ -10,6 +10,7 @@
 // 배선은 P4(현재 비-git 은 front door 에서 refuse 유지 → 이 적용 경로는 프로덕션 미도달).
 
 import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { cpSync, existsSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
@@ -49,7 +50,7 @@ export function stageNonGitDir(opts: { target: string; branch: string }): StageN
   const slug = basename(target).replace(/[^a-zA-Z0-9._-]/g, '-');
   const shadowPath = join(tmpdir(), `elanous-shadow-${slug}-${process.pid}`);
   // 이전 세대 잔여 정리(고아 방지·createWorktree resetExisting 정합).
-  try { spawnSync('rm', ['-rf', shadowPath], { timeout: GIT_TIMEOUT_MS }); } catch { /* fail-soft */ }
+  try { spawnSync('rm', ['-rf', shadowPath], { timeout: GIT_TIMEOUT_MS, maxBuffer: SPAWN_SYNC_MAX_BUFFER }); } catch { /* fail-soft */ }
 
   // ② 대상 → 그림자 복사(내용 전체·심볼릭 보존 X: cpSync 기본).
   cpSync(target, shadowPath, { recursive: true });
@@ -69,7 +70,7 @@ export function stageNonGitDir(opts: { target: string; branch: string }): StageN
     path: shadowPath,
     branch,
     base,
-    cleanup: () => { try { spawnSync('rm', ['-rf', shadowPath], { timeout: GIT_TIMEOUT_MS }); } catch { /* fail-soft */ } },
+    cleanup: () => { try { spawnSync('rm', ['-rf', shadowPath], { timeout: GIT_TIMEOUT_MS, maxBuffer: SPAWN_SYNC_MAX_BUFFER }); } catch { /* fail-soft */ } },
   };
 }
 
@@ -94,9 +95,9 @@ export function stageFile(opts: { target: string; branch: string }): StageFileRe
   const fileName = basename(target);
   const slug = fileName.replace(/[^a-zA-Z0-9._-]/g, '-');
   const shadowPath = join(tmpdir(), `elanous-shadow-file-${slug}-${process.pid}`);
-  try { spawnSync('rm', ['-rf', shadowPath], { timeout: GIT_TIMEOUT_MS }); } catch { /* fail-soft */ }
+  try { spawnSync('rm', ['-rf', shadowPath], { timeout: GIT_TIMEOUT_MS, maxBuffer: SPAWN_SYNC_MAX_BUFFER }); } catch { /* fail-soft */ }
 
-  spawnSync('mkdir', ['-p', shadowPath], { timeout: GIT_TIMEOUT_MS });
+  spawnSync('mkdir', ['-p', shadowPath], { timeout: GIT_TIMEOUT_MS, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
   cpSync(target, join(shadowPath, fileName));
 
   git(shadowPath, ['init', '-b', 'shadow-base']);
@@ -113,7 +114,7 @@ export function stageFile(opts: { target: string; branch: string }): StageFileRe
     fileName,
     branch,
     base,
-    cleanup: () => { try { spawnSync('rm', ['-rf', shadowPath], { timeout: GIT_TIMEOUT_MS }); } catch { /* fail-soft */ } },
+    cleanup: () => { try { spawnSync('rm', ['-rf', shadowPath], { timeout: GIT_TIMEOUT_MS, maxBuffer: SPAWN_SYNC_MAX_BUFFER }); } catch { /* fail-soft */ } },
   };
 }
 
@@ -166,7 +167,7 @@ export function applyShadowToTarget(opts: { shadowPath: string; target: string;
   debug.log('harness.target', 'apply.backup', { target: target.slice(-48), backup: backup.slice(-48) });
 
   // ② rsync 미러링(--delete·그림자 git 메타 제외). rsync 부재 = fail-closed(백업만 남기고 미적용).
-  const probe = spawnSync('rsync', ['--version'], { encoding: 'utf8', timeout: 5_000 });
+  const probe = spawnSync('rsync', ['--version'], { encoding: 'utf8', timeout: 5_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
   if (probe.status !== 0) {
     debug.log('harness.target', 'apply.no-rsync', { target: target.slice(-48) });
     return { backup, applied: false, log: 'rsync 미설치 → 적용 안 함(백업만 생성·fail-closed). 수동 적용 필요.' };

package/src/self-implement/stop-autoheal.ts

@@ -13,7 +13,7 @@
  *   main-sync          → rebase-regate            리베이스(MERGE-INTENT-RESOLVE 의도 해석) 뒤 재게이트
  *   pod-died           → resume-from-salvage      `salvage/run-<6hex>/<leaf>` 가지에서 resume(DRAFT-NOT-ARCHIVE)
  *   evidence-uncovered → derive-evidence-rejudge  런 출력·시험·배선에서 증거를 끌어내 1회 재판정
- *   review-repeat · review-out-of-scope · fabric · launch-failed · unclassified → needs-owner(새 라운드 없음)
+ *   review-repeat · review-out-of-scope · fabric · launch-failed · gate-failed · unclassified → needs-owner(새 라운드 없음)
  *
  * 사다리의 «출처»: `graphs/overlays/stop-heal-ladder.yaml` 이 갈래마다 처방 노드(id = 처방 이름)를 선언한다.
  *    그 갈래에 얹힌 오버레이가 더한 노드 id 가 처방이다(source='graph'). 선언이 없거나 못 읽으면
@@ -52,6 +52,7 @@ export const AUTOHEAL_ACTION_BY_CLASS: Readonly<Record<RunStopClass, AutohealAct
   'review-out-of-scope': 'needs-owner',
   fabric: 'needs-owner',
   'launch-failed': 'needs-owner',
+  'gate-failed': 'needs-owner',
   unclassified: 'needs-owner',
 };
 

package/src/self-implement/train-gate-remote.ts

@@ -3,9 +3,10 @@
  *  Unlike `dispatchHeavyCheck` it never falls back to a local run: a busy host or an infra failure is «unmeasured».
  *  The only local commands are git (cat-file · rev-parse · push · diff). */
 import { debug } from '../debug/log.js';
+import { parseGateScenario, readGateScenarioFile } from './gate-scenario.js';
 import { getDefaultLogStore } from '../mss/logging/log-store.js';
 import {
-  realGateRemoteRunner, resolveGateRemoteSettings, runOnRemote,
+  gateRemoteHostCap, realGateRemoteRunner, resolveGateRemoteSettings, runOnRemote,
   type GateRemoteRunner, type GateRemoteSettings, type RemoteRunOutcome,
 } from './gate-remote.js';
 
@@ -21,6 +22,9 @@ export interface TrainGateInput {
   changedFiles: readonly string[];
   /** Paths deleted by the integration commit — kept in `changedFiles` for tsc/PWA reach, never run as tests. */
   deletedFiles?: readonly string[];
+  /** Optional v0 JSON scenario. Selected tests are additive; invalid input is unmeasured. */
+  scenario?: unknown;
+  scenarioFile?: string;
   settings?: GateRemoteSettings;
 }
 
@@ -42,9 +46,10 @@ const quote = (value: string) => `'${value.replaceAll("'", `'\\''`)}'`;
 const TEST_FILE = /\.test\.[cm]?[jt]sx?$/;
 
 /** The host-side shell body: each step runs only if the one before it passed. Exported for tests. */
-export function trainGateScript(baseSha: string, changedFiles: readonly string[], deleted: ReadonlySet<string> = new Set()): string {
+export function trainGateScript(baseSha: string, changedFiles: readonly string[], deleted: ReadonlySet<string> = new Set(), scenarioTests: readonly string[] = []): string {
   // A deleted test file is a changed path (tsc/PWA reach) but not something to run.
-  const tests = changedFiles.filter((file) => TEST_FILE.test(file) && !deleted.has(file));
+  const changedTests = changedFiles.filter((file) => TEST_FILE.test(file) && !deleted.has(file));
+  const tests = scenarioTests.length ? [...new Set([...changedTests, ...scenarioTests])] : changedTests;
   const steps = [
     `TSC_BASE_REF=${quote(baseSha)} bun scripts/ci-typecheck-changed.ts --local`,
     ...(tests.length ? [`bun run test:deterministic ${tests.map(quote).join(' ')}`] : []),
@@ -72,6 +77,30 @@ export const TRAIN_GATE_HOST = 'node-b';
 export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemoteRunner = realGateRemoteRunner, deps: TrainGateDeps = {}): Promise<TrainGateResult> {
   const settings = input.settings ?? await loadSettings();
   const host = settings.host;
+  const hostCap = gateRemoteHostCap(settings, host);
+  let scenarioTests: string[] = [];
+  if (input.scenario !== undefined || input.scenarioFile !== undefined) {
+    try {
+      if (input.scenario !== undefined && input.scenarioFile !== undefined) throw new Error('choose scenario or scenarioFile');
+      const scenario = parseGateScenario(input.scenarioFile === undefined ? input.scenario : readGateScenarioFile(input.scenarioFile), { baseSha: input.baseSha, headSha: input.commit, changedFiles: input.changedFiles });
+      if (scenario.selectedTests.some(({ path }) => input.deletedFiles?.includes(path))) throw new Error('selected test deleted');
+      scenarioTests = scenario.selectedTests.map(({ path }) => path);
+      // The remote checks out this exact commit. Verify every path against its tree locally before spending a host slot.
+      for (const path of scenarioTests) {
+        const file = runner.local('git', ['cat-file', '-e', `${input.commit}:${path}`], input.repo);
+        if (file.rc !== 0 || file.error) throw new Error(`selected test missing at head: ${path}`);
+        const tree = runner.local('git', ['ls-tree', '-z', input.commit, '--', path], input.repo);
+        if (tree.rc !== 0 || tree.error || !/^100(?:644|755) blob [0-9a-f]{40}\t/.test(tree.stdout)
+          || !tree.stdout.endsWith(`\t${path}\0`)) throw new Error(`selected test is not a regular file at head: ${path}`);
+      }
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      const entry: TrainGateObservation = { host, commit: input.commit, baseSha: input.baseSha, outcome: 'unmeasured', reason, changedFiles: input.changedFiles.length };
+      debug.log('merge-queue', 'train-gate', entry);
+      try { (deps.observe ?? defaultObserve)(entry); } catch { /* observation only */ }
+      return { outcome: 'unmeasured', host, reason };
+    }
+  }
   if (host !== TRAIN_GATE_HOST) {
     const entry: TrainGateObservation = { host, commit: input.commit, baseSha: input.baseSha, outcome: 'unmeasured', reason: `host-not-gate-host (${host} ≠ ${TRAIN_GATE_HOST})`, changedFiles: input.changedFiles.length };
     debug.log('merge-queue', 'train-gate', entry);
@@ -81,13 +110,13 @@ export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemo
   const sleep = deps.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
   const now = deps.now ?? Date.now;
   const deadline = now() + settings.slotWaitSeconds * 1000;
-  const script = trainGateScript(input.baseSha, input.changedFiles, new Set(input.deletedFiles ?? []));
+  const script = trainGateScript(input.baseSha, input.changedFiles, new Set(input.deletedFiles ?? []), scenarioTests);
   let outcome: RemoteRunOutcome;
   for (;;) {
     try {
       outcome = runOnRemote({
         repo: input.repo, host, mirror: settings.mirror, commit: input.commit, refs: [input.baseSha],
-        argv: ['sh', '-c', script], installPwa: true, hostCap: settings.hostCap,
+        argv: ['sh', '-c', script], installPwa: true, hostCap,
       }, runner);
     } catch (error) {
       outcome = { kind: 'infra', reason: `exception: ${error instanceof Error ? error.message : String(error)}` };
@@ -100,7 +129,7 @@ export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemo
   }
   const result: TrainGateResult = outcome.kind === 'ran'
     ? { outcome: outcome.rc === 0 ? 'pass' : 'fail', host, ms: outcome.ms, rc: outcome.rc }
-    : { outcome: 'unmeasured', host, reason: outcome.kind === 'busy' ? `host-busy (cap ${settings.hostCap} held for ${settings.slotWaitSeconds}s)` : outcome.reason };
+    : { outcome: 'unmeasured', host, reason: outcome.kind === 'busy' ? `host-busy (occupied ${outcome.occupied ?? 'unknown'}/${hostCap}, held for ${settings.slotWaitSeconds}s)` : outcome.reason };
   const entry: TrainGateObservation = {
     host, commit: input.commit, baseSha: input.baseSha, outcome: result.outcome,
     rc: result.rc, ms: result.ms, reason: result.reason, changedFiles: input.changedFiles.length,
@@ -116,7 +145,7 @@ export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemo
  *  integration commit's diff against `baseSha` (local git only); a diff failure is «unmeasured», never a local run. */
 export type TrainGate = (commitSha: string, prNumbers: readonly number[]) => Promise<TrainGateOutcome>;
 
-export function trainGateOnHost(opts: { repo: string; baseSha: string; settings?: GateRemoteSettings }, runner: GateRemoteRunner = realGateRemoteRunner, deps: TrainGateDeps = {}): TrainGate {
+export function trainGateOnHost(opts: { repo: string; baseSha: string; settings?: GateRemoteSettings; scenario?: unknown; scenarioFile?: string }, runner: GateRemoteRunner = realGateRemoteRunner, deps: TrainGateDeps = {}): TrainGate {
   const unmeasured = (commitSha: string, reason: string): 'unmeasured' => {
     const entry: TrainGateObservation = { host: opts.settings?.host ?? TRAIN_GATE_HOST, commit: commitSha, baseSha: opts.baseSha, outcome: 'unmeasured', reason, changedFiles: 0 };
     debug.log('merge-queue', 'train-gate', entry);
@@ -128,7 +157,7 @@ export function trainGateOnHost(opts: { repo: string; baseSha: string; settings?
       const diff = runner.local('git', ['diff', '--name-status', '-z', opts.baseSha, commitSha], opts.repo);
       if (diff.rc !== 0 || diff.error) return unmeasured(commitSha, 'changed-files-unavailable');
       const { changedFiles, deletedFiles } = parseNameStatus(diff.stdout);
-      return (await runTrainGateOnHost({ repo: opts.repo, commit: commitSha, baseSha: opts.baseSha, changedFiles, deletedFiles, settings: opts.settings }, runner, deps)).outcome;
+      return (await runTrainGateOnHost({ repo: opts.repo, commit: commitSha, baseSha: opts.baseSha, changedFiles, deletedFiles, settings: opts.settings, scenario: opts.scenario, scenarioFile: opts.scenarioFile }, runner, deps)).outcome;
     } catch (error) {
       // Any preparation failure (local git spawn, parse, settings) is «unmeasured» — never a rejected promise, never a local run.
       return unmeasured(commitSha, `prepare-failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 200));