elanous 0.2.4 → 0.2.6

package/scripts/release-loop/release-docs.ts

@@ -1,26 +1,27 @@
+import { debug } from '../../src/debug/log.js';
 import type { ReleaseManifest } from '../../src/release-loop/manifest.js';
 
-/** Render the cutoff's IN set, never the deferred or escalation lists. */
+/** Render public IN lines only; keep private titles and PR numbers out of release notes. */
 export function renderReleaseNotes(manifest: ReleaseManifest, version: string): string {
   const sections = [
     { heading: 'Behavior changes', kinds: ['feat', 'fix'] },
     { heading: 'Security', kinds: ['security'] },
-    { heading: 'Internal', kinds: ['internal'] },
-    { heading: 'Other changes', kinds: ['unknown'] },
   ] as const;
   const lines = [`# ${version}`, ''];
+  let shown = 0;
   for (const section of sections) {
-    const entries = manifest.in.filter((entry) => section.kinds.some((kind) => kind === (entry.kind ?? 'unknown')));
+    const entries = manifest.in.filter((entry) => section.kinds.some((kind) => kind === entry.kind) && entry.line);
     if (!entries.length) continue;
     lines.push(`## ${section.heading}`, '');
     for (const entry of entries) {
-      const label = (entry.line ?? entry.title).replace(/\r?\n/g, ' ').trim();
-      lines.push(entry.prNumber === undefined
-        ? `- ${label}`
-        : `- ${label} ([#${entry.prNumber}](https://github.com/ElanvitalAI/elanous/pull/${entry.prNumber}))`);
+      lines.push(`- ${entry.line!.replace(/\r?\n/g, ' ').trim()}`);
+      shown++;
     }
     lines.push('');
   }
+  const omitted = manifest.in.length - shown;
+  if (omitted) lines.push(`Plus ${omitted} internal ${omitted === 1 ? 'change' : 'changes'}.`);
+  debug.log('release-loop.docs', 'notes-rendered', { version, shown, omitted });
   return `${lines.join('\n').trimEnd()}\n`;
 }
 
