elanous 0.2.11 → 0.2.12

package/scripts/measure-pod-memory-by-goal.ts

@@ -0,0 +1,130 @@
+#!/usr/bin/env bun
+/** Seven-day read-only measurement of self-implement Pod memory by goal kind. */
+import { existsSync } from 'node:fs';
+import { LogStore, logsDbPath, type LogStoreRow } from '../src/mss/logging/log-store.js';
+
+export const GOAL_TYPES = ['test', 'code', 'pwa-build', 'docs'] as const;
+export type GoalType = typeof GOAL_TYPES[number];
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const MIB = 1024 * 1024;
+
+type Observation = Pick<LogStoreRow, 'ts_ms' | 'event' | 'data' | 'category'>;
+type Run = { type: GoalType | null; limit: string | null; peakMiB: number | null; samples: number; terminated: boolean; oomKilled: boolean };
+type MemorySample = { cgroupBytes?: unknown };
+export type MemoryMeasurement = {
+  window: { since: string; until: string };
+  sources: { logs: string; observations: number; samples: number; unclassifiedRuns: number; classification: 'goal-fields-or-space-id'; peakCoverage: 'recorded-samples-only' };
+  byGoalType: Array<{ goalType: GoalType; runs: number; measured: number; missingPeak: number; samples: number; memoryLimits: Record<string, number>; terminations: number; oomKilled: number; peakMiB: { p50: number | null; p95: number | null; max: number | null } }>;
+};
+
+function payload(raw: string | null): Record<string, unknown> {
+  try {
+    const parsed: unknown = JSON.parse(raw ?? 'null');
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+  } catch { return {}; }
+}
+
+/** Infer only unambiguous kinds from free text; never turn an unknown title into code. */
+export function goalTypeOf(description: string): GoalType | null {
+  const kinds: GoalType[] = [];
+  if (/\b(?:pwa|next\.js|frontend|front-end|web app)[-\s]+(?:build|compile|typecheck|bundle)\b/i.test(description)) kinds.push('pwa-build');
+  if (/\b(?:test|tests|testing|spec|coverage|gate)\b/i.test(description) || /시험|테스트|검증/.test(description)) kinds.push('test');
+  if (/\b(?:docs?|documentation|readme|manual|report)\b/i.test(description) || /문서|보고서/.test(description)) kinds.push('docs');
+  if (/\b(?:implement|implementation|coding|code|cli)\b/i.test(description) || /구현|코드/.test(description)) kinds.push('code');
+  return kinds.length === 1 ? kinds[0]! : null;
+}
+
+function recordedGoalType(data: Record<string, unknown>, spaceId: string): GoalType | null {
+  if ('goalType' in data) return GOAL_TYPES.find((type) => type === data.goalType) ?? null;
+  if ('goalKind' in data) return GOAL_TYPES.find((type) => type === data.goalKind) ?? null;
+  const descriptions = [data.goalTitle, data.goalDescription, data.feature].filter((value): value is string => typeof value === 'string' && value.trim().length > 0);
+  return descriptions.length ? goalTypeOf(descriptions.join(' ')) : goalTypeOf(spaceId);
+}
+
+function percentile(sorted: readonly number[], fraction: number): number | null {
+  if (!sorted.length) return null;
+  const index = (sorted.length - 1) * fraction;
+  const low = Math.floor(index);
+  return Math.round((sorted[low]! + (sorted[Math.ceil(index)]! - sorted[low]!) * (index - low)) * 100) / 100;
+}
+
+/** All rows are read before aggregation: log query's default 100-row limit is not a seven-day census. */
+export function measurePodMemoryByGoal(rows: readonly Observation[], nowMs: number = Date.now(), logs = logsDbPath()): MemoryMeasurement {
+  const sinceMs = nowMs - WEEK_MS;
+  const windowRows = rows.filter((row) => row.ts_ms >= sinceMs && row.ts_ms <= nowMs && row.category === 'self-implement.pod');
+  const runs = new Map<string, Run>();
+  const jobToSpace = new Map<string, string>();
+  let samples = 0;
+  const ordered = [...windowRows].sort((a, b) => a.ts_ms - b.ts_ms);
+  for (const row of ordered) {
+    if (row.event !== 'memory-limit') continue;
+    const data = payload(row.data);
+    const id = typeof data.spaceId === 'string' ? data.spaceId : '';
+    if (!id) continue;
+    runs.set(id, { type: recordedGoalType(data, id), limit: typeof data.memoryLimit === 'string' ? data.memoryLimit : null,
+      peakMiB: null, samples: 0, terminated: false, oomKilled: false });
+  }
+  for (const row of ordered) {
+    const data = payload(row.data);
+    const job = typeof data.job === 'string' ? data.job : '';
+    const directId = typeof data.spaceId === 'string' ? data.spaceId : '';
+    if (row.event === 'job-applied' && job && runs.has(directId)) jobToSpace.set(job, directId);
+    const run = runs.get(directId || jobToSpace.get(job) || '');
+    if (!run) continue;
+    if (row.event === 'job-finished') {
+      run.terminated = true;
+      run.oomKilled ||= data.containerReason === 'OOMKilled';
+    }
+    if (row.event === 'oom-evidence') { run.terminated = true; run.oomKilled = true; }
+    if (data.reason === 'OOMKilled') { run.terminated = true; run.oomKilled = true; }
+    if (row.event !== 'oom-evidence' && row.event !== 'memory-last') continue;
+    const rawSamples: unknown[] = row.event === 'oom-evidence' && Array.isArray(data.samples) ? data.samples : [data.sample];
+    for (const raw of rawSamples) {
+      const record = raw && typeof raw === 'object' ? raw as MemorySample : {};
+      const bytes = record.cgroupBytes;
+      if (typeof bytes !== 'number' || !Number.isSafeInteger(bytes) || bytes < 0) continue;
+      const reading = bytes / MIB;
+      run.peakMiB = Math.max(run.peakMiB ?? 0, reading);
+      run.samples++;
+      samples++;
+    }
+  }
+  return {
+    window: { since: new Date(sinceMs).toISOString(), until: new Date(nowMs).toISOString() },
+    sources: { logs, observations: windowRows.length, samples, unclassifiedRuns: [...runs.values()].filter((run) => run.type === null).length,
+      classification: 'goal-fields-or-space-id', peakCoverage: 'recorded-samples-only' },
+    byGoalType: GOAL_TYPES.map((goalType) => {
+      const group = [...runs.values()].filter((run) => run.type === goalType);
+      const peaks = group.flatMap((run) => run.peakMiB === null ? [] : [run.peakMiB]).sort((a, b) => a - b);
+      const memoryLimits: Record<string, number> = {};
+      for (const run of group) if (run.limit) memoryLimits[run.limit] = (memoryLimits[run.limit] ?? 0) + 1;
+      return { goalType, runs: group.length, measured: peaks.length, missingPeak: group.length - peaks.length,
+        samples: group.reduce((count, run) => count + run.samples, 0), memoryLimits,
+        terminations: group.filter((run) => run.terminated).length, oomKilled: group.filter((run) => run.oomKilled).length,
+        peakMiB: { p50: percentile(peaks, 0.5), p95: percentile(peaks, 0.95), max: peaks.at(-1) ?? null } };
+    }),
+  };
+}
+
+export function readPodMemoryMeasurement(path: string = logsDbPath(), nowMs: number = Date.now()): MemoryMeasurement {
+  if (!existsSync(path)) throw new Error(`log store not found: ${path}`);
+  const store = LogStore.openReadOnly(path);
+  try {
+    return measurePodMemoryByGoal(store.queryAll({ exactCategories: ['self-implement.pod'], sinceMs: nowMs - WEEK_MS, untilMs: nowMs }), nowMs, path);
+  } finally { store.close(); }
+}
+
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const usage = 'Usage: bun scripts/measure-pod-memory-by-goal.ts [--json] [--logs-db <existing-logs.db>] [--help]';
+  const dbArg = args.indexOf('--logs-db');
+  const db = dbArg === -1 ? logsDbPath() : args[dbArg + 1];
+  if (!db || (dbArg !== -1 && (db.startsWith('--') || args.lastIndexOf('--logs-db') !== dbArg))
+    || args.some((arg, index) => !['--json', '--help', '--logs-db'].includes(arg) && index !== dbArg + 1)) throw new Error(usage);
+  if (args.includes('--help')) console.log(usage);
+  else {
+    const result = readPodMemoryMeasurement(db);
+    if (args.includes('--json')) console.log(JSON.stringify(result, null, 2));
+    else for (const group of result.byGoalType) console.log(`${group.goalType}: runs=${group.runs} measured=${group.measured} peak p50=${group.peakMiB.p50 ?? 'n/a'} MiB p95=${group.peakMiB.p95 ?? 'n/a'} MiB OOMKilled=${group.oomKilled}`);
+  }
+}

