elanous 0.2.14 → 0.2.16

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/measure/author-section-contribution.ts

@@ -0,0 +1,84 @@
+import { Database } from 'bun:sqlite';
+import { readFileSync } from 'node:fs';
+
+export interface AuthorSummary {
+  authorRunId: string;
+  sectionChars: Record<string, number>;
+}
+
+export interface AssignedGoalEvent {
+  category: string;
+  event: string;
+  ts: string;
+  data: { authorRunId?: string; goalId?: string };
+}
+
+export interface ExecutionRun {
+  runId: string;
+  goalId: string;
+  startedAt: string;
+  outcome: string;
+}
+
+export interface SectionContribution {
+  authorRunId: string;
+  goalId: string;
+  runId: string;
+  section: string;
+  chars: number;
+  outcome: string;
+}
+
+/** Join an authored summary to the first execution starting after that author's assignment. */
+export function measureAuthorSectionContribution(
+  summaries: readonly AuthorSummary[],
+  events: readonly AssignedGoalEvent[],
+  runs: readonly ExecutionRun[],
+): SectionContribution[] {
+  const rows: SectionContribution[] = [];
+  for (const summary of summaries) {
+    const assignment = events.filter((event) => event.category === 'goal-author'
+      && event.event === 'goal-id-assigned'
+      && event.data?.authorRunId === summary.authorRunId
+      && typeof event.data.goalId === 'string'
+      && Number.isFinite(Date.parse(event.ts)))
+      .sort((left, right) => Date.parse(left.ts) - Date.parse(right.ts)
+        || left.data.goalId!.localeCompare(right.data.goalId!))[0];
+    if (!assignment) continue;
+    const assignedAt = Date.parse(assignment.ts);
+    const run = runs.filter((candidate) => candidate.goalId === assignment.data.goalId
+      && Number.isFinite(Date.parse(candidate.startedAt))
+      && Date.parse(candidate.startedAt) >= assignedAt)
+      .sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt)
+        || left.runId.localeCompare(right.runId))[0];
+    if (!run) continue;
+    for (const [section, chars] of Object.entries(summary.sectionChars)) {
+      rows.push({ authorRunId: summary.authorRunId, goalId: run.goalId, runId: run.runId, section, chars, outcome: run.outcome });
+    }
+  }
+  return rows;
+}
+
+function readRunLedger(path: string): ExecutionRun[] {
+  const db = new Database(path, { readonly: true });
+  try {
+    const records = db.query('SELECT run_id, goal_id, doc FROM goal_run').all() as Array<{ run_id: string; goal_id: string; doc: string }>;
+    return records.map(({ run_id, goal_id, doc }) => {
+      const record = JSON.parse(doc) as { startedAt: string; outcome: string };
+      return { runId: run_id, goalId: goal_id, startedAt: record.startedAt, outcome: record.outcome };
+    });
+  } finally {
+    db.close();
+  }
+}
+
+if (import.meta.main) {
+  const [summaryFile, eventsFile, ledgerFile] = process.argv.slice(2);
+  if (!summaryFile || !eventsFile || !ledgerFile) throw new Error('usage: bun scripts/measure/author-section-contribution.ts <summaries.json> <events.jsonl> <goal-runs.db>');
+  const summaries = JSON.parse(readFileSync(summaryFile, 'utf8')) as AuthorSummary[];
+  const events = readFileSync(eventsFile, 'utf8').split('\n').filter(Boolean).map((line) => JSON.parse(line) as AssignedGoalEvent);
+  const rows = measureAuthorSectionContribution(summaries, events, readRunLedger(ledgerFile));
+  console.log('| authorRunId | goalId | runId | section | chars | outcome |');
+  console.log('| --- | --- | --- | --- | ---: | --- |');
+  for (const row of rows) console.log(`| ${row.authorRunId} | ${row.goalId} | ${row.runId} | ${row.section} | ${row.chars} | ${row.outcome} |`);
+}

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/cut-branch.ts

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 
-export interface CutBranchOptions { version: string; base: string; pick: string[]; dryRun?: boolean; repoRoot?: string; log?: (line: string) => void }
+export interface CutBranchOptions { version: string; base: string; pick: string[]; append?: boolean; dryRun?: boolean; repoRoot?: string; log?: (line: string) => void }
 
 // git-spawn-allow: release branch operations happen only in an isolated temporary worktree; main is never checked out or changed.
 function git(repo: string, args: string[]): string {
@@ -23,8 +23,8 @@ export function cutReleaseBranch(opts: CutBranchOptions): { branch: string; comm
   const repo = resolve(opts.repoRoot ?? process.cwd());
   const branch = `release/${opts.version}`;
   const log = opts.log ?? console.log;
-  const report = (event: 'created' | 'refused' | 'conflict', reason?: string, commit?: string) =>
-    debug.log('release-loop.cut-branch', event, { version: opts.version, branch, ...(commit ? { commit } : {}), ...(reason ? { reason } : {}) });
+  const report = (event: 'created' | 'refused' | 'conflict' | 'appended', reason?: string, commit?: string, extra?: Record<string, string | string[]>) =>
+    debug.log('release-loop.cut-branch', event, { version: opts.version, branch, ...(commit ? { commit } : {}), ...(reason ? { reason } : {}), ...extra });
   try {
     if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(opts.version)) throw new Error(`invalid release version: ${opts.version}`);
     if (!opts.pick.length) throw new Error('at least one --pick commit is required');
@@ -37,18 +37,31 @@ export function cutReleaseBranch(opts: CutBranchOptions): { branch: string; comm
     for (const sha of picks) if (ancestor(repo, sha, base)) throw new Error(`pick ${sha} is already in base ${base}`);
     if (new Set(picks).size !== picks.length) throw new Error('duplicate --pick commit');
     for (const sha of picks) if (git(repo, ['rev-list', '--parents', '-n', '1', sha]).split(' ').length !== 2) throw new Error(`pick ${sha} must have exactly one parent`);
-    if (git(repo, ['ls-remote', '--heads', 'origin', `refs/heads/${branch}`])) throw new Error(`${branch} already exists on origin`);
+    const remoteLine = git(repo, ['ls-remote', '--heads', 'origin', `refs/heads/${branch}`]);
+    if (remoteLine && !opts.append) throw new Error(`${branch} already exists on origin — use --append to fast-forward more picks onto it`);
+    if (!remoteLine && opts.append) throw new Error(`${branch} does not exist on origin — omit --append to create it`);
     if (spawnSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], { cwd: repo }).status === 0) throw new Error(`${branch} already exists locally`);
-    const pkg = JSON.parse(git(repo, ['show', `${base}:package.json`])) as { version?: unknown };
-    if (pkg.version !== opts.version) throw new Error(`base package.json version ${pkg.version} is not ${opts.version}`);
-    log(`${branch}: ${base} + ${picks.join(' + ')}${opts.dryRun ? ' (dry-run)' : ''}`);
+    let remoteTip: string | undefined;
+    if (opts.append) {
+      const advertised = remoteLine.split(/\s+/)[0] ?? '';
+      if (!/^[0-9a-f]{40}$/i.test(advertised)) throw new Error(`${branch} remote tip is not a commit SHA`);
+      git(repo, ['fetch', 'origin', `refs/heads/${branch}:refs/remotes/origin/${branch}`]);
+      remoteTip = git(repo, ['rev-parse', '--verify', `refs/remotes/origin/${branch}^{commit}`]);
+      if (advertised !== remoteTip) throw new Error(`${branch} remote tip moved — fast-forward refused (no force push)`);
+      for (const sha of picks) if (ancestor(repo, sha, remoteTip)) throw new Error(`pick ${sha} is already in ${branch}`);
+    }
+    const versionAt = remoteTip ?? base;
+    const pkg = JSON.parse(git(repo, ['show', `${versionAt}:package.json`])) as { version?: unknown };
+    if (pkg.version !== opts.version) throw new Error(`${opts.append ? 'release branch' : 'base'} package.json version ${pkg.version} is not ${opts.version}`);
+    const start = remoteTip ?? base;
+    log(`${branch}: ${start} + ${picks.join(' + ')}${opts.append ? ' (append)' : ''}${opts.dryRun ? ' (dry-run)' : ''}`);
     if (opts.dryRun) return { branch, commit: null, dryRun: true };
     const temp = mkdtempSync(join(tmpdir(), 'release-cut-branch-'));
     const tree = join(temp, 'tree');
     let added = false;
     let commit: string | undefined;
     try {
-      git(repo, ['worktree', 'add', '--detach', tree, base]);
+      git(repo, ['worktree', 'add', '--detach', tree, start]);
       added = true;
       for (const sha of picks) {
         try { git(tree, ['cherry-pick', sha]); }
@@ -68,13 +81,30 @@ export function cutReleaseBranch(opts: CutBranchOptions): { branch: string; comm
       } finally { rmSync(temp, { recursive: true, force: true }); }
     }
     if (!commit) throw new Error('cherry-pick produced no commit');
-    const push = git(repo, ['push', '--porcelain', `--force-with-lease=refs/heads/${branch}:`, 'origin', `${commit}:refs/heads/${branch}`]);
-    const newBranch = push.split('\n').some((line) => {
+    const lease = opts.append ? remoteTip! : '';
+    let push: string;
+    try {
+      push = git(repo, ['push', '--porcelain', `--force-with-lease=refs/heads/${branch}:${lease}`, 'origin', `${commit}:refs/heads/${branch}`]);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (opts.append && /stale info|rejected|non-fast-forward|failed to push/i.test(message)) {
+        throw new Error(`${branch} remote tip moved — fast-forward refused (no force push)`);
+      }
+      throw error;
+    }
+    const landed = push.split('\n').some((line) => {
       const [flag, ref, summary] = line.split('\t');
-      return flag === '*' && ref?.endsWith(`:refs/heads/${branch}`) && summary === '[new branch]';
+      if (flag !== ' ' && flag !== '*') return false;
+      if (!ref?.endsWith(`:refs/heads/${branch}`)) return false;
+      if (!opts.append) return flag === '*' && summary === '[new branch]';
+      const range = summary?.match(/^([0-9a-f]+)\.\.([0-9a-f]+)$/i);
+      return flag === ' ' && !!range && remoteTip!.startsWith(range[1]!) && commit.startsWith(range[2]!);
     });
-    if (!newBranch) throw new Error(`${branch} already exists on origin (push did not create a new branch)`);
-    report('created', undefined, commit);
+    if (!landed) throw new Error(opts.append
+      ? `${branch} remote tip moved — fast-forward refused (no force push)`
+      : `${branch} already exists on origin (push did not create a new branch)`);
+    if (opts.append) report('appended', undefined, commit, { from: remoteTip!, to: commit, picks });
+    else report('created', undefined, commit);
     log(`${branch} → ${commit}`);
     return { branch, commit, dryRun: false };
   } catch (error) {

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,65 @@ 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)}') ` : '';
+      // Start in /tmp, not the caller checkout. macOS resolves that symlink to /private/tmp before the child sees it;
+      // the remote command still `cd`s to the quoted path, so either spelling is the same directory.
+      const run = spawnSync('ssh', [remote, `PATH=$HOME/.bun/bin:/opt/homebrew/bin:$PATH; export PATH; cd ${quote(cwd)} && ${limitPrefix}${[cmd, ...args].map(quote).join(' ')}`],
+        { cwd: '/tmp', 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 +678,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 +744,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);