elanous 0.2.23 → 0.2.25

package/scripts/measure-log-diet-2.ts

@@ -0,0 +1,213 @@
+#!/usr/bin/env bun
+/**
+ * LOG-DIET-2 (0.2.24) — «같은 부하»에서 관측 «행 수»가 얼마나 줄었나를 재생(replay)으로 잰다.
+ *
+ * 왜 재생인가: 판정선은 «같은 부하에서 시간당 행 −60%»인데 72분 실물 런은 이 칸의 창에 들어가지
+ * 않는다. 그래서 칸 문면이 «측정값»으로 준 부하를 기록열로 재구성하고, 그 «같은» 기록열을
+ * 0.2.23 정책과 현재 정책 두 가드에 흘려 내보낸 행을 센다. 측정은 «정책 차이»이지 실물 재현이
+ * 아니다 — 이 한계를 출력에도 적는다.
+ *
+ * 실행: bun scripts/measure-log-diet-2.ts [--json]
+ * 계약: bun test scripts/measure-log-diet-2.test.ts
+ */
+import { LOG_DIET_KEYS, LogDietGuard } from '../src/debug/log-diet.js';
+import type { DebugEvent } from '../src/debug/log.js';
+
+/** 0.2.23 절식 정책 — A/B «기준선»으로 얼려 둔 사본(현재 `LOG_DIET_KEYS` 와 의도적으로 다르다). */
+export const LOG_DIET_KEYS_0_2_23: Readonly<Record<string, 'repeat' | 'consecutive'>> = {
+  'watchdog/activity': 'consecutive',
+  'user-config.llm/provider-resolved': 'repeat',
+  'hitl.card-bridge/skipped': 'repeat',
+  'input.cursor.claim/chat-main': 'repeat',
+  'tox.loop/waiting-capacity': 'repeat',
+  'tox.loop/tick': 'repeat',
+};
+
+/** 관측된 `log.diet/suppressed` 4,313행(72분) ≈ 초당 1회 flush — 그 주기를 기준선으로 쓴다. */
+export const REPLAY_FLUSH_EVERY_MS = 1_000;
+export const REPLAY_WINDOW_MS = 72 * 60_000;
+
+export type ReplayRecord = Pick<DebugEvent, 'category' | 'event' | 'data' | 'level'> & { atMs: number };
+
+export type LoadGroup = {
+  /** `category/event` */
+  key: string;
+  level?: DebugEvent['level'];
+  /** 창(72분) 동안 관측된 행 수 */
+  rows: number;
+  /** 서로 다른 payload 수 — 1 이면 전부 한 스트림으로 접힌다 */
+  distinctValues: number;
+  source: 'measured' | 'assumed';
+  note: string;
+};
+
+/** 판정 부하: 칸 문면이 수로 준 군 ⊕ 판정 경로(미등록 키) 0-손실 대조군. */
+export const LOG_DIET_2_LOAD: readonly LoadGroup[] = [
+  {
+    key: 'llm.credential/provider-key-missing', level: 'warn', rows: 5_207, distinctValues: 1,
+    source: 'measured', note: '칸 문면 측정값 — 72분 5,207행, 같은 (provider, source, context)',
+  },
+  {
+    key: 'log-diet.replay/judgment-path', rows: 300, distinctValues: 300,
+    source: 'assumed', note: '합성 대조군 — 미등록(판정 경로) 키는 100% 통과해야 한다',
+  },
+];
+
+export type ReplayResult = {
+  rowsIn: number;
+  /** 통과한 원본 행 + `log.diet/suppressed` 요약 행 */
+  rowsOut: number;
+  originalRows: number;
+  summaryRows: number;
+  /** 요약 행이 실어 나른 접힌 기록의 총수 — `originalRows + suppressedTotal === rowsIn` 이어야 한다 */
+  suppressedTotal: number;
+  judgmentRowsIn: number;
+  judgmentRowsOut: number;
+  judgmentLoss: number;
+  /** 1 − rowsOut/rowsIn */
+  reductionRatio: number;
+  /** 참고값 — 내보낸 행 중 `log.diet` 요약 행의 비중(0~1). 판정 ② «총/목록 밖 비»가 «아니다» — 그 비는 재생으로 못 잰다. */
+  summaryShare: number;
+};
+
+export function isJudgmentPath(rec: Pick<DebugEvent, 'category' | 'event'>): boolean {
+  return rec.category !== 'log.diet' && !LOG_DIET_KEYS[`${rec.category}/${rec.event}`];
+}
+
+/** 같은 기록열을 두 정책(기준선/현재)에 흘릴 수 있게 군을 시간순 기록열로 펼친다. */
+export function buildReplayRecords(
+  groups: readonly LoadGroup[],
+  windowMs = REPLAY_WINDOW_MS,
+): ReplayRecord[] {
+  const records: ReplayRecord[] = [];
+  for (const group of groups) {
+    const [category, event] = group.key.split('/');
+    if (!category || !event) throw new Error(`잘못된 부하 키: ${group.key}`);
+    const step = group.rows > 0 ? windowMs / group.rows : windowMs;
+    for (let i = 0; i < group.rows; i++) {
+      const seq = group.distinctValues > 1 ? i % group.distinctValues : 0;
+      records.push({
+        atMs: Math.round(i * step),
+        category,
+        event,
+        data: { key: group.key, seq },
+        ...(group.level ? { level: group.level } : {}),
+      });
+    }
+  }
+  return records.sort((a, b) => a.atMs - b.atMs);
+}
+
+export function replayDiet(
+  records: readonly ReplayRecord[],
+  makeGuard: (now: () => number) => LogDietGuard,
+  flushEveryMs = REPLAY_FLUSH_EVERY_MS,
+): ReplayResult {
+  let clock = 0;
+  const guard = makeGuard(() => clock);
+  let originalRows = 0;
+  let summaryRows = 0;
+  let suppressedTotal = 0;
+  let judgmentRowsIn = 0;
+  let judgmentRowsOut = 0;
+  let nextFlush = flushEveryMs;
+  for (const rec of records) {
+    while (nextFlush <= rec.atMs) {
+      clock = nextFlush;
+      const released = guard.flushPending();
+      summaryRows += released.length;
+      suppressedTotal += released.reduce((sum, s) => sum + s.count, 0);
+      nextFlush += flushEveryMs;
+    }
+    clock = rec.atMs;
+    const judgment = isJudgmentPath(rec);
+    if (judgment) judgmentRowsIn++;
+    const decision = guard.admit(rec);
+    if (decision.pass) {
+      originalRows++;
+      if (judgment) judgmentRowsOut++;
+    }
+    summaryRows += decision.summaries.length;
+    suppressedTotal += decision.summaries.reduce((sum, s) => sum + s.count, 0);
+  }
+  clock = (records.at(-1)?.atMs ?? 0) + flushEveryMs;
+  const drained = guard.drain();
+  summaryRows += drained.length;
+  suppressedTotal += drained.reduce((sum, s) => sum + s.count, 0);
+  const rowsOut = originalRows + summaryRows;
+  return {
+    rowsIn: records.length,
+    rowsOut,
+    originalRows,
+    summaryRows,
+    suppressedTotal,
+    judgmentRowsIn,
+    judgmentRowsOut,
+    judgmentLoss: judgmentRowsIn - judgmentRowsOut,
+    reductionRatio: records.length === 0 ? 0 : 1 - rowsOut / records.length,
+    summaryShare: rowsOut === 0 ? 0 : summaryRows / rowsOut,
+  };
+}
+
+export type Diet2Measurement = {
+  windowMinutes: number;
+  flushEveryMs: number;
+  records: number;
+  groups: readonly LoadGroup[];
+  /** 0.2.23 정책(기준선) */
+  before: ReplayResult;
+  /** 현재 정책(LOG-DIET-2) */
+  after: ReplayResult;
+  /** 1 − after.rowsOut / before.rowsOut — 판정선 −60% 가 무는 값 */
+  reduction: number;
+};
+
+export function measureLogDiet2(
+  groups: readonly LoadGroup[] = LOG_DIET_2_LOAD,
+  windowMs = REPLAY_WINDOW_MS,
+): Diet2Measurement {
+  const records = buildReplayRecords(groups, windowMs);
+  const before = replayDiet(records, now => new LogDietGuard({
+    now,
+    keys: LOG_DIET_KEYS_0_2_23,
+    summaryMinIntervalMs: 0,
+    summaryMaxPending: 1,
+  }));
+  const after = replayDiet(records, now => new LogDietGuard({ now }));
+  return {
+    windowMinutes: Math.round(windowMs / 60_000),
+    flushEveryMs: REPLAY_FLUSH_EVERY_MS,
+    records: records.length,
+    groups,
+    before,
+    after,
+    reduction: before.rowsOut === 0 ? 0 : 1 - after.rowsOut / before.rowsOut,
+  };
+}
+
+const pct = (ratio: number): string => `${(ratio * 100).toFixed(1)}%`;
+
+function report(m: Diet2Measurement): string {
+  const lines: string[] = [
+    `LOG-DIET-2 재생 측정 — 창 ${m.windowMinutes}분 · flush ${m.flushEveryMs}ms · 기록 ${m.records}행`,
+    '⚠ 정책 차이의 재생 측정이다(72분 실물 런 아님). 부하 군:',
+    ...m.groups.map(g => `   - ${g.key} ${g.rows}행/${g.distinctValues}값 [${g.source}] ${g.note}`),
+    '',
+    `기준선(0.2.23)  행 ${m.before.rowsOut} (원본 ${m.before.originalRows} + 요약 ${m.before.summaryRows} · 접힌 기록 ${m.before.suppressedTotal})`,
+    `현재(LOG-DIET-2) 행 ${m.after.rowsOut} (원본 ${m.after.originalRows} + 요약 ${m.after.summaryRows} · 접힌 기록 ${m.after.suppressedTotal})`,
+    `보존            : 원본+접힌 기록 = 입력  → ${m.after.originalRows}+${m.after.suppressedTotal}=${m.records}  ${m.after.originalRows + m.after.suppressedTotal === m.records ? 'PASS' : 'FAIL'}`,
+    '',
+    `판정 ① 같은 부하 시간당 행 −60%      : ${pct(m.reduction)} 감소  → ${m.reduction >= 0.6 ? 'PASS' : 'FAIL'}`,
+    `판정 ② 총/목록 밖 비 ≤ 1.03          : 재생으로 못 잰다(unmeasured · 실물 logs 목록 대비 필요) — 참고: 요약 행 비중 ${m.after.summaryShare.toFixed(3)}`,
+    `판정 ③ 판정 경로 이벤트 0 손실       : ${m.after.judgmentRowsOut}/${m.after.judgmentRowsIn} 통과 (손실 ${m.after.judgmentLoss})  → ${m.after.judgmentLoss === 0 ? 'PASS' : 'FAIL'}`,
+  ];
+  return lines.join('\n');
+}
+
+if (import.meta.main) {
+  const m = measureLogDiet2();
+  if (process.argv.includes('--json')) console.log(JSON.stringify(m, null, 2));
+  else console.log(report(m));
+  const ok = m.reduction >= 0.6 && m.after.judgmentLoss === 0; // 판정 ② 는 여기서 판정하지 않는다(unmeasured)
+  process.exit(ok ? 0 : 1);
+}