package/scripts/release-loop/auto-approve-node.ts

@@ -15,7 +15,7 @@ const outcomeMetric = (name: string, node: Record<string, unknown> | undefined):
 });
 
 /** Rows shown in auto-approval.md but never counted toward the 8 blocking metrics. */
-const WARNING_ONLY = new Set(['tui-regress', 'mac-smoke']);
+export const WARNING_ONLY = new Set(['tui-regress', 'mac-smoke']);
 
 /** `ok` · `warn` (a failure) · `unmeasured` (error or no output) — the macOS smoke never blocks publishing. */
 function macSmokeLevel(node: Record<string, unknown> | undefined): 'ok' | 'warn' | 'unmeasured' {

package/scripts/release-loop/checklist-gate-node.ts

@@ -11,10 +11,11 @@ export function runChecklistGate(context: GraphContext = readGraphContext()) {
   if (gate.ok && gate.moved.length) {
     const [major, minor, patch] = version.split('.').map(Number);
     const next = `${major}.${minor}.${patch! + 1}`;
+    // 이월은 «같은 칸»을 다음 판으로 옮기는 것 — 다른 판 id 충돌 검사(CKID #23407)의 대상이 아니다.
     for (const id of gate.moved) {
       const item = data.items.find((candidate) => candidate.id === id)!;
       if (listChecklist(next).items.some((candidate) => candidate.id === id)) continue;
-      try { addItem(next, { id, title: item.title, ...(item.owner !== undefined ? { owner: item.owner } : {}), ...(item.kind !== undefined ? { kind: item.kind } : {}) }); }
+      try { addItem(next, { id, title: item.title, ...(item.owner !== undefined ? { owner: item.owner } : {}), ...(item.kind !== undefined ? { kind: item.kind } : {}) }, { allowDuplicateId: true }); }
       catch (error) {
         if (!listChecklist(next).items.some((candidate) => candidate.id === id)) throw error;
       }

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

@@ -124,7 +124,8 @@ export const POD_MEMORY_SOURCE = 'docs/measurements/td1-whole-gate-mechanical-20
 /** GT1 — files per retry chunk when a root shard fails (0.2.7: bundles of 54+ files OOMed at 16Gi, smaller passed). */
 export const POD_SHARD_FILE_CAP = 27;
 
-export const POD_SWEEP_INTEGRATION_ONLY: readonly string[] = ['scripts/install.test.ts'];
+// review-model-ab: Pod 에서 출력 없이 멈춤 2/2(10-04 0.2.11 · 로컬 단독 4/0 · 1.7s) — GATE-STALL 수리 전까지 Pod 밖.
+export const POD_SWEEP_INTEGRATION_ONLY: readonly string[] = ['scripts/install.test.ts', 'scripts/review-model-ab.test.ts'];
 /** Nightly-only whole-repository cases; gate runs the fixture cases in these same files. */
 export const GATE_NIGHTLY_AUDITS: readonly string[] = [
   // Replaces F12's real-repo bucket B apps/pwa scope check and its whole-repo export partition check.
@@ -267,7 +268,7 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
     }, 0);
     const knownTimes = assignable.map((file) => durations.get(file)).filter((value): value is number => value !== undefined && Number.isFinite(value) && value >= 0).sort((a, b) => a - b);
     const unknownSeconds = knownTimes.length ? (knownTimes[Math.floor((knownTimes.length - 1) / 2)]! + knownTimes[Math.floor(knownTimes.length / 2)]!) / 2 : 1;
-    const runShard = async (paths: string[], shard: number, depth = 0, branch = ''): Promise<{ runs: ShardRun[]; stalled: NonNullable<GateResult['stalledShards']> }> => {
+    const runShard = async (paths: string[], shard: number, depth = 0, branch = '', retriedNoOutput = false): Promise<{ runs: ShardRun[]; stalled: NonNullable<GateResult['stalledShards']> }> => {
       const ignores = cdpPatterns.filter((pattern) => paths.includes(pattern))
         .flatMap((pattern) => ['--path-ignore-patterns', pattern]);
       // 파일별 소요는 junit 으로 남긴다 — 콘솔 요약(판정 원천)은 그대로이고, 느린 시험 목록(K10 D4)·계층 분리(D2)의 자가 된다.
@@ -354,6 +355,11 @@ export function createGateRunner(repo: string, remote?: string, commandOverride?
           }
         }
       }
+      if (reason === 'no-output' && !retriedNoOutput) {
+        const retry = await runShard(paths, shard, depth, `${branch}-retry`, true);
+        debug.log('release-loop.gate', 'pod-shard-retry', { shard, files: paths, reason, outcome: retry.stalled[0]?.reason ?? 'ok' });
+        return retry;
+      }
       if (reason) {
         // 깊이 2 에서 «이름 없는 실패»·«불완전»도 파일 단위로 가른다 — 아니면 149파일 조각의 실패 하나가 끝까지 주인 없이 남는다(09-30 G1e 7번 조각: 요약 28 · 이름 27).
         // 로그 없이 죽은 조각(`no-output` · OOM)도 같다 — 09-30 G1f ② 4-0-0 은 150파일이 격리 0 으로 남았다.

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

@@ -1,12 +1,43 @@
 #!/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; 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)}`);
+      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'));
+      // 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)}`);
+    } catch (error) {
+      cleanup();
+      throw error;
+    }
+    return { checkout: tree, commit, cleanup };
+  };
+}
 
 function localInstallSource(): string | null {
   try {
@@ -54,11 +85,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}`, 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-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(); }
 }