elanous 0.2.14 → 0.2.15

package/scripts/marketing/generate-ax-brief.ts

@@ -0,0 +1,140 @@
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { FEATURE_MATURITY } from '../../src/maturity/feature-maturity.js';
+import type { ChecklistItem } from '../../src/release-loop/checklist.js';
+import type { ReleaseSchedule } from '../../src/release-loop/release-schedule.js';
+import type { MergedRunLedgerQuery } from '../../src/self-implement/run-ledger.js';
+import { generateFeatureMap } from './generate-feature-map.js';
+
+const MAP = resolve(import.meta.dir, '../../docs/marketing/MAP-value-props-to-features.md');
+const AUTONOMY = new Set(['ORCH1', 'ORCH2', 'LOOP-LIVE1', 'AUTOQ-LOOP', 'AUTHOR-PAR', 'RUN-HELPER', 'FINISH-RATE']);
+const ROADMAP = /^(?:ENT-|KPACK|GRID)/;
+
+export interface AxBriefSources {
+  featureMap: () => string;
+  checklist: (version: string) => readonly ChecklistItem[];
+  schedules: () => readonly ReleaseSchedule[];
+  merges: () => Pick<MergedRunLedgerQuery, 'entries' | 'ledgerDirectoryMissing' | 'unreadableLedgerCount' | 'excludedLedgerCount'>;
+  now?: () => Date;
+}
+
+type Source<T> = { ok: true; value: T } | { ok: false; reason: string };
+
+function readSource<T>(read: () => T): Source<T> {
+  try { return { ok: true, value: read() }; }
+  catch (error) { return { ok: false, reason: error instanceof Error ? error.message : String(error) }; }
+}
+
+function cell(text: string): string {
+  return text.replace(/\|/g, '\\|').replace(/[\r\n]+/g, ' ').trim();
+}
+
+function reason(source: Source<unknown>): string {
+  return source.ok ? '' : `못 읽음 · 사유: ${cell(source.reason)}`;
+}
+
+function versionNumbers(version: string): number[] | null {
+  return /^\d+\.\d+\.\d+$/.test(version) ? version.split('.').map(Number) : null;
+}
+
+function after03(version: string): boolean {
+  const parts = versionNumbers(version);
+  return !!parts && (parts[0]! > 0 || parts[1]! >= 3);
+}
+
+function compareVersions(left: string, right: string): number {
+  const a = versionNumbers(left)!, b = versionNumbers(right)!;
+  return a[0]! - b[0]! || a[1]! - b[1]! || a[2]! - b[2]!;
+}
+
+function firstLine(evidence: string | undefined): string {
+  return evidence?.split(/\r?\n/, 1)[0]?.trim() || '근거 없음';
+}
+
+/** Read-only report: failures in one ledger do not turn other sections into claims of success. */
+export function generateAxBrief(version: string, sources: AxBriefSources): string {
+  const now = (sources.now ?? (() => new Date()))().toISOString();
+  const feature = readSource(sources.featureMap);
+  const current = readSource(() => sources.checklist(version));
+  const schedules = readSource(sources.schedules);
+  const merges = readSource(sources.merges);
+  const mergeCount = merges.ok && !merges.value.ledgerDirectoryMissing
+    ? new Set(merges.value.entries.filter((entry) => entry.merged).map((entry) => entry.prNumber)).size : null;
+  const mergeValue = merges.ok && !merges.value.ledgerDirectoryMissing && merges.value.unreadableLedgerCount > 0
+    ? `못 읽음 · 사유: 원장 ${merges.value.unreadableLedgerCount}건 판독 실패 · 확인된 병합 ${mergeCount}건 (집계 불완전)`
+    : mergeCount ?? (merges.ok ? '못 읽음 · 사유: 원장 디렉터리 없음' : reason(merges));
+  const mergeCaveat = merges.ok && !merges.value.ledgerDirectoryMissing && (merges.value.unreadableLedgerCount || merges.value.excludedLedgerCount)
+    ? ` · 미반영 원장: 못 읽음 ${merges.value.unreadableLedgerCount}건 · 중복 병합 제외 ${merges.value.excludedLedgerCount}건` : '';
+  const featureRows = feature.ok ? feature.value.split(/\r?\n/).filter((line) => /^\| .* \| (?:된다|베타) \|/.test(line)) : [];
+  const autonomous = current.ok ? current.value.filter((item) => AUTONOMY.has(item.id)) : [];
+  const roadmap = schedules.ok ? schedules.value.filter((schedule) => after03(schedule.version)).sort((a, b) => compareVersions(a.version, b.version)) : [];
+  const roadmapSources = roadmap.map((schedule) => ({ version: schedule.version, result: schedule.version === version ? current : readSource(() => sources.checklist(schedule.version)) }));
+  const roadmapFailures = roadmapSources.filter(({ result }) => !result.ok).map(({ version: v, result }) => `${v}: ${reason(result)}`);
+  const roadmapRows = roadmapSources.flatMap(({ version: v, result }) => result.ok
+    ? result.value.filter((item) => ROADMAP.test(item.id)).map((item) => `| ${cell(v)} | ${cell(item.id)} | ${cell(item.title)} |`)
+    : []);
+  const owners = [...new Set(autonomous.map((item) => item.owner).filter((owner): owner is string => !!owner))];
+  return [
+    '# AX-BRIEF — 내부·파트너용 AX 브리핑',
+    '',
+    '> 공개 문서가 아닙니다. 내부 수치·자리 이름을 포함하며 외부 공개 판정으로 쓰지 않습니다.',
+    `> 생성: ${cell(version)} · ${now} · 원천: FEATURE-MAP 생성 출력, 릴리스 체크리스트, 릴리스 일정(release schedules), self-implement run-ledger`,
+    '',
+    '## 1. 지금 되는 것',
+    '',
+    feature.ok ? '| 기능 | 성숙도 | 칸 id | 근거 PR |' : reason(feature),
+    ...(feature.ok ? ['|---|---|---|---|', ...featureRows] : []),
+    '',
+    '## 2. 자율 단계표',
+    '',
+    current.ok ? '| 칸 | 판 | 상태 | 근거 첫 줄 |' : reason(current),
+    ...(current.ok ? ['|---|---|---|---|', ...autonomous.map((item) => `| ${cell(item.id)} | ${cell(version)} | ${cell(item.status)} | ${cell(firstLine(item.evidence))} |`)] : []),
+    ...(current.ok ? [`자리 이름: ${owners.length ? owners.map(cell).join(' · ') : '원장에 없음'}`] : []),
+    '',
+    `실제 병합 수 (self-implement run-ledger 전체 기록 · 중복 PR 제외 · 외부/수동 병합 제외): ${mergeValue}${mergeCaveat}`,
+    '',
+    '## 3. 로드맵 계단',
+    '',
+    '> 계획 · 바뀔 수 있습니다',
+    schedules.ok ? '| 판 | 칸 | 제목 |' : reason(schedules),
+    ...(schedules.ok ? ['|---|---|---|', ...roadmapRows, ...roadmapFailures.map((failure) => `못 읽음 · 사유: ${cell(failure)}`)] : []),
+    '',
+    '## 4. 도입 경로 (파일럿 기준 · 한 자리부터)',
+    '',
+    '1. **설치 한 줄 → 웹 앱 첫 화면** — 쓰던 구독을 그대로 알아본다.',
+    '2. **한 자리(예: 마케팅 또는 기술)만** — L1(한 줄 → 병합)을 그 팀 저장소에서. 측정: 발사 대비 병합 · 사람 수확 비율.',
+    '3. **결정 카드** — 비가역·공개만 사람에게. 나머지는 자리에 위임 범위를 적는다.',
+    '4. **자리 넷 ⊕ 그림자 루프** — L2 를 «기록만»으로 일주일 대조한 뒤 live.',
+    '5. **지식 팩** — 사내 문서·절차를 팩으로(로드맵 §3 · 유료 판매는 결정 뒤).',
+    '',
+  ].join('\n');
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const option = (name: string) => {
+    const index = args.indexOf(name);
+    if (index < 0) return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--')) throw new Error(`${name} 값이 필요하다`);
+    args.splice(index, 2);
+    return value;
+  };
+  const version = option('--version');
+  const out = option('--out');
+  if (!version || args.length) throw new Error('Usage: bun scripts/marketing/generate-ax-brief.ts --version <v> [--out <file>]');
+  const { listChecklist } = await import('../../src/release-loop/checklist.js');
+  const { listSchedules } = await import('../../src/release-loop/release-schedule.js');
+  const { queryMergedRunLedgers } = await import('../../src/self-implement/run-ledger.js');
+  const { releaseLedgerRoot } = await import('../../src/instance/resolve.js');
+  const root = releaseLedgerRoot();
+  const checklist = (v: string) => listChecklist(v, root).items;
+  const body = generateAxBrief(version, {
+    featureMap: () => generateFeatureMap({ map: readFileSync(MAP, 'utf8'), items: checklist(version), registry: FEATURE_MATURITY, version }),
+    checklist,
+    schedules: () => listSchedules(root),
+    merges: () => queryMergedRunLedgers(),
+  });
+  if (out) writeFileSync(out, body);
+  else process.stdout.write(body);
+}

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

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

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

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

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

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