elanous 0.2.9 → 0.2.11

package/scripts/ops-now-probe.ts

@@ -0,0 +1,327 @@
+#!/usr/bin/env bun
+import { spawn } from 'node:child_process';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { debug, redactSecrets } from '../src/debug/log.js';
+import { sendOutbound } from '../src/domains/outbound-alert.js';
+import { DecisionLedger } from '../src/decisions/decision-ledger.js';
+import { effectiveInstanceRoot, prodInstanceRoot, releaseLedgerRoot } from '../src/instance/resolve.js';
+import { listMemories } from '../src/memory.js';
+import { listSchedules, getSchedule } from '../src/release-loop/release-schedule.js';
+import { listChecklist, summarizeChecklist } from '../src/release-loop/checklist.js';
+import { getUserConfig } from '../src/user-config.js';
+import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js';
+
+export type ProbeKind = 'cut' | 'green' | 'open';
+export type ProbeVerdict = 'match' | 'mismatch' | 'pending' | 'unmeasured';
+export interface ProbeRow {
+  ts: string;
+  question: string;
+  verdict: ProbeVerdict;
+  botValue: string | number | null;
+  ledgerValue: string | number | null;
+  opsNowUpdatedAt: string | null;
+  reason: string | null;
+  botReply: string | null;
+}
+export const STANDARD_QUESTIONS: ReadonlyArray<{ kind: ProbeKind; ask: (version: string) => string }> = [
+  { kind: 'cut', ask: (version) => `${version} 컷 언제야?` },
+  { kind: 'green', ask: (version) => `${version} 체크리스트 초록 몇 개야?` },
+  { kind: 'open', ask: () => '지금 미결 결정 몇 개야?' },
+];
+
+export interface ProbeDeps {
+  schedules?: () => Promise<Array<{ version: string; cutAt: string }>> | Array<{ version: string; cutAt: string }>;
+  published?: (version: string) => Promise<boolean> | boolean;
+  cut?: (version: string) => Promise<string | null> | string | null;
+  green?: (version: string) => Promise<number> | number;
+  open?: () => Promise<number> | number;
+  ask?: (question: string, model?: string) => Promise<string>;
+  send?: typeof sendOutbound;
+  memoryUpdatedAt?: () => string | null;
+  model?: () => string | undefined;
+  root?: string;
+  now?: () => Date;
+  print?: (line: string) => void;
+  observe?: (question: string, verdict: ProbeVerdict, reason: string | null) => void;
+}
+export interface ProbeOptions { version?: string; dryRun?: boolean; json?: boolean }
+
+function kstDate(date: Date): string {
+  return new Date(date.getTime() + 9 * 3_600_000).toISOString().slice(0, 10);
+}
+
+const CUT_ISO = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})(?!\d)/g;
+const CUT_LOCAL = /(?:(\d{4})\s*[년./-]\s*)?(\d{1,2})\s*(?:월|[./-])\s*(\d{1,2})\s*(?:일)?(?:\s*\([^)]*\))?(?:\s*(?:오전|오후|AM|PM))?\s*(\d{1,2})\s*(?:시\s*(\d{1,2})\s*분?|:\s*(\d{2}))(?!\d)\s*(?:KST|한국시간)?/gi;
+
+function cutValue(text: string): string | null {
+  const iso = new RegExp(CUT_ISO.source).exec(text)?.[0];
+  if (iso && Number.isFinite(Date.parse(iso))) return new Date(Date.parse(iso) + 9 * 3_600_000).toISOString().slice(0, 16);
+  const match = new RegExp(CUT_LOCAL.source, 'i').exec(text);
+  if (!match) return null;
+  const year = match[1] ? Number(match[1]) : null;
+  const month = Number(match[2]), day = Number(match[3]);
+  let hour = Number(match[4]);
+  const minute = Number(match[5] ?? match[6]);
+  if (/오후|PM/i.test(match[0]) && hour < 12) hour += 12;
+  if (/오전|AM/i.test(match[0]) && hour === 12) hour = 0;
+  if (month < 1 || month > 12 || day < 1 || day > 31 || hour > 23 || minute > 59) return null;
+  return `${year ?? '????'}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}T${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}`;
+}
+
+function normalizedCut(value: string, reference?: string): string | null {
+  const parsed = cutValue(value);
+  if (!parsed) return null;
+  if (parsed.startsWith('????-') && reference) return `${reference.slice(0, 4)}${parsed.slice(4)}`;
+  return parsed;
+}
+
+function ledgerCutValue(value: string): string | null {
+  const millis = Date.parse(value);
+  if (!Number.isFinite(millis)) return null;
+  return new Date(millis + 9 * 3_600_000).toISOString().slice(0, 16);
+}
+
+type ParsedValue<T> = { value: T | null; ambiguous: boolean };
+type Candidate<T> = { start: number; end: number; value: T };
+
+function selectClaim<T>(reply: string, candidates: Candidate<T>[]): ParsedValue<T> {
+  if (candidates.length === 1) {
+    const after = reply.slice(candidates[0]!.end);
+    if (/^\s*(?:개|건|KST|한국시간)?\s*(?:가|이|은|는)?\s*(?:아닙니다|아니다|아니에요|아님|아닌|말고)/i.test(after)) {
+      return { value: null, ambiguous: true };
+    }
+    return { value: candidates[0]!.value, ambiguous: false };
+  }
+  if (candidates.length === 2) {
+    const between = reply.slice(candidates[0]!.end, candidates[1]!.start);
+    // «57개가 아니라 50개» · «3개, 아니 4개» — the later value is the asserted one.
+    if (/^(?:\s*(?:개|건|KST|한국시간))?\s*(?:가|이|은|는)?\s*(?:아니라|아닌|말고|[,，]?\s*아니(?:요|고)?\s*[,，]?)\s*$/i.test(between)) {
+      return { value: candidates[1]!.value, ambiguous: false };
+    }
+  }
+  return { value: null, ambiguous: candidates.length > 1 };
+}
+
+const NEGATED_AFTER = /^\s*(?:개|건)?\s*(?:가|이|은|는)?\s*(?:아닙니다|아니다|아니에요|아님|아닌|말고)/i;
+// A number counts as the metric only when it carries a unit (개·건) or sits right after the label («초록은 57»).
+// Anything else (a version «0.2.10판», a date) is not a claim about the count — unmeasured, never a false drift.
+const DIRECT_AFTER_LABEL = /^\s*(?:은|는|이|가|도|:|=)?\s*(?:총|현재|지금|모두|전부)?\s*$/;
+
+function countValue(reply: string, kind: 'green' | 'open'): ParsedValue<number> {
+  const label = kind === 'green' ? /(?:초록|녹색|green|🟢)/i : /(?:미결\s*결정|열린\s*결정|open\s*decisions?|미결)/i;
+  const found = label.exec(reply);
+  if (!found) {
+    const bare = /^\s*(\d[\d,]*)\s*(?:개|건)?[.。!\s]*$/.exec(reply);
+    if (!bare) return { value: null, ambiguous: false };
+    const value = Number(bare[1]!.replaceAll(',', ''));
+    return Number.isSafeInteger(value) && value >= 0 ? { value, ambiguous: false } : { value: null, ambiguous: false };
+  }
+  const answer = reply.slice(found.index + found[0].length);
+  const candidates: Candidate<number>[] = [];
+  for (const match of answer.matchAll(/(?<![\d.])\d[\d,]*(?![\d.])/g)) {
+    const value = Number(match[0].replaceAll(',', ''));
+    if (!Number.isSafeInteger(value) || value < 0) continue;
+    const end = match.index + match[0].length;
+    const unit = /^\s*(?:개|건)/.test(answer.slice(end));
+    const direct = DIRECT_AFTER_LABEL.test(answer.slice(0, match.index));
+    if (unit || direct) candidates.push({ start: match.index, end, value });
+  }
+  if (candidates.length) return selectClaim(answer, candidates);
+  // Number before the label («57개가 초록», «57개 초록이 아닙니다») — keep the negation that follows the label.
+  const reverse = new RegExp(`(?<![\\d.])(\\d[\\d,]*)(?![\\d.])\\s*(?:개|건)?\\s*(?:가|이|의)?\\s*${label.source}`, 'i').exec(reply);
+  if (!reverse) return { value: null, ambiguous: false };
+  const tail = reply.slice(reverse.index + reverse[0].length);
+  if (NEGATED_AFTER.test(tail)) return { value: null, ambiguous: true };
+  const value = Number(reverse[1]!.replaceAll(',', ''));
+  return Number.isSafeInteger(value) && value >= 0 ? { value, ambiguous: false } : { value: null, ambiguous: false };
+}
+
+function replyValue(kind: ProbeKind, reply: string, ledger: string | number): ParsedValue<string | number> {
+  if (kind !== 'cut') return countValue(reply, kind);
+  const candidates: Candidate<string>[] = [];
+  for (const match of reply.matchAll(CUT_ISO)) {
+    const value = normalizedCut(match[0], String(ledger));
+    if (value) candidates.push({ start: match.index, end: match.index + match[0].length, value });
+  }
+  for (const match of reply.matchAll(CUT_LOCAL)) {
+    if (candidates.some((candidate) => match.index < candidate.end && match.index + match[0].length > candidate.start)) continue;
+    let value = normalizedCut(match[0], String(ledger));
+    const zone = /^\s*(UTC|GMT|Z\b|[A-Z]{2,4}T\b|[+-]\d{1,2}(?::?\d{2})?\b)\s*([+-]\d{1,2}(?::?\d{2})?)?/i.exec(reply.slice(match.index + match[0].length));
+    if (value && zone && !/KST/i.test(match[0])) {
+      // A written zone other than KST: UTC/GMT converts (+9h); any other zone or offset is not guessed — unmeasured.
+      if (/^(?:UTC|GMT|Z)$/i.test(zone[1]!) && !zone[2] && !value.startsWith('????')) {
+        const millis = Date.parse(`${value}:00Z`);
+        value = Number.isFinite(millis) ? new Date(millis + 9 * 3_600_000).toISOString().slice(0, 16) : null;
+      } else value = null;
+    }
+    if (value) candidates.push({ start: match.index, end: match.index + match[0].length + (zone && !/KST/i.test(match[0]) ? zone[0].length : 0), value });
+  }
+  candidates.sort((a, b) => a.start - b.start);
+  const valid = candidates.filter(({ value: parsed }) => {
+    const millis = Date.parse(`${parsed}:00Z`);
+    return Number.isFinite(millis) && new Date(millis).toISOString().slice(0, 16) === parsed;
+  });
+  return selectClaim(reply, valid);
+}
+
+function askBot(question: string, model?: string): Promise<string> {
+  const root = effectiveInstanceRoot();
+  return new Promise((resolve, reject) => {
+    const args = ['bin/elanous.mjs', ...(root === prodInstanceRoot() ? [] : [`--test=${root}`]), 'ask', question, '--json'];
+    const child = spawn('bun', args, {
+      cwd: join(import.meta.dir, '..'),
+      env: { ...process.env, ...(model ? { ELANOUS_LLM_MODEL: model } : {}) },
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    let out = '';
+    let tooLong = false;
+    let timedOut = false;
+    const timer = setTimeout(() => { timedOut = true; child.kill(); reject(new Error('timeout')); }, 90_000);
+    child.stdout.on('data', (chunk: Buffer) => {
+      out += chunk.toString();
+      if (out.length > 1024 * 1024) { tooLong = true; child.kill(); }
+    });
+    child.on('error', (error) => { clearTimeout(timer); reject(error); });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (timedOut) return reject(new Error('timeout'));
+      if (tooLong) return reject(new Error('bot-output-too-large'));
+      if (code !== 0) return reject(new Error('bot-error'));
+      try {
+        const result = JSON.parse(out) as { reply?: unknown; error?: unknown };
+        if (typeof result.reply !== 'string') throw new Error('bot-no-reply');
+        resolve(result.reply);
+      } catch { reject(new Error('bot-no-reply')); }
+    });
+  });
+}
+
+function isPublished(version: string, releaseRoot: string): boolean {
+  try {
+    const record = JSON.parse(readFileSync(join(releaseRoot, 'release', version, 'release.json'), 'utf8')) as { publishedAt?: unknown; version?: unknown };
+    return record.version === version && typeof record.publishedAt === 'string';
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+function ledgerOpen(): number { return new DecisionLedger().list({ status: 'open' }).length; }
+function memoryUpdatedAt(): string | null { return listMemories().find((entry) => entry.name === 'ops-now')?.updatedAt ?? null; }
+function probeModel(): string | undefined {
+  const config = getUserConfig().raw.opsNowProbe;
+  if (!config || typeof config !== 'object' || Array.isArray(config)) return undefined;
+  const model = (config as Record<string, unknown>).model;
+  return typeof model === 'string' && model.trim() ? model.trim() : undefined;
+}
+
+export async function runOpsNowProbe(options: ProbeOptions = {}, deps: ProbeDeps = {}): Promise<{ rows: ProbeRow[]; exitCode: number; alert: string | null }> {
+  const now = (deps.now ?? (() => new Date()))();
+  const root = deps.root ?? effectiveInstanceRoot();
+  const releaseRoot = releaseLedgerRoot();
+  let version = options.version;
+  if (!version) {
+    try {
+      if (!deps.schedules && !existsSync(join(releaseRoot, 'release', 'features.sqlite'))) throw new Error('ledger-unreadable');
+      const schedules = await (deps.schedules ?? (() => listSchedules(releaseRoot)))();
+      const ordered = schedules.filter((row) => Number.isFinite(Date.parse(row.cutAt)))
+        .sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt));
+      for (const row of ordered) {
+        if (!await (deps.published ?? ((v) => isPublished(v, releaseRoot)))(row.version)) {
+          version = row.version;
+          break;
+        }
+      }
+    } catch { /* A missing version makes the two release questions unmeasured. */ }
+  }
+  const updatedAt = (() => { try { return (deps.memoryUpdatedAt ?? memoryUpdatedAt)(); } catch { return null; } })();
+  let model: string | undefined;
+  try { model = deps.model ? deps.model() : probeModel(); } catch { /* Use the ask path's configured model. */ }
+  const rows: ProbeRow[] = [];
+  for (const item of STANDARD_QUESTIONS) {
+    const question = item.ask(version ?? '(판 미상)');
+    let ledgerValue: string | number | null = null;
+    let reason: string | null = null;
+    try {
+      if (item.kind !== 'open' && !version) throw new Error('ledger-unreadable');
+      if (item.kind === 'green' && !deps.green && !existsSync(join(releaseRoot, 'release', 'features.sqlite')) && !existsSync(join(releaseRoot, 'release', version!, 'checklist.json'))) throw new Error('ledger-unreadable');
+      if (item.kind === 'open' && !deps.open && !existsSync(new DecisionLedger().path)) throw new Error('ledger-unreadable');
+      const value = item.kind === 'cut' ? await (deps.cut ?? ((v) => getSchedule(v, releaseRoot)?.cutAt ?? null))(version!)
+        : item.kind === 'green' ? await (deps.green ?? ((v) => summarizeChecklist(listChecklist(v)).green))(version!) : await (deps.open ?? ledgerOpen)();
+      if (item.kind === 'cut') ledgerValue = typeof value === 'string' ? ledgerCutValue(value) : null;
+      else ledgerValue = typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+      if (ledgerValue === null) reason = 'ledger-unreadable';
+    } catch { reason = 'ledger-unreadable'; }
+    let reply: string | null = null;
+    let botValue: string | number | null = null;
+    try { reply = await (deps.ask ?? askBot)(question, model); }
+    catch (error) { if (!reason) reason = (error as Error).message === 'timeout' ? 'timeout' : 'bot-unresponsive'; }
+    let verdict: ProbeVerdict = 'unmeasured';
+    if (!reason) {
+      if (!reply?.trim()) reason = 'bot-unresponsive';
+      else if (/확인\s*(?:중|해\s*보겠|해\s*볼게|해\s*보도록|이\s*필요)|조회\s*중|살펴\s*보겠/.test(reply)) { verdict = 'pending'; reason = 'bot-pending'; }
+      else {
+        const parsed = replyValue(item.kind, reply, ledgerValue!);
+        botValue = parsed.value;
+        if (botValue === null) reason = parsed.ambiguous ? 'value-ambiguous' : 'value-unparseable';
+        else verdict = botValue === ledgerValue ? 'match' : 'mismatch';
+      }
+    }
+    const row: ProbeRow = { ts: now.toISOString(), question, verdict, botValue, ledgerValue, opsNowUpdatedAt: updatedAt,
+      reason, botReply: reply === null ? null : redactSecrets({ reply }).reply.slice(0, 200) };
+    rows.push(row);
+    debug.log('ops-now.probe', 'verdict', { question, verdict, reason });
+    deps.observe?.(question, verdict, reason);
+  }
+  const path = join(root, 'ops-now-probe', `${kstDate(now)}.jsonl`);
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, rows.map((row) => JSON.stringify(row)).join('\n') + '\n', { mode: 0o600 });
+  const mismatches = rows.filter((row) => row.verdict === 'mismatch');
+  const alert = mismatches.length ? `🚨 ops-now 봇 답 불일치 — ${mismatches.map((row) => `${row.question} 봇 ${row.botValue} / 원장 ${row.ledgerValue}`).join(' · ')} · ops-now updatedAt ${updatedAt ?? '미상'}` : null;
+  let alertDelivery: 'sent' | 'failed' | 'dry-run' | null = alert ? (options.dryRun ? 'dry-run' : 'failed') : null;
+  if (alert && !options.dryRun) {
+    try {
+      if (await (deps.send ?? sendOutbound)(alert, 'ops-alert')) alertDelivery = 'sent';
+    } catch {
+      // A throwing sender has the same undelivered outcome as a false return.
+    }
+    if (alertDelivery === 'failed') debug.log('ops-now.probe', 'alert-failed', { kind: 'ops-alert' });
+  }
+  const print = deps.print ?? console.log;
+  const warning = [
+    ...(rows.some((row) => row.verdict === 'unmeasured') ? ['⚠ 측정하지 못한 질문이 있습니다.'] : []),
+    ...(alertDelivery === 'failed' ? ['⚠ ops-alert 전송 실패'] : []),
+  ].join(' ') || null;
+  if (options.json) print(JSON.stringify({ version: version ?? null, rows, alert, alertDelivery, warning, wouldSend: Boolean(alert && options.dryRun), exitCode: mismatches.length ? 1 : 0 }));
+  else {
+    for (const row of rows) print(`${row.verdict} · ${row.question} · 봇 ${row.botValue ?? '-'} · 원장 ${row.ledgerValue ?? '-'}${row.reason ? ` · ${row.reason}` : ''}`);
+    if (warning) print(warning);
+    if (alert) {
+      if (alertDelivery === 'dry-run') print(`보냈을 것: ${alert}`);
+      else if (alertDelivery === 'sent') print(alert);
+    }
+  }
+  return { rows, exitCode: mismatches.length ? 1 : 0, alert };
+}
+
+export async function main(args: string[] = process.argv.slice(2)): Promise<number> {
+  let version: string | undefined;
+  let dryRun = false, json = false, once = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--once') once = true;
+    else if (arg === '--dry-run') dryRun = true;
+    else if (arg === '--json') json = true;
+    else if (arg === '--version' && args[i + 1] && !args[i + 1]!.startsWith('--')) version = args[++i];
+    else throw new Error(`알 수 없는 옵션: ${arg}`);
+  }
+  if (!once) throw new Error('--once 필요');
+  await registerStandaloneLogSink('ops-now-probe');
+  return (await runOpsNowProbe({ version, dryRun, json })).exitCode;
+}
+
+if (import.meta.main) {
+  try { process.exitCode = await main(); }
+  catch (error) { console.error(`ops-now-probe: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 2; }
+}

package/scripts/publish-internal-dist.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { createHash } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { spawnSyncText } from '../src/util/spawn-sync-output.js';
 
@@ -74,11 +74,21 @@ export function publishInternalDist(checkout: string, out: string, keep = 3): {
     } else {
       renameSync(staging, target);
     }
+    const alias = join(download, `v${pkg.version}`);
+    try {
+      if (!lstatSync(alias).isSymbolicLink()) throw new Error(`version alias is not a symlink: ${alias}`);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
     mkdirSync(join(out, 'latest'), { recursive: true });
     link = join(out, 'latest', `.download-${process.pid}-${Date.now()}`);
     symlinkSync(`../download/${name}`, link, 'dir');
     renameSync(link, join(out, 'latest', 'download'));
     link = undefined;
+    link = join(download, `.alias-${process.pid}-${Date.now()}`);
+    symlinkSync(name, link, 'dir');
+    renameSync(link, alias);
+    link = undefined;
     const versions = readdirSync(download, { withFileTypes: true })
       .filter((entry) => entry.isDirectory() && /^v[0-9A-Za-z][0-9A-Za-z._-]*-[0-9a-f]{12}$/.test(entry.name))
       .map((entry) => ({ name: entry.name, mtime: statSync(join(download, entry.name)).mtimeMs }))

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

@@ -4,15 +4,26 @@ import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.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';
 
 export type MetricVerdict = 'pass' | 'fail' | 'unmeasured';
-export interface ApprovalMetric { name: string; value: string; verdict: MetricVerdict }
+export interface ApprovalMetric { name: string; value: string; verdict: MetricVerdict; reason?: string }
 
 const outcomeMetric = (name: string, node: Record<string, unknown> | undefined): ApprovalMetric => ({
   name, value: node?.outcome === undefined ? 'missing' : String(node.outcome),
   verdict: node?.outcome === undefined ? 'unmeasured' : node.outcome === 'ok' ? 'pass' : 'fail',
 });
 
+/** Rows shown in auto-approval.md but never counted toward the 8 blocking metrics. */
+const WARNING_ONLY = new Set(['tui-regress', 'mac-smoke']);
+
+/** `ok` · `warn` (a failure) · `unmeasured` (error or no output) — the macOS smoke never blocks publishing. */
+function macSmokeLevel(node: Record<string, unknown> | undefined): 'ok' | 'warn' | 'unmeasured' {
+  if (node?.outcome === 'ok') return 'ok';
+  if (node?.outcome === 'fail') return 'warn';
+  return 'unmeasured';
+}
+
 export function runAutoApprove(context: GraphContext = readGraphContext(), deps: { instanceRoot?: string; repo?: string; bunVersion?: string } = {}) {
   const { version } = context.input;
   const root = deps.instanceRoot ?? effectiveInstanceRoot();
@@ -30,6 +41,8 @@ export function runAutoApprove(context: GraphContext = readGraphContext(), deps:
     catch { distCount = undefined; }
   }
   const gateErrorAbsent = gate && !Object.hasOwn(gate, 'error');
+  const regressStatus = regressWarning(validatedTuiRegress(context.outputs.tui?.regress));
+  const macSmoke = context.outputs['mac-smoke'];
   const metrics: ApprovalMetric[] = [
     { name: 'gate regressions and measurement', value: JSON.stringify({ outcome: gate?.outcome ?? null, introduced: gate?.introduced ?? null, error: gate?.error ?? null }),
       verdict: !gate || gate.outcome === undefined || !Array.isArray(gate.introduced) ? 'unmeasured'
@@ -47,16 +60,20 @@ export function runAutoApprove(context: GraphContext = readGraphContext(), deps:
     { name: 'installation files', value: `dist files=${distCount ?? 'missing'}; prepare.out=${String(out ?? 'missing')}`,
       verdict: prepare?.outcome !== 'ok' ? prepare?.outcome === undefined ? 'unmeasured' : 'fail'
         : distCount === undefined ? 'unmeasured' : distCount === 5 ? 'pass' : 'fail' },
+    // Warning-only and last, so the numbered rows 1–8 keep their places in auto-approval.md (V1g follow-up).
+    { name: 'tui-regress', value: regressStatus.level, reason: regressStatus.line, verdict: 'pass' },
+    // MAC1: the macOS smoke is warning-only too (ship with known issues) — shown, never counted.
+    { name: 'mac-smoke', value: macSmokeLevel(macSmoke), reason: typeof macSmoke?.summary === 'string' ? macSmoke.summary : undefined, verdict: 'pass' },
   ];
-  const outcome = metrics.every((metric) => metric.verdict === 'pass') ? 'ok' as const : 'fail' as const;
+  const outcome = metrics.filter((metric) => !WARNING_ONLY.has(metric.name)).every((metric) => metric.verdict === 'pass') ? 'ok' as const : 'fail' as const;
   const report = join(root, 'release', version, 'auto-approval.md');
   const lines = [`# v${version} auto-approval`, '', `Outcome: ${outcome}`, '', '| # | Metric | Value | Verdict |', '|---|---|---|---|',
-    ...metrics.map((metric, i) => `| ${i + 1} | ${metric.name} | ${metric.value.replaceAll('|', '\\|').replace(/[\r\n]/g, ' ')} | ${metric.verdict} |`),
+    ...metrics.map((metric, i) => `| ${i + 1} | ${metric.name} | ${[metric.value, metric.reason].filter(Boolean).join(' — ').replaceAll('|', '\\|').replace(/[\r\n]/g, ' ')} | ${metric.verdict} |`),
     '', '## 되돌리는 법', `gh release edit v${version} --draft`, `git tag -d v${version} && git push origin :refs/tags/v${version}`, '해당 docs PR revert', ''];
   mkdirSync(dirname(report), { recursive: true });
   writeFileSync(report, lines.join('\n'));
   debug.log('release-loop.approve', 'auto-decision', { version, outcome, metrics });
-  return { outcome, verdict: outcome === 'ok' ? 'pass' as const : 'fail' as const, summary: `auto approval ${outcome}: ${metrics.filter((metric) => metric.verdict === 'pass').length}/8`,
+  return { outcome, verdict: outcome === 'ok' ? 'pass' as const : 'fail' as const, summary: `auto approval ${outcome}: ${metrics.filter((metric) => !WARNING_ONLY.has(metric.name) && metric.verdict === 'pass').length}/8`,
     ...(outcome === 'ok' ? { decidedBy: 'release-loop metrics' as const } : {}), metrics, report };
 }
 

package/scripts/release-loop/cut-branch.ts

@@ -0,0 +1,84 @@
+import { spawnSync } 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';
+
+export interface CutBranchOptions { version: string; base: string; pick: string[]; 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 {
+  const result = spawnSync('git', args, { cwd: repo, encoding: 'utf8' });
+  if (result.status !== 0 || result.error) throw new Error(`git ${args[0]} failed: ${(result.stderr || result.error || result.stdout || 'no output').toString().trim()}`);
+  return result.stdout.trim();
+}
+
+function ancestor(repo: string, sha: string, ref: string): boolean {
+  const result = spawnSync('git', ['merge-base', '--is-ancestor', sha, ref], { cwd: repo });
+  if (result.status !== 0 && result.status !== 1) throw new Error(`git merge-base failed: ${result.error || result.stderr || 'unknown'}`);
+  return result.status === 0;
+}
+
+export function cutReleaseBranch(opts: CutBranchOptions): { branch: string; commit: string | null; dryRun: boolean } {
+  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 } : {}) });
+  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');
+    for (const sha of [opts.base, ...opts.pick]) if (!/^[0-9a-f]{7,40}$/i.test(sha)) throw new Error(`invalid commit SHA: ${sha}`);
+    git(repo, ['fetch', 'origin', 'main']);
+    const base = git(repo, ['rev-parse', '--verify', `${opts.base}^{commit}`]);
+    if (!ancestor(repo, base, 'origin/main')) throw new Error(`base ${base} is not an ancestor of origin/main`);
+    const picks = opts.pick.map((sha) => git(repo, ['rev-parse', '--verify', `${sha}^{commit}`]));
+    for (const sha of picks) if (!ancestor(repo, sha, 'origin/main')) throw new Error(`pick ${sha} is not an ancestor of origin/main`);
+    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`);
+    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)' : ''}`);
+    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]);
+      added = true;
+      for (const sha of picks) {
+        try { git(tree, ['cherry-pick', sha]); }
+        catch (error) {
+          const files = git(tree, ['diff', '--name-only', '--diff-filter=U']);
+          if (!files) throw error;
+          report('conflict', `cherry-pick ${sha}`);
+          throw new Error(`cherry-pick ${sha} 충돌 — 손으로 풀 곳: ${files.split('\n').join(', ')} (release/${opts.version} 가지는 만들지 않음)`);
+        }
+      }
+      commit = git(tree, ['rev-parse', 'HEAD']);
+      const finalPackage = JSON.parse(git(tree, ['show', 'HEAD:package.json'])) as { version?: unknown };
+      if (finalPackage.version !== opts.version) throw new Error(`picked branch package.json version ${finalPackage.version} is not ${opts.version}`);
+    } finally {
+      try {
+        if (added) git(repo, ['worktree', 'remove', '--force', tree]);
+      } 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 [flag, ref, summary] = line.split('\t');
+      return flag === '*' && ref?.endsWith(`:refs/heads/${branch}`) && summary === '[new branch]';
+    });
+    if (!newBranch) throw new Error(`${branch} already exists on origin (push did not create a new branch)`);
+    report('created', undefined, commit);
+    log(`${branch} → ${commit}`);
+    return { branch, commit, dryRun: false };
+  } catch (error) {
+    if (!(error instanceof Error && error.message.includes('충돌'))) report('refused', error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}

package/scripts/release-loop/cutoff.ts

@@ -62,20 +62,30 @@ function landingAt(sha: string, title: string): ReleaseLanding {
   };
 }
 
