elanous 0.2.11 → 0.2.13

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

@@ -1,12 +1,55 @@
 #!/usr/bin/env bun
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { existsSync, mkdtempSync, readFileSync, rmSync, symlinkSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
 import { join, isAbsolute } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandResult, type CommandRunner } from './node-verdict.js';
 
 interface HostResult { host: string; ok: boolean; before: string; after: string; error?: string; skipped?: string; hooks?: string; restart?: 'no-service' }
-interface OpsUpgradeDeps { exists?: (path: string) => boolean; installSource?: () => string | null }
+/** Where the internal feed is packed from: a checkout of the release tag, never the run's working tree. */
+export interface FeedSource { checkout: string; commit: string; deps: 'linked' | 'installed'; cleanup: () => void }
+interface OpsUpgradeDeps { exists?: (path: string) => boolean; installSource?: () => string | null; feedSource?: (version: string) => FeedSource }
+
+/** Detached worktree at refs/tags/v<version> with the PWA built — the feed ships what was released (10-04 0.2.11:
+ *  packing process.cwd() shipped main HEAD ee689ad2 as «0.2.11» to node-b·cloud-vm instead of the cut 31129c91). */
+export function tagFeedSource(run: CommandRunner, repo: string = process.cwd()): (version: string) => FeedSource {
+  return (version) => {
+    const tag = run('git', ['rev-parse', '--verify', `refs/tags/v${version}^{commit}`], repo);
+    const commit = tag.stdout.trim();
+    if (tag.status !== 0 || !/^[0-9a-f]{40,64}$/.test(commit)) throw new Error(`태그 없음: v${version}`);
+    const dir = mkdtempSync(join(tmpdir(), 'ops-feed-'));
+    const tree = join(dir, 'tree');
+    const cleanup = () => {
+      run('git', ['worktree', 'remove', '--force', tree], repo);
+      rmSync(dir, { recursive: true, force: true });
+    };
+    try {
+      const added = run('git', ['worktree', 'add', '--detach', tree, commit], repo);
+      if (added.status !== 0) throw new Error(`태그 체크아웃 실패: ${reason(added)}`);
+      const sameDeps = ['bun.lock', 'apps/pwa/bun.lock', 'package.json', 'apps/pwa/package.json'].every((file) => {
+        try { return readFileSync(join(repo, file), 'utf8') === readFileSync(join(tree, file), 'utf8'); }
+        catch { return false; }
+      });
+      const deps: FeedSource['deps'] = sameDeps ? 'linked' : 'installed';
+      if (sameDeps) {
+        symlinkSync(join(repo, 'node_modules'), join(tree, 'node_modules'));
+        if (existsSync(join(repo, 'apps/pwa/node_modules'))) symlinkSync(join(repo, 'apps/pwa/node_modules'), join(tree, 'apps/pwa/node_modules'));
+      } else {
+        for (const cwd of [tree, join(tree, 'apps/pwa')]) {
+          const installed = run('bun', ['install', '--frozen-lockfile'], cwd, 900_000);
+          if (installed.status !== 0) throw new Error(`태그 의존성 설치 실패: ${reason(installed)}`);
+        }
+      }
+      // The feed carries the PWA build (apps/pwa/out is ignored, so a fresh tag checkout has none until built).
+      const built = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], tree, 900_000);
+      if (built.status !== 0) throw new Error(`태그 PWA 빌드 실패: ${reason(built)}`);
+      return { checkout: tree, commit, deps, cleanup };
+    } catch (error) {
+      cleanup();
+      throw error;
+    }
+  };
+}
 
 function localInstallSource(): string | null {
   try {
@@ -54,11 +97,21 @@ export function runOpsUpgrade(run: CommandRunner = runCommand, deps: OpsUpgradeD
     : (deps.exists ?? existsSync)(defaultFeed) ? defaultFeed : undefined;
   let feedError = '';
   if (feedPath !== undefined) {
+    let source: FeedSource | undefined;
     try {
-      const feed = run('bun', ['scripts/publish-internal-dist.ts', '--checkout', process.cwd(), '--out', feedPath]);
-      const data = lastResult(feed);
-      if (feed.status !== 0 || data?.ok !== true || data.version !== version) feedError = `내부 피드 발행 실패: ${feed.status === 0 && data?.ok === true ? `판 불일치 (${String(data.version)})` : reason(feed)}`;
+      source = (deps.feedSource ?? tagFeedSource(run))(version);
+      const released = context.outputs['version-release']?.commit;
+      if (typeof released === 'string' && released && released !== source.commit) {
+        feedError = `내부 피드 발행 실패: 태그 v${version}(${source.commit.slice(0, 12)})가 컷(${released.slice(0, 12)})과 다르다`;
+      } else {
+        const feed = run('bun', ['scripts/publish-internal-dist.ts', '--checkout', source.checkout, '--out', feedPath]);
+        const data = lastResult(feed);
+        if (feed.status !== 0 || data?.ok !== true || data.version !== version) feedError = `내부 피드 발행 실패: ${feed.status === 0 && data?.ok === true ? `판 불일치 (${String(data.version)})` : reason(feed)}`;
+        else if (data.commit !== source.commit) feedError = `내부 피드 발행 실패: 묶은 커밋 ${String(data.commit).slice(0, 12)} ≠ 태그 ${source.commit.slice(0, 12)}`;
+        debug.log('release-loop.ops-upgrade', 'feed-source', { version, commit: source.commit, source: `refs/tags/v${version}`, deps: source.deps, packed: data?.commit, pwaBuild: data?.pwaBuild });
+      }
     } catch (error) { feedError = `내부 피드 발행 실패: ${firstLine(String(error))}`; }
+    finally { source?.cleanup(); }
   }
   const results: HostResult[] = [];
   for (const host of hosts as string[]) {

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

@@ -2,6 +2,7 @@
 import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { WARNING_ONLY } from './auto-approve-node.js';
 import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
 
 export function publicNotes(markdown: string, pages: { pages: Array<{ id: string; slug?: string; source?: string }> }): string {
@@ -40,7 +41,9 @@ export function runPublish(run: CommandRunner = runCommand) {
   const auto = context.outputs['auto-approve'];
   if (context.outputs['approve-publish']?.outcome !== 'approved' &&
     !(auto?.outcome === 'ok' && auto.decidedBy === 'release-loop metrics'
-      && Array.isArray(auto.metrics) && auto.metrics.length === 8
+      // The 8 blocking metrics; warning-only rows (tui-regress · mac-smoke) are shown but never counted (V1g · MAC1).
+      && Array.isArray(auto.metrics)
+      && auto.metrics.filter((metric: unknown) => !(metric && typeof metric === 'object' && 'name' in metric && WARNING_ONLY.has(String(metric.name)))).length === 8
       && auto.metrics.every((metric: unknown) => metric && typeof metric === 'object' && 'verdict' in metric && metric.verdict === 'pass'))) {
     return { outcome: 'fail' as const, verdict: 'fail' as const, summary: 'publish blocked: neither auto-approve nor approve-publish approved' };
   }

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

@@ -7,7 +7,7 @@ import { emitNodeResult } from './node-verdict.js';
 import { debug } from '../../src/debug/log.js';
 
 type Kind = 'release' | 'dev-bump';
-type Output = { outcome: 'ok' | 'error'; kind: Kind | null; version: string | null; commit: string | null; pr: number | null; worktree?: string; error?: string };
+type Output = { outcome: 'ok' | 'error'; kind: Kind | null; version: string | null; commit: string | null; pr: number | null; files?: string[]; worktree?: string; error?: string };
 
 export function nextDevVersion(version: string): string {
   const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(version);
@@ -120,12 +120,22 @@ function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string,
     const old = `"version": "${current}"`;
     if (!text.includes(old)) throw new Error(`package.json version field not found: ${current}`);
     writeFileSync(path, text.replace(old, `"version": "${target}"`));
+    const files = ['package.json'];
     const serverPath = join(worktree, 'server.json');
     if (existsSync(serverPath)) {
       const server = JSON.parse(readFileSync(serverPath, 'utf8')) as { version: string; packages: Array<{ version: string }> };
       server.version = target;
       server.packages[0]!.version = target;
       writeFileSync(serverPath, `${JSON.stringify(server, null, 2)}\n`);
+      files.push('server.json');
+    }
+    const agentPath = join(worktree, 'integrations', 'acp-registry', 'elanous', 'agent.json');
+    if (existsSync(agentPath)) {
+      const agent = JSON.parse(readFileSync(agentPath, 'utf8')) as { version: string; distribution: { npx: { package: string } } };
+      agent.version = target;
+      agent.distribution.npx.package = `elanous@${target}`;
+      writeFileSync(agentPath, `${JSON.stringify(agent, null, 2)}\n`);
+      files.push('agent.json');
     }
     const lockPath = join(worktree, 'bun.lock');
     const lock = readFileSync(lockPath, 'utf8');
@@ -185,7 +195,7 @@ function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string,
     fetchMain(repo);
     const commit = git(repo, 'rev-parse', 'origin/main');
     if (versionAt(repo) !== target || commit === before) throw new Error(`origin/main did not advance to ${target} after merge`);
-    const output: Output = { outcome: 'ok', kind, version: target, commit, pr: pr ? Number(pr[1]) : null };
+    const output: Output = { outcome: 'ok', kind, version: target, commit, pr: pr ? Number(pr[1]) : null, files };
     if (kind === 'release') debug.log('release-loop.cut', 'chosen', { version: releaseVersion, source: 'main', commit });
     git(repo, 'worktree', 'remove', '--force', worktree);
     rmSync(temp, { recursive: true, force: true });
@@ -240,7 +250,7 @@ function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Out
 
 if (import.meta.main) {
   const output = main();
-  debug.log(`release-loop.version-${output.kind ?? 'unknown'}`, 'result', { version: output.version, outcome: output.outcome });
+  debug.log(`release-loop.version-${output.kind ?? 'unknown'}`, 'result', { version: output.version, outcome: output.outcome, files: output.files ?? [] });
   emitNodeResult({ ...output, verdict: output.outcome === 'ok' ? 'pass' : 'fail', summary: output.outcome === 'ok' ? `${output.kind} ${output.version} · ${output.commit}` : `${output.kind ?? 'version'}: ${output.error ?? 'failed'}` });
   if (output.outcome === 'error') process.exitCode = 1;
 }

package/scripts/telegram-inject.ts

@@ -16,6 +16,7 @@
 import { TelegramClient, Api } from 'telegram';
 import { StringSession } from 'telegram/sessions';
 import { createInterface } from 'node:readline/promises';
+import { parseInjectArgs } from './lib/telegram-inject-args.js';
 
 const args = process.argv.slice(2);
 const has = (f: string): boolean => args.includes(f);
@@ -201,15 +202,22 @@ if (has('--buttons') || has('--click') || has('--react')) {
 
 // 무인 주입: SESSION STRING 으로 로그인 → 봇에게 메시지.
 const sessionStr = process.env.TELEGRAM_USER_SESSION ?? val('--session');
-const to = val('--to') ?? process.env.TELEGRAM_TEST_BOT ?? configBot;
-const text = val('--text');
 if (!sessionStr) { console.error('❌ TELEGRAM_USER_SESSION 필요 — 먼저 `--login` 으로 발급.'); process.exit(2); }
-if (!to || !text) { console.error('사용: telegram-inject.ts --to @monad_test_bot --text "<objective>"'); process.exit(2); }
-
+let inject: ReturnType<typeof parseInjectArgs>;
+try {
+  inject = parseInjectArgs(args, { TELEGRAM_TEST_BOT: process.env.TELEGRAM_TEST_BOT ?? configBot });
+} catch (error) {
+  console.error((error as Error).message);
+  process.exit(2);
+}
+const { to, text, photos, caption } = inject;
 const client = new TelegramClient(new StringSession(sessionStr), apiId, apiHash, { connectionRetries: 5 });
 await client.connect();
-const msg = await client.sendMessage(to, { message: text });
-console.log(`✅ 주입 완료 → ${to} (msgId=${(msg as { id?: number }).id ?? '?'}). 이 계정의 텔레그램 앱에도 대화가 보입니다.`);
+const msg = photos.length > 0
+  ? await client.sendFile(to, { file: photos.length === 1 ? photos[0]! : photos, caption })
+  : await client.sendMessage(to, { message: text! });
+const sent = Array.isArray(msg) ? msg[0] : msg;
+console.log(`✅ 주입 완료 → ${to} (msgId=${(sent as { id?: number } | undefined)?.id ?? '?'}). 이 계정의 텔레그램 앱에도 대화가 보입니다.`);
 console.log('   → 데몬 처리 후 watchdog 검증: log/watchdog-stall.log (stall 없으면 A subprocess 격리 정상).');
 await client.disconnect();
 process.exit(0);

package/scripts/test-deterministic.ts

@@ -31,8 +31,9 @@
 //     reports the failure.
 
 import { mkdtempSync, rmSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 // The predicate lives in its own side-effect-free module so it can be tested:
 // importing THIS file used to spawn the suite at load time. The runner is now
 // behind `import.meta.main` / `runDeterministicTests()`, but the filter stays
@@ -56,6 +57,8 @@ const HARNESS_TEST_ENV_KEYS = [
 // 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 GIT_LOCATION_ENV_KEYS = ['GIT_DIR', 'GIT_WORK_TREE', 'GIT_COMMON_DIR'] as const;
+
 const EXECUTION_ORIGIN_ENV_KEYS = [
   'ELANOUS_HOST_ID',
   'ELANOUS_RUN_ID',
@@ -120,6 +123,7 @@ export type DeterministicRunnerDeps = {
   childGraceMs?: number;
   killProcessGroup?: KillProcessGroup;
   getProcessGroupId?: GetProcessGroupId;
+  gitConfig?: (cwd: string, args: string[]) => string;
 };
 
 export function isLivePid(pid: number): boolean {
@@ -269,11 +273,22 @@ export async function terminateDirectChild(
   reportVisible(`failed to terminate child pid=${pid}`, report);
 }
 
+function gitConfig(cwd: string, args: string[]): string {
+  const env = { ...process.env };
+  for (const key of GIT_LOCATION_ENV_KEYS) delete env[key];
+  const result = spawnSync('git', args, { cwd, env, encoding: 'utf8' });
+  if (result.error || (result.status !== 0 && !(result.status === 1 && args.includes('--get-all') && !result.stderr))) {
+    throw new Error(`git ${args.join(' ')} failed: ${result.error?.message ?? result.stderr}`);
+  }
+  return result.stdout.trim();
+}
+
 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])
-      && !EXECUTION_ORIGIN_ENV_KEYS.includes(key as typeof EXECUTION_ORIGIN_ENV_KEYS[number])),
+      && !EXECUTION_ORIGIN_ENV_KEYS.includes(key as typeof EXECUTION_ORIGIN_ENV_KEYS[number])
+      && !GIT_LOCATION_ENV_KEYS.includes(key as typeof GIT_LOCATION_ENV_KEYS[number])),
   );
   env.HOME = testRoot;
   // userConfigPath() warns whenever XDG_CONFIG_HOME is set, including when
@@ -392,6 +407,38 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
   const report = deps.report ?? console.error;
   const spawn = deps.spawn ?? defaultSpawn;
   const argv = deps.argv ?? process.argv.slice(2);
+  const cwd = deps.cwd ?? process.cwd();
+  const config = deps.gitConfig ?? gitConfig;
+  const commonDir = config(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  const configFile = join(resolve(cwd, commonDir), 'config');
+  const bareArgs = ['config', '--file', configFile];
+  const readBare = () => config(cwd, [...bareArgs, '--get-all', 'core.bare']);
+  const bareBefore = readBare();
+  let bareChanged = false;
+  let bareChecked = false;
+  const checkBare = (): void => {
+    bareChecked = true;
+    let bareAfter = '<unreadable>';
+    const visible = (values: string) => values ? values.replaceAll('\n', ',') : '<unset>';
+    try {
+      bareAfter = readBare();
+      if (bareAfter === bareBefore) return;
+      bareChanged = true;
+      const originalValues = bareBefore ? bareBefore.split('\n') : [];
+      if (originalValues.length > 0) {
+        config(cwd, [...bareArgs, '--replace-all', 'core.bare', originalValues[0]!]);
+        for (const value of originalValues.slice(1)) config(cwd, [...bareArgs, '--add', 'core.bare', value]);
+      } else if (bareAfter) {
+        config(cwd, [...bareArgs, '--unset-all', 'core.bare']);
+      }
+      const restored = readBare();
+      if (restored !== bareBefore) throw new Error(`expected ${visible(bareBefore)}, got ${visible(restored)}`);
+      report(`[test-deterministic] core.bare changed ${visible(bareBefore)} -> ${visible(bareAfter)}; restored ${visible(bareBefore)}; failing run`);
+    } catch (error) {
+      bareChanged = true;
+      report(`[test-deterministic] core.bare changed ${visible(bareBefore)} -> ${visible(bareAfter)}; restore failed: ${formatError(error)}`);
+    }
+  };
   // ⛔ 사람이 «경로»를 직접 준 창에서는 아무것도 빼지 않는다 — 그 창은 「이것만 돌려라」다.
   const explicitPaths = argv.some((arg) => !arg.startsWith('-'));
   const cdpPatterns = explicitPaths ? [] : (deps.deriveCdpPatterns ?? deriveCdpTestPatterns)();
@@ -451,6 +498,7 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
       });
       cleanupTemporaryRoot(testRoot, { rmSync: deps.rmSync, report });
       rootCleanupAttempted = true;
+      checkBare();
       gate?.dispose();
       gate = undefined;
       if (deps.killSelf) {
@@ -465,7 +513,8 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
     }
 
     cleanupRoot();
-    return outcome.code ?? 1;
+    checkBare();
+    return bareChanged ? 1 : (outcome.code ?? 1);
   } catch (error) {
     if (child) {
       try {
@@ -484,6 +533,7 @@ export async function runDeterministicTests(deps: DeterministicRunnerDeps = {}):
   } finally {
     gate?.dispose();
     cleanupRoot();
+    if (!bareChecked) checkBare();
   }
 }
 

package/scripts/test-diet/remeasure-list.ts

@@ -0,0 +1,112 @@
+#!/usr/bin/env bun
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { release } from 'node:os';
+
+export const FILE_TIMEOUT_MS = 300_000;
+export type Execution = { rc: number | null; stdout: string; stderr: string; secs: number; timedOut: boolean };
+export type Executor = (file: string, timeoutMs: number) => Promise<Execution>;
+export type Measurement = {
+  file: string; rc: number | null; pass: number | null; fail: number | null; skip: number | null;
+  secs: number; platform: string; release: string; verdict: 'pass' | 'fail' | 'skip' | '못 잼';
+};
+
+export const TIMEOUT_EXIT_GRACE_MS = 5_000;
+
+// The wrapper handles SIGTERM by stopping its detached test group. Do not
+// start another file until the wrapper closes, even after SIGKILL.
+export function execute(
+  file: string,
+  timeoutMs: number,
+  deps: {
+    spawnChild?: typeof spawn;
+    signalGroup?: (pid: number, signal: NodeJS.Signals) => void;
+    graceMs?: number;
+  } = {},
+): Promise<Execution> {
+  return new Promise((resolve, reject) => {
+    const started = performance.now();
+    const child = (deps.spawnChild ?? spawn)('bun', ['run', 'test:deterministic', file], { detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
+    let closed = false;
+    let escalation: ReturnType<typeof setTimeout> | undefined;
+    let terminationCheck: ReturnType<typeof setTimeout> | undefined;
+    const seconds = () => Math.round((performance.now() - started) / 1000 * 100) / 100;
+    const signal = (name: NodeJS.Signals) => {
+      if (child.pid === undefined) return;
+      try { (deps.signalGroup ?? ((pid, sig) => process.kill(-pid, sig)))(child.pid, name); }
+      catch (groupError) {
+        try { child.kill(name); }
+        catch (directError) { stderr += `\n${name} failed: ${String(groupError)}; ${String(directError)}`; }
+      }
+    };
+    // Bun's summary is at the end; bounded capture avoids an unbounded memory cost.
+    const collect = (previous: string, chunk: Buffer) => (previous + chunk.toString('utf8')).slice(-256_000);
+    child.stdout.on('data', (chunk: Buffer) => { stdout = collect(stdout, chunk); });
+    child.stderr.on('data', (chunk: Buffer) => { stderr = collect(stderr, chunk); });
+    const graceMs = deps.graceMs ?? TIMEOUT_EXIT_GRACE_MS;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      signal('SIGTERM');
+      escalation = setTimeout(() => {
+        if (closed) return;
+        signal('SIGKILL');
+        terminationCheck = setTimeout(() => {
+          if (!closed) reject(new Error(`Cannot confirm termination of timed-out test: ${file}; stopping measurements`));
+        }, graceMs);
+      }, graceMs);
+    }, timeoutMs);
+    child.on('error', (error) => { stderr += `\n${error.message}`; });
+    child.on('close', (code) => {
+      closed = true;
+      clearTimeout(timer);
+      if (escalation) clearTimeout(escalation);
+      if (terminationCheck) clearTimeout(terminationCheck);
+      resolve({ rc: timedOut ? null : code, stdout, stderr, secs: seconds(), timedOut });
+    });
+  });
+}
+
+export async function measureList(files: readonly string[], runner: Executor = execute): Promise<Measurement[]> {
+  const measurements: Measurement[] = [];
+  for (const file of files) {
+    const result = await runner(file, FILE_TIMEOUT_MS);
+    const output = `${result.stdout}\n${result.stderr}`;
+    const count = (kind: 'pass' | 'fail' | 'skip'): number | null => {
+      const matches = [...output.matchAll(new RegExp(`^\\s*(\\d+) ${kind}\\b`, 'gm'))];
+      return matches.length ? Number(matches.at(-1)![1]) : null;
+    };
+    const pass = result.timedOut ? null : count('pass');
+    const fail = result.timedOut ? null : count('fail');
+    const skip = result.timedOut ? null : count('skip');
+    const measured = pass !== null || fail !== null || skip !== null;
+    const verdict = result.timedOut || !measured || result.rc === null ? '못 잼'
+      : fail !== null && fail > 0 ? 'fail'
+      : result.rc !== 0 ? '못 잼'
+      : skip !== null && skip > 0 ? 'skip'
+      : pass !== null && pass > 0 ? 'pass' : '못 잼';
+    measurements.push({ file, rc: result.rc, pass, fail, skip, secs: result.secs, platform: process.platform, release: release(), verdict });
+  }
+  return measurements;
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  if (args.length < 1 || args.length > 2 || (args.length === 2 && args[1] !== '--json')) {
+    console.error('usage: bun scripts/test-diet/remeasure-list.ts <목록 파일> [--json]');
+    process.exitCode = 2;
+  } else {
+    try {
+      const files = readFileSync(args[0]!, 'utf8').split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith('#'));
+      if (!files.length) throw new Error('empty test list');
+      const results = await measureList(files);
+      if (args[1] === '--json') console.log(JSON.stringify(results, null, 2));
+      else for (const row of results) console.log([row.file, row.rc ?? 'null', row.pass ?? '?', row.fail ?? '?', row.skip ?? '?', row.secs, row.platform, row.release, row.verdict].join('\t'));
+    } catch (error) {
+      console.error(error);
+      process.exitCode = 2;
+    }
+  }
+}

package/scripts/ux/demo-rehearsal.ts

@@ -5,6 +5,11 @@ 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';
 
 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))}})()`;
+}
 
 type Args = { url: string; out: string; secs: number; width: number; height: number; demo: boolean; tokenStdin: boolean };
 
@@ -168,23 +173,20 @@ export async function run(args: Args): Promise<number> {
     const initialEvents = observer.take();
     const scenes = [];
     for (let scene = 1; scene <= 6; scene++) {
-      const hiddenByDemo = args.demo && scene === 5;
-      if (hiddenByDemo) {
-        const result = judgeScene({ scene, title: TITLES[scene - 1]!, hiddenByDemo, secs: 0, frames: 0, exceptions: [], failedRequests: [], textLength: 0, leaks: [], sectionsInDom: 0, visibleScene: null });
-        scenes.push(result);
-        console.log(`scene ${scene} ${result.verdict} 0s frames=0`);
-        continue;
-      }
+      const hiddenByDemo = false;
       if (scene !== 1) {
         await cdp.ev<boolean>(`(()=>{const n=${scene}; const nav=document.querySelector('nav[aria-label="장면 선택"]'); const button=[...(nav?.querySelectorAll('button')??[])].find(b=>b.textContent?.trim().startsWith(n+' ')); button?.click(); return !!button})()`);
         await sleep(300);
       }
       const frames = new Frames(join(args.out, `scene-${scene}`));
       const states: SceneState[] = [];
+      const emptyStates = new Set<string>();
       const sceneRect = await cdp.ev<FrameRect | null>(`(()=>{const s=document.querySelector('[data-inside-scene="${scene}"]'); if (!s || s.hidden) return null; const r=s.getBoundingClientRect(); return {x:r.x,y:r.y,width:r.width,height:r.height}})()`);
       let blankFrames = 0;
       const inspect = async () => {
-        states.push(await cdp.ev<SceneState>(`(()=>{const sections=[...document.querySelectorAll('[data-inside-scene]')]; const visible=sections.filter(s=>!s.hidden && s.getClientRects().length>0); return {sectionsInDom:sections.length,visibleScene:visible.length===1?Number(visible[0].getAttribute('data-inside-scene')):null,textLength:visible.length===1?visible[0].innerText.length:0}})()`));
+        const { emptyStates: observedEmpty, ...state } = await cdp.ev<SceneState & { emptyStates: string[] }>(sceneSnapshotScript());
+        states.push(state);
+        for (const phrase of observedEmpty) emptyStates.add(phrase);
       };
       const until = Date.now() + args.secs * 1000;
       await inspect();
@@ -203,7 +205,7 @@ export async function run(args: Args): Promise<number> {
         failedRequests: [...initialEvents.failedRequests, ...observed.failedRequests],
       } : observed;
       frames.toMp4(join(args.out, `scene-${scene}.mp4`), args.width, args.height);
-      const obs: SceneObservation = { scene, title: TITLES[scene - 1]!, hiddenByDemo, secs: args.secs, frames: frames.list.length, ...events, ...dom, leaks: bad, blankFrames };
+      const obs: SceneObservation = { scene, title: TITLES[scene - 1]!, hiddenByDemo, secs: args.secs, frames: frames.list.length, ...events, ...dom, leaks: bad, blankFrames, emptyStates: [...emptyStates] };
       const result = judgeScene(obs);
       scenes.push(result);
       console.log(`scene ${scene} ${result.verdict} ${args.secs}s frames=${result.frames}`);
@@ -222,13 +224,15 @@ export async function run(args: Args): Promise<number> {
       '|---|---|---:|---:|---|',
       ...scenes.map((s) => `| ${s.scene} ${s.title} | ${s.verdict} | ${s.secs} | ${s.frames} | ${s.reasons.join('; ') || '없음'} |`),
       '',
-      `ok ${result.ok} · broken ${result.broken} · 미검증 ${result.unverified}`,
+      `ok ${result.ok} · broken ${result.broken} · 미검증 ${result.unverified} · 실데이터 없음 ${result.noData}`,
+      '',
+      '종료 코드: ok=0 · broken=1 · unverified=2 · no-data=3',
       '',
     ].join('\n'));
     for (const line of result.banner) console.log(`⚠️ ${line}`);
-    console.log(`rehearsal ${result.verdict} ok=${result.ok} broken=${result.broken} unverified=${result.unverified}`);
-    // 0 = all seen and ok · 1 = broken · 2 = nothing broken but a scene was not seen (not a pass).
-    return result.verdict === 'broken' ? 1 : result.verdict === 'unverified' ? 2 : 0;
+    console.log(`rehearsal ${result.verdict} ok=${result.ok} broken=${result.broken} unverified=${result.unverified} no-data=${result.noData}`);
+    // 0 = ok · 1 = broken · 2 = unverified · 3 = no-data.
+    return result.verdict === 'broken' ? 1 : result.verdict === 'unverified' ? 2 : result.verdict === 'no-data' ? 3 : 0;
   } finally { observer?.close(); cdp.close(); }
 }
 

package/scripts/ux/demo-seed.ts

@@ -0,0 +1,108 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+export type SeedArgs = { only: 'graph' | 'wizard' | 'all'; dryRun: boolean; json: boolean };
+export type SeedEvent = { target: 'graph' | 'wizard'; phase: 'start' | 'finish' | 'failure'; command: string[]; exitCode?: number; output?: string };
+
+export const SCENE_SIX_GUIDANCE = '⑥ PTY 인텔리전스는 이 시드로 생성하지 않습니다. 실제 격리 미션을 실행하고 read → judge → answer 이벤트를 관측하세요.';
+const GRAPH = 'graphs/demo/inside-seed.yaml';
+const WIZARD_REQUEST = '데모용 자료 조사 커넥터와 스킬·그래프 초안을 만들어 주세요. 설치하거나 실행하지 마세요.';
+const DRAFT = { description: 'Demo research draft only; no connector credentials or outbound messages.', connectors: [],
+  skill: { description: 'Demo research draft', instructions: 'Research draft only. Implement and validate processing before installing or running.', requires: [] } };
+
+export function parseArgs(argv: string[]): SeedArgs {
+  const result: SeedArgs = { only: 'all', dryRun: false, json: false };
+  const seen = new Set<string>();
+  for (let i = 0; i < argv.length; i++) {
+    const flag = argv[i]!;
+    if (!['--only', '--dry-run', '--json'].includes(flag)) throw new Error(`알 수 없는 인자: ${flag}`);
+    if (seen.has(flag)) throw new Error(`중복 인자: ${flag}`);
+    seen.add(flag);
+    if (flag === '--only') {
+      const value = argv[++i];
+      if (value !== 'all' && value !== 'graph' && value !== 'wizard') throw new Error('--only 값은 graph|wizard|all 이어야 합니다');
+      result.only = value;
+    } else if (flag === '--dry-run') result.dryRun = true;
+    else result.json = true;
+  }
+  return result;
+}
+
+export type SeedDeps = {
+  repo: string;
+  run: (command: string[], cwd: string) => Promise<{ exitCode: number; output: string; stdout?: string }>;
+  prepareDraft: (repo: string) => { file: string; parent: string };
+};
+
+function prepareDraft(repo: string): { file: string; parent: string } {
+  const root = resolve(repo, '.elanous-test', 'demo-seed');
+  mkdirSync(root, { recursive: true });
+  const parent = mkdtempSync(join(root, 'wizard-'));
+  const file = join(parent, 'research-draft.json');
+  writeFileSync(file, JSON.stringify(DRAFT) + '\n');
+  return { file, parent };
+}
+
+const defaultDeps: SeedDeps = {
+  repo: resolve(import.meta.dir, '../..'),
+  prepareDraft,
+  run: async (command, cwd) => {
+    const child = Bun.spawn(command, { cwd, env: { ...process.env, NODE_ENV: 'test' }, stdout: 'pipe', stderr: 'pipe' });
+    const [output, errors, exitCode] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+    return { exitCode, stdout: output, output: [output, errors].filter(Boolean).join('\n').trim() };
+  },
+};
+
+export async function seed(args: SeedArgs, deps: SeedDeps = defaultDeps, onEvent?: (event: SeedEvent) => void): Promise<{ events: SeedEvent[]; guidance: string; ok: boolean }> {
+  const events: SeedEvent[] = [];
+  const emit = (event: SeedEvent): void => { events.push(event); onEvent?.(event); };
+  let ok = true;
+  for (const target of (args.only === 'all' ? ['graph', 'wizard'] : [args.only]) as Array<'graph' | 'wizard'>) {
+    const base = ['bun', 'bin/elanous.mjs', '--test'];
+    const graphCommand = [...base, 'graph', 'run', GRAPH, '--json'];
+    const wizardCommand = [...base, 'plugin', 'make', WIZARD_REQUEST, '--name', 'inside-demo-draft', '--draft-file', '<isolated-draft-file>', '--dir', '<isolated-parent>', '--json'];
+    const command = target === 'graph' ? graphCommand : wizardCommand;
+    if (args.dryRun) {
+      emit({ target, phase: 'start', command });
+      emit({ target, phase: 'finish', command, exitCode: 0, output: 'dry-run: no process started' });
+      continue;
+    }
+    try {
+      if (target === 'wizard') {
+        const { file, parent } = deps.prepareDraft(deps.repo);
+        command.splice(command.indexOf('<isolated-draft-file>'), 1, file);
+        command.splice(command.indexOf('<isolated-parent>'), 1, parent);
+      }
+      emit({ target, phase: 'start', command });
+      const result = await deps.run(command, deps.repo);
+      const parsed = (() => {
+        try { return JSON.parse(result.stdout ?? result.output) as { status?: string; dryRun?: boolean; errors?: string[]; timings?: { install?: number } }; } catch { return null; }
+      })();
+      const complete = target === 'wizard'
+        ? parsed?.status === 'draft' && parsed.timings?.install === 0 && parsed.errors?.length === 0
+        : parsed?.status === 'done' && parsed.dryRun === false;
+      const phase = result.exitCode === 0 && complete ? 'finish' : 'failure';
+      emit({ target, phase, command, exitCode: result.exitCode, output: result.output });
+      if (phase === 'failure') ok = false;
+    } catch (error) {
+      ok = false;
+      emit({ target, phase: 'failure', command, output: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return { events, guidance: SCENE_SIX_GUIDANCE, ok };
+}
+
+if (import.meta.main) {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const report = await seed(args, defaultDeps, args.json ? undefined : (event) => {
+      console.log(`${event.target} ${event.phase}${event.exitCode === undefined ? '' : ` (exit ${event.exitCode})`}: ${event.command.join(' ')}${event.output ? `\n${event.output}` : ''}`);
+    });
+    if (args.json) console.log(JSON.stringify(report));
+    else console.log(report.guidance);
+    if (!report.ok) process.exitCode = 1;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}