package/scripts/measure-tsc-affected-roots.ts

@@ -0,0 +1,289 @@
+import { spawn } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { debug } from '../src/debug/log.js';
+import { parseTypecheckErrors, tscEnv } from '../src/typecheck-ratchet.js';
+import { compareDiagnostics, normalizeDiagnostics, type NormalizedDiagnostic } from './tsc-baseline-comparison.js';
+
+export interface CommandResult {
+  status: number | null;
+  signal?: NodeJS.Signals | null;
+  stdout: string;
+  stderr: string;
+  error?: Error;
+  durationMs: number;
+}
+export type Runner = (command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv) => Promise<CommandResult>;
+export interface Metrics { durationMs: number | null; rssMb: number | null; }
+export interface PrMeasurement {
+  pr: number;
+  head: string;
+  base: string;
+  verdict: 'missed' | 'same' | 'stricter' | 'unmeasured';
+  missedDiagnostics: NormalizedDiagnostic[];
+  addedDiagnostics: NormalizedDiagnostic[];
+  fullBase: Metrics;
+  fullHead: Metrics;
+  narrowed: Metrics;
+  gateExitCode: number | null;
+  reason?: string;
+  worktree: string;
+}
+export interface MeasurementReport {
+  prs: PrMeasurement[];
+  summary: { missed: number; same: number; stricter: number; unmeasured: number; of: number };
+  exitCode: number;
+}
+export interface Options { run?: Runner; platform?: NodeJS.Platform; makeTemp?: () => string; removeTemp?: (path: string) => void; }
+interface Pr { number: number; mergeCommit: { oid: string } | null; files: { path: string }[]; mergedAt?: string; changedFiles?: number; }
+const emptyMetrics = (): Metrics => ({ durationMs: null, rssMb: null });
+const hash = (text: string): boolean => /^[0-9a-f]{40}$/i.test(text);
+const reason = (result: CommandResult): string => result.error?.message ?? (result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`);
+
+export const spawnRunner: Runner = (command, args, cwd, extraEnv) => new Promise((done) => {
+  const started = performance.now();
+  const env = tscEnv({ ...process.env, ...extraEnv });
+  delete env.GIT_DIR;
+  delete env.GIT_WORK_TREE;
+  delete env.GIT_COMMON_DIR;
+  let child;
+  try { child = spawn(command, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] }); }
+  catch (cause) {
+    done({ status: null, stdout: '', stderr: '', error: cause instanceof Error ? cause : new Error(String(cause)), durationMs: performance.now() - started });
+    return;
+  }
+  const stdout: Buffer[] = [];
+  const stderr: Buffer[] = [];
+  child.stdout.on('data', (chunk: Buffer) => stdout.push(chunk));
+  child.stderr.on('data', (chunk: Buffer) => stderr.push(chunk));
+  let error: Error | undefined;
+  child.on('error', (cause: Error) => { error = cause; });
+  child.on('close', (status, signal) => done({ status, signal, stdout: Buffer.concat(stdout).toString(), stderr: Buffer.concat(stderr).toString(), error, durationMs: performance.now() - started }));
+});
+
+export function parseRss(output: string, platform: NodeJS.Platform): number | null {
+  const mac = output.match(/^\s*(\d+)\s+maximum resident set size\s*$/im);
+  const linux = output.match(/^\s*Maximum resident set size \(kbytes\):\s*(\d+)\s*$/im);
+  const value = platform === 'darwin' ? mac : platform === 'linux' ? linux : null;
+  if (!value) return null;
+  const bytes = Number(value[1]) * (platform === 'linux' ? 1024 : 1);
+  return Number.isSafeInteger(bytes) ? bytes / 1048576 : null;
+}
+
+function optionsFromArgs(argv: readonly string[]): { numbers: number[] | null; recent: number; keep: boolean } {
+  let numbers: number[] | null = null;
+  let recent = 10;
+  let explicitRecent = false;
+  let keep = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--prs' || arg === '--recent') {
+      const value = argv[++i];
+      if (!value) throw new Error(`${arg} requires a value`);
+      if (arg === '--prs') {
+        if (numbers || explicitRecent || !/^\d+(,\d+)*$/.test(value)) throw new Error('invalid --prs list');
+        numbers = value.split(',').map(Number);
+        if (numbers.some((n) => !Number.isSafeInteger(n) || n < 1) || new Set(numbers).size !== numbers.length) throw new Error('invalid --prs list');
+      } else {
+        if (numbers || explicitRecent || !/^\d+$/.test(value)) throw new Error('invalid --recent count');
+        recent = Number(value);
+        if (!Number.isSafeInteger(recent) || recent < 1) throw new Error('invalid --recent count');
+        explicitRecent = true;
+      }
+    } else if (arg === '--json') continue;
+    else if (arg === '--keep') keep = true;
+    else throw new Error(`unknown option: ${arg}`);
+  }
+  return { numbers, recent, keep };
+}
+
+async function required(run: Runner, command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): Promise<CommandResult> {
+  const result = await run(command, args, cwd, env);
+  if (result.error || result.signal || result.status !== 0) throw new Error(`${command} ${args.join(' ')}: ${reason(result)}`);
+  return result;
+}
+function parsePr(value: unknown): Pr {
+  if (!value || typeof value !== 'object') throw new Error('invalid PR response');
+  const pr = value as Pr;
+  if (!Number.isSafeInteger(pr.number) || pr.number < 1 || !pr.mergeCommit || !hash(pr.mergeCommit.oid) || !Array.isArray(pr.files) || !pr.files.every((file) => typeof file?.path === 'string')) throw new Error(`invalid merged PR response: ${JSON.stringify(value)}`);
+  return pr;
+}
+const typeScriptFile = (path: string): boolean => /\.[cm]?tsx?$/.test(path);
+/** The list API truncates `files`; when the listed files are fewer than `changedFiles`, read the full paginated list. */
+async function touchesTypeScript(run: Runner, repo: string, pr: Pr): Promise<boolean> {
+  if (pr.files.some((file) => typeScriptFile(file.path))) return true;
+  if (typeof pr.changedFiles === 'number' && pr.changedFiles <= pr.files.length) return false;
+  const all = (await required(run, 'gh', ['api', '--paginate', `repos/{owner}/{repo}/pulls/${pr.number}/files`, '--jq', '.[].filename'], repo)).stdout.split('\n').map((line) => line.trim()).filter(Boolean);
+  if (typeof pr.changedFiles === 'number' && all.length < pr.changedFiles) throw new Error(`PR #${pr.number}: file list incomplete (${all.length} of ${pr.changedFiles})`);
+  return all.some(typeScriptFile);
+}
+async function selectPrs(repo: string, opts: ReturnType<typeof optionsFromArgs>, run: Runner): Promise<Pr[]> {
+  if (opts.numbers) {
+    const prs: Pr[] = [];
+    for (const n of opts.numbers) {
+      const pr = parsePr(JSON.parse((await required(run, 'gh', ['pr', 'view', String(n), '--json', 'number,mergeCommit,files'], repo)).stdout));
+      if (pr.number !== n) throw new Error(`requested PR #${n} but received #${pr.number}`);
+      prs.push(pr);
+    }
+    return prs;
+  }
+  let limit = Math.max(100, opts.recent);
+  let previousCount = -1;
+  for (;;) {
+    const result = await required(run, 'gh', ['pr', 'list', '--state', 'merged', '--base', 'main', '--search', 'sort:merged-desc', '--limit', String(limit), '--json', 'number,mergeCommit,files,mergedAt,changedFiles'], repo);
+    const raw: unknown = JSON.parse(result.stdout);
+    if (!Array.isArray(raw)) throw new Error('invalid merged PR list');
+    if (raw.some((item) => typeof item?.mergedAt !== 'string')) throw new Error('merged PR list has no merge dates');
+    const prs: Pr[] = [];
+    for (const pr of raw.map(parsePr)) if (await touchesTypeScript(run, repo, pr)) prs.push(pr);
+    if (prs.length >= opts.recent || raw.length < limit || raw.length === previousCount) return prs.sort((a, b) => b.mergedAt!.localeCompare(a.mergedAt!)).slice(0, opts.recent);
+    previousCount = raw.length;
+    limit += 100;
+  }
+}
+
+function elapsed(result: CommandResult, platform: NodeJS.Platform): Metrics {
+  return { durationMs: Number.isFinite(result.durationMs) ? result.durationMs : null, rssMb: parseRss(result.stderr, platform) };
+}
+function checked(result: CommandResult, label: string, output: string): void {
+  if (result.error || result.signal || ![0, 1, 2].includes(result.status ?? -1) || /error TS(?:2688|5083|6053)\b|heap out of memory|Ineffective mark-compacts near heap limit/i.test(output)) throw new Error(`${label}: tsc not measured: ${reason(result)}`);
+  const diagnostics = parseTypecheckErrors(output);
+  if (result.status !== 0 && diagnostics.length === 0) throw new Error(`${label}: nonzero exit without parseable diagnostics: ${reason(result)}`);
+  if ((/error TS\d+/.test(output) && diagnostics.length === 0) || (result.status === 0 && diagnostics.length > 0 && label === 'full')) throw new Error(`${label}: inconsistent tsc diagnostics and exit status`);
+}
+function fullDiagnostics(result: CommandResult, root: string): NormalizedDiagnostic[] {
+  const output = `${result.stdout}\n${result.stderr}`;
+  checked(result, 'full', output);
+  return normalizeDiagnostics(parseTypecheckErrors(output), root);
+}
+function gateDiagnostics(result: CommandResult, root: string): NormalizedDiagnostic[] {
+  const output = `${result.stdout}\n${result.stderr}`;
+  const diagnosticOutput = output.split('\n').map((line) => line.replace(/^  /, '')).join('\n');
+  checked(result, 'narrowed', diagnosticOutput);
+  if (/tsc 를 «못 쟀다»|tsc 가 정상 실행됐음을 확인할 수 없다|변경 파일 없음|변경 파일 수집 실패/i.test(output)
+    || (result.status === 0 && !/\[tsc-gate\] PASS —/.test(output))
+    || (result.status !== 0 && !/\[tsc-gate\] FAIL —/.test(output))) throw new Error('narrowed gate did not measure tsc');
+  return normalizeDiagnostics(parseTypecheckErrors(diagnosticOutput), root);
+}
+async function timed(run: Runner, platform: NodeJS.Platform, command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): Promise<CommandResult> {
+  if (platform === 'darwin' || platform === 'linux') return run('/usr/bin/time', [platform === 'darwin' ? '-l' : '-v', command, ...args], cwd, env);
+  return run(command, args, cwd, env);
+}
+
+/**
+ * The pre-merge base of the whole PR. Merge commit → first parent. Single-parent merge commit: the PR's complete
+ * commit count comes from REST (`pulls/N .commits`) for every PR — never from the possibly truncated listed commits.
+ * One commit → `head^1`. k > 1 commits → squash (one commit on main) or rebase-merge (k rewritten commits); the
+ * method is decided by GitHub's commit↔PR association of `head~1 … head~(k-1)` (all ours → rebase → `head~k`,
+ * none ours → squash → `head^1`), never by commit subjects. Anything else is ambiguous and the PR is unmeasured,
+ * so an error introduced by an earlier rebased commit is never hidden behind a wrong baseline.
+ */
+async function preMergeRevision(run: Runner, repo: string, pr: Pr, head: string): Promise<string> {
+  const parents = (await required(run, 'git', ['rev-list', '--parents', '-n', '1', head], repo)).stdout.trim().split(/\s+/).filter(Boolean);
+  if (parents.length > 2) return `${head}^1`;
+  const totalText = (await required(run, 'gh', ['api', `repos/{owner}/{repo}/pulls/${pr.number}`, '--jq', '.commits'], repo)).stdout.trim();
+  const total = Number(totalText);
+  if (!/^\d+$/.test(totalText) || !Number.isSafeInteger(total) || total < 1) throw new Error(`PR #${pr.number}: commit count unreadable (${totalText || 'empty'}) — pre-merge base not determinable`);
+  if (total === 1) return `${head}^1`;
+  const ours: boolean[] = [];
+  for (let back = 1; back < total; back += 1) {
+    const sha = (await required(run, 'git', ['rev-parse', `${head}~${back}`], repo)).stdout.trim();
+    if (!hash(sha)) throw new Error(`PR #${pr.number}: ${head}~${back} unresolvable — pre-merge base not determinable`);
+    const numbers = (await required(run, 'gh', ['api', `repos/{owner}/{repo}/commits/${sha}/pulls`, '--jq', '.[].number'], repo)).stdout.split(/\s+/).filter(Boolean);
+    ours.push(numbers.includes(String(pr.number)));
+  }
+  if (ours.every(Boolean)) return `${head}~${total}`;
+  if (ours.every((owned) => !owned)) return `${head}^1`;
+  throw new Error(`PR #${pr.number}: merge method ambiguous (${ours.filter(Boolean).length}/${ours.length} of the preceding commits belong to the PR) — pre-merge base not determinable`);
+}
+
+async function measurePr(repo: string, pr: Pr, run: Runner, platform: NodeJS.Platform, keep: boolean, makeTemp: () => string, removeTemp: (path: string) => void): Promise<PrMeasurement> {
+  const head = pr.mergeCommit!.oid;
+  const workspace = makeTemp();
+  const worktree = join(workspace, 'pr');
+  const result: PrMeasurement = { pr: pr.number, head, base: '', worktree, verdict: 'unmeasured', missedDiagnostics: [], addedDiagnostics: [], fullBase: emptyMetrics(), fullHead: emptyMetrics(), narrowed: emptyMetrics(), gateExitCode: null };
+  let attempted = false;
+  try {
+    const base = (await required(run, 'git', ['rev-parse', await preMergeRevision(run, repo, pr, head)], repo)).stdout.trim();
+    if (!hash(base)) throw new Error(`invalid first parent of ${head}: ${base}`);
+    result.base = base;
+    attempted = true;
+    await required(run, 'git', ['worktree', 'add', '--detach', worktree, head], repo);
+    await required(run, 'git', ['checkout', '--detach', base], worktree);
+    await required(run, 'bun', ['install', '--frozen-lockfile'], worktree);
+    const baseRun = await timed(run, platform, './node_modules/.bin/tsc', ['--noEmit', '-p', 'tsconfig.gate.json'], worktree);
+    result.fullBase = elapsed(baseRun, platform);
+    const baseline = fullDiagnostics(baseRun, worktree);
+    await required(run, 'git', ['checkout', '--detach', head], worktree);
+    await required(run, 'bun', ['install', '--frozen-lockfile'], worktree);
+    const headRun = await timed(run, platform, './node_modules/.bin/tsc', ['--noEmit', '-p', 'tsconfig.gate.json'], worktree);
+    result.fullHead = elapsed(headRun, platform);
+    const current = fullDiagnostics(headRun, worktree);
+    const added = compareDiagnostics(current, baseline);
+    if (added.kind === 'unavailable') throw new Error(added.reason);
+    result.addedDiagnostics = added.added;
+    const gateRun = await timed(run, platform, 'bun', ['scripts/ci-typecheck-changed.ts', '--local'], worktree, { ...process.env, TSC_BASE_REF: base });
+    result.narrowed = elapsed(gateRun, platform);
+    result.gateExitCode = gateRun.status;
+    const seen = gateDiagnostics(gateRun, worktree);
+    const unseen = compareDiagnostics(added.added, seen);
+    result.missedDiagnostics = unseen.kind === 'added' ? unseen.added : [];
+    result.verdict = added.added.length > 0
+      ? gateRun.status === 0 || result.missedDiagnostics.length > 0 ? 'missed' : 'same'
+      : gateRun.status === 0 ? 'same' : 'stricter';
+  } catch (error) {
+    result.reason = error instanceof Error ? error.message : String(error);
+    result.verdict = 'unmeasured';
+  } finally {
+    if (!keep) {
+      try {
+        if (attempted) {
+          const removed = await run('git', ['worktree', 'remove', '--force', worktree], repo);
+          if (removed.error || removed.signal || (removed.status !== 0 && !/is not a working tree|is not a worktree/i.test(removed.stderr))) throw new Error(`git worktree remove: ${reason(removed)}`);
+        }
+      } catch (error) {
+        if (result.verdict !== 'missed') result.verdict = 'unmeasured';
+        result.reason = `${result.reason ? `${result.reason}; ` : ''}cleanup failed: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      try { removeTemp(workspace); }
+      catch (error) {
+        if (result.verdict !== 'missed') result.verdict = 'unmeasured';
+        result.reason = `${result.reason ? `${result.reason}; ` : ''}workspace cleanup failed: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    }
+    debug.log('tsc.affected-roots', 'measure-pr', { pr: result.pr, head, base: result.base, verdict: result.verdict, missedDiagnostics: result.missedDiagnostics.length, fullBase: result.fullBase, fullHead: result.fullHead, narrowed: result.narrowed, reason: result.reason });
+  }
+  return result;
+}
+
+export async function measureAffectedRoots(repo: string, argv: readonly string[] = [], options: Options = {}): Promise<MeasurementReport> {
+  const opts = optionsFromArgs(argv);
+  const run = options.run ?? spawnRunner;
+  const prs = await selectPrs(repo, opts, run);
+  if (prs.length === 0) throw new Error('no merged TypeScript PRs to measure');
+  const rows: PrMeasurement[] = [];
+  for (const pr of prs) rows.push(await measurePr(repo, pr, run, options.platform ?? process.platform, opts.keep, options.makeTemp ?? (() => mkdtempSync(join(tmpdir(), 'tsc-affected-roots-'))), options.removeTemp ?? ((path) => rmSync(path, { recursive: true, force: true }))));
+  const summary = { missed: rows.filter((row) => row.verdict === 'missed').length, same: rows.filter((row) => row.verdict === 'same').length, stricter: rows.filter((row) => row.verdict === 'stricter').length, unmeasured: rows.filter((row) => row.verdict === 'unmeasured').length, of: rows.length };
+  return { prs: rows, summary, exitCode: summary.missed ? 1 : summary.unmeasured ? 2 : 0 };
+}
+export function formatReport(report: MeasurementReport, json = false): string {
+  if (json) return JSON.stringify(report);
+  const metric = (m: Metrics) => `${m.durationMs === null ? '—' : Math.round(m.durationMs)} / ${m.rssMb === null ? '—' : m.rssMb}`;
+  return [
+    'PR | verdict | missed diagnostics | full base ms/RSS MB | full head ms/RSS MB | narrowed ms/RSS MB',
+    ...report.prs.map((row) => `#${row.pr} | ${row.verdict} | ${row.missedDiagnostics.length} | ${metric(row.fullBase)} | ${metric(row.fullHead)} | ${metric(row.narrowed)}${row.reason ? ` | ${row.reason}` : ''}`),
+    `missed=${report.summary.missed} same=${report.summary.same} stricter=${report.summary.stricter} unmeasured=${report.summary.unmeasured} of ${report.summary.of}`,
+  ].join('\n');
+}
+if (import.meta.main) {
+  try {
+    const argv = process.argv.slice(2);
+    const report = await measureAffectedRoots(resolve(process.cwd()), argv);
+    console.log(formatReport(report, argv.includes('--json')));
+    process.exitCode = report.exitCode;
+  } catch (error) {
+    console.error(`tsc affected roots measurement unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 2;
+  }
+}

package/scripts/release-loop/auto-approve-node.ts

@@ -2,6 +2,7 @@
 import { mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
+import { registerStandaloneLogSink } from '../../src/domains/standalone-log-sink.js';
 import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
 import { emitNodeResult, readGraphContext, type GraphContext } from './node-verdict.js';
 import { regressWarning, validatedTuiRegress } from './tui-node-checks.js';
@@ -78,6 +79,11 @@ export function runAutoApprove(context: GraphContext = readGraphContext(), deps:
 }
 
 if (import.meta.main) {
+  // GATE-OBS2-1 — the release graph spawns this node as its own process, which inherits no daemon sink. Without this the
+  // `release-loop.approve / auto-decision` event (the one that says why a release was or was not published unattended)
+  // stayed in the file trail and `elanous logs` read 0 rows. Same pattern as gate-node.ts.
+  // Observability must never stop the release node from emitting its verdict — a failed sink registration is skipped.
+  try { await registerStandaloneLogSink('release-loop'); } catch { /* fail-soft: the decision still goes to stdout */ }
   try {
     const result = runAutoApprove();
     emitNodeResult(result);