elanous 0.2.35 → 0.2.37

package/src/release-loop/feature-store.ts

@@ -36,7 +36,7 @@ const walWait = new Int32Array(new SharedArrayBuffer(4));
 const SCHEMA_COLUMNS: Record<string, readonly string[]> = {
   imported_versions: ['json_hash', 'imported_at'],
   events: ['reason', 'generation'],
-  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs', 'dispatch_kind'],
+  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs', 'dispatch_kind', 'known_issue'],
   release_schedules: ['freeze_from', 'freeze_until', 'publish_at'],
 };
 function schemaCurrent(db: Database): boolean {
@@ -81,7 +81,7 @@ function open(root = releaseLedgerRoot()): Database {
       if (!eventColumns.some((column) => column.name === 'generation')) db.exec('ALTER TABLE events ADD COLUMN generation INTEGER');
       db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
       const assignmentColumns = db.query('PRAGMA table_info(assignments)').all() as Array<{ name: string }>;
-      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT'], ['accelerator', 'INTEGER'], ['refs', 'TEXT'], ['dispatch_kind', 'TEXT']] as const) {
+      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT'], ['accelerator', 'INTEGER'], ['refs', 'TEXT'], ['dispatch_kind', 'TEXT'], ['known_issue', 'TEXT']] as const) {
         if (!assignmentColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE assignments ADD COLUMN ${name} ${sql}`);
       }
       const scheduleColumns = db.query('PRAGMA table_info(release_schedules)').all() as Array<{ name: string }>;
@@ -178,7 +178,7 @@ function evidenceRefs(db: Database, version: string, id: string): string[] {
   return (db.query('SELECT ref FROM evidence WHERE feature_id = ? AND version = ? ORDER BY rowid').all(id, version) as Array<{ ref: string }>).map((row) => row.ref);
 }
 function items(db: Database, version: string): ChecklistItem[] {
-  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.dispatch_kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.accelerator, a.refs, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
+  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.dispatch_kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.accelerator, a.refs, a.status, a.disposition, a.evidence, a.known_issue, a.updated_at, a.updated_by
     FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.version = ? ORDER BY a.rowid`).all(version) as Array<Record<string, string | number | null>>;
   return rows.map((r) => {
     const evidence = [r.evidence, ...evidenceRefs(db, version, r.id as string)].filter((value) => value !== null).join('\n');
@@ -190,7 +190,7 @@ function items(db: Database, version: string): ChecklistItem[] {
       ...(r.ceo_minutes !== null ? { ceoMinutes: r.ceo_minutes as number } : {}), ...(r.ceo_date !== null ? { ceoDate: r.ceo_date as string } : {}),
       ...(r.accelerator === 1 ? { accelerator: true as const } : {}),
       ...(r.refs !== null && r.refs !== undefined ? { refs: JSON.parse(r.refs as string) as string[] } : {}),
-      ...(r.evidence !== null || evidence ? { evidence } : {}), ...(r.disposition !== null ? { disposition: r.disposition as ChecklistItem['disposition'] } : {}),
+      ...(r.evidence !== null || evidence ? { evidence } : {}), ...(r.known_issue !== null ? { knownIssue: r.known_issue as string } : {}), ...(r.disposition !== null ? { disposition: r.disposition as ChecklistItem['disposition'] } : {}),
       updatedAt: r.updated_at as string, updatedBy: r.updated_by as string };
   });
 }
@@ -203,9 +203,9 @@ function putItem(db: Database, version: string, item: ChecklistItem): void {
   if (!feature) db.query('INSERT INTO features (id, title, owner, kind, created_at) VALUES (?, ?, ?, ?, ?)').run(item.id, item.title, item.owner ?? null, item.kind ?? null, item.updatedAt);
   // features.owner/kind follow the latest assignment so details() and the checklist never disagree after a set.
   else if (item.owner !== undefined || item.kind !== undefined) db.query('UPDATE features SET owner = COALESCE(?, owner), kind = COALESCE(?, kind) WHERE id = ?').run(item.owner ?? null, item.kind ?? null, item.id);
-  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, dispatch_kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, dispatch_kind=excluded.dispatch_kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, accelerator=excluded.accelerator, refs=excluded.refs, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.dispatchKind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
+  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, dispatch_kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, known_issue, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, dispatch_kind=excluded.dispatch_kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, accelerator=excluded.accelerator, refs=excluded.refs, known_issue=excluded.known_issue, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.dispatchKind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.knownIssue ?? null, item.updatedAt, item.updatedBy);
 }
 function jsonHash(contents: string | Buffer): string { return createHash('sha256').update(contents).digest('hex'); }
 