-/** next.md lines at the cutoff, each tied to the last landing in range whose diff added that exact line. */
-function nextMdNotes(cutoff: string, landings: ReleaseLanding[]): NextMdNote[] {
+/**
+ * next.md lines added between the baseline and the cutoff, each tied to the last landing in range whose diff added that
+ * exact line. Lines already in the file at the baseline shipped with an earlier release and are left out (REL7b).
+ */
+function nextMdNotes(baseline: string, cutoff: string, landings: ReleaseLanding[]): { notes: NextMdNote[]; carried: number } {
   const text = git(['show', `${cutoff}:${NEXT_MD}`], true);
-  if (!text) return [];
+  if (!text) return { notes: [], carried: 0 };
+  const inRange = new Set(addedLines(requiredGit(['diff', '-U0', baseline, cutoff, '--', NEXT_MD])));
   const addedBy = new Map<string, string>();
   for (const landing of landings) {
     if (!landing.changedFiles.includes(NEXT_MD)) continue;
     const diff = requiredGit(['show', '-m', '--first-parent', '--format=', '-U0', landing.sha, '--', NEXT_MD]);
-    for (const line of diff.split('\n')) if (line.startsWith('+') && !line.startsWith('+++')) addedBy.set(line.slice(1).trim(), landing.sha);
+    for (const line of addedLines(diff)) addedBy.set(line, landing.sha);
   }
-  return parseNextMdNotes(text).map((note) => {
-    const sha = note.raw ? addedBy.get(note.raw) : undefined;
+  const all = parseNextMdNotes(text);
+  const notes = all.filter((note) => note.raw !== undefined && inRange.has(note.raw)).map((note) => {
+    const sha = addedBy.get(note.raw!);
     return { kind: note.kind, line: note.line, ...(sha ? { sha } : {}) };
   });
+  return { notes, carried: all.length - notes.length };
+}
+
+function addedLines(diff: string): string[] {
+  return diff.split('\n').filter((line) => line.startsWith('+') && !line.startsWith('+++')).map((line) => line.slice(1).trim());
 }
 
 function runningGoalPaths(): string[] {
@@ -135,12 +145,13 @@ export function main(args: string[] = process.argv.slice(2)): void {
   const instanceRoot = effectiveInstanceRoot();
   const notes = readReleaseNotes(releaseNotesDir(instanceRoot));
   debug.log('release.notes', 'read', { fragments: notes.size, problems: notes.problems });
+  const nextMd = nextMdNotes(baselineSha, cutoff, landings);
   const manifest = buildReleaseManifest({
-    version, baseline: { ref: baseline.ref, sha: baselineSha }, cutoff: { sha: cutoff }, landings, notes, nextMd: nextMdNotes(cutoff, landings),
+    version, baseline: { ref: baseline.ref, sha: baselineSha }, cutoff: { sha: cutoff }, landings, notes, nextMd: nextMd.notes,
     runningGoalPaths: runningGoalPaths(), publicCommandsBefore: commandsAt(baselineSha), publicCommandsAfter: commandsAt(cutoff),
   });
   const output = { ...manifest, baselineSource: baseline.source };
-  debug.log('release-loop.notes', 'fragments', { version, ...manifest.fragments });
+  debug.log('release-loop.notes', 'fragments', { version, ...manifest.fragments, carriedFromEarlier: nextMd.carried });
   const directory = join(instanceRoot, 'release', version);
   mkdirSync(directory, { recursive: true });
   writeFileSync(join(directory, 'manifest.json'), JSON.stringify(output, null, 2) + '\n');

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

@@ -125,13 +125,14 @@ export const POD_MEMORY_SOURCE = 'docs/measurements/td1-whole-gate-mechanical-20
 export const POD_SHARD_FILE_CAP = 27;
 
 export const POD_SWEEP_INTEGRATION_ONLY: readonly string[] = ['scripts/install.test.ts'];
-/** Whole-repository audits run alone in the nightly test-diet graph, not in release-gate shards. */
+/** Nightly-only whole-repository cases; gate runs the fixture cases in these same files. */
 export const GATE_NIGHTLY_AUDITS: readonly string[] = [
-  'test/f12-sweep.test.ts', // Sweeps the whole repository; 7.8 GB even after TD1a.
-  'scripts/unwired-exports.test.ts', // Compiles and scans all exports; 9.9 GB.
-  'test/guardian/dispatch-surface-contract.test.ts', // Compiles repository-wide dispatch contracts; 8.3 GB.
-  'test/pwa-build-typecheck.test.ts', // Builds and typechecks the whole PWA; 4.2 GB.
-  'test/user-config-mcp.test.ts', // 2.1 GB peak; keep the gate below the 2 GB audit budget.
+  // Replaces F12's real-repo bucket B apps/pwa scope check and its whole-repo export partition check.
+  'test/f12-sweep.test.ts',
+  // Replaces unwired-exports' real src/oauth caller check and its src/ad-pipeline CLI scan.
+  'scripts/unwired-exports.test.ts',
+  // Replaces pwa-build-typecheck's full root tsc and PWA tsc sweeps (PWA build also runs in the release loop).
+  'test/pwa-build-typecheck.test.ts',
 ];
 const tail40 = (output: string) => output.trimEnd().split(/\r?\n/).slice(-40).join('\n');
 const lastStartedTestFile = (output: string, paths: string[]): string | undefined => {
@@ -219,15 +220,15 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     // CDP 시험은 `test:deterministic` 이 스스로 뺀다 — 조각에 그것만 남으면 bun «시험 없음» exit 1 을 «불완전»으로 읽었다(09-30 G1d 실측 둘).
     // bun 의 탐색은 숨은 디렉터리(`.x/`)를 안 연다 — 사람의 `bun test` 가 한 번도 안 돌리는 빈 픽스처가 조각에 혼자 남아 «Ran 0 tests» 를 «불완전»으로 읽었다(09-30 G1e 5번 조각).
     const assignable = files.filter((file) => !cdpPatterns.includes(file) && !POD_SWEEP_INTEGRATION_ONLY.includes(file)
-      && !GATE_NIGHTLY_AUDITS.includes(file) && !file.split('/').some((part) => part.startsWith('.')));
+      && !file.split('/').some((part) => part.startsWith('.')));
     const integrationOnly = files.filter((file) => POD_SWEEP_INTEGRATION_ONLY.includes(file));
     if (integrationOnly.length) debug.log('release-loop.gate', 'pod-sweep-integration-only', { files: integrationOnly });
-    const nightlyAudits = files.filter((file) => GATE_NIGHTLY_AUDITS.includes(file));
-    if (nightlyAudits.length) debug.log('release-loop.gate', 'pod-sweep-nightly-audit', { files: nightlyAudits });
     if (!assignable.length) throw new Error('sweep incomplete: no tests ran');
     const durations = pod.durationSource ? readFileDurations(pod.durationSource) : new Map<string, number>();
     const memory = readFileMemory(join(tree, POD_MEMORY_SOURCE));
-    const heavy = new Set(assignable.filter((file) => (memory.get(file) ?? 0) >= POD_HEAVY_FILE_MB));
+    // The TD1 measurements predate the fixture-only gate; do not isolate those five files at their old 2–13 GB peaks.
+    const fixtureOnly = new Set([...GATE_NIGHTLY_AUDITS, 'test/guardian/dispatch-surface-contract.test.ts', 'test/user-config-mcp.test.ts']);
+    const heavy = new Set(assignable.filter((file) => !fixtureOnly.has(file) && (memory.get(file) ?? 0) >= POD_HEAVY_FILE_MB));
     const light = assignable.filter((file) => !heavy.has(file));
     const shards = [
       ...(light.length ? planShards(light, durations, shardCount) : []),
@@ -437,9 +438,9 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
       const outputs: string[] = [];
       let total = { pass: 0, fail: 0, errors: 0, ran: 0, files: 0 };
       for (const group of groups) {
-        if (!group.paths.length || !files.some((f) => !GATE_NIGHTLY_AUDITS.includes(f) && group.paths.some((p) => f === p || f.startsWith(`${p}/`)))) continue;
+        if (!group.paths.length || !files.some((f) => group.paths.some((p) => f === p || f.startsWith(`${p}/`)))) continue;
         const start = Date.now();
-        const groupIgnores = [...new Set([...cdpPatterns, ...GATE_NIGHTLY_AUDITS])]
+        const groupIgnores = [...new Set(cdpPatterns)]
           .filter((pattern) => files.includes(pattern) && group.paths.some((p) => pattern === p || pattern.startsWith(`${p}/`)))
           .flatMap((pattern) => ['--path-ignore-patterns', pattern]);
         const run = await command('bun', ['run', 'test:deterministic', ...groupIgnores, ...group.paths.map(asPath)], tree);
@@ -508,7 +509,7 @@ function readBaseline(root: string, version: string): { commit: string; failures
   return record;
 }
 
-function baselineCommit(root: string, version: string): string {
+export function baselineCommit(root: string, version: string): string {
   const path = join(root, 'release', version, 'release.json');
   const manifest: unknown = JSON.parse(readFileSync(path, 'utf8'));
   const commit = manifest && typeof manifest === 'object' && 'sourceCommit' in manifest ? manifest.sourceCommit : undefined;