@@ -33,8 +34,8 @@ export function flipNextReleaseMarkers(text: string, version: string): string {
  * Fold notes that landed before the release loop (a PR appending its own line, a headline paragraph)
  * into the rendered notes instead of refusing or overwriting them. Paragraphs before any section stay
  * under the title (the headline slot); list lines the cutoff did not render keep their own `##` section
- * (lines outside any section go to «Also in this release»). A line that differs from a rendered one only
- * by the trailing PR link is the same line. Folding its own output again gives the same bytes.
+ * (lines outside any section go to «Also in this release»). A hand-written link cannot be identified
+ * as generator output from its shape alone. Folding its own output again gives the same bytes.
  */
 export function foldPreLandedNotes(existing: string, rendered: string): { text: string; folded: number } {
   const key = (line: string) => line.trim().replace(/\s*\(\[#\d+\]\([^)]*\)\)\s*$/, '').trim();
@@ -46,12 +47,14 @@ export function foldPreLandedNotes(existing: string, rendered: string): { text:
   const alreadyRendered = (line: string, section: string | null) => section === null ? renderedAll.has(key(line)) : (renderedBySection.get(section)?.has(key(line)) ?? false);
   const paragraphs: string[] = [];
   const sections = new Map<string, string[]>();
+  const [title, ...rest] = rendered.trimEnd().split('\n');
+  const footer = rest.find((line) => /^Plus \d+ internal changes?\.$/.test(line));
   const DEFAULT = '## Also in this release';
   let heading: string | null = null;
   for (const raw of existing.split(/\r?\n/)) {
     const line = raw.trimEnd();
     const trimmed = line.trim();
-    if (/^#\s/.test(trimmed)) continue;
+    if (/^#\s/.test(trimmed) || /^Plus \d+ internal changes?\.$/.test(trimmed)) continue;
     if (!trimmed) {
       // Keep paragraph breaks (collapse runs of blank lines to one) in the headline block and in sections.
       if (heading === null) { if (paragraphs.length && paragraphs.at(-1) !== '') paragraphs.push(''); }
@@ -75,9 +78,9 @@ export function foldPreLandedNotes(existing: string, rendered: string): { text:
     }
   }
   // Rendered notes = title ⊕ ordered `##` sections. A pre-landed section with the same heading merges into it.
-  const [title, ...rest] = rendered.trimEnd().split('\n');
   const renderedSections: Array<{ heading: string; lines: string[] }> = [];
   for (const line of rest) {
+    if (line === footer) continue;
     if (/^##\s/.test(line.trim())) renderedSections.push({ heading: line.trim(), lines: [] });
     else if (renderedSections.length && line.trim()) renderedSections.at(-1)!.lines.push(line);
   }
@@ -97,6 +100,10 @@ export function foldPreLandedNotes(existing: string, rendered: string): { text:
   while (paragraphs.at(-1) === '') paragraphs.pop();
   if (paragraphs.length) parts.push(paragraphs.join('\n'), '');
   for (const section of renderedSections) parts.push(section.heading, '', ...section.lines, '');
-  for (const [name, lines] of sections) { parts.push(name, '', ...lines, ''); folded += Math.max(lines.filter(Boolean).length, 1); }
+  for (const [name, lines] of sections) {
+    parts.push(name, '', ...lines, '');
+    folded += Math.max(lines.filter(Boolean).length, 1);
+  }
+  if (footer) parts.push(footer);
   return { text: `${parts.join('\n').trimEnd()}\n`, folded };
 }

package/scripts/release-loop/shard-plan.ts

@@ -0,0 +1,47 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** Read per-file seconds from previous cut Pod reports; missing or damaged reports are not estimates. */
+export function readFileDurations(dir: string): Map<string, number> {
+  const durations = new Map<string, number>();
+  let names: string[];
+  const entities: Record<string, string> = { '&amp;': '&', '&quot;': '"', '&apos;': "'", '&lt;': '<', '&gt;': '>' };
+  try { names = readdirSync(dir).filter((name) => name.endsWith('.junit.xml')).sort(); }
+  catch { return durations; }
+  for (const name of names) {
+    try {
+      const xml = readFileSync(join(dir, name), 'utf8');
+      for (const match of xml.matchAll(/<testsuite\b([^>]*)>/g)) {
+        const attrs = match[1]!;
+        const file = /\bfile="([^"]+)"/.exec(attrs)?.[1];
+        const rawTime = /\btime="([^"]+)"/.exec(attrs)?.[1];
+        if (!file || rawTime === undefined) continue;
+        const seconds = Number(rawTime);
+        if (!Number.isFinite(seconds) || seconds < 0) continue;
+        const path = file.replace(/&(?:amp|quot|apos|lt|gt);/g, (entity) => entities[entity]!);
+        durations.set(path, Math.max(durations.get(path) ?? 0, seconds));
+      }
+    } catch { /* One unreadable report must not discard the others. */ }
+  }
+  return durations;
+}
+
+/** Longest processing time first; tie-breaks use lexical paths, then the least populated lightest shard. */
+export function planShards(files: string[], durations: Map<string, number>, count: number): Array<{ files: string[]; plannedSeconds: number }> {
+  if (!Number.isSafeInteger(count) || count < 1) throw new Error('invalid shard count');
+  const known = files.map((file) => durations.get(file)).filter((value): value is number => value !== undefined && Number.isFinite(value) && value >= 0).sort((a, b) => a - b);
+  const median = known.length ? (known[Math.floor((known.length - 1) / 2)]! + known[Math.floor(known.length / 2)]!) / 2 : 1;
+  const weight = (file: string) => {
+    const value = durations.get(file);
+    return value !== undefined && Number.isFinite(value) && value >= 0 ? value : median;
+  };
+  const shards = Array.from({ length: Math.min(count, files.length) }, () => ({ files: [] as string[], plannedSeconds: 0 }));
+  for (const file of [...files].sort((a, b) => weight(b) - weight(a) || (a < b ? -1 : a > b ? 1 : 0))) {
+    let lightest = shards[0]!;
+    for (const shard of shards) if (shard.plannedSeconds < lightest.plannedSeconds
+      || (shard.plannedSeconds === lightest.plannedSeconds && shard.files.length < lightest.files.length)) lightest = shard;
+    lightest.files.push(file);
+    lightest.plannedSeconds += weight(file);
+  }
+  return shards.filter((shard) => shard.files.length > 0);
+}

package/scripts/release-loop/test-durations.ts

@@ -0,0 +1,63 @@
+#!/usr/bin/env bun
+/**
+ * 게이트 조각 junit(`gate-logs/<cut|baseline>/pod-*.junit.xml`)에서 파일별 소요를 모은다 — K10 D4 «느린 시험 목록»의 자.
+ * 같은 파일이 여러 번 돌았으면(반쪼개기·격리) 가장 적은 파일과 함께 돈 기록을 쓴다 — 혼자 돈 값이 그 파일의 값에 가장 가깝다.
+ *
+ *   bun scripts/release-loop/test-durations.ts <gate-logs/cut 디렉터리> [--top 5] [--json]
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export type FileDuration = { file: string; seconds: number; tests: number; runFiles: number };
+
+/** junit 한 벌에서 `<testsuite file=… time=… tests=…>` 를 읽는다. */
+export function parseJunitSuites(xml: string): Array<{ file: string; seconds: number; tests: number }> {
+  const suites: Array<{ file: string; seconds: number; tests: number }> = [];
+  for (const match of xml.matchAll(/<testsuite\b([^>]*)>/g)) {
+    const attrs = match[1]!;
+    const file = /\bfile="([^"]+)"/.exec(attrs)?.[1];
+    const time = Number(/\btime="([^"]+)"/.exec(attrs)?.[1]);
+    const tests = Number(/\btests="([^"]+)"/.exec(attrs)?.[1] ?? '0');
+    if (file && Number.isFinite(time)) suites.push({ file, seconds: time, tests: Number.isFinite(tests) ? tests : 0 });
+  }
+  return suites;
+}
+
+/** 여러 조각의 junit 을 파일별 하나로 접는다. */
+export function collectDurations(reports: string[]): FileDuration[] {
+  const best = new Map<string, FileDuration>();
+  for (const xml of reports) {
+    const suites = parseJunitSuites(xml);
+    for (const suite of suites) {
+      const current = best.get(suite.file);
+      if (!current || suites.length < current.runFiles) best.set(suite.file, { ...suite, runFiles: suites.length });
+    }
+  }
+  return [...best.values()].sort((a, b) => b.seconds - a.seconds || a.file.localeCompare(b.file));
+}
+
+/** 상위 `percent`% 파일과 그 몫. */
+export function topShare(durations: FileDuration[], percent: number): { files: FileDuration[]; seconds: number; totalSeconds: number; share: number } {
+  const count = Math.max(1, Math.ceil(durations.length * percent / 100));
+  const files = durations.slice(0, count);
+  const seconds = files.reduce((sum, item) => sum + item.seconds, 0);
+  const totalSeconds = durations.reduce((sum, item) => sum + item.seconds, 0);
+  return { files, seconds, totalSeconds, share: totalSeconds ? seconds / totalSeconds : 0 };
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const dir = args.find((arg) => !arg.startsWith('--'));
+  if (!dir) { console.error('usage: test-durations.ts <gate-logs/cut> [--top 5] [--json]'); process.exit(2); }
+  const topIndex = args.indexOf('--top');
+  const percent = topIndex >= 0 ? Number(args[topIndex + 1]) : 5;
+  const names = readdirSync(dir).filter((name) => name.endsWith('.junit.xml'));
+  if (!names.length) { console.error(`no *.junit.xml under ${dir} — was this sweep run before junit reports were kept?`); process.exit(1); }
+  const durations = collectDurations(names.map((name) => readFileSync(join(dir, name), 'utf8')));
+  const top = topShare(durations, percent);
+  if (args.includes('--json')) console.log(JSON.stringify({ reports: names.length, files: durations.length, totalSeconds: top.totalSeconds, topPercent: percent, topSeconds: top.seconds, topShare: top.share, top: top.files }, null, 2));
+  else {
+    console.log(`reports ${names.length} · files ${durations.length} · total ${top.totalSeconds.toFixed(0)}s · top ${percent}% = ${top.files.length} files · ${top.seconds.toFixed(0)}s (${(top.share * 100).toFixed(1)}%)`);
+    for (const item of top.files) console.log(`${item.seconds.toFixed(1)}\t${item.tests}\t${item.file}`);
+  }
+}

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

@@ -11,8 +11,9 @@ export function runUpgrade(run: CommandRunner = runCommand) {
   const output = run('bash', ['scripts/release-upgrade-check.sh', '--from', context.input.previousVersion, '--candidate', candidate]);
   if (output.stderr) process.stderr.write(output.stderr);
   const verdicts = output.stdout.split('\n').filter((line) => /\[upgrade\] verdict\b/.test(line));
-  const passed = verdicts.length === 2 && verdicts.some((line) => /^ubuntu:24\.04\s+\[upgrade\] verdict ok\s*$/.test(line))
-    && verdicts.some((line) => /^debian:12\s+\[upgrade\] verdict ok\s*$/.test(line));
+  // `release-upgrade-check.sh` appends `from=<v> to=«<v> <sha>»` after the verdict (0.2.4) — the verdict word is what counts.
+  const passed = verdicts.length === 2 && verdicts.some((line) => /^ubuntu:24\.04\s+\[upgrade\] verdict ok(?:\s|$)/.test(line))
+    && verdicts.some((line) => /^debian:12\s+\[upgrade\] verdict ok(?:\s|$)/.test(line));
   const outcome: NodeOutcome = output.status === 0 && passed ? 'ok' : verdicts.length === 0 || output.status === null || output.status === 2 ? 'error' : 'fail';
   return { outcome, verdict: outcome === 'ok' ? 'pass' as const : 'fail' as const,
     summary: outcome === 'ok' ? `upgrade ${context.input.previousVersion} → ${context.input.version} · ${verdicts.length} images` : `upgrade failed (rc=${output.status}): ${output.stdout.trim().split('\n').at(-1) || output.stderr.trim() || 'no upgrade verdict'}` };

package/scripts/test-audit-coverage-per-file.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# K10 D5b ① — test/ 파일별 커버리지(node-b). 산출: ~/f-audit/cov/<n>/lcov.info ⊕ index.tsv(file n rc secs)
+set -u
+A=~/f-audit; rm -rf $A && mkdir -p $A/cov $A/logs && cd $A
+git clone -q --depth 1 file://$HOME/mirror/elanous-agent.git repo || exit 2
+cd repo && git log --oneline -1 > $A/COMMIT && ~/.local/share/elanous/bin/bun install --frozen-lockfile >/dev/null 2>&1 || echo "install rc=$?" >> $A/COMMIT
+git ls-files 'test/*.test.ts' 'test/**/*.test.ts' | grep -v '^test/integration/' | awk '{print NR"\t"$0}' > $A/list.tsv
+wc -l < $A/list.tsv > $A/TOTAL
+run_one() {
+  n="$1"; f="$2"; s=$(date +%s)
+  ( ulimit -v 8000000 2>/dev/null; timeout 120 ~/.local/share/elanous/bin/bun test "./$f" --coverage --coverage-reporter=lcov --coverage-dir "$HOME/f-audit/cov/$n" > "$HOME/f-audit/logs/$n.log" 2>&1 ); rc=$?
+  printf '%s\t%s\t%s\t%s\n' "$f" "$n" "$rc" "$(( $(date +%s) - s ))" >> "$HOME/f-audit/index.tsv"
+}
+export -f run_one
+cd $A/repo && awk -F'\t' '{print $1" "$2}' $A/list.tsv | xargs -P 8 -n 2 bash -c 'run_one "$0" "$1"'
+echo DONE > $A/DONE

package/scripts/test-audit-meaningless.ts

@@ -0,0 +1,88 @@
+// K10 D5 — 무의미 시험 전수조사(읽기 전용 · 정적). 산출 = TSV(파일 · 분류 · 근거) ⊕ 요약 JSON.
+// 분류: A 대상 없음(상대 import 가 가리키는 파일이 없다 · 또는 저장소 코드를 하나도 안 부른다)
+//       B 상수=상수(expect(<리터럴>)의 리터럴이 기대값과 같다 · expect(x).toBe(x) 같은 식)
+//       C 중복(파일 본문 해시 동일 · 또는 같은 대상 모듈 ⊕ 같은 시험 제목 집합)
+//       D 문면 고정(소스·문서를 readFileSync 로 읽어 toContain/toMatch 만 한다 — 동작을 안 부른다)
+//       E 영구 skip(skip/todo/xit · skipIf(true) · 전부 skip)
+import { execFileSync } from 'node:child_process';
+import { readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, join, resolve } from 'node:path';
+
+const root = process.argv[2]; const out = process.argv[3];
+const files = execFileSync('git', ['ls-files', '*.test.*'], { cwd: root, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).split('\n').filter(Boolean);
+
+const EXT = ['', '.ts', '.tsx', '.js', '.mjs', '.cjs', '.mts', '/index.ts', '/index.tsx', '/index.js'];
+function resolveRel(fromFile: string, spec: string): boolean {
+  const base = resolve(root, dirname(fromFile), spec);
+  const cands = [base, base.replace(/\.js$/, '.ts'), base.replace(/\.js$/, '.tsx'), base.replace(/\.mjs$/, '.mts')];
+  for (const c of cands) for (const e of EXT) if (existsSync(c + e)) return true;
+  return false;
+}
+function resolveAlias(fromFile: string, spec: string): boolean {
+  // PWA `@/x` → apps/pwa/src/x
+  if (!spec.startsWith('@/')) return true;
+  const base = join(root, 'apps/pwa/src', spec.slice(2));
+  for (const e of EXT) if (existsSync(base + e)) return true;
+  return false;
+}
+
+type Row = { file: string; cls: string[]; evidence: string[]; lines: number; tests: number };
+const rows: Row[] = [];
+const hashes = new Map<string, string[]>();
+const titleSig = new Map<string, string[]>();
+
+for (const f of files) {
+  const text = readFileSync(join(root, f), 'utf8');
+  const lines = text.split('\n').length;
+  const cls: string[] = []; const ev: string[] = [];
+  const tests = (text.match(/\b(?:test|it)(?:\.(?:only|each\([^)]*\)))?\s*\(/g) ?? []).length;
+  // imports
+  // 실제 import 문만(줄 맨 앞 import/export … from · 줄 맨 앞 await/const … import('…')) — 픽스처 문자열·주석 속 모양은 뺀다.
+  const specs = [
+    ...[...text.matchAll(/^\s*(?:import|export)\b[^'";`]*?\bfrom\s+['"]([^'"]+)['"]/gm)].map((m) => m[1]),
+    ...[...text.matchAll(/^\s*import\s+['"]([^'"]+)['"]/gm)].map((m) => m[1]),
+    ...[...text.matchAll(/^[^'"`\n/]*\bawait\s+import\(\s*['"]([^'"]+)['"]\s*\)/gm)].map((m) => m[1]),
+    ...[...text.matchAll(/^[^'"`\n/]*\bimport\(\s*`(\.{1,2}\/[^`$?]+)/gm)].map((m) => m[1]),
+  ];
+  const rel = specs.filter((s) => s.startsWith('.') || s.startsWith('@/'));
+  const missing = rel.filter((s) => (s.startsWith('@/') ? !resolveAlias(f, s) : !resolveRel(f, s)));
+  if (missing.length) { cls.push('A'); ev.push(`missing-import:${missing.slice(0, 3).join(',')}`); }
+  const repoCode = rel.filter((s) => !/\.(json|md|txt|css)$/.test(s));
+  // E: skip
+  const skips = (text.match(/\b(?:test|it|describe)\.(?:skip|todo)\s*\(|\bx(?:it|describe|test)\s*\(|\.skipIf\(\s*true\s*\)/g) ?? []).length;
+  if (skips > 0 && (tests === 0 || skips >= tests)) { cls.push('E'); ev.push(`all-skipped:${skips}/${tests}`); }
+  else if (skips > 0) ev.push(`some-skipped:${skips}/${tests}`);
+  // B: constant = constant
+  const constEq = [...text.matchAll(/^[^'"`\n]*?expect\(\s*(['"`][^'"`\n]{0,80}['"`]|-?\d+(?:\.\d+)?|true|false|null)\s*\)\s*\.\s*(?:toBe|toEqual|toStrictEqual)\(\s*(['"`][^'"`\n]{0,80}['"`]|-?\d+(?:\.\d+)?|true|false|null)\s*\)/gm)]
+    .filter((m) => m[1] === m[2]);
+  const selfEq = [...text.matchAll(/^[^'"`\n]*?expect\(\s*([A-Za-z_$][\w$.]*)\s*\)\s*\.\s*(?:toBe|toEqual|toStrictEqual)\(\s*([A-Za-z_$][\w$.]*)\s*\)/gm)].filter((m) => m[1] === m[2]);
+  const litExpect = (text.match(/expect\(\s*(?:['"`][^'"`\n]*['"`]|-?\d+(?:\.\d+)?|true|false|null)\s*\)/g) ?? []).length;
+  if (constEq.length + selfEq.length > 0) { cls.push('B'); ev.push(`const-eq:${constEq.length + selfEq.length}`); }
+  else if (litExpect >= 3) ev.push(`literal-subject-expects:${litExpect}`);
+  // D: text pinning — readFileSync of source/docs ⊕ toContain/toMatch only, no calls into imported code
+  const readsText = /readFileSync\(|Bun\.file\([^)]*\)\.text\(/.test(text);
+  const matchers = (text.match(/\.\s*(?:toContain|toMatch|not\.toContain|not\.toMatch)\(/g) ?? []).length;
+  const allExpects = (text.match(/\bexpect\(/g) ?? []).length;
+  if (readsText && allExpects > 0 && matchers / allExpects >= 0.8 && repoCode.length === 0) { cls.push('D'); ev.push(`text-pin:${matchers}/${allExpects}`); }
+  else if (readsText && allExpects > 0 && matchers / allExpects >= 0.8) ev.push(`text-pin-with-imports:${matchers}/${allExpects}`);
+  // A(2): no repo code at all and no file reads — tests only itself
+  if (repoCode.length === 0 && !readsText && !/spawn|execFile|Bun\.spawn|fetch\(/.test(text)) { if (!cls.includes('A')) { cls.push('A'); ev.push('no-repo-code'); } }
+  // C: duplicates
+  const h = createHash('sha256').update(text).digest('hex').slice(0, 16);
+  hashes.set(h, [...(hashes.get(h) ?? []), f]);
+  const titles = [...text.matchAll(/\b(?:test|it)\s*\(\s*['"`]([^'"`]{4,})['"`]/g)].map((m) => m[1]).sort();
+  if (titles.length >= 2) { const sig = createHash('sha256').update(repoCode.sort().join('|') + '#' + titles.join('|')).digest('hex').slice(0, 16); titleSig.set(sig, [...(titleSig.get(sig) ?? []), f]); }
+  rows.push({ file: f, cls, evidence: ev, lines, tests });
+}
+const byFile = new Map(rows.map((r) => [r.file, r]));
+for (const [h, fs] of hashes) if (fs.length > 1) for (const f of fs) { const r = byFile.get(f)!; if (!r.cls.includes('C')) r.cls.push('C'); r.evidence.push(`same-bytes:${fs.filter((x) => x !== f).slice(0, 2).join(',')}`); }
+for (const [s, fs] of titleSig) if (fs.length > 1) for (const f of fs) { const r = byFile.get(f)!; if (!r.cls.includes('C')) r.cls.push('C'); r.evidence.push(`same-target+titles:${fs.filter((x) => x !== f).slice(0, 2).join(',')}`); }
+
+const tsv = ['file\tclasses\ttests\tlines\tevidence', ...rows.filter((r) => r.cls.length).map((r) => `${r.file}\t${r.cls.join(',')}\t${r.tests}\t${r.lines}\t${r.evidence.join(' ; ')}`)].join('\n');
+writeFileSync(join(out, 'test-audit.tsv'), tsv + '\n');
+const count = (c: string) => rows.filter((r) => r.cls.includes(c)).length;
+const summary = { total: rows.length, flagged: rows.filter((r) => r.cls.length).length, A: count('A'), B: count('B'), C: count('C'), D: count('D'), E: count('E'),
+  A_missing: rows.filter((r) => r.evidence.some((e) => e.startsWith('missing-import'))).length, A_noRepo: rows.filter((r) => r.evidence.includes('no-repo-code')).length };
+writeFileSync(join(out, 'test-audit-summary.json'), JSON.stringify(summary, null, 2));
+console.log(JSON.stringify(summary));

package/scripts/test-audit-overlap-and-weak.ts

@@ -0,0 +1,73 @@
+// K10 D5b — ① 커버리지 겹침(고유 기여) ② 은퇴 기능 시험 ③ 약한 단언. 읽기 전용.
+// 사용: bun test-audit-b.ts <repo> <cov-root|-> <out-dir>
+//   cov-root = 파일별 lcov 폴더(<n>/lcov.info) ⊕ index.tsv(file n rc secs). '-' 면 ①을 건너뛴다.
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const [repo, covRoot, out] = process.argv.slice(2);
+const files = execFileSync('git', ['ls-files', '*.test.ts', '*.test.tsx'], { cwd: repo, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 }).split('\n').filter(Boolean);
+
+// ③ 약한 단언 — 파일마다 매처 종류를 센다(줄이 아니라 출현 수).
+const WEAK = new Set(['toBeDefined', 'toBeTruthy', 'toBeFalsy', 'not.toThrow', 'toBeInstanceOf', 'not.toBeNull', 'not.toBeUndefined']);
+const weakRows: string[] = ['file\texpects\tweak\tkinds'];
+let weakOnly = 0;
+// ② 은퇴 기능 — 제목에 은퇴·제거·옛 낱말 ⊕ 부정 단언(없음을 지킴)이 아닌 것
+const RETIRED = /\b(retired|legacy|deprecated|obsolete)\b|은퇴|폐기|옛 (?:문|경로|명령|이름|동작)/i;
+const retiredRows: string[] = ['file\ttitles\tnegative\tpositive\tverdict'];
+for (const f of files) {
+  const text = readFileSync(join(repo, f), 'utf8');
+  const kinds = new Map<string, number>();
+  for (const m of text.matchAll(/\)\s*\.\s*((?:not\s*\.\s*)?[a-zA-Z]+)\s*\(/g)) {
+    const k = m[1].replace(/\s+/g, '');
+    if (!/^(not\.)?to[A-Z]/.test(k)) continue;
+    kinds.set(k, (kinds.get(k) ?? 0) + 1);
+  }
+  const total = [...kinds.values()].reduce((a, b) => a + b, 0);
+  const weak = [...kinds].filter(([k]) => WEAK.has(k)).reduce((a, [, v]) => a + v, 0);
+  if (total > 0 && weak === total) { weakOnly++; weakRows.push(`${f}\t${total}\t${weak}\t${[...kinds].map(([k, v]) => `${k}:${v}`).join(',')}`); }
+  const titles = [...text.matchAll(/\b(?:test|it|describe)\s*\(\s*['"`]([^'"`]{4,})['"`]/g)].map((m) => m[1]).filter((t) => RETIRED.test(t));
+  if (titles.length) {
+    const neg = [...kinds].filter(([k]) => k.startsWith('not.') || ['toThrow','toBeUndefined','toBeNull','toBeFalsy'].includes(k)).reduce((a, [, v]) => a + v, 0)
+      + (text.match(/toHaveLength\(0\)|toEqual\(\[\]\)|toBe\(false\)|toBe\(0\)/g) ?? []).length;
+    const pos = total - neg;
+    const verdict = neg >= pos ? '가드(없음을 지킨다) — 유지' : '옛 동작 검사 후보 — 열어 보기';
+    retiredRows.push(`${f}\t${titles.slice(0, 3).join(' | ')}\t${neg}\t${pos}\t${verdict}`);
+  }
+}
+writeFileSync(join(out, 'weak-assertions.tsv'), weakRows.join('\n') + '\n');
+writeFileSync(join(out, 'retired-feature-tests.tsv'), retiredRows.join('\n') + '\n');
+
+// ① 커버리지 겹침
+let covSummary: Record<string, unknown> = { skipped: true };
+if (covRoot !== '-') {
+  const index = readFileSync(join(covRoot, 'index.tsv'), 'utf8').split('\n').filter(Boolean).map((l) => l.split('\t'));
+  const lineOwners = new Map<string, number>(); // "src:line" → 몇 파일이 닿나
+  const perTest = new Map<string, Set<string>>();
+  for (const [file, n, rc] of index) {
+    if (rc !== '0') continue;
+    const p = join(covRoot, 'cov', n, 'lcov.info');
+    if (!existsSync(p)) continue;
+    const set = new Set<string>(); let sf = '';
+    for (const line of readFileSync(p, 'utf8').split('\n')) {
+      if (line.startsWith('SF:')) sf = line.slice(3);
+      else if (line.startsWith('DA:') && sf.startsWith('src/') && !/\.test\.tsx?$/.test(sf)) {
+        const [ln, hits] = line.slice(3).split(',');
+        if (Number(hits) > 0) set.add(`${sf}:${ln}`);
+      }
+    }
+    perTest.set(file, set);
+    for (const k of set) lineOwners.set(k, (lineOwners.get(k) ?? 0) + 1);
+  }
+  const rows = [...perTest].map(([file, set]) => {
+    let unique = 0; for (const k of set) if (lineOwners.get(k) === 1) unique++;
+    return { file, lines: set.size, unique };
+  }).sort((a, b) => a.unique - b.unique || b.lines - a.lines);
+  writeFileSync(join(out, 'coverage-unique.tsv'), ['file\tcovered_src_lines\tunique_src_lines', ...rows.map((r) => `${r.file}\t${r.lines}\t${r.unique}`)].join('\n') + '\n');
+  const zero = rows.filter((r) => r.unique === 0 && r.lines > 0).length;
+  const noSrc = rows.filter((r) => r.lines === 0).length;
+  covSummary = { measured: rows.length, failedOrSkipped: index.filter((r) => r[2] !== '0').length, zeroUnique: zero, touchesNoSrc: noSrc, uniqueLe5: rows.filter((r) => r.lines > 0 && r.unique > 0 && r.unique <= 5).length, distinctSrcLines: lineOwners.size };
+}
+const summary = { files: files.length, weakOnly, retiredTitled: retiredRows.length - 1, retiredOldBehaviour: retiredRows.filter((r) => r.includes('옛 동작')).length, coverage: covSummary };
+writeFileSync(join(out, 'test-audit-b-summary.json'), JSON.stringify(summary, null, 2));
+console.log(JSON.stringify(summary));

package/scripts/test-deterministic.ts

@@ -51,7 +51,24 @@ const HARNESS_TEST_ENV_KEYS = [
   'ELANOUS_HARNESS_BOUNDARY',
   'ELANOUS_HARNESS_ROLE',
   'ELANOUS_HARNESS_DETACHED',
+] as const;
+
+// Discovery: rg -n "process\.env\.ELANOUS_(HOST|RUN|ORIGIN|SUPERVISOR|PARENT)" src
+// These are ambient execution identities, not inputs to a deterministic test.
+// debug.log also attributes SUBSTRATE and ARM_ID to every plain-object record.
+const EXECUTION_ORIGIN_ENV_KEYS = [
+  'ELANOUS_HOST_ID',
   'ELANOUS_RUN_ID',
+  'ELANOUS_RUN_CONTEXT',
+  'ELANOUS_PARENT_RUN_ID',
+  'ELANOUS_PARENT_PTY_ID',
+  'ELANOUS_PARENT_SELF_DEV_RUNS_DIR',
+  'ELANOUS_SUBSTRATE',
+  'ELANOUS_ARM_ID',
+  // Parent account selection changes CLI rotation assertions in the child.
+  'ELANOUS_CODEX_ACCOUNT',
+  // A parent's derived-root label must not reclassify a test's explicit state dir.
+  'ELANOUS_STATE_DIR_SOURCE',
 ] as const;
 
 export type ShutdownSignal = 'SIGINT' | 'SIGTERM';
@@ -254,10 +271,16 @@ export async function terminateDirectChild(
 
 export function prepareIsolatedTestEnv(sourceEnv: NodeJS.ProcessEnv, testRoot: string): NodeJS.ProcessEnv {
   const env = Object.fromEntries(
-    Object.entries(sourceEnv).filter(([key]) => !isCredentialKey(key) && !HARNESS_TEST_ENV_KEYS.includes(key as typeof HARNESS_TEST_ENV_KEYS[number])),
+    Object.entries(sourceEnv).filter(([key]) => !isCredentialKey(key)
+      && !HARNESS_TEST_ENV_KEYS.includes(key as typeof HARNESS_TEST_ENV_KEYS[number])
+      && !EXECUTION_ORIGIN_ENV_KEYS.includes(key as typeof EXECUTION_ORIGIN_ENV_KEYS[number])),
   );
   env.HOME = testRoot;
-  env.XDG_CONFIG_HOME = join(testRoot, '.config');
+  // userConfigPath() warns whenever XDG_CONFIG_HOME is set, including when
+  // config.json is absent. Use its non-XDG path; migrateLegacyXdgUserConfig()
+  // 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"
@@ -267,9 +290,8 @@ export function prepareIsolatedTestEnv(sourceEnv: NodeJS.ProcessEnv, testRoot: s
   // isolation legible in the child's own environment rather than implied.
   env.ELANOUS_STATE_DIR = join(testRoot, 'state');
   env.ELANOUS_CONFIG_DIR = join(testRoot, 'config');
-  // A deterministic test child must not inherit the harness run identity:
-  // logger API-shape tests use its absence to validate legacy records.
-  delete env.ELANOUS_RUN_ID;
+  // 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,
   // and an env var with no consumer is a surface that looks like a contract
   // while guaranteeing nothing — a later test could branch on it believing it

package/scripts/tui-sim.ts

@@ -45,6 +45,10 @@ import {
   writeFileSync, appendFileSync, readFileSync, mkdirSync, readdirSync, existsSync, unlinkSync, rmSync, renameSync,
 } from 'node:fs';
 import { execFileSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { getCapturedEnv } from '../src/shell-env-bootstrap.js';
+import { identityEnvKeys } from '../src/agent/identity-env.js';
+import { resolveKeyBytes, resolveKeyInput, writeKeyInput } from './lib/tui-sim-keys.js';
 
 const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
 
@@ -91,14 +95,18 @@ function writeMeta(id: string, m: Meta): void {
   renameSync(tmp, metaPath(id));
 }
 
-// ── named keys → escape sequences ──
-const KEYS: Record<string, string> = {
-  enter: '\r', return: '\r', tab: '\t', 'shift-tab': '\x1b[Z', esc: '\x1b', escape: '\x1b',
-  space: ' ', backspace: '\x7f', delete: '\x1b[3~',
-  up: '\x1b[A', down: '\x1b[B', right: '\x1b[C', left: '\x1b[D',
-  pageup: '\x1b[5~', pagedown: '\x1b[6~', home: '\x1b[H', end: '\x1b[F',
-  'ctrl-c': '\x03', 'ctrl-d': '\x04', 'ctrl-u': '\x15', 'ctrl-a': '\x01', 'ctrl-e': '\x05',
-};
+// ── optional child credential isolation ──
+const CLEAN_ENV_KEYS = new Set([
+  'PATH', 'HOME', 'USER', 'LOGNAME', 'SHELL', 'LANG', 'TERM', 'COLORTERM', 'TZ', 'TMPDIR',
+  'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES', 'LC_COLLATE', 'LC_NUMERIC', 'LC_TIME', 'LC_MONETARY',
+  'LC_PAPER', 'LC_NAME', 'LC_ADDRESS', 'LC_TELEPHONE', 'LC_MEASUREMENT', 'LC_IDENTIFICATION',
+]);
+
+/** Block everything except basic execution/locale variables after PTY env synthesis. */
+export function cleanPtyUnsetEnv(captured: Record<string, string>, parent: NodeJS.ProcessEnv): string[] {
+  return [...new Set([...Object.keys(captured), ...Object.keys(parent), ...identityEnvKeys()])]
+    .filter((key) => !CLEAN_ENV_KEYS.has(key));
+}
 
 // ── client: drop a command into inbox, optionally await result ──
 function argVal(args: string[], flag: string): string | null {
@@ -136,6 +144,10 @@ async function runDaemon(args: string[]): Promise<void> {
   const testMode = args.includes('--test');
   const autoWorktree = args.includes('--worktree');
   const explicitWorkdir = argVal(args, '--workdir');
+  const home = argVal(args, '--home');
+  const cleanEnv = args.includes('--clean-env');
+  if (args.includes('--home') && (!home || home.startsWith('--'))) { console.error('[tui-sim] --home requires a directory'); process.exit(1); }
+  const childHome = home ? resolve(home) : null;
   const cols = Number(argVal(args, '--cols')) || 220;
   const rows = Number(argVal(args, '--rows')) || 60;
   const bootSec = Number(argVal(args, '--boot')) || 8;
@@ -176,9 +188,12 @@ async function runDaemon(args: string[]): Promise<void> {
     + `# follow live:  tail -f ${forwardPath}\n\n`);
   console.error(`[tui-sim] start id=${id} workdir=${workdir} test=${testMode}`);
   console.error(`[tui-sim] 📡 live timeline → ${forwardPath}   (follow:  tail -f ${forwardPath})`);
+  if (childHome) mkdirSync(childHome, { recursive: true });
+  const unsetEnv = cleanEnv ? cleanPtyUnsetEnv(getCapturedEnv(), process.env) : undefined;
   const h: PtyHandle = startPty({
     cmd: 'bun', args: [binPath, ...isoArgs], cols, rows, workdir,
-    env: { ELANOUS_DRIVE_TUI: '1', ...(testMode ? { ELANOUS_STATE_DIR: testDir } : {}) },
+    env: { ELANOUS_DRIVE_TUI: '1', ...(testMode ? { ELANOUS_STATE_DIR: testDir } : {}), ...(childHome ? { HOME: childHome } : {}) },
+    ...(unsetEnv ? { unsetEnv } : {}),
   });
 
   const meta: Meta = {
@@ -296,9 +311,9 @@ async function runDaemon(args: string[]): Promise<void> {
           feed(text, verb === 'send');
           res = { ok: true, sent: text.length };
         } else if (verb === 'key') {
-          const seq = KEYS[String(cmd.name).toLowerCase()];
-          if (!seq) { res = { ok: false, error: `unknown key '${cmd.name}'` }; }
-          else { const n = Number(cmd.repeat) || 1; for (let i = 0; i < n; i++) h.write(seq); res = { ok: true }; }
+          const seq = resolveKeyInput(String(cmd.name));
+          if (seq === null) { res = { ok: false, error: `unknown key '${cmd.name}'` }; }
+          else { const n = Number(cmd.repeat) || 1; for (let i = 0; i < n; i++) writeKeyInput(h, seq); res = { ok: true }; }
         } else if (verb === 'mouse') {
           const x = Number(cmd.x), y = Number(cmd.y);
           const btn = cmd.button === 'right' ? 2 : cmd.button === 'middle' ? 1 : 0;
@@ -369,6 +384,23 @@ async function main(): Promise<void> {
   const verb = argv[0];
   const rest = argv.slice(1);
 
+  if (verb === '--help' || verb === 'help') {
+    console.log(`usage: tui-sim <verb> [args]
+  start [--id id] [--test] [--worktree] [--workdir dir] [--cols n] [--rows n]
+  start --home <dir>       Set the child TUI HOME (default: inherited).
+  start --clean-env        Allow only basic execution/locale env into the child (default: off).
+  send|type <id> <text>    Send text with|without Enter.
+  key <id> <name> [--repeat n]  Send a named key; unknown keys exit 1.
+  key names: enter/return/tab/shift-tab/esc/escape/space/backspace/delete/up/down/right/left/pageup/pagedown/home/end.
+  key ctrl-<a..z>         Send control byte (ctrl-j sends newline).
+  key ctrl-\\ | ctrl-]    Send 0x1c | 0x1d.
+  key alt-<key>           Send ESC followed by the named key or one character.
+  key shift-enter         Send ESC [ 13 ; 2 u.
+  key hex:<bytes>         Send raw hex bytes (e.g. hex:1b5b41).
+  resize <id> <cols> <rows>  Resize the running PTY.
+  mouse|dump|text|transcript|status|list|stop|promote|clean`);
+    return;
+  }
   if (verb === 'start') { await runDaemon(rest); return; }
 
   if (verb === 'list') {
@@ -394,9 +426,22 @@ async function main(): Promise<void> {
     }
     case 'key': {
       const name = rest[1];
+      if (!name || resolveKeyBytes(name) === null) { console.error(`알 수 없는 키 '${name}'`); process.exit(1); }
       const repeat = argVal(rest, '--repeat');
       const res = await sendCommand(id, 'key', { name, ...(repeat ? { repeat: Number(repeat) } : {}) }, true);
       console.log(res?.ok ? `✓ key ${name}` : `✗ ${res?.error}`);
+      if (!res?.ok) process.exitCode = 1;
+      break;
+    }
+    case 'resize': {
+      const cols = Number(rest[1]), rows = Number(rest[2]);
+      if (!Number.isSafeInteger(cols) || cols < 2 || !Number.isSafeInteger(rows) || rows < 2) {
+        console.error('usage: tui-sim resize <id> <cols> <rows> (positive integers >= 2)');
+        process.exit(1);
+      }
+      const res = await sendCommand(id, 'resize', { cols, rows }, true);
+      console.log(res?.ok ? `✓ resize ${cols}x${rows}` : `✗ ${res?.error ?? 'failed'}`);
+      if (!res?.ok) process.exitCode = 1;
       break;
     }
     case 'mouse': {
@@ -508,9 +553,9 @@ async function main(): Promise<void> {
       break;
     }
     default:
-      console.error(`unknown verb '${verb}'. verbs: start|send|type|key|mouse|dump|text|transcript|status|list|promote|clean|stop`);
+      console.error(`unknown verb '${verb}'. verbs: start|send|type|key|resize|mouse|dump|text|transcript|status|list|promote|clean|stop`);
       process.exit(1);
   }
 }
 
-main().catch((e) => { console.error(e); process.exit(1); });
+if (import.meta.main) main().catch((e) => { console.error(e); process.exit(1); });

package/scripts/ux/bump-installed.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env zsh
+# 판올림(설치본 갱신) — UX 자리 · 내부 문서 `UX` §3a.
+# origin/main 을 깨끗한 체크아웃(D)에 떼어 놓고, 설치본을 그 체크아웃으로 갱신하고 넥서스를 재시작한 뒤, 서빙 화면이 새 판인지 잰다.
+# 사용: zsh scripts/ux/bump-installed.sh [<ref>=origin/main]
+# ⛔ zsh 에서 set -e 는 아무것도 안 한다 — 단계는 전부 && 로 잇는다. ⛔ 채널 공지(전·후)는 이 스크립트 밖에서 사람이/자리가 한다.
+REF=${1:-origin/main}
+D=${UX_DEPLOY_DIR:-$TMPDIR/deploy-main}
+[[ -d $D/.git || -f $D/.git ]] || { echo "deploy checkout missing: $D (git worktree add --detach $D origin/main 로 한 번 만든다)"; exit 64; }
+cd "$D" && git fetch -q origin && git checkout -q --detach "$REF" && bun install --silent && (cd apps/pwa && bun install --silent) \
+  && echo "[bump] checkout $(git rev-parse --short HEAD) — $(git log -1 --format=%s | cut -c1-80)" \
+  && cd ~ && elanous update --from "$D" --restart \
+  || { echo "[bump] FAILED — PWA 빌드가 깨졌으면 도구의 처방(cd $D/apps/pwa && bun install --force)을 먼저 본다"; exit 1; }
+# 재는 칸 셋: 데몬 pid · 설치본 판 · 서빙 화면 = 설치본 out/index.html
+sleep 15
+launchctl list | rg com.elanous.nexus
+elanous --version
+CUR=~/.local/share/elanous/current
+WANT=$(rg -o 'page-[a-f0-9]+\.js' -m1 "$CUR/node_modules/elanous/apps/pwa/out/index.html" | head -1)
+GOT=$(curl -s --max-time 15 http://127.0.0.1:31415/app/ | rg -o 'page-[a-f0-9]+\.js' -m1 | head -1)
+[[ -n $WANT && $WANT == $GOT ]] && echo "[bump] ok — serving $GOT" || { echo "[bump] MISMATCH installed=$WANT serving=$GOT"; exit 1; }