elanous 0.2.13 → 0.2.15

package/scripts/test-deterministic.ts

@@ -296,15 +296,11 @@ export function prepareIsolatedTestEnv(sourceEnv: NodeJS.ProcessEnv, testRoot: s
   // resolves the old path through ELANOUS_TEST_HOME rather than the real home.
   delete env.XDG_CONFIG_HOME;
   env.ELANOUS_TEST_HOME = testRoot;
-  // ⚠️ Redirect elanous's OWN roots explicitly — do not merely inherit them.
-  // `ELANOUS_STATE_DIR` / `ELANOUS_CONFIG_DIR` are absolute paths that win over
-  // HOME, so a developer who exports either one keeps pointing the "isolated"
-  // run straight back at their real state while every other signal says the run
-  // is contained. Deleting them is not enough either: absence resolves to the
-  // default under HOME, which is fine here, but pinning them makes the
-  // isolation legible in the child's own environment rather than implied.
+  // HOME and ELANOUS_STATE_DIR isolate both the state and default config roots.
+  // ELANOUS_CONFIG_DIR is not a config-dir override; discard an inherited value
+  // rather than passing an ignored variable that appears to provide isolation.
   env.ELANOUS_STATE_DIR = join(testRoot, 'state');
-  env.ELANOUS_CONFIG_DIR = join(testRoot, 'config');
+  delete env.ELANOUS_CONFIG_DIR;
   // All ambient execution identities are removed by EXECUTION_ORIGIN_ENV_KEYS
   // above, before the child is spawned; logger API-shape tests need their absence.
   // ⚠️ No `ELANOUS_TEST_DETERMINISTIC` marker is exported. Nothing reads it yet,

package/scripts/test-diet/effectiveness.ts

@@ -0,0 +1,195 @@
+import { spawnSync } from 'node:child_process';
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, existsSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import ts from 'typescript';
+import { pickRange } from './lib.js';
+
+export type Flake = 'stable' | 'flaky' | 'failing';
+export type Mutation = 'caught' | 'survived' | 'n/a';
+export type TestRun = { rc: number | null; pass: number | null; fail: number | null };
+
+export function flakeVerdict(runs: Array<{ rc: number | null; pass: number | null; fail: number | null }>): Flake {
+  if (runs.length !== 3) throw new Error('flakeVerdict requires exactly 3 runs');
+  const passed = runs.map((r) => r.rc === 0 && (r.fail === null || r.fail === 0) && r.pass !== null && r.pass > 0);
+  return passed.every(Boolean) ? 'stable' : passed.some(Boolean) ? 'flaky' : 'failing';
+}
+
+export function sweepSlice({ totalCostSecs, runsPerDay = 4, days = 7, safety = 1.2, files, costs, start = 0, remaining = files?.length, slotsLeft = runsPerDay * days, minBudgetSecs = 0 }: {
+  totalCostSecs: number; runsPerDay?: number; days?: number; safety?: number;
+  files?: readonly string[]; costs?: ReadonlyMap<string, number>; start?: number; remaining?: number; slotsLeft?: number; minBudgetSecs?: number;
+}): { budgetSecs: number; slicesNeeded: number } {
+  if (![totalCostSecs, runsPerDay, days, safety].every((n) => Number.isFinite(n) && n > 0)) throw new Error('sweepSlice requires positive finite inputs');
+  const baseBudget = totalCostSecs / (runsPerDay * days) * safety;
+  if (!files) return { budgetSecs: baseBudget, slicesNeeded: Math.ceil(totalCostSecs / baseBudget) };
+  if (!Number.isSafeInteger(start) || start < 0 || !Number.isSafeInteger(remaining) || remaining! < 0 || remaining! > files.length
+    || !Number.isSafeInteger(slotsLeft) || slotsLeft < 1 || !Number.isFinite(minBudgetSecs) || minBudgetSecs < 0)
+    throw new Error('sweepSlice requires a valid cursor, remaining file count and slots');
+  const sliceCount = (budget: number): number => {
+    let cursor = start;
+    let visited = 0;
+    let count = 0;
+    while (visited < remaining!) {
+      const slice = pickRange(files, cursor, costs ?? new Map(), budget);
+      visited += slice.files.length;
+      cursor = slice.next;
+      count++;
+    }
+    return count;
+  };
+  const target = slotsLeft;
+  let budgetSecs = Math.max(baseBudget, minBudgetSecs);
+  let slicesNeeded = sliceCount(budgetSecs);
+  if (slicesNeeded > target) {
+    // Whole files cannot be split across slices. Grow the budget until the actual cursor walk fits.
+    let low = budgetSecs;
+    let high = budgetSecs;
+    do {
+      high *= 2;
+      if (!Number.isFinite(high)) throw new Error('sweepSlice budget overflow');
+    } while (sliceCount(high) > target);
+    for (let i = 0; i < 48; i++) {
+      const mid = (low + high) / 2;
+      if (sliceCount(mid) > target) low = mid;
+      else high = mid;
+    }
+    budgetSecs = high;
+    slicesNeeded = sliceCount(budgetSecs);
+  }
+  return { budgetSecs, slicesNeeded };
+}
+
+const repositoryRead = /\b(?:readdirSync|globSync|new\s+Glob)\b|['"]ls-files['"]|\b(?:execFileSync\s*\(\s*['"]git['"]|spawnSync\s*\(\s*['"](?:git|rg)['"])/;
+
+/** Static signal only: literal count assertions coupled to a direct repository reader. */
+export function fixedCountAssertions(testPath: string, root: string): Array<{ line: number; count: number }> {
+  const repo = realpathSync(resolve(root));
+  const testFile = resolve(repo, testPath);
+  const inside = (path: string) => path !== repo && !relative(repo, path).startsWith(`..${sep}`)
+    && relative(repo, path) !== '..' && !isAbsolute(relative(repo, path));
+  if (!inside(testFile) || realpathSync(testFile) !== testFile) throw new Error('test path outside repository or symlinked');
+  const text = readFileSync(testFile, 'utf8');
+  const source = ts.createSourceFile(testFile, text, ts.ScriptTarget.Latest, true);
+  let readsRepository = repositoryRead.test(text);
+  if (!readsRepository) {
+    const imports: string[] = [];
+    const collectImports = (node: ts.Node): void => {
+      if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) imports.push(node.moduleSpecifier.text);
+      if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword
+        && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0]!)) imports.push(node.arguments[0]!.text);
+      ts.forEachChild(node, collectImports);
+    };
+    collectImports(source);
+    for (const specifier of imports) {
+      if (!/^\.{1,2}\//.test(specifier)) continue;
+      const base = resolve(dirname(testFile), specifier);
+      const candidates = base.endsWith('.js')
+        ? [base.replace(/\.js$/, '.ts'), base, `${base}.ts`, join(base, 'index.ts')]
+        : [base, `${base}.ts`, join(base, 'index.ts')];
+      for (const candidate of candidates) {
+        if (!inside(candidate) || !existsSync(candidate) || realpathSync(candidate) !== candidate || !statSync(candidate).isFile()) continue;
+        if (repositoryRead.test(readFileSync(candidate, 'utf8'))) readsRepository = true;
+        break;
+      }
+      if (readsRepository) break;
+    }
+  }
+  if (!readsRepository) return [];
+
+  const assertions: Array<{ line: number; count: number }> = [];
+  const visit = (node: ts.Node): void => {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.arguments.length === 1
+      && ['toBe', 'toEqual', 'toHaveLength'].includes(node.expression.name.text)
+      && ts.isNumericLiteral(node.arguments[0]!)
+      && /^(?:\d[\d_]*|0[xX][\da-fA-F_]+|0[bB][01_]+|0[oO][0-7_]+)$/.test(node.arguments[0]!.text)) {
+      const receiver = node.expression.expression;
+      if (ts.isCallExpression(receiver) && ts.isIdentifier(receiver.expression) && receiver.expression.text === 'expect'
+        && receiver.arguments.length === 1) {
+        const line = source.getLineAndCharacterOfPosition(receiver.getStart(source)).line + 1;
+        const matcherLine = source.getLineAndCharacterOfPosition(node.expression.name.getStart(source)).line + 1;
+        if (line === matcherLine && (node.expression.name.text === 'toHaveLength'
+          || /\.(?:length|size)\b|\bcount\b/.test(receiver.arguments[0]!.getText(source)))) {
+          assertions.push({ line, count: Number(node.arguments[0]!.text.replaceAll('_', '')) });
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return assertions.sort((a, b) => a.line - b.line);
+}
+
+export function mutationProbe(file: string, deps: { root: string; run?: (root: string, file: string) => number | null; baselineStable?: boolean }): Mutation {
+  if (deps.baselineStable === false) return 'n/a';
+  const root = realpathSync(resolve(deps.root));
+  const testPath = resolve(root, file);
+  const inside = (path: string) => path !== root && !relative(root, path).startsWith(`..${sep}`) && relative(root, path) !== '..' && !isAbsolute(relative(root, path));
+  if (!inside(testPath) || realpathSync(testPath) !== testPath) throw new Error('test path outside repository or symlinked');
+  const source = readFileSync(testPath, 'utf8');
+  // Only direct relative imports into src/ qualify; never mutate the test or an external dependency.
+  const imports = source.matchAll(/(?:\bfrom\s*|\bimport\s*\(|\bimport\s*)['"](\.{1,2}\/[^'"]+)['"]/g);
+  let target: string | undefined;
+  let changed: string | undefined;
+  for (const match of imports) {
+    const base = resolve(dirname(testPath), match[1]!);
+    for (const candidate of [base, base.replace(/\.js$/, '.ts'), `${base}.ts`, join(base, 'index.ts')]) {
+      if (!inside(candidate) || !relative(root, candidate).startsWith(`src${sep}`) || !existsSync(candidate) || realpathSync(candidate) !== candidate) continue;
+      const original = readFileSync(candidate, 'utf8');
+      const mutation = original.includes('return true') ? original.replace('return true', 'return false')
+        : original.includes('===') ? original.replace('===', '!==') : undefined;
+      if (!mutation) return 'n/a';
+      target = candidate;
+      changed = mutation;
+      break;
+    }
+    if (target) break;
+  }
+  if (!target || changed === undefined) return 'n/a';
+  // Real path up front: on macOS tmpdir is under /var → /private/var, and the symlink guards below compare real paths.
+  const temp = realpathSync(mkdtempSync(join(tmpdir(), 'test-diet-mutation-')));
+  try {
+    const clone = join(temp, 'repo');
+    const copied = spawnSync('git', ['clone', '--quiet', '--no-hardlinks', '--', root, clone], { encoding: 'utf8', timeout: 300_000 });
+    if (copied.status !== 0) throw new Error(`mutation copy failed: ${copied.error?.message ?? copied.stderr}`);
+    // Copy the actual file bytes (including uncommitted fixture edits) into the isolated clone.
+    for (const path of [testPath, target]) {
+      const destination = join(clone, relative(root, path));
+      mkdirSync(dirname(destination), { recursive: true });
+      if (existsSync(destination) && realpathSync(destination) !== destination) throw new Error('mutation copy destination is symlinked');
+      cpSync(path, destination);
+    }
+    if (!deps.run && existsSync(join(clone, 'package.json'))) {
+      const install = spawnSync('bun', ['install', '--frozen-lockfile'], { cwd: clone, timeout: 300_000, stdio: 'ignore' });
+      if (install.status !== 0) throw new Error('mutation copy install failed');
+      if (relative(root, testPath).startsWith(`apps${sep}pwa${sep}`) && existsSync(join(clone, 'apps/pwa/package.json'))) {
+        const pwa = spawnSync('bun', ['install', '--frozen-lockfile'], { cwd: join(clone, 'apps/pwa'), timeout: 300_000, stdio: 'ignore' });
+        if (pwa.status !== 0) throw new Error('mutation copy PWA install failed');
+      }
+    }
+    const targetInCopy = join(clone, relative(root, target));
+    if (existsSync(targetInCopy) && realpathSync(targetInCopy) !== targetInCopy) throw new Error('mutation target in copy is symlinked');
+    const testFile = `./${relative(root, testPath)}`;
+    const command = existsSync(join(clone, 'scripts/test-deterministic.ts'))
+      ? ['run', 'scripts/test-deterministic.ts', testFile] : ['test', testFile];
+    const runTest = () => deps.run ? { status: deps.run(clone, relative(root, testPath)), stdout: '', stderr: '' }
+      : spawnSync('bun', command, { cwd: clone, timeout: 300_000, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    if (deps.baselineStable !== true) {
+      for (let i = 0; i < 3; i++) {
+        const baseline = runTest();
+        if (baseline.status === null) throw new Error('baseline test did not complete');
+        if (baseline.status !== 0) return 'n/a';
+      }
+    }
+    writeFileSync(targetInCopy, changed);
+    const run = runTest();
+    if (run.status === null) throw new Error('mutation test did not complete');
+    if (!deps.run && run.status !== 0 && !/^\s*[1-9][0-9]* fail\b/m.test(`${run.stdout}\n${run.stderr}`))
+      throw new Error('mutation test did not report a failing assertion');
+    return run.status === 0 ? 'survived' : 'caught';
+  } finally { rmSync(temp, { recursive: true, force: true }); }
+}
+
+if (import.meta.main) {
+  const result = mutationProbe(process.argv[2]!, { root: process.cwd(), baselineStable: process.argv[3] === 'stable' });
+  console.log(result);
+}

package/scripts/test-diet/lib.ts

@@ -7,12 +7,13 @@ export const DEFAULT_COST_SECS = 10;
 export const SLOW_SECS = 60;
 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 interface Effectiveness { flake: 'stable' | 'flaky' | 'failing'; mutation: 'caught' | 'survived' | 'n/a'; fixedCounts?: number }
+export interface Measurement { file: string; secs: number; rssMb: number | null; rc: number | null; pass: number | null; fail: number | null; reason?: string; effectiveness?: Effectiveness }
 export type Verdict = 'keep' | 'failing' | 'review';
 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[] }
+export interface Judged extends Measurement { caught90: number; flags: string[]; verdict: Verdict; effectiveness?: Effectiveness; 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[]; sweepVisited?: number; sweepCostSecs?: number; sweepSlices?: number }
 
 /** `file\tsecs\t…` (TD1 whole-gate TSV) → seconds per file. */
 export function costTable(tsv: string): Map<string, number> {
@@ -47,8 +48,13 @@ export function propose(judged: Judged, td1: ReadonlyMap<string, Td1Disposition>
     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.effectiveness?.flake === 'flaky') return { ...judged, proposal: 'investigate', basis: '3회 중 갈림' };
+  if (judged.effectiveness?.flake === 'stable' && judged.effectiveness.mutation === 'survived' && judged.caught90 === 0)
+    return { ...judged, proposal: 'rewrite-cheap', basis: '돌연변이를 못 잡음' };
   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}` };
+  if (judged.effectiveness?.fixedCounts && judged.effectiveness.fixedCounts > 0)
+    return { ...judged, proposal: 'investigate', basis: `저장소 전수 개수 고정 단언 ${judged.effectiveness.fixedCounts}줄 — 관련 시험 묶음 후보` };
   return { ...judged, proposal: null, basis: null };
 }
 
@@ -75,7 +81,9 @@ export function judge(m: Measurement, caught90: number): Judged {
   const flags: string[] = [];
   if (m.secs >= SLOW_SECS) flags.push('slow');
   if (m.rssMb !== null && m.rssMb >= HEAVY_MB) flags.push('heavy');
-  const verdict: Verdict = m.rc !== 0 ? 'failing' : flags.length > 0 && caught90 === 0 ? 'review' : 'keep';
+  const verdict: Verdict = m.effectiveness?.flake === 'flaky' ? 'review'
+    : (m.effectiveness?.flake === 'failing' || (m.effectiveness === undefined && m.rc !== 0)) ? 'failing'
+      : flags.length > 0 && caught90 === 0 ? 'review' : 'keep';
   return { ...m, caught90, flags, verdict };
 }
 
@@ -96,19 +104,19 @@ export function appendLedger(root: string, line: LedgerLine): void {
 
 /** Draft approval card — written as a file for a person to read; nothing is acted on. */
 export function writeCardDraft(root: string, line: LedgerLine): string | null {
-  const items = line.results.filter((r) => r.verdict !== 'keep');
+  const items = line.results.filter((r) => r.verdict !== 'keep' || r.proposal != null);
   if (items.length === 0) return null;
   const dir = join(root, 'test-diet', 'cards');
   mkdirSync(dir, { recursive: true });
   const path = join(dir, `${line.at.slice(0, 10)}-${line.range.replace(/[^0-9a-z~#-]/gi, '')}.md`);
-  const rows = items.map((r) => `| \`${r.file}\` | ${r.verdict} | ${r.secs}s | ${r.rssMb ?? '?'} MB | ${r.caught90} | ${r.flags.join(', ') || '—'} | ${(r.reason ?? '').replace(/\|/g, '/')} |`);
+  const rows = items.map((r) => `| \`${r.file}\` | ${r.verdict} | ${r.secs}s | ${r.rssMb ?? '?'} MB | ${r.caught90} | ${r.flags.join(', ') || '—'} | ${(r.reason ?? '').replace(/\|/g, '/')} | ${r.proposal ?? '—'} | ${(r.basis ?? '—').replace(/\|/g, '/')} |`);
   writeFileSync(path, [
     `# 시험 리뷰 초안 — ${line.range} (${line.at.slice(0, 10)})`,
     '',
     '> 초안이다. 아무것도 지우거나 옮기지 않았다. 사람이 읽고 정한다.',
     '',
-    '| 파일 | 판정 | 단독 시간 | 피크 메모리 | 90일 fix 커밋 | 표지 | 실패 사유(첫 줄) |',
-    '|---|---|---|---|---|---|---|',
+    '| 파일 | 판정 | 단독 시간 | 피크 메모리 | 90일 fix 커밋 | 표지 | 실패 사유(첫 줄) | 제안 | 근거 |',
+    '|---|---|---|---|---|---|---|---|---|',
     ...rows,
     '',
     `원장: ${line.results.length}개 중 ${items.length}개 · 측정 판 ${line.commit}`,

package/scripts/test-diet/node.ts

@@ -10,6 +10,7 @@ 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, ledgerPath, nightlyAuditLedgerPath, pickRange, propose, td1Dispositions, writeCardDraft, type LedgerLine, type Measurement, type Td1Disposition } from './lib.js';
+import { fixedCountAssertions, flakeVerdict, sweepSlice, type Mutation, type TestRun } from './effectiveness.js';
 
 type Context = { graphId?: string; input: Record<string, unknown>; outputs: Record<string, Record<string, unknown> | null> };
 function context(): Context {
@@ -24,20 +25,29 @@ function emit(result: Record<string, unknown> & { outcome: 'ok' | 'fail' | 'erro
 }
 const git = (args: string[]) => spawnSync('git', args, { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).stdout ?? '';
 
-function pick(ctx: Context): number {
-  const budgetSecs = typeof ctx.input.budgetSecs === 'number' && ctx.input.budgetSecs > 0 ? ctx.input.budgetSecs : 1800;
+function pick(ctx: Context, sweep = false): number {
   const files = git(['ls-files', '*.test.ts']).split('\n').filter(Boolean).sort();
   const costs = costTable(readFileSync(join(process.cwd(), 'docs/measurements/td1-whole-gate-mechanical-2026-10-01.tsv'), 'utf8'));
   const last = lastLedgerLine(effectiveInstanceRoot());
   for (const r of last?.results ?? []) costs.set(r.file, r.secs);
+  const totalCostSecs = sweep ? files.reduce((sum, file) => sum + (costs.get(file) ?? 10), 0) : 0;
   // `start` re-looks a slice on purpose; otherwise continue from the ledger cursor.
   const startAt = typeof ctx.input.start === 'number' && ctx.input.start >= 0 ? ctx.input.start : last?.next ?? 0;
+  const continuing = ctx.input.start === undefined && last?.sweepVisited && last.sweepVisited < files.length && last.next === startAt && last.total === files.length;
+  const remaining = continuing ? files.length - last.sweepVisited! : files.length;
+  const elapsed = continuing ? last.sweepSlices ?? 0 : 0;
+  const slotsLeft = Math.max(1, 28 - elapsed);
+  const sweepPlan = sweep && files.length > 0 ? sweepSlice({ totalCostSecs, files, costs, start: startAt, remaining,
+    slotsLeft, minBudgetSecs: continuing ? last.budgetSecs : 0 }) : undefined;
+  const budgetSecs = sweepPlan?.budgetSecs
+    ?? (typeof ctx.input.budgetSecs === 'number' && ctx.input.budgetSecs > 0 ? ctx.input.budgetSecs : 1800);
   const range = pickRange(files, startAt, costs, budgetSecs);
-  return emit({ outcome: 'ok', summary: `test-diet pick #${range.start}~#${range.end} of ${files.length} (≈${Math.round(range.estimatedSecs)}s)`, ...range, total: files.length, budgetSecs });
+  return emit({ outcome: 'ok', summary: `test-diet pick #${range.start}~#${range.end} of ${files.length} (≈${Math.round(range.estimatedSecs)}s)`, ...range, total: files.length, budgetSecs,
+    ...(sweep ? { sweep: true, totalCostSecs, slicesNeeded: sweepPlan?.slicesNeeded, sweepElapsed: elapsed } : {}) });
 }
 
 /** One remote run: shallow clone of the mirror, one install, each file alone with its peak memory. */
-function measure(ctx: Context, audit = false): number {
+function measure(ctx: Context, audit = false, effectiveness = 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';
@@ -62,6 +72,25 @@ function measure(ctx: Context, audit = false): 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"',
+    ...(effectiveness && !audit ? [
+      '  runs="$rc,${pass:-},${fail:-}"',
+      '  for n in 2 3; do',
+      '    if [ -n "$TO" ]; then "$TO" -k 10 300 bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; else bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; fi',
+      '    rc2=$?',
+      '    pass2=$(cat "$T/out" "$T/err" | grep -E -o "^ *[0-9]+ pass" | grep -E -o "[0-9]+" | tail -1); fail2=$(cat "$T/out" "$T/err" | grep -E -o "^ *[0-9]+ fail" | grep -E -o "[0-9]+" | tail -1)',
+      '    runs="$runs;$rc2,${pass2:-},${fail2:-}"',
+      '  done',
+      '  stable=1; oldIFS=$IFS; IFS=";"',
+      '  for entry in $runs; do',
+      '    status=${entry%%,*}; counts=${entry#*,}; passing=${counts%%,*}; failing=${counts#*,}',
+      '    [ "$status" = 0 ] && [ "${passing:-0}" -gt 0 ] && [ "${failing:-0}" -eq 0 ] || stable=0',
+      '  done',
+      '  IFS=$oldIFS',
+      '  mutation="n/a"',
+      '  if [ "$stable" -eq 1 ]; then mutation=$(bun scripts/test-diet/effectiveness.ts "$f" stable 2> "$T/mutation-err") || { cat "$T/mutation-err" >&2; exit 5; }; fi',
+      '  e=$(( $(date +%s) - s ))',
+      '  printf "E\\t%s\\t%s\\t%s\\t%s\\n" "$f" "$runs" "$mutation" "$e"',
+    ] : []),
     "done <<'TEST_DIET_FILES'", ...picked, 'TEST_DIET_FILES',
   ].join('\n');
   const run = spawnSync('ssh', ['-o', 'BatchMode=yes', host, 'bash', '-s'], { input: `${script}\n`, encoding: 'utf8', timeout: 4 * 3600_000, maxBuffer: 16 * 1024 * 1024 });
@@ -73,9 +102,35 @@ function measure(ctx: Context, audit = false): number {
     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 } : {}) };
   });
+  if (effectiveness && !audit) {
+    const effects = new Map(String(run.stdout).split('\n').filter((l) => l.startsWith('E\t')).map((l) => {
+      const [, file, raw, mutation, secs] = l.split('\t');
+      const runs: TestRun[] = (raw ?? '').split(';').map((entry) => {
+        const [rc, pass, fail] = entry.split(',');
+        const num = (value: string | undefined) => value === undefined || value === '' ? null : Number(value);
+        return { rc: num(rc), pass: num(pass), fail: num(fail) };
+      });
+      return [file!, { flake: flakeVerdict(runs), mutation: (['caught', 'survived', 'n/a'].includes(mutation ?? '') ? mutation : 'n/a') as Mutation, secs: Number(secs) }] as const;
+    }));
+    for (const measurement of measurements) {
+      const effect = effects.get(measurement.file);
+      if (!effect) continue;
+      measurement.effectiveness = { flake: effect.flake, mutation: effect.flake === 'stable' ? effect.mutation : 'n/a' };
+      try {
+        measurement.effectiveness.fixedCounts = fixedCountAssertions(measurement.file, process.cwd()).length;
+      } catch (error) {
+        debug.log('test-diet.effectiveness', 'fixed-count-unreadable', {
+          file: measurement.file, reason: error instanceof Error ? error.message : String(error),
+        });
+      }
+      debug.log('test-diet.effectiveness', 'judged', { file: measurement.file, ...measurement.effectiveness, secs: effect.secs });
+    }
+  }
   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',
+  const summary = remoteError ?? (effectiveness && measurements.some((m) => !m.effectiveness)
+    ? `effectiveness missing for ${measurements.filter((m) => !m.effectiveness).length} file(s)`
+    : `measured ${measurements.length}/${picked.length} on ${host} at ${commit.slice(0, 9)}`);
+  return emit({ outcome: audit ? complete && !remoteError ? 'ok' : 'error' : effectiveness && (remoteError || measurements.some((m) => !m.effectiveness)) ? 'error' : measurements.length ? 'ok' : 'error',
     summary, host, commit, measurements, ...(remoteError ? { remoteError } : {}) });
 }
 
@@ -123,9 +178,15 @@ export function record(ctx: Context, deps: { createStore?: (root: string) => Pic
   if (!p || measurements.length === 0) return emit({ outcome: 'fail', summary: 'nothing measured' });
   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 previous = p.sweep === true ? lastLedgerLine(effectiveInstanceRoot()) : null;
+  const continuing = previous?.sweepVisited && previous.sweepVisited < Number(p.total)
+    && previous.next === Number(p.start) && previous.total === Number(p.total);
+  const visited = p.sweep === true ? Math.min(Number(p.total), (continuing ? previous.sweepVisited! : 0) + results.length) : undefined;
+  const sweepCostSecs = p.sweep === true ? (continuing ? previous.sweepCostSecs ?? 0 : 0) + Number(p.estimatedSecs) : undefined;
+  const sweepSlices = p.sweep === true ? Number(p.sweepElapsed ?? (continuing ? previous.sweepSlices ?? 0 : 0)) + 1 : undefined;
   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,
+    commit: String(m?.commit ?? '?'), budgetSecs: Number(p.budgetSecs), results, ...(visited === undefined ? {} : { sweepVisited: visited, sweepCostSecs, sweepSlices }),
   };
   const root = effectiveInstanceRoot();
   appendLedger(root, line);
@@ -139,7 +200,7 @@ export function record(ctx: Context, deps: { createStore?: (root: string) => Pic
       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 };
+        secs: result.secs, rssMb: result.rssMb, caught90: result.caught90, range: line.range, ...(result.effectiveness ? { effectiveness: result.effectiveness } : {}) };
       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, {
@@ -155,6 +216,12 @@ export function record(ctx: Context, deps: { createStore?: (root: string) => Pic
       }
     }
   }
+  if (p.sweep === true) {
+    const etaDays = visited === Number(p.total) ? 0 : p.slicesNeeded !== undefined
+      ? Math.ceil((Number(p.slicesNeeded) - 1) / 4)
+      : Math.ceil(Math.max(0, Number(p.totalCostSecs) - (sweepCostSecs ?? 0)) / Number(p.budgetSecs) / 4);
+    debug.log('test-diet.sweep', 'slice', { start: line.start, end: line.end, total: line.total, etaDays });
+  }
   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 });
@@ -210,7 +277,8 @@ if (import.meta.main) {
       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)
+      const flags = process.argv.slice(3);
+      process.exitCode = step === 'pick' ? pick(ctx, flags.includes('--sweep')) : step === 'measure' ? measure(ctx, false, flags.includes('--effectiveness')) : 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) {

package/scripts/ux/demo-rehearsal.ts

@@ -2,10 +2,10 @@ import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import sharp from 'sharp';
 import { Frames, launch, PUBLIC_LEAK_CHECK, sleep } from './lib/cdp.js';
-import { failedApiResponse, judgeRun, judgeScene, worstSceneState, type SceneObservation, type SceneState } from './lib/rehearsal-verdict.js';
+import { EMPTY_STATE_PHRASES, failedApiResponse, judgeRun, judgeScene, worstSceneState, type SceneObservation, type SceneState } from './lib/rehearsal-verdict.js';
+export { EMPTY_STATE_PHRASES } from './lib/rehearsal-verdict.js';
 
 const TITLES = ['문서 아키텍처', '라이브 트레이스', '루프 에이전트', '그래프 편집기', '마법사 → 마켓', 'PTY 인텔리전스'];
-export const EMPTY_STATE_PHRASES = ['지금 도는 런이 없습니다', '마법사가 아직 돌지 않았습니다', '터미널을 기다리는 중', '판단을 기다리는 중', '못 읽음'] as const;
 
 export function sceneSnapshotScript(): string {
   return `(()=>{const sections=[...document.querySelectorAll('[data-inside-scene]')]; const visible=sections.filter(s=>!s.hidden && s.getClientRects().length>0); const text=visible.length===1?visible[0].innerText:''; return {sectionsInDom:sections.length,visibleScene:visible.length===1?Number(visible[0].getAttribute('data-inside-scene')):null,textLength:text.length,emptyStates:${JSON.stringify(EMPTY_STATE_PHRASES)}.filter(phrase=>text.includes(phrase))}})()`;

package/scripts/ux/lib/rehearsal-verdict.ts

@@ -43,6 +43,7 @@ export type SceneResult = SceneObservation & { verdict: 'ok' | 'broken' | 'unver
 /** A scene the demo hides is not a pass — it was not seen. OP 10-03: ⑤ (wizard → market) is the 10-08 highlight. */
 export const UNVERIFIED_REASON = '시연 모드에서 숨긴 장면 — WIZ1 착지 뒤 실물 필요';
 const CIRCLED = ['①', '②', '③', '④', '⑤', '⑥', '⑦', '⑧', '⑨'];
+export const EMPTY_STATE_PHRASES = ['지금 도는 런이 없습니다', '마법사가 아직 돌지 않았습니다', '터미널을 기다리는 중', '판단을 기다리는 중', '못 읽음', '지금 PTY 판단이 없습니다'] as const;
 
 export function judgeScene(obs: SceneObservation): SceneResult {
   if (obs.hiddenByDemo) return { ...obs, verdict: 'unverified', reasons: [UNVERIFIED_REASON] };

package/scripts/video/youtube-summary.ts

@@ -0,0 +1,133 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { downloadAudio, splitAudio } from '../../skills/youtube-master/src/audio.js';
+import { transcribeChunks } from '../../skills/youtube-master/src/stt.js';
+import { which } from '../../skills/youtube-master/src/util.js';
+import { judge } from '../../src/llm/judge-layer.js';
+import {
+  dispatchYoutubeTranscript, extractYoutubeVideoId, type YoutubeTranscriptResult,
+} from '../../src/skills/tools/youtube-transcript.js';
+
+type Summary = { verdict: string; keyPoints: string[]; cards: string[] };
+type StudyNote = { concepts: string[]; terms: { term: string; definition: string }[]; steps: string[]; questions: string[] };
+
+const oneItem = (item: unknown): item is string =>
+  typeof item === 'string' && !!item.trim() &&
+  !/[\r\n\u2028\u2029]/u.test(item) &&
+  !/^(?:#{1,6}(?:\s|$)|[-*+]\s|\d+[.)]\s|>)/u.test(item.trim());
+const lines = (items: unknown): items is string[] =>
+  Array.isArray(items) && items.every(oneItem);
+type Result =
+  | { outcome: 'ok'; path: string; videoId: string }
+  | { outcome: 'no-transcript'; videoId: string; reason?: 'stt-unavailable' }
+  | { outcome: 'invalid-video-id' };
+
+function parseSummary(value: unknown): Summary | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const v = value as Record<string, unknown>;
+  if (!oneItem(v.verdict) ||
+      !lines(v.keyPoints) || v.keyPoints.length < 5 || v.keyPoints.length > 7 ||
+      !lines(v.cards) || v.cards.length === 0 ||
+      !v.cards.every(card => /^Q: \S.*\? A: \S.*$/u.test(card.trim()))) return null;
+  return { verdict: v.verdict.trim(), keyPoints: v.keyPoints.map(s => s.trim()), cards: v.cards.map(s => s.trim()) };
+}
+
+function parseStudyNote(value: unknown): StudyNote | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const v = value as Record<string, unknown>;
+  if (!lines(v.concepts) || v.concepts.length === 0 ||
+      !Array.isArray(v.terms) || v.terms.length === 0 ||
+      !v.terms.every((entry: unknown) => entry && typeof entry === 'object' && !Array.isArray(entry) &&
+        oneItem((entry as Record<string, unknown>).term) && oneItem((entry as Record<string, unknown>).definition)) ||
+      !lines(v.steps) || v.steps.length === 0 ||
+      !lines(v.questions) || v.questions.length < 3 || v.questions.length > 5) return null;
+  return {
+    concepts: v.concepts.map(s => s.trim()),
+    terms: (v.terms as { term: string; definition: string }[]).map(({ term, definition }) => ({ term: term.trim(), definition: definition.trim() })),
+    steps: v.steps.map(s => s.trim()), questions: v.questions.map(s => s.trim()),
+  };
+}
+
+export async function runYoutubeSummary(
+  url: string,
+  stateRoot: string,
+  deps: {
+    transcript?: (url: string) => Promise<YoutubeTranscriptResult>;
+    binary?: (name: 'yt-dlp' | 'ffmpeg') => string;
+    download?: (url: string, dir: string) => Promise<string>;
+    split?: (audio: string, dir: string, seconds: number) => Promise<string[]>;
+    stt?: (chunks: string[]) => Promise<{ transcript: string }>;
+    call?: (args: { prompt: string; signal?: AbortSignal; provider: string; model: string }) => Promise<{ text: string }>;
+    format?: unknown;
+  } = {},
+): Promise<Result> {
+  const format = deps.format === undefined ? 'summary' : deps.format;
+  if (format !== 'summary' && format !== 'study-note') throw new Error('input.format must be summary or study-note');
+  const videoId = extractYoutubeVideoId(url);
+  if (!videoId) return { outcome: 'invalid-video-id' };
+  const transcript = await (deps.transcript ?? (source => dispatchYoutubeTranscript({ url: source })))(url);
+  let text = transcript.text;
+  if (!text.trim() || transcript.provider === 'none') {
+    try {
+      for (const name of ['yt-dlp', 'ffmpeg'] as const) (deps.binary ?? which)(name);
+    } catch {
+      return { outcome: 'no-transcript', videoId, reason: 'stt-unavailable' };
+    }
+    const dir = mkdtempSync(join(tmpdir(), 'youtube-summary-stt-'));
+    try {
+      const audio = await (deps.download ?? downloadAudio)(url, dir);
+      const chunks = await (deps.split ?? splitAudio)(audio, dir, 25 * 60);
+      text = (await (deps.stt ?? transcribeChunks)(chunks)).transcript;
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+    if (!text.trim()) return { outcome: 'no-transcript', videoId };
+  }
+
+  if (format === 'study-note') {
+    const decision = await judge({
+      site: 'video.youtube-summary',
+      prompt: `Create a study note only from the supplied YouTube transcript. Do not invent facts. Return ONLY JSON with exactly these fields: {"concepts":["concise concept explanations"],"terms":[{"term":"term","definition":"definition"}],"steps":["ordered explanation of the subject"],"questions":["3 to 5 self-check questions"]}. Include at least one concept, term and step, and 3 to 5 questions. Keep every item on one line. Write in the transcript's language.\n\nTranscript for ${videoId}:\n${text}`,
+      schema: parseStudyNote,
+      ...(deps.call ? { call: deps.call, resolveRoleProvider: () => ({ provider: { name: 'fake' }, model: 'fake' }) } : {}),
+    });
+    if (!decision.ok) throw new Error(`YouTube study-note judge failed: ${decision.reason}`);
+    const { concepts, terms, steps, questions } = decision.value;
+    const cell = (s: string) => s.replace(/\\/g, '\\\\').replace(/\|/g, '\\|');
+    const markdown = `# YouTube study note — ${videoId}\n\nSource: https://www.youtube.com/watch?v=${videoId}\n\n## 개념 정리\n${concepts.map(s => `- ${s}`).join('\n')}\n\n## 용어 표\n| 용어 | 뜻 |\n| --- | --- |\n${terms.map(({ term, definition }) => `| ${cell(term)} | ${cell(definition)} |`).join('\n')}\n\n## 단계별 설명\n${steps.map((s, index) => `${index + 1}. ${s}`).join('\n')}\n\n## 스스로 확인 문제\n${questions.map((s, index) => `${index + 1}. ${s}`).join('\n')}\n`;
+    const path = join(resolve(stateRoot), 'youtube-summary', `${videoId}.md`);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, markdown);
+    return { outcome: 'ok', path, videoId };
+  }
+
+  const decision = await judge({
+    site: 'video.youtube-summary',
+    prompt: `Summarize only the supplied YouTube transcript. Do not invent facts. Return ONLY JSON with exactly these fields: {"verdict":"one-line conclusion","keyPoints":["5 to 7 concise key points"],"cards":["Q: A question? A: Its answer."]}. Include one or more cards, each on one line in this Q:/A: format. Write in the transcript's language.\n\nTranscript for ${videoId}:\n${text}`,
+    schema: parseSummary,
+    ...(deps.call ? { call: deps.call, resolveRoleProvider: () => ({ provider: { name: 'fake' }, model: 'fake' }) } : {}),
+  });
+  if (!decision.ok) throw new Error(`YouTube summary judge failed: ${decision.reason}`);
+  const { verdict, keyPoints, cards } = decision.value;
+  const markdown = `# YouTube summary — ${videoId}\n\nSource: https://www.youtube.com/watch?v=${videoId}\n\n## One-line verdict\n${verdict}\n\n## Key points\n${keyPoints.map(point => `- ${point}`).join('\n')}\n\n## Cards\n${cards.map((card, index) => `### Card ${index + 1}\n${card}`).join('\n\n')}\n`;
+  const path = join(resolve(stateRoot), 'youtube-summary', `${videoId}.md`);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, markdown);
+  return { outcome: 'ok', path, videoId };
+}
+
+if (import.meta.main) {
+  try {
+    const contextPath = process.env.ELANOUS_GRAPH_CONTEXT;
+    if (!contextPath) throw new Error('ELANOUS_GRAPH_CONTEXT required');
+    const context = JSON.parse(readFileSync(contextPath, 'utf8')) as { graphId?: string; nodeId?: string; input?: { url?: unknown; format?: unknown } };
+    if (context.graphId !== 'youtube-summary' || context.nodeId !== 'summary') throw new Error('youtube-summary graph context mismatch');
+    if (typeof context.input?.url !== 'string' || !context.input.url.trim()) throw new Error('input.url required');
+    const root = resolve(contextPath, '..', '..', '..', '..');
+    console.log(JSON.stringify(await runYoutubeSummary(context.input.url, root, { format: context.input.format })));
+  } catch (error) {
+    console.log(JSON.stringify({ outcome: 'fail', reason: error instanceof Error ? error.message : String(error) }));
+    process.exitCode = 1;
+  }
+}