elanous 0.2.9 → 0.2.10

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 };

package/scripts/test-diet/node.ts

@@ -2,12 +2,14 @@
 // 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|audit|record (test-diet or nightly-audit graph)
 import { spawnSync } from 'node:child_process';
-import { appendFileSync, mkdirSync, 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 { CardStore } from '../../src/task-cards/card-store.js';
 import { GATE_NIGHTLY_AUDITS } from '../release-loop/gate-node.js';
-import { appendLedger, costTable, judge, lastLedgerLine, nightlyAuditLedgerPath, pickRange, writeCardDraft, type Measurement } from './lib.js';
+import { appendLedger, costTable, judge, lastLedgerLine, ledgerPath, nightlyAuditLedgerPath, pickRange, propose, td1Dispositions, writeCardDraft, type LedgerLine, type Measurement, type Td1Disposition } from './lib.js';
 
 type Context = { graphId?: string; input: Record<string, unknown>; outputs: Record<string, Record<string, unknown> | null> };
 function context(): Context {
@@ -114,12 +116,13 @@ function recordNightlyAudit(ctx: Context): number {
   return emit({ outcome: failing ? 'fail' : 'ok', summary: `nightly audit ${results.length} · failing ${failing}${card ? ' · card draft' : ''}`, failing, ledger: path, ...(card ? { card } : {}) });
 }
 
-function record(ctx: Context): number {
+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,
@@ -127,17 +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 === '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}` });
+    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);

package/scripts/waitlist-daily-digest.ts

@@ -99,7 +99,7 @@ export async function main(): Promise<void> {
       try { return JSON.parse(readFileSync(statePath, 'utf8')); } catch { return null; }
     },
     writeState: (s) => { mkdirSync(dirname(statePath), { recursive: true }); writeFileSync(statePath, JSON.stringify(s)); },
-    send: (text) => sendOutbound(text, 'report'),
+    send: (text) => sendOutbound(text, 'ops-report'),
   });
   debug.log('waitlist.digest', 'reported', result);
   console.log(`[waitlist-daily-digest] sent=${result.sent} total=${result.total} fresh=${result.fresh}`);

package/skills/explainer-video/SKILL.md