@@ -274,7 +274,7 @@ function importOnDb(db: Database, version: string): boolean {
       record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: null, to: item, released: data.released, dev: data.dev });
       continue;
     }
-    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'dispatchKind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const;
+    const fields = ['title', 'status', 'evidence', 'knownIssue', 'owner', 'disposition', 'kind', 'dispatchKind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const;
     const baseEvidence = (db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(item.id, version) as { evidence: string | null }).evidence ?? undefined;
     const preserveRefs = item.evidence === baseEvidence || item.evidence === current.evidence;
     const differs = fields.some((field) => field === 'evidence'
@@ -441,7 +441,7 @@ export function set(version: string, id: string, patch: Partial<ChecklistItem>,
   return mutate(version, released, dev, (data) => {
     const item = data.items.find((i) => i.id === id);
     if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
-    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind'] as const).filter((field) => patch[field] !== undefined && patch[field] !== item[field]);
+    const fields = (['evidence', 'knownIssue', 'owner', 'status', 'disposition', 'kind'] as const).filter((field) => patch[field] !== undefined && patch[field] !== item[field]);
     if (!fields.length) return false;
     const at = new Date().toISOString();
     for (const field of fields) {

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

@@ -1,4 +1,6 @@
 import { ownerMatches, type ChecklistItem } from './checklist.js';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
 
 export interface MergedChecklistPr { number: number; title: string; body: string | null; mergedAt: string }
 type PrMatchBasis = 'cell-line' | 'title-strong' | 'mention';
@@ -113,35 +115,106 @@ 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 }
+export interface MergedPrRunResult { status: number | null; stdout: string; stderr: string; timedOut?: boolean }
 /** One `gh` invocation; resolves when the process exits. */
-export type MergedPrRunner = (command: string, args: readonly string[], cwd: string) => Promise<MergedPrRunResult>;
+export type MergedPrRunner = (command: string, args: readonly string[], cwd: string, timeoutMs?: number) => 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;
 
+export interface MergedChecklistFetch {
+  prs: MergedChecklistPr[];
+  truncated: boolean;
+  calls: number;
+  /** Set when a time budget stopped the window walk before every window was fetched. */
+  stopReason: 'time-budget-exceeded' | undefined;
+  /** UTC windows not yet fetched when `stopReason` is set. */
+  remainingWindows: string[];
+}
+
+const FETCH_CACHE_TTL_MS = 10 * 60_000;
+interface PersistedFetchCache { schema: 1; entries: Record<string, { savedAt: number; result: MergedChecklistFetch }> }
+
+function cacheRead(path: string, key: string, nowMs: number): MergedChecklistFetch | undefined {
+  try {
+    if (!existsSync(path)) return undefined;
+    const cache = JSON.parse(readFileSync(path, 'utf8')) as PersistedFetchCache;
+    const entry = cache?.schema === 1 ? cache.entries?.[key] : undefined;
+    if (!entry || !Number.isFinite(entry.savedAt) || nowMs - entry.savedAt < 0 || nowMs - entry.savedAt >= FETCH_CACHE_TTL_MS) return undefined;
+    if (!Array.isArray(entry.result?.prs) || entry.result.stopReason !== undefined) return undefined;
+    return { ...entry.result, calls: 0 };
+  } catch { return undefined; }
+}
+
+function cacheWrite(path: string, key: string, result: MergedChecklistFetch, nowMs: number): void {
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    let entries: PersistedFetchCache['entries'] = {};
+    try {
+      const cache = JSON.parse(readFileSync(path, 'utf8')) as PersistedFetchCache;
+      if (cache?.schema === 1 && cache.entries && typeof cache.entries === 'object') entries = cache.entries;
+    } catch { /* replace an unreadable cache with a fresh one */ }
+    for (const [entryKey, entry] of Object.entries(entries)) if (!Number.isFinite(entry.savedAt) || nowMs - entry.savedAt >= FETCH_CACHE_TTL_MS) delete entries[entryKey];
+    entries[key] = { savedAt: nowMs, result };
+    const temp = `${path}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    writeFileSync(temp, `${JSON.stringify({ schema: 1, entries } satisfies PersistedFetchCache)}\n`, { mode: 0o600 });
+    renameSync(temp, path);
+  } catch { /* cache is an optimization; a failed write must not fail the read-only command */ }
+}
+
 /**
  * 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.
+ * With `timeBudgetMs`, each gh request is bounded by the remaining time; a slow initial request or window returns the
+ * partial result with `stopReason: 'time-budget-exceeded'` and UTC window starts in `remainingWindows`.
  * The returned set and the truncation flag match the former sequential bisection; only call shape and time differ.
+ * A completed result is cached across CLI processes for ten minutes; a partial (`stopReason`) result is never cached.
  */
 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 }> {
+  { concurrency = MERGED_PR_CONCURRENCY, timeBudgetMs, cacheFile }: { concurrency?: number; timeBudgetMs?: number; cacheFile?: string } = {}): Promise<MergedChecklistFetch> {
+  const cacheKey = JSON.stringify([since, now.toISOString().slice(0, 10), cwd, concurrency,
+    process.env.GH_REPO ?? process.env.GITHUB_REPOSITORY ?? '']);
+  const cached = cacheFile ? cacheRead(cacheFile, cacheKey, Date.now()) : undefined;
+  if (cached) return cached;
+  const deadline = timeBudgetMs === undefined ? undefined : performance.now() + timeBudgetMs;
+  const over = (): boolean => deadline !== undefined && performance.now() >= deadline;
+  const cacheable = (result: MergedChecklistFetch): MergedChecklistFetch => {
+    if (result.stopReason !== undefined || !cacheFile) return result;
+    cacheWrite(cacheFile, cacheKey, result, Date.now());
+    return result;
+  };
   let calls = 0;
-  const fetch = async (lower: string, upper?: string, limit = MERGED_PR_LIMIT): Promise<MergedChecklistPr[]> => {
+  const fetch = async (lower: string, upper?: string, limit = MERGED_PR_LIMIT): Promise<MergedChecklistPr[] | null> => {
     const search = `merged:>=${lower}${upper ? ` merged:<${upper}` : ''}`;
+    if (over()) return null;
     calls++;
-    const r = await run('gh', ['pr', 'list', '--state', 'merged', '--search', search, '--limit', String(limit), '--json', 'number,title,body,mergedAt'], cwd);
+    const args = ['pr', 'list', '--state', 'merged', '--search', search, '--limit', String(limit), '--json', 'number,title,body,mergedAt'];
+    const remainingMs = deadline === undefined ? undefined : Math.max(1, Math.ceil(deadline - performance.now()));
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const request = run('gh', args, cwd, remainingMs);
+    let r: MergedPrRunResult | null;
+    try {
+      r = remainingMs === undefined ? await request : await Promise.race([
+        request,
+        new Promise<null>((resolve) => { timer = setTimeout(() => resolve(null), remainingMs); }),
+      ]);
+    } finally { if (timer !== undefined) clearTimeout(timer); }
+    if (r === null || r.timedOut) return null;
     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 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 first = await fetch(since);
-  if (first.length < MERGED_PR_LIMIT) return { prs: first, truncated: false, calls };
+  if (first === null) return cacheable({ prs: [], truncated: false, calls, stopReason: 'time-budget-exceeded', remainingWindows: windows.map(([start]) => new Date(start).toISOString()) });
+  if (first.length < MERGED_PR_LIMIT) return cacheable({ prs: first, truncated: false, calls, stopReason: undefined, remainingWindows: [] });
   // Bounded pool: at most `concurrency` gh processes at once; a failure stops new calls and rejects.
   let active = 0;
   let failed: unknown;
@@ -155,14 +228,20 @@ export async function fetchMergedChecklistPrs(since: string, now: Date, run: Mer
     finally { active--; if (failed !== undefined) for (const wake of waiting.splice(0)) wake(); else waiting.shift()?.(); }
   };
   let truncated = false;
+  const remainingWindows: string[] = [];
   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));
+    // The budget is checked when the window actually starts (inside the pool), not when `visit` is mapped —
+    // every window is mapped at once, so a check here would run before the first fetch resolves.
+    const page = await limited(async () => (over() ? null : fetch(from, to)));
+    if (page === null) { remainingWindows.push(from); return []; }
     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.
+      if (over()) { remainingWindows.push(from); return page.slice(0, MERGED_PR_LIMIT); }
       const probe = await limited(() => fetch(from, to, MERGED_PR_LIMIT + 1));
+      if (probe === null) { remainingWindows.push(from); return page.slice(0, MERGED_PR_LIMIT); }
       if (probe.length > MERGED_PR_LIMIT) truncated = true;
       return probe.slice(0, MERGED_PR_LIMIT);
     }
@@ -170,15 +249,17 @@ export async function fetchMergedChecklistPrs(since: string, now: Date, run: Mer
     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 };
+  remainingWindows.sort();
+  if (remainingWindows.length) {
+    // The broad first page is usable partial evidence if the detailed window walk runs out of budget.
+    for (const pr of first) if (!unique.has(pr.number)) unique.set(pr.number, pr);
+    truncated = true;
+  }
+  return cacheable({ prs: [...unique.values()], truncated, calls, stopReason: remainingWindows.length ? 'time-budget-exceeded' : undefined, remainingWindows });
 }

package/src/release-loop/rehearsal.ts

@@ -186,26 +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', hardRehearsalGateArgs(version, runId, sha, previous, pool), {
-      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 {

package/src/repl/index.ts

@@ -50,6 +50,7 @@ import { parse as parseYaml } from 'yaml';
 import type { PendingTaskNotification } from '../agent/task-notification.js';
 import { dispatchReplMessageTool, isReplMessageTool } from './ops-msg-bridge.js';
 import { buildSeatBootSystemMessages, type SeatBootDeps } from '../dashboard/seat-boot-preamble.js';
+import { installNextTuiSelfHealthTracker } from '../tui/chat/self-health-status.js';
 
 /** Private side channel for the next TUI. Ordinary REPL JSONL stdout is unchanged. */
 const NEXT_TUI_BG_PREFIX = 'ELANOUS_TUI_BG_STATUS\t';
@@ -189,6 +190,14 @@ function buildReplTools(): {
   const bashMod = require('../skills/tools/index.js') as typeof import('../skills/tools/index.js');
   specs.push(bashMod.buildBashTool());
   dispatchByName.set('Bash', async (args) => bashMod.dispatchBash(args, { cwd: process.cwd() }));
+  // TUI-NEXT-QUEUE-AND-WAKE: the next TUI parent opens an IPC hop only for its own REPL children;
+  // the classic ScheduleWakeup spec is advertised and each call is answered by the parent's scheduler.
+  const wakeMod = require('../tui-client/next-wakeup.js') as typeof import('../tui-client/next-wakeup.js');
+  const wakeup = wakeMod.createReplWakeupTool(process as unknown as import('../tui-client/next-wakeup.js').WakeupIpcProcess);
+  if (wakeup) {
+    specs.push(wakeup.spec);
+    dispatchByName.set(wakeup.spec.name, wakeup.dispatch);
+  }
   const planner = sr.createSearchPlannerState({ maxAutoNarrowCandidates: 2 });
   const dispatch = async (name: string, args: Record<string, unknown>): Promise<unknown> => {
     try {
@@ -202,6 +211,14 @@ function buildReplTools(): {
         searchPlannerState: planner,
         turnIndex: undefined,
         ptyDashboardOn: false,
+        // Match the CLI agent path: native Agent fallback needs the parent's
+        // catalog and dispatcher so children can actually use inherited tools.
+        agentHostTools: specs,
+        agentDispatchTool: dispatch,
+        buildChildToolCatalog: (childCwd: string) => {
+          const cli = require('../cli/agent-cli.js') as typeof import('../cli/agent-cli.js');
+          return cli.buildCliAgentTools(undefined, undefined, childCwd);
+        },
         getToolRuntime: () => undefined,
         dispatchToolRuntime: async (n) => ({ error: `runtime unavailable in REPL: ${n}` }),
         dispatchPluginTool: async (n) => ({ ok: false as const, error: `plugin unavailable in REPL: ${n}` }),
@@ -594,6 +611,8 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
     } catch { /* suggestions must not interrupt the REPL */ }
   }
   const sessionIdRef = { current: session.id };
+  const selfHealthTracker = installNextTuiSelfHealthTracker();
+  selfHealthTracker?.setSessionId(session.id);
 
   const nextTuiDelivery = process.env.ELANOUS_NEXT_TUI_BG_STATUS === '1'
     ? { pending: [] as PendingTaskNotification[] } : undefined;
@@ -747,6 +766,11 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         if (att) turnAttachments.push(att);
       }
       backgroundBridge?.beginTurn();
+      const selfHealth = selfHealthTracker?.snapshot(sessionIdRef.current) ?? null;
+      if (selfHealth && typeof turn.id === 'string') {
+        process.stdout.write(`${JSON.stringify({ event: 'self-health', turnId: turn.id, sessionId: sessionIdRef.current, selfHealth })}\n`);
+      }
+      const turnSystemPrompt = selfHealth ? `${systemPrompt}\n\n${selfHealth.line}` : systemPrompt;
       let result: Awaited<ReturnType<typeof runOneTurn>>;
       try {
         result = await runOneTurn(
@@ -755,7 +779,7 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
           turn.prompt,
           turnAttachments,
           tools,
-          systemPrompt,
+          turnSystemPrompt,
           true, // JSONL stream → always JSON output
           nextTuiDelivery,
           process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
@@ -779,10 +803,12 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         durationMs: result.durationMs,
         logPath: result.logPath,
         assertFailures: failures,
+        selfHealth,
       };
       console.log(JSON.stringify(out));
     }
     backgroundBridge?.dispose();
+    selfHealthTracker?.dispose();
     return 0;
   }
 

package/src/seat-loop/knowhow-lint.ts

@@ -139,7 +139,7 @@ interface KnowhowCard {
 }
 
 /** 카드 제목 — `## K-<자리>-<번호>` 뒤에는 줄 끝·공백·콜론·em 대시만 온다. */
-const CARD_HEADING = /^[ \t]{0,3}##\s+(K-[A-Za-z]+-\d+)(?=$|\s|:|—)/u;
+const CARD_HEADING = /^[ \t]{0,3}##\s+(K-[A-Za-z]+(?:-[A-Za-z]{1,4})?-\d+)(?=$|\s|:|—)/u;
 /** 카드처럼 보이는 `##` 제목(예: `## K-OP-7a`) — CARD_HEADING 을 벗어나면 인식 실패로 명시 거부한다. */
 const CARD_HEADING_LIKE = /^[ \t]{0,3}##\s*(K-[^\s:]*)/iu;
 

package/src/seat-loop/seat-report.ts

@@ -134,6 +134,7 @@ export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promi
         const [{ resolveRepositoryName }, { githubDraftSweepAdapters }] = await Promise.all([
           import('../harness/repository-name.js'), import('../harness/harness-cli-command.js'),
         ]);
+        // The collector folds repeated PR pages before this report formats the census.
         return collectDraftMetrics(resolveRepositoryName({}), githubDraftSweepAdapters(), clock);
       }))(now);
       draftDetail = ` · draft 재고 ${metrics.inventory} · 최장 나이 ${metrics.oldestAgeHours === null ? '해당 없음' : `${metrics.oldestAgeHours.toFixed(1)}h`} · needs-owner ${metrics.needsOwner} · 48h 전환율 ${metrics.conversion48h === null ? '표본 없음' : `${(metrics.conversion48h * 100).toFixed(1)}% (${metrics.converted48h}/${metrics.cohort48h})`}`;

package/src/self-dev/ask-launch-flow.ts

@@ -10,7 +10,7 @@
 //   (바꾸면 이 추출이 회귀인지 개선인지 사후에 못 가른다.)
 // ⛔ 종료(`process.exit`)는 여기가 «안» 한다 — 호출자가 자기 표면에 맞게 끝낸다.
 //   그래서 결과를 «세 값»으로 낸다: 발사 / 저작 전 중단 / 전제 검사 중단.
-import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { linesOutsideFencedCode, readGoalAuthorGroundingTimebox, type GoalAuthorGroundingTimebox } from '../self-implement/goal-author.js';
 import { existsSync } from 'node:fs';
 import { debug } from '../debug/log.js';
 import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
@@ -69,6 +69,23 @@ export interface AskAuthoredGoal {
   readonly authored?: { readonly document?: string; readonly grounded?: boolean | null; readonly authorRunId?: string } | null;
 }
 
+/**
+ * ⭐ AUTHOR-TIMEBOX 결과 줄 — `formatOrchestrateResultLine`
+ * (`  ${icon} ${status} · ${feature}${disp}${error}`)과 **같은 모양**을 쓴다.
+ *
+ * ⛔ `src/self-dev/orchestrate-summary-line.ts` 는 «안 고친다» — 다른 명령·화면의 기본 동작과
+ *   원장 형식은 보존 계약이다. 그래서 같은 모양을 이 자리에서 «쓴다».
+ * ⛔ 접지가 예산 초과로 끊긴 저작이 «조용히» 지나가면 상위 디스패처는 그 런을 성공으로도
+ *   실패로도 판정하지 못한다(80분 런 사망의 실제 모양).
+ */
+export function formatGoalAuthorTimeboxResultLine(
+  goalFile: string,
+  timebox: GoalAuthorGroundingTimebox,
+): string {
+  const feature = (goalFile.split('/').at(-1) ?? goalFile).slice(0, 56);
+  return `  ❌ NOT-GROUNDED · ${feature} [author-timebox] — grounding-timebox: exceeded ${timebox.budgetMs}ms budget after ${timebox.elapsedMs}ms; authoring stopped before launch`;
+}
+
 export type LaunchingTreeProbe =
   | { readonly kind: 'measured'; readonly ahead: number; readonly behind: number; readonly reference: string }
   | { readonly kind: 'unmeasurable'; readonly error: string };
@@ -240,7 +257,12 @@ export type AskLaunchFlowResult =
   /** ⓪ 저작 «전»에 막혔다 — 100초를 안 썼다. */
   | { readonly kind: 'stopped-before-authoring'; readonly goalFile?: undefined }
   /** ⑵⑶⑷ 에서 막혔다 — 골은 «있다»(사람이 열어볼 수 있게 돌려준다). */
-  | { readonly kind: 'stopped-by-preflight'; readonly goalFile: string; readonly blockers: LaunchPreflightResult['blockers'] };
+  | { readonly kind: 'stopped-by-preflight'; readonly goalFile: string; readonly blockers: LaunchPreflightResult['blockers'] }
+  /** ⑴ 저작에서 접지 예산(AUTHOR-TIMEBOX)을 넘겨 NOT-GROUNDED 로 끝났다 — 발사하지 «않는다». */
+  | { readonly kind: 'stopped-by-timebox'; readonly goalFile: string };
+
+/** ⑴ AUTHOR-TIMEBOX NOT-GROUNDED — 결과 줄을 쓰고 흐름을 끊는 값. */
+export type AskLaunchFlowTimeboxStop = Extract<AskLaunchFlowResult, { kind: 'stopped-by-timebox' }>;
 
 /** 런 식별자가 흐름 뒤에 확정된 호출자는 이 관측으로 입구와 런을 조인한다. */
 export function observeAskLaunchRunIdentity(
@@ -738,7 +760,7 @@ async function intakeClarifications(
   input: AskLaunchFlowInput,
   deps: AskLaunchFlowDeps,
   selfResolveClarifications: ResolvedSelfResolveClarifications,
-): Promise<string> {
+): Promise<string | AskLaunchFlowTimeboxStop> {
   let effectiveGoalFile = authored.path;
   let document = deps.readFile(effectiveGoalFile);
   const { pending, mode } = planClarificationIntake(document, deps.isInteractive());
@@ -824,6 +846,28 @@ async function intakeClarifications(
   const parentDocument = document;
   effectiveGoalFile = isAbsolutePath(reauthored.path) ? reauthored.path : resolvePath(deps.cwd(), reauthored.path);
   deps.print(`[ask] ⑴b 재저작됨: ${reauthored.path}`);
+  // 재저작도 «같은 저작 진입점»이다 — 접지가 예산 초과로 끊기면 같은 결과 줄을 쓴다(조용히 넘기지 않는다).
+  const reauthoredTimebox = reauthored.authored?.document === undefined
+    ? null
+    : readGoalAuthorGroundingTimebox(reauthored.authored.document);
+  if (reauthoredTimebox !== null) {
+    deps.print(formatGoalAuthorTimeboxResultLine(reauthored.path, reauthoredTimebox));
+    deps.log('ask-author-timebox', {
+      goalFile: reauthored.path,
+      provenance: 'reauthor',
+      outcome: 'NOT-GROUNDED',
+      budgetMs: reauthoredTimebox.budgetMs,
+      elapsedMs: reauthoredTimebox.elapsedMs,
+      grounded: reauthored.authored?.grounded ?? null,
+    }, 'warn');
+    // ⛔⭐⭐ 재저작 NOT-GROUNDED 도 «끝»이다 — 결과 줄을 쓰고 되묻기 이후 단계로 지나가지 않는다.
+    observeFrontNodeExit({ node: 'author', outcome: 'not-grounded' }, {
+      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      attempt: 1, goalFile: effectiveGoalFile,
+      reason: `grounding-timebox-exhausted (budget ${reauthoredTimebox.budgetMs}ms, elapsed ${reauthoredTimebox.elapsedMs}ms)`,
+    });
+    return { kind: 'stopped-by-timebox', goalFile: effectiveGoalFile };
+  }
   // ⛔ 「재저작이 «났다»」와 「재저작이 «옳았다»」는 다른 물음이다(JDG-T35 3단 ⑶).
   const childDocument = reauthored.authored?.document ?? deps.readFile(effectiveGoalFile);
   const askFidelity = classifyReauthoredAsk(parentDocument, childDocument);
@@ -886,10 +930,10 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = [], attempt = 1): Promise<{
-    readonly goalFile: string;
-    readonly decision: ReturnType<typeof decideAskPreflight>;
-  }> => {
+  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = [], attempt = 1): Promise<
+    | { readonly goalFile: string; readonly decision: ReturnType<typeof decideAskPreflight> }
+    | AskLaunchFlowTimeboxStop
+  > => {
     // ⛔ 수를 박지 않는다 — 「100~110초」가 박혀 있었고 2026-08-23 prod 실측은 «206초»(2배)였다.
     //    재는 명령: elanous logs --category goal-author --event phase-end --json --json-data
     deps.print('[ask] ⑴ 저작 — self author (수 분 걸린다 · 페이즈별 실측은 goal-author/phase-end)');
@@ -926,6 +970,29 @@ export async function runAskLaunchFlow(
       throw error;
     });
     deps.print(`[ask] 저작됨: ${authored.path}`);
+    // ⛔⭐⭐ AUTHOR-TIMEBOX — 접지가 예산을 넘겨 끊긴 저작은 «결과 줄» 없이 지나가면 안 된다.
+    //   이 자리가 ask → Pod 발사를 쥔 곳이므로(이 흐름이 발사 여부를 정한다), 여기서 한 줄을 쓴다.
+    const groundingTimebox = authored.authored?.document === undefined
+      ? null
+      : readGoalAuthorGroundingTimebox(authored.authored.document);
+    if (groundingTimebox !== null) {
+      deps.print(formatGoalAuthorTimeboxResultLine(authored.path, groundingTimebox));
+      deps.log('ask-author-timebox', {
+        goalFile: authored.path,
+        provenance: 'author',
+        outcome: 'NOT-GROUNDED',
+        budgetMs: groundingTimebox.budgetMs,
+        elapsedMs: groundingTimebox.elapsedMs,
+        grounded: authored.authored?.grounded ?? null,
+      }, 'warn');
+      // ⛔⭐⭐ NOT-GROUNDED 는 «끝»이다 — 이 흐름이 발사 여부를 정하므로, 결과 줄을 쓰고 나서
+      //   되묻기·전제 검사·발사로 «지나가지 않는다». 저작 종료 출구를 그래프에 남기고 흐름을 끊는다.
+      observeFrontNodeExit({ node: 'author', outcome: 'not-grounded' }, {
+        ...frontObservation, attempt, goalFile: authored.path,
+        reason: `grounding-timebox-exhausted (budget ${groundingTimebox.budgetMs}ms, elapsed ${groundingTimebox.elapsedMs}ms)`,
+      });
+      return { kind: 'stopped-by-timebox', goalFile: authored.path };
+    }
     // AUTHOR-TRACE: the authored goal file can be cleaned up later — keep path ⊕ sha256 ⊕ size in the run ledger and
     // archive the body, so authoring length is measurable after the fact (GOAL-BENCH · AUTHOR-LITE).
     const traceIds = {
@@ -979,10 +1046,13 @@ export async function runAskLaunchFlow(
     }, markerCounts !== null && markerCounts.missingMarkers > 0 ? 'warn' : 'info');
 
     // ⛔ 되묻기에 답하면 «새 골»이 나온다 — 아래 전제 검사·발사는 그 «최종» 골을 써야 한다.
-    const goalFile = await intakeClarifications({
+    const clarifiedGoalFile = await intakeClarifications({
       ...authored,
       path: isAbsolutePath(authored.path) ? authored.path : resolvePath(deps.cwd(), authored.path),
     }, input, deps, selfResolveClarifications);
+    // 재저작이 AUTHOR-TIMEBOX 로 끊겼으면 이 흐름도 그대로 끊는다 — 전제 검사·발사로 지나가지 않는다.
+    if (typeof clarifiedGoalFile !== 'string') return clarifiedGoalFile;
+    const goalFile = clarifiedGoalFile;
     // The child reads this file again. Filtering only preflight.paths would leave the same bogus
     // TRACED PATHS prose in the child and repeat its missing-file failure.
     let sanitizeFailed = false;
@@ -1090,7 +1160,10 @@ export async function runAskLaunchFlow(
     });
   };
 
-  let authored = await authorAndPreflight();
+  let firstAuthored = await authorAndPreflight();
+  // 저작 단계가 AUTHOR-TIMEBOX NOT-GROUNDED 로 끝났으면 이 흐름도 그대로 끊는다.
+  if ('kind' in firstAuthored) return firstAuthored;
+  let authored = firstAuthored;
   let reauthored = false;
   const retryableNoTargetPaths = !input.forceRequested
     && !authored.decision.shouldLaunch
@@ -1142,9 +1215,12 @@ export async function runAskLaunchFlow(
       deps.print('[ask] ⑴ ⚠️ 자동 재저작에 넣을 대상 경로 후보가 없다. 대상 경로를 확인해야 한다');
     }
     recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, outcome: 'started' });
-    authored = await authorAndPreflight(selectedPaths.length > 0
+    const secondAuthored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
       : input.askText, selectedPaths, 2);
+    // 재시도 저작도 AUTHOR-TIMEBOX 로 끊길 수 있다 — 그러면 발사하지 않는다.
+    if ('kind' in secondAuthored) return secondAuthored;
+    authored = secondAuthored;
     // 두 번째 not-grounded 는 re-ground 예산(max_visits 1)을 넘어 needs-human(근거 카드)으로 — 판정은 observeFrontNodeExit 가 선언에서 읽는다.
     observeAuthorExit(2, authored, !authored.decision.shouldLaunch && authorNotGrounded(authored.decision) ? 'not-grounded' : 're-authored');
     deps.log('ask-auto-reauthor', {