elanous 0.2.8 → 0.2.10

package/scripts/storyboard/storyboard.ts

@@ -1,167 +1,11 @@
 #!/usr/bin/env bun
-// 스토리보드 정본(storyboards/<kind>/<id>.yaml) — 검사 ⊕ MD 뽑기 (대표 10-01 23:0x · OP 형식 결정 = YAML 정본 ⊕ 스키마 ⊕ 생성 MD).
-//   bun scripts/storyboard/storyboard.ts lint [파일…]     스키마 필수 칸 · 시간 겹침 · 화면 문구 출처 · 승인본 규칙
-//   bun scripts/storyboard/storyboard.ts render [파일…]   내부 문서 `STORYBOARD-<id>-v<version>` 를 다시 쓴다(손으로 안 고친다)
-// 인자가 없으면 storyboards/ 아래 전부. lint 는 오류가 있으면 rc 1, 경고만이면 rc 0.
-import { readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { join, relative, resolve } from 'node:path';
-import { parse } from 'yaml';
-
-const ROOT = resolve(import.meta.dir, '../..');
-const DIR = join(ROOT, 'storyboards');
-
-type Text = { text: string; source: string; ref?: string };
-type Shot = {
-  id: string; t: [number, number]; stage: string; layer?: string; persona?: string; purpose: string; subject?: string; action?: string;
-  camera?: { move?: string; lens_mm?: number; angle?: string; framing?: string }; lighting?: string; color?: string;
-  transition_in?: { type: string; intent: string }; on_screen_text?: Text[]; audio?: { vo?: string; sfx?: string; bgm?: string };
-  generation?: { tool: string; model?: string; prompt?: string; asset?: string }; real_or_staged: string; state: string; notes?: string;
-};
-/** kind: site — a site's page structure, menu and copy draft, planned like a storyboard (SITE2 · 10-02). */
-type Section = { id: string; title: string; purpose: string; change: string; copy?: Text[]; notes?: string };
-type Site = { domain: string; role: string; preview?: string; branch?: string; nav: Array<{ label: string; href: string }>; pages: Array<{ path: string; sections: Section[] }> };
-export type Storyboard = {
-  id: string; kind: string; title: string; version: number; status: string; approved?: { by: string; at: string; note?: string } | null;
-  supersedes?: string; owner: string; directive?: string; format: { aspects: string[]; duration_s: number; fps?: number; loop?: boolean; surface?: string };
-  scqa?: { s?: string; c?: string; q?: string; a?: string }; principles?: string[]; layers?: Record<string, string>; shots: Shot[]; sites?: Site[];
-  references?: string[]; open_questions?: string[];
-};
-
-const KINDS = ['teaser', 'site-hero', 'event-demo', 'persona-scene', 'explainer', 'ad', 'site'];
-const CHANGES = ['keep', 'move', 'new', 'replace', 'remove'];
-const STAGES = ['hook', 'buildup', 'climax', 'transition', 'end', 'loop'];
-const SOURCES = ['real-ui', 'real-cli', 'real-output', 'copy', 'example'];
-
-export function lint(sb: Storyboard, file = ''): { errors: string[]; warnings: string[] } {
-  const errors: string[] = [], warnings: string[] = [];
-  const need = (cond: unknown, msg: string) => { if (!cond) errors.push(msg); };
-  need(/^[a-z0-9][a-z0-9-]{2,80}$/.test(sb.id ?? ''), 'id: 소문자·숫자·하이픈 3~80자');
-  need(KINDS.includes(sb.kind), `kind: ${KINDS.join('|')}`);
-  need(Number.isInteger(sb.version) && sb.version >= 1, 'version: 1 이상 정수');
-  need(['draft', 'approved', 'superseded'].includes(sb.status), 'status: draft|approved|superseded');
-  need(sb.owner, 'owner 필요');
-  if (sb.status === 'approved') need(sb.approved?.by && sb.approved?.at, '승인본은 approved.by·at 필요');
-  if (file && sb.kind && !file.includes(`/${sb.kind}/`)) errors.push(`파일 위치가 kind(${sb.kind}) 폴더가 아니다`);
-  if (sb.kind === 'site') return lintSite(sb, errors, warnings);
-  need(sb.format?.aspects?.length && sb.format.duration_s > 0, 'format.aspects ⊕ duration_s 필요');
-  if (!Array.isArray(sb.shots) || !sb.shots.length) { errors.push('shots 가 비었다'); return { errors, warnings }; }
-  const ids = new Set<string>();
-  sb.shots.forEach((s, i) => {
-    const at = `shots[${i}](${s.id ?? '?'})`;
-    need(s.id && !ids.has(s.id), `${at}: id 없음·중복`); ids.add(s.id);
-    need(Array.isArray(s.t) && s.t.length === 2 && s.t[0] < s.t[1], `${at}: t = [시작, 끝] 이고 시작 < 끝`);
-    need(STAGES.includes(s.stage), `${at}: stage ${STAGES.join('|')}`);
-    need(s.purpose, `${at}: purpose(이 비트의 한 가지) 필요`);
-    need(['real', 'staged', 'composite'].includes(s.real_or_staged), `${at}: real_or_staged 필요`);
-    need(['planned', 'shot', 'approved'].includes(s.state), `${at}: state planned|shot|approved`);
-    if (s.transition_in && !s.transition_in.intent) errors.push(`${at}: 전환에는 의도 한 줄(«그냥 컷»은 설계가 아니다)`);
-    for (const txt of s.on_screen_text ?? []) {
-      need(SOURCES.includes(txt.source), `${at}: 화면 문구 «${txt.text}» 의 source 가 ${SOURCES.join('|')} 가 아니다`);
-      if (txt.source?.startsWith('real-') && !txt.ref) warnings.push(`${at}: 실제 문면 «${txt.text}» 에 ref(출처) 가 없다`);
-      if (/\d/.test(txt.text) && txt.source === 'copy') warnings.push(`${at}: 마케팅 문구에 숫자 «${txt.text}» — 실측 근거나 «example» 로`);
-    }
-    if (s.generation?.tool === 'higgsfield' && !s.generation.prompt) warnings.push(`${at}: 힉스필드 샷에 prompt 가 없다`);
-    if (s.real_or_staged !== 'real' && !/연출/.test(JSON.stringify(sb))) warnings.push(`${at}: 연출 샷이 있는데 문서 어디에도 «연출 장면» 표기가 없다`);
-  });
-  const end = Math.max(...sb.shots.map((s) => s.t?.[1] ?? 0));
-  if (sb.format?.duration_s && Math.abs(end - sb.format.duration_s) > 0.5) warnings.push(`마지막 샷 끝(${end}s) ≠ format.duration_s(${sb.format.duration_s}s)`);
-  return { errors, warnings };
-}
-
-/** A site plan has pages instead of shots: every section says why it is there and what changes; copy names its source. */
-function lintSite(sb: Storyboard, errors: string[], warnings: string[]): { errors: string[]; warnings: string[] } {
-  if (!Array.isArray(sb.sites) || !sb.sites.length) { errors.push('site 종류는 sites 가 필요하다'); return { errors, warnings }; }
-  for (const site of sb.sites) {
-    const at = `sites(${site.domain ?? '?'})`;
-    if (!site.domain || !site.role) errors.push(`${at}: domain ⊕ role(이 사이트가 맡는 것) 필요`);
-    if (!site.nav?.length) errors.push(`${at}: nav(메뉴) 필요`);
-    if (!site.pages?.length) errors.push(`${at}: pages 필요`);
-    if (!site.preview) warnings.push(`${at}: preview(미리보기 주소) 없음`);
-    const ids = new Set<string>();
-    for (const page of site.pages ?? []) for (const sec of page.sections ?? []) {
-      const where = `${at}${page.path} #${sec.id ?? '?'}`;
-      if (!sec.id || ids.has(`${page.path}#${sec.id}`)) errors.push(`${where}: id 없음·중복`);
-      ids.add(`${page.path}#${sec.id}`);
-      if (!sec.purpose) errors.push(`${where}: purpose(이 칸이 하는 한 가지) 필요`);
-      if (!CHANGES.includes(sec.change)) errors.push(`${where}: change ${CHANGES.join('|')}`);
-      for (const txt of sec.copy ?? []) {
-        if (!SOURCES.includes(txt.source)) errors.push(`${where}: 문구 «${txt.text}» 의 source 가 ${SOURCES.join('|')} 가 아니다`);
-        if (/\d/.test(txt.text) && txt.source === 'copy' && !txt.ref) warnings.push(`${where}: 마케팅 문구에 숫자 «${txt.text}» — ref(실측 근거) 를 단다`);
-      }
-    }
-  }
-  return { errors, warnings };
-}
-
-function renderSites(sb: Storyboard): string[] {
-  return (sb.sites ?? []).flatMap((site) => [
-    `## ${site.domain} — ${site.role}`, '',
-    ...(site.preview ? [`- 미리보기: ${site.preview}${site.branch ? ` (가지 \`${site.branch}\`)` : ''}`] : []),
-    `- 메뉴: ${site.nav.map((n) => `${n.label}(${n.href})`).join(' · ')}`, '',
-    ...site.pages.flatMap((page) => [
-      `### ${page.path}`, '', '| # | 칸 | 제목 | 목적 | 바뀜 | 문구(출처) | 메모 |', '|---|---|---|---|---|---|---|',
-      ...page.sections.map((sec, i) => `| ${i + 1} | ${md(sec.id)} | ${md(sec.title)} | ${md(sec.purpose)} | ${sec.change} | ${md((sec.copy ?? []).map((x) => `«${x.text}»(${x.source}${x.ref ? ` · ${x.ref}` : ''})`).join(' / '))} | ${md(sec.notes)} |`),
-      '',
-    ]),
-  ]);
-}
-
-const md = (v: unknown) => String(v ?? '').replace(/\|/g, '\\|').replace(/\n+/g, ' ');
-export function render(sb: Storyboard, file: string): string {
-  const head = [
-    `# STORYBOARD — ${sb.title} (v${sb.version} · ${sb.status}${sb.approved ? ` · 승인 ${sb.approved.by} ${sb.approved.at}` : ''})`,
-    '',
-    `> ⛔ 자동 생성 — 손으로 고치지 않는다. 정본 = \`${file}\` · 다시 뽑기 = \`bun scripts/storyboard/storyboard.ts render ${file}\`.`,
-    `> 종류 ${sb.kind} · 소유 ${sb.owner}${sb.format ? ` · ${sb.format.aspects.join(' · ')} · ${sb.format.duration_s}초${sb.format.loop ? ' · 반복' : ''}${sb.format.surface ? ` · ${sb.format.surface}` : ''}` : ''}${sb.supersedes ? ` · 앞 판 ${sb.supersedes}` : ''}`,
-    ...(sb.directive ? [`> 지시: ${sb.directive}`] : []),
-    '',
-  ];
-  const scqa = sb.scqa ? ['## SCQA', ...(['s', 'c', 'q', 'a'] as const).filter((k) => sb.scqa?.[k]).map((k) => `- **${k.toUpperCase()}** — ${sb.scqa![k]}`), ''] : [];
-  const pr = sb.principles?.length ? ['## 원칙', ...sb.principles.map((p, i) => `${i + 1}. ${p}`), ''] : [];
-  const layers = sb.layers ? ['## 층', ...Object.entries(sb.layers).map(([k, v]) => `- **${k}** — ${v}`), ''] : [];
-  const table = sb.kind === 'site' ? renderSites(sb) : [
-    '## 샷 구조표',
-    '| # | 초 | 단계 | 층·인물 | 목적 | 화면(피사체·행동) | 카메라 | 빛·색 | 전환(의도) | 화면 문구(출처) | 소리 | 만들기 | 실물/연출 · 상태 |',
-    '|---|---|---|---|---|---|---|---|---|---|---|---|---|',
-    ...sb.shots.map((s) => `| ${md(s.id)} | ${s.t[0]}–${s.t[1]} | ${s.stage} | ${md([s.layer, s.persona].filter(Boolean).join(' · '))} | ${md(s.purpose)} | ${md([s.subject, s.action].filter(Boolean).join(' — '))} | ${md(s.camera ? [s.camera.move, s.camera.lens_mm ? `${s.camera.lens_mm}mm` : '', s.camera.angle, s.camera.framing].filter(Boolean).join(' · ') : '')} | ${md([s.lighting, s.color].filter(Boolean).join(' · '))} | ${md(s.transition_in ? `${s.transition_in.type} — ${s.transition_in.intent}` : '')} | ${md((s.on_screen_text ?? []).map((x) => `«${x.text}»(${x.source}${x.ref ? ` · ${x.ref}` : ''})`).join(' / '))} | ${md(s.audio ? [s.audio.vo && `VO ${s.audio.vo}`, s.audio.sfx && `SFX ${s.audio.sfx}`, s.audio.bgm && `BGM ${s.audio.bgm}`].filter(Boolean).join(' · ') : '')} | ${md(s.generation ? [s.generation.tool, s.generation.model].filter(Boolean).join(' · ') : '')} | ${s.real_or_staged} · ${s.state} |`),
-    '',
-  ];
-  const shots = sb.shots ?? [];
-  const prompts = shots.filter((s) => s.generation?.prompt);
-  const pblock = prompts.length ? ['## 생성 프롬프트', ...prompts.flatMap((s) => [`### ${s.id} · ${s.generation!.tool}${s.generation!.model ? ` · ${s.generation!.model}` : ''}`, '```', s.generation!.prompt!.trim(), '```', ...(s.generation!.asset ? [`결과: \`${s.generation!.asset}\``] : []), ''])] : [];
-  const notes = shots.filter((s) => s.notes).map((s) => `- ${s.id}: ${s.notes}`);
-  const tail = [
-    ...(notes.length ? ['## 샷 메모', ...notes, ''] : []),
-    ...(sb.open_questions?.length ? ['## 열린 물음', ...sb.open_questions.map((q) => `- ${q}`), ''] : []),
-    ...(sb.references?.length ? ['## 참고', ...sb.references.map((r) => `- ${r}`), ''] : []),
-  ];
-  return [...head, ...scqa, ...pr, ...layers, ...table, ...pblock, ...tail].join('\n');
-}
-
-function files(args: string[]): string[] {
-  if (args.length) return args.map((a) => resolve(a));
-  const out: string[] = [];
-  const walk = (d: string) => { for (const f of readdirSync(d)) { const p = join(d, f); if (statSync(p).isDirectory()) walk(p); else if (/\.ya?ml$/.test(f) && !f.startsWith('_')) out.push(p); } };
-  walk(DIR);
-  return out.sort();
-}
+// 스토리보드 정본 검사 ⊕ MD 생성. 기존 bun scripts/storyboard/storyboard.ts lint|render 지원.
+import { runStoryboard } from '../../src/cli/storyboard-cli.js';
+export { lint, render } from '../../src/storyboard/storyboard.js';
+export type { Storyboard } from '../../src/storyboard/storyboard.js';
 
 if (import.meta.main) {
   const [cmd, ...rest] = process.argv.slice(2);
   if (cmd !== 'lint' && cmd !== 'render') { console.error('usage: storyboard.ts lint|render [files…]'); process.exit(2); }
-  let bad = 0;
-  for (const f of files(rest)) {
-    const rel = relative(ROOT, f);
-    const sb = parse(readFileSync(f, 'utf8')) as Storyboard;
-    const { errors, warnings } = lint(sb, rel);
-    for (const e of errors) console.log(`✗ ${rel}: ${e}`);
-    for (const w of warnings) console.log(`⚠ ${rel}: ${w}`);
-    if (errors.length) { bad++; continue; }
-    if (cmd === 'render') {
-      const out = join(ROOT, 'docs', 'marketing', `STORYBOARD-${sb.id}-v${sb.version}.md`);
-      writeFileSync(out, render(sb, rel) + '\n');
-      console.log(`✓ ${rel} → ${relative(ROOT, out)}`);
-    } else console.log(`✓ ${rel} · v${sb.version} · ${sb.status} · ${sb.kind === 'site' ? `사이트 ${sb.sites?.length ?? 0}` : `샷 ${sb.shots.length}`}`);
-  }
-  process.exit(bad ? 1 : 0);
+  process.exitCode = runStoryboard(cmd, rest);
 }

package/scripts/test-diet/lib.ts

@@ -9,7 +9,9 @@ export const HEAVY_MB = 2048;
 
 export interface Measurement { file: string; secs: number; rssMb: number | null; rc: number | null; pass: number | null; fail: number | null; reason?: string }
 export type Verdict = 'keep' | 'failing' | 'review';
-export interface Judged extends Measurement { caught90: number; flags: string[]; verdict: Verdict }
+export type Proposal = 'delete' | 'shrink' | 'rewrite-cheap' | 'move-out-of-gate' | 'investigate';
+export interface Td1Disposition { disposition: string; alternative: string; guards: string; why_slow: string }
+export interface Judged extends Measurement { caught90: number; flags: string[]; verdict: Verdict; proposal?: Proposal | null; basis?: string | null }
 export interface LedgerLine { at: string; range: string; start: number; end: number; next: number; total: number; commit: string; budgetSecs: number; results: Judged[] }
 
 /** `file\tsecs\t…` (TD1 whole-gate TSV) → seconds per file. */
@@ -23,6 +25,33 @@ export function costTable(tsv: string): Map<string, number> {
   return costs;
 }
 
+/** TD1's human-reviewed dispositions, resolved by column name rather than TSV position. */
+export function td1Dispositions(tsv: string): Map<string, Td1Disposition> {
+  const [header, ...rows] = tsv.trimEnd().split('\n');
+  const columns = header?.replace(/\r$/, '').split('\t') ?? [];
+  const index = (name: string) => columns.indexOf(name);
+  const result = new Map<string, Td1Disposition>();
+  for (const row of rows) {
+    const cells = row.replace(/\r$/, '').split('\t');
+    const get = (name: string) => cells[index(name)] ?? '';
+    if (get('file') && get('disposition')) result.set(get('file'), {
+      disposition: get('disposition'), alternative: get('alternative'), guards: get('guards'), why_slow: get('why_slow'),
+    });
+  }
+  return result;
+}
+
+export function propose(judged: Judged, td1: ReadonlyMap<string, Td1Disposition>): Judged {
+  const reviewed = td1.get(judged.file);
+  if (reviewed) {
+    const proposal = reviewed.disposition === 'keep' ? null : reviewed.disposition as Proposal;
+    return { ...judged, proposal, basis: proposal ? [reviewed.alternative, reviewed.why_slow, reviewed.guards && `guards: ${reviewed.guards}`].filter(Boolean).join(' · ') : null };
+  }
+  if (judged.verdict === 'failing') return { ...judged, proposal: 'investigate', basis: `failing (rc=${judged.rc}) · caught90=${judged.caught90}` };
+  if (judged.verdict === 'review') return { ...judged, proposal: 'shrink', basis: `${judged.flags.join(', ')} · caught90=${judged.caught90}` };
+  return { ...judged, proposal: null, basis: null };
+}
+
 /** Next slice from the cursor until the known cost reaches the budget (at least one file; wraps at the end). */
 export function pickRange(files: readonly string[], start: number, costs: ReadonlyMap<string, number>, budgetSecs: number): { start: number; end: number; next: number; files: string[]; estimatedSecs: number } {
   if (files.length === 0) return { start: 0, end: -1, next: 0, files: [], estimatedSecs: 0 };
@@ -51,6 +80,7 @@ export function judge(m: Measurement, caught90: number): Judged {
 }
 
 export function ledgerPath(root: string): string { return join(root, 'test-diet', 'ledger.jsonl'); }
+export function nightlyAuditLedgerPath(root: string): string { return join(root, 'test-diet', 'nightly-audit.jsonl'); }
 
 export function lastLedgerLine(root: string): LedgerLine | null {
   const path = ledgerPath(root);

package/scripts/test-diet/node.ts

@@ -1,19 +1,22 @@
 #!/usr/bin/env bun
 // TD2 graph nodes: pick → measure → record. Shadow only — measures alone on a remote host and drafts a card.
-//   bun scripts/test-diet/node.ts pick|measure|record   (inside `elanous graph run graphs/test-diet/test-diet.yaml`)
+//   bun scripts/test-diet/node.ts pick|measure|audit|record (test-diet or nightly-audit graph)
 import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
-import { appendLedger, costTable, judge, lastLedgerLine, pickRange, writeCardDraft, type Measurement } from './lib.js';
+import { CardStore } from '../../src/task-cards/card-store.js';
+import { GATE_NIGHTLY_AUDITS } from '../release-loop/gate-node.js';
+import { appendLedger, costTable, judge, lastLedgerLine, ledgerPath, nightlyAuditLedgerPath, pickRange, propose, td1Dispositions, writeCardDraft, type LedgerLine, type Measurement, type Td1Disposition } from './lib.js';
 
-type Context = { input: Record<string, unknown>; outputs: Record<string, Record<string, unknown>> };
+type Context = { graphId?: string; input: Record<string, unknown>; outputs: Record<string, Record<string, unknown> | null> };
 function context(): Context {
   const at = process.env.ELANOUS_GRAPH_CONTEXT;
   if (!at) throw new Error('ELANOUS_GRAPH_CONTEXT required');
   const raw = JSON.parse(at.trimStart().startsWith('{') ? at : readFileSync(at, 'utf8')) as Partial<Context>;
-  return { input: raw.input ?? {}, outputs: raw.outputs ?? {} };
+  return { graphId: raw.graphId, input: raw.input ?? {}, outputs: raw.outputs ?? {} };
 }
 function emit(result: Record<string, unknown> & { outcome: 'ok' | 'fail' | 'error'; summary: string }): number {
   console.log(JSON.stringify({ verdict: result.outcome === 'ok' ? 'pass' : 'fail', ...result }));
@@ -34,8 +37,8 @@ function pick(ctx: Context): number {
 }
 
 /** One remote run: shallow clone of the mirror, one install, each file alone with its peak memory. */
-function measure(ctx: Context): number {
-  const picked = ctx.outputs.pick?.files;
+function measure(ctx: Context, audit = false): number {
+  const picked = audit ? [...GATE_NIGHTLY_AUDITS] : ctx.outputs.pick?.files;
   if (!Array.isArray(picked) || picked.length === 0) return emit({ outcome: 'fail', summary: 'nothing picked' });
   const host = typeof ctx.input.remote === 'string' ? ctx.input.remote : 'node-b';
   const mirror = typeof ctx.input.mirror === 'string' ? ctx.input.mirror : '~/mirror/elanous-agent.git';
@@ -59,26 +62,67 @@ function measure(ctx: Context): number {
     // A failing file names its first error, so an environment gap (e.g. no Java on the host) is not read as a test defect.
     '  why=""; [ "$rc" -ne 0 ] && why=$(grep -v -E "^\\s*$|^bun test|^ *[0-9]+ \\||^error: *$" "$T/err" | grep -m1 -E "Unable to|Cannot find|not found|ENOENT|EACCES|rror" | tr "\\t" " " | cut -c1-160)',
     '  printf "M\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\t%s\\n" "$f" "$e" "${rss:-}" "$rc" "${pass:-}" "${fail:-}" "$why"',
-    'done',
+    "done <<'TEST_DIET_FILES'", ...picked, 'TEST_DIET_FILES',
   ].join('\n');
-  const run = spawnSync('ssh', ['-o', 'BatchMode=yes', host, 'bash', '-s'], { input: `${script}\n${picked.join('\n')}\n`, encoding: 'utf8', timeout: 4 * 3600_000, maxBuffer: 16 * 1024 * 1024 });
-  // The file list follows the script on stdin; `read` in the loop consumes it.
-  if (run.status !== 0 && !String(run.stdout).includes('\nM\t')) return emit({ outcome: 'error', summary: `remote measure failed (rc=${run.status}): ${String(run.stderr).trim().slice(0, 200)}` });
-  const commit = /^COMMIT (\w+)/m.exec(run.stdout)?.[1] ?? '?';
+  const run = spawnSync('ssh', ['-o', 'BatchMode=yes', host, 'bash', '-s'], { input: `${script}\n`, encoding: 'utf8', timeout: 4 * 3600_000, maxBuffer: 16 * 1024 * 1024 });
+  const remoteError = run.status !== 0 ? `remote measure failed (rc=${run.status ?? 'no exit'}): ${String(run.error ?? run.stderr ?? '').trim().slice(0, 200)}` : undefined;
+  if (!audit && remoteError && !String(run.stdout).includes('\nM\t')) return emit({ outcome: 'error', summary: remoteError });
+  const commit = /^COMMIT (\w+)/m.exec(String(run.stdout))?.[1] ?? '?';
   const measurements: Measurement[] = String(run.stdout).split('\n').filter((l) => l.startsWith('M\t')).map((l) => {
     const [, file, secs, rss, rc, pass, fail, why] = l.split('\t');
     const num = (v: string | undefined) => (v === undefined || v === '' ? null : Number(v));
     return { file: file!, secs: Number(secs), rssMb: num(rss), rc: num(rc), pass: num(pass), fail: num(fail), ...(why ? { reason: why } : {}) };
   });
-  return emit({ outcome: measurements.length ? 'ok' : 'error', summary: `measured ${measurements.length}/${picked.length} on ${host} at ${commit.slice(0, 9)}`, host, commit, measurements });
+  const complete = measurements.length === picked.length && picked.every((file) => measurements.some((m) => m.file === file));
+  const summary = remoteError ?? `measured ${measurements.length}/${picked.length} on ${host} at ${commit.slice(0, 9)}`;
+  return emit({ outcome: audit ? complete && !remoteError ? 'ok' : 'error' : measurements.length ? 'ok' : 'error',
+    summary, host, commit, measurements, ...(remoteError ? { remoteError } : {}) });
 }
 
-function record(ctx: Context): number {
+function recordNightlyAudit(ctx: Context): number {
+  const m = ctx.outputs.audit;
+  const raw = Array.isArray(m?.measurements) ? m.measurements : [];
+  const measured = new Map<string, Measurement>();
+  for (const item of raw) {
+    if (!item || typeof item !== 'object' || !('file' in item) || typeof item.file !== 'string' || !GATE_NIGHTLY_AUDITS.includes(item.file)) continue;
+    const x = item as Partial<Measurement>;
+    if (measured.has(item.file) || typeof x.secs !== 'number' || !Number.isFinite(x.secs)
+      || (x.rssMb !== null && (typeof x.rssMb !== 'number' || !Number.isFinite(x.rssMb)))
+      || (x.rc !== null && (typeof x.rc !== 'number' || !Number.isInteger(x.rc)))
+      || (x.pass !== null && (typeof x.pass !== 'number' || !Number.isInteger(x.pass)))
+      || (x.fail !== null && (typeof x.fail !== 'number' || !Number.isInteger(x.fail)))) continue;
+    measured.set(item.file, x as Measurement);
+  }
+  const error = typeof m?.remoteError === 'string' ? m.remoteError
+    : m?.outcome === 'error' || m?.outcome === 'fail' || !m
+      ? typeof m?.summary === 'string' ? m.summary : 'audit execution produced no result' : undefined;
+  const results = GATE_NIGHTLY_AUDITS.map((file, index) => {
+    const found = measured.get(file);
+    const measurement: Measurement = found ?? { file, secs: 0, rssMb: null, rc: null, pass: null, fail: null,
+      reason: `not measured: ${typeof m?.summary === 'string' ? m.summary : error ?? 'audit result missing'}` };
+    // Even a complete set of file outputs cannot prove a clean audit when the remote process failed afterward.
+    return judge(error && measured.size === GATE_NIGHTLY_AUDITS.length && index === 0 && found
+      ? { ...found, rc: found.rc === 0 ? null : found.rc, reason: `${error}${found.reason ? `; ${found.reason}` : ''}` } : measurement, 1);
+  });
+  const line = { at: new Date().toISOString(), range: 'nightly-audit', start: 0, end: results.length - 1,
+    next: 0, total: results.length, commit: String(m?.commit ?? '?'), budgetSecs: 0, ...(error ? { error } : {}), results };
+  const root = effectiveInstanceRoot();
+  const path = nightlyAuditLedgerPath(root);
+  mkdirSync(join(root, 'test-diet'), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(line)}\n`);
+  const card = writeCardDraft(root, line);
+  const failing = results.filter((r) => r.verdict === 'failing').length;
+  debug.log('test-diet', 'nightly-audit-recorded', { files: results.length, failing, card: card !== null });
+  return emit({ outcome: failing ? 'fail' : 'ok', summary: `nightly audit ${results.length} · failing ${failing}${card ? ' · card draft' : ''}`, failing, ledger: path, ...(card ? { card } : {}) });
+}
+
+export function record(ctx: Context, deps: { createStore?: (root: string) => Pick<CardStore, 'createCard' | 'appendSection' | 'close'>; td1?: ReadonlyMap<string, Td1Disposition> } = {}): number {
   const p = ctx.outputs.pick;
   const m = ctx.outputs.measure;
   const measurements = (m?.measurements ?? []) as Measurement[];
   if (!p || measurements.length === 0) return emit({ outcome: 'fail', summary: 'nothing measured' });
-  const results = measurements.map((x) => judge(x, Number(git(['log', '--since=90.days', '--format=%s', '--', x.file]).split('\n').filter((s) => /^fix\b/i.test(s)).length)));
+  const td1 = deps.td1 ?? td1Dispositions(readFileSync(join(process.cwd(), 'docs/measurements/td1-top200-content-review-2026-10-01.tsv'), 'utf8'));
+  const results = measurements.map((x) => propose(judge(x, git(['log', '--since=90.days', '--format=%s', '--', x.file]).split('\n').filter((s) => /^fix\b/i.test(s)).length), td1));
   const line = {
     at: new Date().toISOString(), range: `#${p.start}~#${p.end}`, start: Number(p.start), end: Number(p.end), next: Number(p.next), total: Number(p.total),
     commit: String(m?.commit ?? '?'), budgetSecs: Number(p.budgetSecs), results,
@@ -86,16 +130,89 @@ function record(ctx: Context): number {
   const root = effectiveInstanceRoot();
   appendLedger(root, line);
   const card = writeCardDraft(root, line);
+  const proposals: Record<string, number> = {};
+  for (const result of results) {
+    if (!result.proposal) continue;
+    proposals[result.proposal] = (proposals[result.proposal] ?? 0) + 1;
+    let store: Pick<CardStore, 'createCard' | 'appendSection' | 'close'> | undefined;
+    try {
+      store = deps.createStore?.(root) ?? new CardStore(root);
+      const task = store.createCard({ goalId: `test-diet:${result.file}:${result.proposal}`, title: `시험 다이어트 제안 — ${result.file} · ${result.proposal}` });
+      const observation = { proposal: result.proposal, basis: result.basis, guards: td1.get(result.file)?.guards ?? '',
+        secs: result.secs, rssMb: result.rssMb, caught90: result.caught90, range: line.range };
+      const fingerprint = createHash('sha256').update(JSON.stringify(observation)).digest('hex');
+      const key = `test-diet:${line.commit}:${fingerprint}`;
+      if (!task.sections.some((section) => section.key === key)) store.appendSection(task.id, {
+        key, owner: 'test-diet', content: JSON.stringify({ ...observation, at: line.at }),
+      });
+    } catch (error) {
+      console.warn(`test-diet card failed: ${result.file}: ${String(error)}`);
+      debug.log('test-diet', 'card-failed', { file: result.file });
+    } finally {
+      try { store?.close(); } catch (error) {
+        console.warn(`test-diet card close failed: ${result.file}: ${String(error)}`);
+        debug.log('test-diet', 'card-failed', { file: result.file });
+      }
+    }
+  }
+  debug.log('test-diet', 'proposed', { range: line.range, proposals });
   const counts = { keep: results.filter((r) => r.verdict === 'keep').length, review: results.filter((r) => r.verdict === 'review').length, failing: results.filter((r) => r.verdict === 'failing').length };
   debug.log('test-diet', 'recorded', { range: line.range, ...counts, card: card !== null });
   return emit({ outcome: 'ok', summary: `test-diet ${line.range} · keep ${counts.keep} · review ${counts.review} · failing ${counts.failing}${card ? ' · card draft' : ''}`, range: line.range, ...counts, ...(card ? { card } : {}) });
 }
 
+function status(root: string, options: { json?: boolean; days?: number } = {}): number {
+  const path = ledgerPath(root);
+  const ledger = existsSync(path) ? readFileSync(path, 'utf8') : '';
+  if (!ledger.trim()) {
+    if (options.json) console.log(JSON.stringify({ error: '원장 없음 — 한 번도 안 돌았다' }));
+    else console.log('원장 없음 — 한 번도 안 돌았다');
+    return 1;
+  }
+  const latest = new Map<string, LedgerLine>();
+  for (const raw of ledger.split('\n').filter(Boolean)) {
+    const line = JSON.parse(raw) as LedgerLine;
+    const date = new Date(new Date(line.at).getTime() + 9 * 3600_000).toISOString().slice(0, 10);
+    if (!latest.has(date) || latest.get(date)!.at <= line.at) latest.set(date, line);
+  }
+  const days = options.days ?? 3;
+  const dates = [...latest.keys()].sort().reverse().slice(0, days);
+  let consecutive = 0;
+  for (const date of [...latest.keys()].sort().reverse()) {
+    const expected = new Date(Date.parse(`${dates[0]}T00:00:00Z`) - consecutive * 86_400_000).toISOString().slice(0, 10);
+    if (date !== expected) break;
+    consecutive++;
+  }
+  const rows = dates.map((date) => {
+    const line = latest.get(date)!;
+    return { date, range: line.range, measured: line.results.length, total: line.total,
+      keep: line.results.filter((r) => r.verdict === 'keep').length,
+      review: line.results.filter((r) => r.verdict === 'review').length,
+      failing: line.results.filter((r) => r.verdict === 'failing').length,
+      proposals: line.results.filter((r) => r.proposal != null).length };
+  });
+  if (options.json) console.log(JSON.stringify({ rows, consecutive, days }));
+  else {
+    for (const row of rows) console.log(`${row.date} · ${row.range} · ${row.measured}/${row.total} · keep ${row.keep}/review ${row.review}/failing ${row.failing} · 제안 ${row.proposals}`);
+    console.log(`연속 산출: ${consecutive}일 (기준 ${days})`);
+  }
+  return 0;
+}
+
 if (import.meta.main) {
   const step = process.argv[2];
   try {
-    const ctx = context();
-    process.exitCode = step === 'pick' ? pick(ctx) : step === 'measure' ? measure(ctx) : step === 'record' ? record(ctx) : emit({ outcome: 'error', summary: `unknown step: ${step}` });
+    if (step === 'status') {
+      const args = process.argv.slice(3);
+      const daysAt = args.indexOf('--days');
+      const days = daysAt < 0 ? 3 : Number(args[daysAt + 1]);
+      if (!Number.isSafeInteger(days) || days < 1) throw new Error('--days needs a positive integer');
+      process.exitCode = status(effectiveInstanceRoot(), { json: args.includes('--json'), days });
+    } else {
+      const ctx = context();
+      process.exitCode = step === 'pick' ? pick(ctx) : step === 'measure' ? measure(ctx) : step === 'audit' ? measure(ctx, true)
+        : step === 'record' ? (ctx.graphId === 'nightly-audit' || Object.hasOwn(ctx.outputs, 'audit') ? recordNightlyAudit(ctx) : record(ctx)) : emit({ outcome: 'error', summary: `unknown step: ${step}` });
+    }
   } catch (error) {
     process.exitCode = emit({ outcome: 'error', summary: error instanceof Error ? error.message : String(error) });
   }

package/scripts/test-timeout-audit.ts

@@ -0,0 +1,114 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import ts from 'typescript';
+
+export type TimeoutStatus = '파일 기본' | '시험별 일부' | '없음';
+export type TimeoutFinding = { file: string; spawnLines: number; timeout: TimeoutStatus };
+
+const target = /\bbin\/elanous\.mjs\b|\bprocess\.execPath\b|["']bun["']|\bscripts\/[^\s"']+\.(?:ts|tsx|sh)\b/;
+const processCalls = new Set(['spawnSync', 'Bun.spawnSync', 'Bun.spawn', 'execFileSync', 'execSync']);
+
+function callName(node: ts.CallExpression): string {
+  return node.expression.getText();
+}
+
+/** Inspect the command and argv, not unrelated options, resolving local const aliases. */
+function commandText(node: ts.Expression, constants: ReadonlyMap<string, ts.Expression>, seen = new Set<string>()): string {
+  if (ts.isIdentifier(node) && constants.has(node.text)) {
+    if (seen.has(node.text)) return '';
+    seen.add(node.text);
+    return commandText(constants.get(node.text)!, constants, seen);
+  }
+  if (ts.isArrayLiteralExpression(node)) return node.elements.map((element) => commandText(element as ts.Expression, constants, new Set(seen))).join(' ');
+  if (ts.isObjectLiteralExpression(node)) return node.properties.map((property) =>
+    ts.isPropertyAssignment(property) ? commandText(property.initializer, constants, new Set(seen)) : '').join(' ');
+  if (ts.isStringLiteralLike(node)) return JSON.stringify(node.text);
+  if (ts.isPropertyAccessExpression(node) && node.getText() === 'process.execPath') return node.getText();
+  if (ts.isTemplateExpression(node)) return JSON.stringify(node.head.text) + node.templateSpans.map((span) => commandText(span.expression, constants, new Set(seen)) + JSON.stringify(span.literal.text)).join('');
+  if (ts.isParenthesizedExpression(node)) return commandText(node.expression, constants, seen);
+  if (ts.isCallExpression(node)) return node.arguments.map((arg) => commandText(arg, constants, new Set(seen))).join(' ');
+  if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) return commandText(node.left, constants, new Set(seen)) + commandText(node.right, constants, new Set(seen));
+  return '';
+}
+
+function hasNumericTimeout(node: ts.Expression | undefined): boolean {
+  return !!node && (ts.isNumericLiteral(node) || (ts.isObjectLiteralExpression(node) && node.properties.some((property) =>
+    ts.isPropertyAssignment(property) && property.name.getText() === 'timeout' && ts.isNumericLiteral(property.initializer))));
+}
+
+function testTimeout(call: ts.CallExpression): boolean {
+  const name = callName(call);
+  if (name === 'test' || name === 'it') return hasNumericTimeout(call.arguments[2]);
+  if (name === 'describe') return call.arguments.some((arg) => hasNumericTimeout(arg));
+  return false;
+}
+
+function withinTimedTest(node: ts.Node): boolean {
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (ts.isCallExpression(parent) && ['test', 'it', 'describe'].includes(callName(parent)) && testTimeout(parent)) return true;
+  }
+  return false;
+}
+
+/** Classify files that actually invoke a Bun/elanous/script subprocess. */
+export function classifyTimeouts(file: string, source: string): TimeoutFinding | null {
+  const tree = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, file.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  const constants = new Map<string, ts.Expression>();
+  const collect = (node: ts.Node): void => {
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isVariableDeclarationList(node.parent)
+      && (node.parent.flags & ts.NodeFlags.Const)) constants.set(node.name.text, node.initializer);
+    ts.forEachChild(node, collect);
+  };
+  collect(tree);
+  const lines = new Set<number>();
+  let fileDefault = false;
+  let uncovered = false;
+  const scan = (node: ts.Node): void => {
+    if (ts.isCallExpression(node)) {
+      const name = callName(node);
+      if (name === 'setDefaultTimeout' && node.arguments.length > 0) fileDefault = true;
+      if (processCalls.has(name)) {
+        const command = node.arguments.slice(0, name === 'execSync' || name.startsWith('Bun.') ? 1 : 2)
+          .map((arg) => commandText(arg, constants)).join(' ');
+        const executable = node.arguments[0] ? commandText(node.arguments[0], constants) : '';
+        if (target.test(command) && !/^\s*"git"/.test(executable)) {
+          lines.add(tree.getLineAndCharacterOfPosition(node.getStart(tree)).line + 1);
+          if (!withinTimedTest(node)) uncovered = true;
+        }
+      }
+    }
+    ts.forEachChild(node, scan);
+  };
+  scan(tree);
+  if (lines.size === 0) return null;
+  return { file, spawnLines: lines.size, timeout: fileDefault ? '파일 기본' : uncovered ? '없음' : '시험별 일부' };
+}
+
+export function auditTimeouts(root: string, paths: readonly string[]): TimeoutFinding[] {
+  return paths.map((file) => classifyTimeouts(file, readFileSync(join(root, file), 'utf8')))
+    .filter((finding): finding is TimeoutFinding => finding !== null)
+    .sort((a, b) => a.file.localeCompare(b.file));
+}
+
+export function renderTimeouts(findings: readonly TimeoutFinding[], json = false): string {
+  if (json) return JSON.stringify(findings, null, 2);
+  return ['파일 · 띄우는 줄 수 · 시한 상태', ...findings.map((f) => `${f.file} · ${f.spawnLines} · ${f.timeout}`)].join('\n');
+}
+
+export function main(root = process.cwd(), args = process.argv.slice(2)): number {
+  if (args.some((arg) => arg !== '--json')) {
+    console.error('Usage: bun scripts/test-timeout-audit.ts [--json]');
+    return 2;
+  }
+  const git = spawnSync('git', ['ls-files', '-z', '*.test.ts', '*.test.tsx'], { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  if (git.status !== 0 || git.error) {
+    console.error(git.error?.message ?? git.stderr ?? 'git ls-files failed');
+    return 2;
+  }
+  const findings = auditTimeouts(root, git.stdout.split('\0').filter(Boolean));
+  console.log(renderTimeouts(findings, args.includes('--json')));
+  return findings.some((f) => f.timeout === '없음') ? 1 : 0;
+}
+
+if (import.meta.main) process.exitCode = main();

package/scripts/tree-sync-alert.ts

@@ -20,6 +20,6 @@ export function renderTreeSyncAlert(tree: string, streak: number, decision: stri
 
 if (import.meta.main) {
   const [tree = '', streak = '0', decision = ''] = process.argv.slice(2);
-  const ok = sendOutbound(renderTreeSyncAlert(tree, Number(streak) || 0, decision), 'alert');
+  const ok = sendOutbound(renderTreeSyncAlert(tree, Number(streak) || 0, decision), 'ops-alert');
   process.exit(ok ? 0 : 1);
 }

package/scripts/tui-regress.ts

@@ -0,0 +1,71 @@
+// V1 — rerun the hand-measured TUI checks (scripts/lib/tui-regress-checks.ts) on a real PTY, every release.
+//
+//   bun scripts/tui-regress.ts [--only R2,R5] [--json]
+//
+// ⛔ Not under `bun test`: a real PTY of the real TUI is outside the test gate (NODE_ENV=test turns the PTY
+// manifest off, and the run takes ~1 minute). Each check gets a fresh temp config/state dir and its own PTY;
+// both are removed when the check ends, so the run leaves no process or folder behind.
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { startPty } from '../src/pty-shell/registry.js';
+import { ERASE, TUI_REGRESS_CHECKS, type TuiCheck, type Verdict } from './lib/tui-regress-checks.js';
+
+const COLS = 160;
+const ROWS = 50;
+const BOOT_MS = 9_000;
+const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+async function runCheck(check: TuiCheck): Promise<Verdict> {
+  const dir = mkdtempSync(join(tmpdir(), `tui-regress-${check.id}-`));
+  const cli = join(import.meta.dir, '..', 'bin', 'elanous.mjs');
+  if (check.role && check.role !== 'owner') {
+    // A config written from scratch has onboarding unfinished → bare entry would take the first-run (web-first) path,
+    // not the TUI. Mark onboarding done so the check sees the same TUI as an existing user.
+    spawnSync(process.execPath, [cli, '--config-dir', dir, 'config', 'set', 'tui.role', check.role], { stdio: 'ignore' });
+    spawnSync(process.execPath, [cli, '--config-dir', dir, 'config', 'set', 'onboarding.completed', 'true'], { stdio: 'ignore' });
+  }
+  const handle = startPty({
+    cmd: process.execPath, args: [cli, '--config-dir', dir, '--test-state-dir', dir],
+    cols: COLS, rows: ROWS, workdir: join(import.meta.dir, '..'),
+    env: { ...process.env, ELANOUS_DRIVE_TUI: '1', ELANOUS_STATE_DIR: dir },
+  });
+  const snaps: Record<string, string> = {};
+  try {
+    await sleep(BOOT_MS);
+    for (const step of check.steps) {
+      if (step.kind === 'type') handle.write(step.text);
+      else if (step.kind === 'key') handle.write(step.data);
+      else if (step.kind === 'erase') handle.write(ERASE.repeat(step.count));
+      else if (step.kind === 'wait') await sleep(step.ms);
+      else snaps[step.as] = await handle.renderScreen();
+    }
+    // TUI_REGRESS_DUMP=<id> prints that check's screens (to see why a verdict failed).
+    if (process.env.TUI_REGRESS_DUMP === check.id) for (const [k, v] of Object.entries(snaps)) console.log(`--- ${check.id}:${k}\n${v.split('\n').filter((l) => l.trim()).join('\n')}`);
+    return check.judge(snaps);
+  } catch (error) {
+    return { ok: false, reason: `실행 오류: ${String(error).slice(0, 120)}` };
+  } finally {
+    try { handle.kill('SIGKILL'); } catch { /* already gone */ }
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+const args = process.argv.slice(2);
+const onlyArg = args.indexOf('--only');
+const only = onlyArg >= 0 ? new Set((args[onlyArg + 1] ?? '').split(',').map((s) => s.trim()).filter(Boolean)) : null;
+const json = args.includes('--json');
+const checks = TUI_REGRESS_CHECKS.filter((check) => !only || only.has(check.id));
+if (checks.length === 0) { console.error('tui-regress: 고른 칸이 없다 (--only 확인)'); process.exit(2); }
+
+const results: { id: string; title: string; ok: boolean; reason: string }[] = [];
+for (const check of checks) {
+  const verdict = await runCheck(check);
+  results.push({ id: check.id, title: check.title, ...verdict });
+  if (!json) console.log(`${check.id} ${verdict.ok ? '✅' : '❌'} ${check.title} — ${verdict.reason}`);
+}
+const fail = results.filter((r) => !r.ok).length;
+if (json) console.log(JSON.stringify({ results, pass: results.length - fail, fail }));
+console.log(`tui-regress: pass ${results.length - fail} · fail ${fail}`);
+process.exit(fail ? 1 : 0);