@@ -91,8 +91,12 @@ The reference is used only for its structure (header, chapter cards, a diagram t
 
 ```bash
 zsh $SKILL/engine/reel.sh <folder> --title "마케터의 밤" --sub "2026.10.02 · 서울"
+zsh $SKILL/engine/reel.sh --warm-cards --title "마케터의 밤" --sub "2026.10.02 · 서울"  # 행사 전 카드 미리 굽기
+zsh $SKILL/engine/reel.sh <folder> --title "마케터의 밤" --sub "2026.10.02 · 서울" --instant  # 사진 구간만 렌더
 ```
 
+즉석판 카드 캐시: `~/.cache/elanous-explainer/cards/<sha256(JSON 배열 [title, sub, 1080, 1920, 카드판번호]) 앞 16자>/{intro,end}.mp4` (`EXPLAINER_CACHE`로 루트 변경 가능).
+
 - **Input**: a folder of phone photos (jpg · png · heic) and short clips (mp4 · mov). The default upload folder is `~/.elanous/field/<event>/`.
 - **Order**: by capture time (`mdls` creation date), then by file name.
 - **Captions**: optional `<folder>/captions.txt`, one line per item as `파일명 | 자막`. A photo without a line gets one line from a vision model (`codex exec -i`, all photos in parallel, 30 s cap each); if that fails it shows «현장 N». `FIELD_REEL_VISION=0` turns the vision step off.

package/skills/explainer-video/engine/reel.mjs

@@ -12,15 +12,18 @@ import { join, dirname, resolve, extname, basename } from "node:path";
 import { homedir } from "node:os";
 import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import { normalizeCardTitle } from "./stitch.mjs";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const argv = process.argv.slice(2);
 const opt = (k, d) => { const i = argv.indexOf(`--${k}`); return i >= 0 ? argv[i + 1] : d; };
 const folder = resolve(argv.find((a, i) => !a.startsWith("--") && !(i > 0 && argv[i - 1].startsWith("--"))) ?? ".");
 const PART = opt("part", "full");
+if (!["full", "body", "intro", "end"].includes(PART)) throw new Error(`unknown reel part: ${PART}`);
+const CARD = PART === "intro" || PART === "end";
 const MAX = Number(opt("max", 60)), MIN = Number(opt("min", 24));
 const W = 1080, H = 1920, PHOTO = 4.2, CLIP_MAX = 5, XF = 0.5;
-const INTRO = PART === "body" ? 0 : 3.0, END = PART === "body" ? 0 : 3.4;
+const INTRO = PART === "body" || PART === "end" ? 0 : 3.0, END = PART === "body" || PART === "intro" ? 0 : 3.4;
 const out = join(folder, "reel"), hf = join(out, "hf"), media = join(hf, "assets", "media");
 mkdirSync(media, { recursive: true }); mkdirSync(join(hf, "assets", "fonts"), { recursive: true });
 const T0 = Date.now(), lap = (s) => console.log(`reel: ${s} · ${((Date.now() - T0) / 1000).toFixed(1)}s`);
@@ -37,18 +40,19 @@ const created = (p) => {
   return Number.isFinite(t) ? t : statSync(p).mtimeMs;
 };
 const probeDur = (p) => Number(run("ffprobe", ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", p]).stdout.trim()) || 0;
-const caps = Object.fromEntries((existsSync(join(folder, "captions.txt")) ? readFileSync(join(folder, "captions.txt"), "utf8") : "")
+let TITLE = opt("title", ""), SUB = opt("sub", "");
+const caps = Object.fromEntries((!CARD && existsSync(join(folder, "captions.txt")) ? readFileSync(join(folder, "captions.txt"), "utf8") : "")
   .split("\n").filter((l) => l.includes("|")).map((l) => l.split("|").map((s) => s.trim())));
-let items = readdirSync(folder).filter((f) => [...IMG, ...VID].includes(extname(f).toLowerCase()))
+let items = CARD ? [] : readdirSync(folder).filter((f) => [...IMG, ...VID].includes(extname(f).toLowerCase()))
   .map((f) => ({ f, p: join(folder, f), video: VID.includes(extname(f).toLowerCase()), t: created(join(folder, f)) }))
   .sort((a, b) => a.t - b.t || a.f.localeCompare(b.f));
-if (!items.length) throw new Error(`no photos or clips in ${folder}`);
+if (!CARD && !items.length) throw new Error(`no photos or clips in ${folder}`);
 
 // ── durations: fit into [MIN, MAX] ─────────────────────────────────────────────
 for (const it of items) it.dur = it.video ? Math.min(CLIP_MAX, Math.max(1.5, probeDur(it.p))) : PHOTO;
 const body = () => items.reduce((a, it) => a + it.dur, 0);
 while (INTRO + body() + END > MAX && items.length > 1) items.splice(Math.floor(items.length / 2), 1); // drop from the middle, keep first & last
-if (PART !== "body" && INTRO + body() + END < MIN) { const photos = items.filter((i) => !i.video); const need = MIN - (INTRO + body() + END); for (const p of photos) p.dur += need / Math.max(1, photos.length); }
+if (PART === "full" && INTRO + body() + END < MIN) { const photos = items.filter((i) => !i.video); const need = MIN - (INTRO + body() + END); for (const p of photos) p.dur += need / Math.max(1, photos.length); }
 
 // ── media prep: HEIC → jpg · big photos down to 2160 · a small copy for the vision model · clips re-encoded short & muted ──
 let t = INTRO;
@@ -92,18 +96,17 @@ const oneLine = (s, max) => {
 const CAP_PROMPT = "행사 현장 사진이다. 세로 영상 자막으로 쓸 한국어 한 줄을 출력하라 — 18자 이내 · 마침표 없이 · 보이는 장면만 · 사람 이름·외모 묘사·추측 금지 · 화면 속 글자(행사명·회사명)는 읽히면 써도 된다. 그 한 줄만.";
 const HEAD_PROMPT = "같은 행사에서 찍은 사진들이다. 영상 첫 화면 제목으로 쓸 한국어 행사 이름 한 줄을 출력하라 — 16자 이내 · 화면 속 글자에서 읽히는 행사·회사 이름을 우선 · 읽히지 않으면 장면을 짧게(예: «상장 기념식 현장») · 추측 금지. 그 한 줄만.";
 const slugTitle = (s) => !s || /^[a-z0-9]+(?:-[a-z0-9]+)*$/i.test(s);
-let TITLE = opt("title", ""), SUB = opt("sub", "");
 const photos = items.filter((it) => !it.video);
 const VT0 = Date.now();
-const jobs = VISION ? [
+const jobs = VISION && !CARD ? [
   ...photos.filter((it) => !caps[it.f]).map(async (it) => { it.vcap = oneLine(await ask(CAP_PROMPT, [join(out, `v${items.indexOf(it)}.jpg`)]), 22); }),
   ...(PART !== "body" && slugTitle(TITLE) && photos.length ? [(async () => { TITLE = oneLine(await ask(HEAD_PROMPT, photos.slice(0, 3).map((it) => join(out, `v${items.indexOf(it)}.jpg`))), 20) || TITLE; })()] : []),
 ] : [];
 await Promise.all(jobs);
 const visionMs = Date.now() - VT0;
 items.forEach((it, i) => { it.cap = caps[it.f] || it.vcap || (it.video ? "" : `현장 ${i + 1}`); });
-if (slugTitle(TITLE)) TITLE = "현장 스케치";
-if (!SUB) { const d = new Date(items[0].t + 9 * 3600e3); SUB = `${d.getUTCFullYear()}.${String(d.getUTCMonth() + 1).padStart(2, "0")}.${String(d.getUTCDate()).padStart(2, "0")}`; }
+TITLE = normalizeCardTitle(TITLE);
+if (!CARD && !SUB) { const d = new Date(items[0].t + 9 * 3600e3); SUB = `${d.getUTCFullYear()}.${String(d.getUTCMonth() + 1).padStart(2, "0")}.${String(d.getUTCDate()).padStart(2, "0")}`; }
 lap(`vision ${jobs.length ? `${items.filter((i) => i.vcap).length}/${photos.filter((p) => !caps[p.f]).length} captions` : "off"} · title «${TITLE}»`);
 
 // ── assets (same cache as build.mjs) ───────────────────────────────────────────
@@ -119,7 +122,7 @@ for (const [rel, url] of Object.entries(ASSETS)) {
 // ── music: cut to length · fade in/out · level to about -16 LUFS (the whole mix is music) ──
 const BGM = process.env.FIELD_REEL_BGM || join(CACHE, "bgm", "field.wav");
 let music = "";
-if (PART !== "body" && existsSync(BGM)) {
+if (PART === "full" && existsSync(BGM)) {
   const r = run("ffmpeg", ["-v", "error", "-y", "-i", BGM, "-t", String(TOTAL), "-af", `afade=t=in:d=0.4,afade=t=out:st=${f(TOTAL - 1.6)}:d=1.6,loudnorm=I=-16:TP=-1.5:LRA=9`, "-ar", "48000", "-ac", "2", join(media, "bgm.wav")]);
   if (r.status === 0) music = "bgm.wav"; else console.error(`reel: music skipped — ${r.stderr.slice(0, 160)}`);
 }
@@ -165,16 +168,18 @@ const clips = items.map((it, i) => {
   return vis + cap;
 }).join("\n");
 
-const intro = PART === "body" ? "" : `<section class="clip card" data-start="0" data-duration="${INTRO}" data-track-index="6">`
+const intro = PART === "body" || PART === "end" ? "" : `<section class="clip card" data-start="0" data-duration="${INTRO}" data-track-index="6">`
   + `<div class="kick ik">현장 스케치</div>${mark(200, "im")}<h1>${words(TITLE, "it")}</h1><div class="line il"></div><p class="is">${esc(SUB)}</p></section>`;
-const end = PART === "body" ? "" : `<section class="clip card" data-start="${f(t)}" data-duration="${END}" data-track-index="6">`
+const end = PART === "body" || PART === "intro" ? "" : `<section class="clip card" data-start="${f(t)}" data-duration="${END}" data-track-index="6">`
   + `${mark(230, "em")}<h1 class="et">Elanous</h1><p class="et">사진을 올리면, 영상이 됩니다</p><p class="et red">elanous.ai</p></section>`;
-if (PART !== "body") {
+if (PART === "full" || PART === "intro") {
   tw.push(`tl.fromTo(".ik", {opacity:0, letterSpacing:"0.6em"}, {opacity:1, letterSpacing:"0.28em", duration:0.8, ease:"power3.out"}, 0.1);`);
   tw.push(`tl.fromTo(".im", {rotation:-160, scale:0.6, opacity:0}, {rotation:0, scale:1, opacity:1, duration:1.0, ease:"power3.out"}, 0.0);`);
   tw.push(`tl.fromTo(".it", {opacity:0, y:50}, {opacity:1, y:0, duration:0.55, stagger:0.1, ease:"power3.out"}, 0.45);`);
   tw.push(`tl.fromTo(".il", {scaleX:0}, {scaleX:1, duration:0.6, ease:"power3.inOut"}, 0.9);`);
   tw.push(`tl.fromTo(".is", {opacity:0, y:16}, {opacity:1, y:0, duration:0.45, ease:"power3.out"}, 1.15);`);
+}
+if (PART === "full" || PART === "end") {
   tw.push(`tl.fromTo(".em", {rotation:-200, scale:0.5}, {rotation:0, scale:1, duration:1.2, ease:"power3.out"}, ${f(t)});`);
   tw.push(`tl.fromTo(".et", {opacity:0, y:20}, {opacity:1, y:0, duration:0.5, stagger:0.14, ease:"power3.out"}, ${f(t + 0.5)});`);
 }

package/skills/explainer-video/engine/reel.sh

@@ -1,9 +1,28 @@
 #!/bin/zsh
-# Field reel in one command: folder of phone photos/clips → <folder>/reel/<name>-9x16.mp4 · prints the elapsed seconds.
+# Field reel: standard full composition or instant body with cached cards.
 # The layout/contrast check is advisory: phone photos behind captions often miss 3:1, and a failed check must not stop the reel.
-# Usage: zsh reel.sh <folder> [--title "…"] [--sub "…"]   (captions: <folder>/captions.txt — `파일 | 자막`)
-E=${0:A:h}; F=${1:A}; shift
+# Usage: zsh reel.sh <folder> [--title "…"] [--sub "…"] [--instant]   (captions: <folder>/captions.txt — `파일 | 자막`)
+E=${0:A:h}
+if [[ $1 == --warm-cards ]]; then
+  shift
+  node $E/stitch.mjs --warm-cards "$@"
+  exit $?
+fi
+F=${1:A}; shift
 [[ -d $F ]] || { print -u2 "reel: no folder $F"; exit 2 }
 T0=$(date +%s)
-rm -rf $F/reel && node $E/reel.mjs $F "$@" && (cd $F/reel/hf && { npx -y hyperframes@${HYPERFRAMES_VERSION:-0.8.95} check >../render.log 2>&1 || print "reel: check reported issues (continuing — user photos vary; see above)" >>../render.log }; npx -y hyperframes@${HYPERFRAMES_VERSION:-0.8.95} render --fps 30 --workers 4 --output ../reel-9x16.mp4 >>../render.log 2>&1) || { print -u2 "reel: FAILED — see $F/reel/render.log"; exit 1 }
-print "reel: $F/reel/reel-9x16.mp4 · $(( $(date +%s) - T0 ))s"
+instant=0
+args=()
+for arg in "$@"; do
+  if [[ $arg == --instant ]]; then instant=1; else args+=("$arg"); fi
+done
+rm -rf $F/reel
+if (( instant )); then
+  node $E/reel.mjs $F "${args[@]}" --part body &&
+    (cd $F/reel/hf && { npx -y hyperframes@${HYPERFRAMES_VERSION:-0.8.95} check >../render.log 2>&1 || print "reel: check reported issues (continuing — user photos vary; see above)" >>../render.log }; npx -y hyperframes@${HYPERFRAMES_VERSION:-0.8.95} render --fps 30 --workers 4 --output ../body.mp4 >>../render.log 2>&1) &&
+    node $E/stitch.mjs --instant $F >>$F/reel/render.log 2>&1 || { print -u2 "reel: FAILED — see $F/reel/render.log"; exit 1 }
+  print "reel: $F/reel/reel-9x16.mp4 · $(( $(date +%s) - T0 ))s (instant)"
+else
+  node $E/reel.mjs $F "${args[@]}" && (cd $F/reel/hf && { npx -y hyperframes@${HYPERFRAMES_VERSION:-0.8.95} check >../render.log 2>&1 || print "reel: check reported issues (continuing — user photos vary; see above)" >>../render.log }; npx -y hyperframes@${HYPERFRAMES_VERSION:-0.8.95} render --fps 30 --workers 4 --output ../reel-9x16.mp4 >>../render.log 2>&1) || { print -u2 "reel: FAILED — see $F/reel/render.log"; exit 1 }
+  print "reel: $F/reel/reel-9x16.mp4 · $(( $(date +%s) - T0 ))s"
+fi