elanous 0.2.10 → 0.2.12

package/scripts/release-loop/tui-sim-node.ts

@@ -6,7 +6,7 @@
  *
  * Steps: temp worktree at <sha> → `scripts/tui-sim.ts start --test` (that commit's code, the
  * repo's `.elanous-test` config so no first-run wizard) → first screen → `/help` → Esc → dump PNG
- * → stop, clean, remove worktree. Never touches the production daemon or ~/.elanous.
+ * → stop, clean → run seven PTY regression checks → remove worktree. Never touches the production daemon or ~/.elanous.
  * macOS only (the TUI PTY checks run on the mbp). One retry of the whole session → «flaky».
  *
  * Exit: 0 = pass or flaky · 1 = fail · 2 = could not run (not macOS, worktree).
@@ -15,7 +15,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { copyFileSync, existsSync, mkdtempSync, openSync, symlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
-import { tuiChecks, tuiVerdict, type TuiCheck } from './tui-node-checks';
+import { parseTuiRegress, regressWarning, tuiChecks, tuiVerdict, type TuiCheck, type TuiRegress } from './tui-node-checks';
 
 const log = (msg: string) => process.stderr.write(`[tui-node] ${msg}\n`);
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
@@ -64,6 +64,27 @@ async function session(worktree: string, stateDir: string, id: string, work: str
   }
 }
 
+export function measureTuiRegress(worktree: string, runner: typeof spawnSync = spawnSync): TuiRegress {
+  try {
+    const measured = runner('bun', ['scripts/tui-regress.ts', '--json'], {
+      cwd: worktree, encoding: 'utf8', timeout: 180_000, maxBuffer: 16 * 1024 * 1024,
+    });
+    if (measured.error) return { unmeasured: measured.error.message };
+    if (measured.status !== 0 && measured.status !== 1) {
+      return { unmeasured: `실행 종료 코드 ${measured.status ?? measured.signal ?? '없음'}: ${(measured.stderr ?? '').trim().slice(0, 200)}` };
+    }
+    return parseTuiRegress(measured.stdout ?? '');
+  } catch (error) {
+    return { unmeasured: String(error) };
+  }
+}
+
+export function tuiNodeOutput(commit: string, attempts: Array<{ checks: TuiCheck[]; png?: string }>, regress: TuiRegress, failure?: string) {
+  const last = attempts.at(-1);
+  const verdict = !last ? 'error' : tuiVerdict(last.checks) === 'fail' ? 'fail' : attempts.length > 1 ? 'flaky' : 'pass';
+  return { verdict, commit, attempts: attempts.length, checks: last?.checks ?? [], png: last?.png, regress, ...(failure ? { error: failure } : {}) };
+}
+
 async function main(): Promise<number> {
   const argv = process.argv.slice(2);
   const commit = argv[argv.indexOf('--commit') + 1] ?? '';
@@ -77,9 +98,12 @@ async function main(): Promise<number> {
   const worktree = join(work, 'tree');
   let attempts: Array<{ checks: TuiCheck[]; png?: string }> = [];
   let failure: string | undefined;
+  let regress: TuiRegress = { unmeasured: 'worktree를 만들지 못했다' };
+  let worktreeReady = false;
   try {
     const add = spawnSync('git', ['worktree', 'add', '--detach', worktree, commit], { cwd: repo, encoding: 'utf8' });
     if (add.status !== 0) throw new Error(`worktree add failed: ${(add.stderr ?? '').trim()}`);
+    worktreeReady = true;
     symlinkSync(join(repo, 'node_modules'), join(worktree, 'node_modules'));
     if (!existsSync(join(stateDir, 'config.json'))) log(`⚠ ${stateDir}/config.json missing — the TUI may open the first-run wizard`);
     const id = `rl-${commit.slice(0, 8)}-${Date.now().toString(36)}`;
@@ -94,20 +118,20 @@ async function main(): Promise<number> {
     log(`could not run: ${failure}`);
     attempts = [];
   } finally {
+    if (worktreeReady) regress = measureTuiRegress(worktree);
     spawnSync('git', ['worktree', 'remove', '--force', worktree], { cwd: repo });
   }
 
-  const last = attempts.at(-1);
-  const verdict = !last ? 'error' : tuiVerdict(last.checks) === 'fail' ? 'fail' : attempts.length > 1 ? 'flaky' : 'pass';
-  const out = { verdict, commit, attempts: attempts.length, checks: last?.checks ?? [], png: last?.png, ...(failure ? { error: failure } : {}) };
+  const out = tuiNodeOutput(commit, attempts, regress, failure);
   if (json) console.log(JSON.stringify(out));
   else {
-    console.log(`tui-node: ${verdict} · ${commit.slice(0, 10)} · attempts ${attempts.length}`);
+    console.log(`tui-node: ${out.verdict} · ${commit.slice(0, 10)} · attempts ${attempts.length}`);
     for (const c of out.checks) console.log(`  ${c.pass ? '✓' : '✗'} ${c.id} — ${c.detail}`);
     if (out.png) console.log(`  screen: ${out.png}`);
+    console.log(`  ${regressWarning(regress).line}`);
     if (failure) console.log(`  error: ${failure}`);
   }
-  return verdict === 'error' ? 2 : verdict === 'fail' ? 1 : 0;
+  return out.verdict === 'error' ? 2 : out.verdict === 'fail' ? 1 : 0;
 }
 
-process.exit(await main());
+if (import.meta.main) process.exit(await main());

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

@@ -24,6 +24,7 @@ export interface ReleaseLoopConfig {
 export interface ReleaseRunInput extends ReleaseLoopConfig {
   version: string;
   previousVersion: string;
+  cutCommit?: string;
   gatePodPool: string;
 }
 
@@ -67,7 +68,7 @@ export function releaseLoopConfig(configPath = getElanousConfigDirOverride() ? j
   return raw.release?.loop ?? {};
 }
 
-export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDeps = {}): ReleaseRunInput {
+export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDeps = {}, cutCommit?: string): ReleaseRunInput {
   const config = deps.config ?? releaseLoopConfig(deps.configPath);
   const pool = config.gatePodPool;
   if (typeof pool !== 'string' || !pool.trim()) throw new Error('release.loop.gatePodPool is required before graph execution');
@@ -75,16 +76,17 @@ export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDep
   return {
     ...config,
     version, previousVersion,
+    ...(cutCommit !== undefined ? { cutCommit } : {}),
     gatePodPool: pool.trim(),
   };
 }
 
 /** Fail closed at the entry boundary, before any graph node can change a release. */
 export async function runUnattendedRelease(
-  opts: { version: string; dryRun?: boolean },
+  opts: { version: string; dryRun?: boolean; cutCommit?: string },
   deps: UnattendedReleaseDeps = {},
 ): Promise<{ input: ReleaseRunInput; dryRun: boolean; state?: GraphRunState }> {
-  const input = buildReleaseRunInput(opts.version, deps);
+  const input = buildReleaseRunInput(opts.version, deps, opts.cutCommit);
   if (opts.dryRun) return { input, dryRun: true };
   const gate = (deps.checklist ?? checklistGate)(opts.version);
   if (!gate.ok) throw new Error(`release checklist blocked: ${[...gate.red, ...gate.undecided, ...gate.blocked].join(', ')}`);

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);
@@ -49,9 +49,9 @@ function fetchMain(repo: string): void {
   }
 }
 
-function versionAt(repo: string): string {
-  const pkg = JSON.parse(git(repo, 'show', 'origin/main:package.json')) as { version?: unknown };
-  if (typeof pkg.version !== 'string') throw new Error('origin/main package.json has no version');
+function versionAt(repo: string, ref = 'origin/main'): string {
+  const pkg = JSON.parse(git(repo, 'show', `${ref}:package.json`)) as { version?: unknown };
+  if (typeof pkg.version !== 'string') throw new Error(`${ref} package.json has no version`);
   return pkg.version;
 }
 
@@ -64,13 +64,49 @@ function shippedNextMdLines(repo: string, cut: string | undefined): { lines: Set
   return { lines: new Set(shown.stdout.split('\n').map((line) => line.trim()).filter((line) => line.startsWith('- '))) };
 }
 
-function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string): Output {
+function landing(repo: string, kind: Kind, releaseVersion: string, cut?: string, cutCommit?: string): Output {
   const target = kind === 'release' ? releaseVersion : nextDevVersion(releaseVersion);
   const source = kind === 'release' ? `${releaseVersion}-dev.N` : releaseVersion;
   fetchMain(repo);
+  if (kind === 'release' && cutCommit !== undefined) {
+    if (!/^[0-9a-f]{7,40}$/i.test(cutCommit)) throw new Error(`invalid cut commit SHA: ${cutCommit}`);
+    const local = spawnSync('git', ['rev-parse', '--verify', `${cutCommit}^{commit}`], { cwd: repo, encoding: 'utf8' });
+    let chosen = local.status === 0 ? local.stdout.trim() : '';
+    const onMain = chosen ? spawnSync('git', ['merge-base', '--is-ancestor', chosen, 'origin/main'], { cwd: repo }) : null;
+    if (onMain && onMain.status !== 0 && onMain.status !== 1) throw new Error(`git merge-base failed: ${onMain.error || onMain.stderr || 'unknown'}`);
+    if (onMain?.status !== 0) {
+      const remote = git(repo, 'ls-remote', '--heads', 'origin', `refs/heads/release/${releaseVersion}`);
+      const branchTip = remote.split(/\s+/)[0];
+      if (!chosen && branchTip?.toLowerCase().startsWith(cutCommit.toLowerCase())) {
+        git(repo, 'fetch', 'origin', `refs/heads/release/${releaseVersion}`);
+        chosen = git(repo, 'rev-parse', '--verify', `${cutCommit}^{commit}`);
+      }
+      if (!chosen) chosen = git(repo, 'rev-parse', '--verify', `${cutCommit}^{commit}`);
+      if (branchTip !== chosen) {
+        throw new Error(`cut commit ${chosen} is neither an ancestor of origin/main nor the tip of release/${releaseVersion}`);
+      }
+    }
+    const current = versionAt(repo, chosen);
+    if (current !== target) throw new Error(`cut commit ${chosen} package.json version ${current} is not ${target}`);
+    debug.log('release-loop.cut', 'chosen', { version: releaseVersion, source: 'cut-commit', commit: chosen });
+    return { outcome: 'ok', kind, version: target, commit: chosen, pr: null };
+  }
   const current = versionAt(repo);
   const before = git(repo, 'rev-parse', 'origin/main');
-  if (current === target) return { outcome: 'ok', kind, version: target, commit: before, pr: null };
+  if (current === target) {
+    if (kind === 'release') debug.log('release-loop.cut', 'chosen', { version: releaseVersion, source: 'main', commit: before });
+    return { outcome: 'ok', kind, version: target, commit: before, pr: null };
+  }
+  // An older chosen cut may finish after main has already advanced to the next stable release.
+  // Keep that newer main untouched; a -dev.N mismatch is not evidence of a later release.
+  if (kind === 'dev-bump' && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(current)) {
+    const mainParts = current.split('.').map(BigInt);
+    const nextParts = target.slice(0, -'-dev.0'.length).split('.').map(BigInt);
+    const firstDifference = mainParts.findIndex((part, index) => part !== nextParts[index]);
+    if (firstDifference === -1 || mainParts[firstDifference]! > nextParts[firstDifference]!) {
+      return { outcome: 'ok', kind, version: current, commit: before, pr: null };
+    }
+  }
   if (kind === 'release' ? !new RegExp(`^${releaseVersion.replaceAll('.', '\\.')}\\-dev\\.(0|[1-9][0-9]*)$`).test(current) : current !== source) {
     throw new Error(`origin/main version ${current} is not ${source} (target ${target})`);
   }
@@ -84,6 +120,23 @@ 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');
     const root = /"workspaces"\s*:\s*\{\s*""\s*:\s*\{([\s\S]*?)(?=\s*"(?:dependencies|devDependencies|optionalDependencies)"\s*:)/.exec(lock);
@@ -142,7 +195,8 @@ 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 });
     return output;
@@ -156,27 +210,34 @@ function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Out
   let kind: Kind | null = null;
   let version: string | null = null;
   let cut: string | undefined;
+  let cutCommit: string | undefined;
   try {
-    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] [--cut <sha>] --json');
+    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] [--cut <sha>] [--cut-commit <sha>] --json');
     kind = args[0];
     for (let i = 1; i < args.length; i++) {
       if (args[i] === '--json') continue;
       if (args[i] === '--version' && args[i + 1]) { version = args[++i]!; continue; }
       if (args[i] === '--cut' && args[i + 1]) { cut = args[++i]!; continue; }
+      if (args[i] === '--cut-commit' && args[i + 1]) { cutCommit = args[++i]!; continue; }
       throw new Error(`unknown or incomplete argument: ${args[i]}`);
     }
     if (process.env.ELANOUS_GRAPH_CONTEXT) {
       const location = process.env.ELANOUS_GRAPH_CONTEXT;
       const context = JSON.parse(location.trimStart().startsWith('{') ? location : readFileSync(location, 'utf8')) as {
-        input?: { version?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
+        input?: { version?: unknown; cutCommit?: unknown }; outputs?: Record<string, { commit?: unknown } | undefined> };
       if (!version && typeof context.input?.version === 'string') version = context.input.version;
+      if (kind === 'release' && cutCommit === undefined && context.input?.cutCommit !== undefined) {
+        if (typeof context.input.cutCommit !== 'string') throw new Error('cutCommit must be a commit SHA');
+        cutCommit = context.input.cutCommit;
+      }
       // The cut = the commit version-release landed (what cutoff and the gate measured).
-      const cutCommit = context.outputs?.['version-release']?.commit;
-      if (!cut && typeof cutCommit === 'string' && cutCommit) cut = cutCommit;
+      const releasedCommit = context.outputs?.['version-release']?.commit;
+      if (!cut && typeof releasedCommit === 'string' && releasedCommit) cut = releasedCommit;
     }
     if (!version) throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version)');
     nextDevVersion(version);
-    return landing(resolve(repo), kind, version, cut);
+    if (kind === 'dev-bump' && cutCommit !== undefined) throw new Error('--cut-commit is only valid for release');
+    return landing(resolve(repo), kind, version, cut, cutCommit);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     const worktree = /\[worktree: ([^\]]+)\]$/.exec(message)?.[1];
@@ -189,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/signal-digest-cycle.ts

@@ -13,8 +13,7 @@ import { appendFileSync } from 'node:fs';
 import { SignalPool } from '../src/domains/signal-pool.js';
 import { runDigest, runCommunityBuzzDigest } from '../src/domains/signal-router.js';
 import { sendOutbound } from '../src/domains/outbound-alert.js';
-import { sendReportPhotoBuffer } from '../src/telegram-report.js';
-import { getUserConfig } from '../src/user-config.js';
+import { createDigestPhotoSender } from './signal-digest-photo.js';
 import { ensureCronNodePath } from '../src/domains/cron-path.js';
 import { unknownCronFlag } from '../src/domains/cron-flag-contract.js';
 
@@ -35,14 +34,10 @@ function log(msg: string): void {
   try { appendFileSync(LOG, line + '\n'); } catch { /* fail-soft */ }
 }
 
-async function sendDigestPhoto(png: Buffer, opts?: { caption?: string }): Promise<boolean> {
-  return sendReportPhotoBuffer(getUserConfig(), png, opts);
-}
-
 async function main(): Promise<void> {
   const pool = new SignalPool();
   try {
-    const d = await runDigest(pool, LIVE ? { send: sendOutbound, sendPhoto: sendDigestPhoto } : {});
+    const d = await runDigest(pool, LIVE ? { send: sendOutbound, sendPhoto: createDigestPhotoSender() } : {});
     log(`[${d.mode}] 다이제스트 대기 ${d.count} · 발송 ${d.sent}`);
     if (!LIVE && d.count > 0) {
       log(`  ▶ [digest shadow]\n${d.preview}`);

package/scripts/signal-digest-photo.ts

@@ -0,0 +1,11 @@
+import type { UserConfig } from '../src/user-config.js';
+import { getUserConfig } from '../src/user-config.js';
+import { sendReportPhotoBuffer } from '../src/telegram-report.js';
+
+/** The callback passed to runDigest for trading signal images. */
+export function createDigestPhotoSender(
+  config: () => UserConfig = getUserConfig,
+  sendPhoto: typeof sendReportPhotoBuffer = sendReportPhotoBuffer,
+): (png: Buffer, opts?: { caption?: string }) => Promise<boolean> {
+  return (png, opts) => sendPhoto(config(), png, { ...opts, kind: 'digest' });
+}

package/scripts/tech1-public-measure.ts

@@ -0,0 +1,94 @@
+import { readFileSync } from 'node:fs';
+import { loadGraphTemplatesFrom, defaultGraphsDir } from '../src/self-implement/graph-templates.js';
+
+// Public metrics for release/public/tech/tech1.json. Log metrics read the installed `elanous`
+// (operational universe) over --since/--until; `--all` adds every registered instance incl. test.
+const key = process.argv[2];
+const flag = (name: string): string | undefined => {
+  const at = process.argv.indexOf(name);
+  return at < 0 ? undefined : process.argv[at + 1];
+};
+const PAGE = 100000;
+
+type Row = { id?: number; category: string; event: string; data?: unknown };
+
+function logRows(args: string[]): { rows: Row[]; limitReached: boolean } {
+  const proc = Bun.spawnSync(['elanous', 'logs', ...args, '--json', '--json-data'], { stdout: 'pipe', stderr: 'pipe', maxBuffer: 2 ** 31 } as Parameters<typeof Bun.spawnSync>[1]);
+  if (proc.exitCode !== 0) throw new Error(`elanous logs failed: ${new TextDecoder().decode(proc.stderr).slice(0, 300)}`);
+  const rows: Row[] = [];
+  let limitReached = false;
+  for (const line of new TextDecoder().decode(proc.stdout).split('\n')) {
+    if (!line) continue;
+    const row = JSON.parse(line) as Row & { _meta?: { type?: string; limitReached?: boolean } };
+    if (row._meta) { if (row._meta.type === 'log-query-limit' && row._meta.limitReached) limitReached = true; continue; }
+    rows.push(row);
+  }
+  return { rows, limitReached };
+}
+
+function window(): string[] {
+  const since = flag('--since');
+  const until = flag('--until');
+  if (!since || !until) throw new Error('--since <ISO> --until <ISO> required');
+  return ['--since', since, '--until', until];
+}
+
+/** One page across all instances; refuses a truncated page instead of reporting a short count. */
+function unionCount(categories: string, events?: string): Map<string, number> {
+  const args = [...window(), '--all', '--include-test', '--limit', String(PAGE), '--category', categories, ...(events ? ['--event', events] : [])];
+  const { rows, limitReached } = logRows(args);
+  if (limitReached) throw new Error(`truncated at ${PAGE} rows — narrow --event`);
+  const counts = new Map<string, number>();
+  for (const row of rows) counts.set(`${row.category} ${row.event}`, (counts.get(`${row.category} ${row.event}`) ?? 0) + 1);
+  return counts;
+}
+
+const at = (counts: Map<string, number>, k: string): number => counts.get(k) ?? 0;
+
+if (key === 'graph.templates') {
+  const result = loadGraphTemplatesFrom(defaultGraphsDir());
+  console.log(Object.keys(result.templates).length);
+} else if (key === 'loop-agents.loops') {
+  const proc = Bun.spawnSync(['bun', 'bin/elanous.mjs', '--test', 'loop', 'list', '--json'], { stdout: 'pipe', stderr: 'pipe' });
+  if (proc.exitCode !== 0) throw new Error('loop catalog unavailable');
+  console.log(JSON.parse(new TextDecoder().decode(proc.stdout)).length);
+} else if (key === 'harness.author-tags') {
+  const tags = [...readFileSync('src/self-implement/goal-author.ts', 'utf8').matchAll(/tag: '([a-z-]+)'/g)].map(match => match[1]);
+  console.log(new Set(tags).size);
+} else if (key === 'observability.events') {
+  // Operational instance only; pages with --before so the 100k page cap does not cut the count.
+  let before: number | undefined;
+  let total = 0;
+  for (;;) {
+    const { rows } = logRows([...window(), '--limit', String(PAGE), ...(before === undefined ? [] : ['--before', String(before)])]);
+    total += rows.length;
+    if (rows.length < PAGE) break;
+    before = Math.min(...rows.map((row) => row.id ?? Number.POSITIVE_INFINITY));
+  }
+  console.log(total);
+} else if (key === 'stages.author') {
+  const c = unionCount('harness.author', 'goal-id-assigned');
+  console.log(JSON.stringify({ auto: at(c, 'harness.author goal-id-assigned') }));
+} else if (key === 'stages.clarify') {
+  const c = unionCount('hitl.execution,harness.author.clarify', 'auto-recommended,assumed,asked,self-answered,unresolved');
+  console.log(JSON.stringify({
+    auto: at(c, 'hitl.execution auto-recommended') + at(c, 'hitl.execution assumed') + at(c, 'harness.author.clarify self-answered'),
+    human: at(c, 'hitl.execution asked'),
+    unknown: at(c, 'harness.author.clarify unresolved'),
+  }));
+} else if (key === 'stages.ledger') {
+  const { rows, limitReached } = logRows([...window(), '--all', '--include-test', '--limit', String(PAGE), '--category', 'self-implement.pod', '--event', 'ledger-live-appended']);
+  if (limitReached) throw new Error(`truncated at ${PAGE} rows`);
+  const runs = new Set(rows.map((row) => (row.data as { runId?: string } | undefined)?.runId).filter(Boolean));
+  console.log(JSON.stringify({ auto: runs.size, appends: rows.length }));
+} else if (key === 'stages.heal') {
+  const c = unionCount('self-dev.rework,self-dev.hitl', 'repeat-count,escalation');
+  console.log(JSON.stringify({ auto: at(c, 'self-dev.rework repeat-count'), human: at(c, 'self-dev.hitl escalation') }));
+} else if (key === 'pty.missions') {
+  // External coding agents driven through an inner PTY (agent-mission) — distinct missions with any row in the window.
+  const { rows, limitReached } = logRows([...window(), '--all', '--include-test', '--limit', String(PAGE), '--category', 'agent-mission']);
+  if (limitReached) throw new Error(`truncated at ${PAGE} rows`);
+  console.log(new Set(rows.map((row) => (row.data as { missionId?: string } | undefined)?.missionId).filter(Boolean)).size);
+} else {
+  throw new Error(`Unknown public metric: ${key ?? '(missing)'}`);
+}

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/node.ts

@@ -54,7 +54,7 @@ function measure(ctx: Context, audit = false): number {
     'while IFS= read -r f; do',
     '  [ -n "$f" ] || continue',
     '  s=$(date +%s)',
-    '  if [ -n "$TO" ]; then /usr/bin/time -l "$TO" -k 10 300 bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; else /usr/bin/time -l bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; fi',
+    `  if [ -n "$TO" ]; then /usr/bin/time -l "$TO" -k 10 300 ${audit ? 'env ELANOUS_NIGHTLY_AUDIT=1 ' : ''}bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; else /usr/bin/time -l ${audit ? 'env ELANOUS_NIGHTLY_AUDIT=1 ' : ''}bun run scripts/test-deterministic.ts "./$f" > "$T/out" 2> "$T/err"; fi`,
     '  rc=$?; e=$(( $(date +%s) - s ))',
     '  rss=$(awk \'/maximum resident set size/ {printf "%d", $1/1048576}\' "$T/err")',
     // bun test prints its summary on stderr — read both streams.

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/tui-regress.ts

@@ -42,7 +42,7 @@ async function runCheck(check: TuiCheck): Promise<Verdict> {
       else snaps[step.as] = await handle.renderScreen();
     }
     // TUI_REGRESS_DUMP=<id> prints that check's screens (to see why a verdict failed).
-    if (process.env.TUI_REGRESS_DUMP === check.id) for (const [k, v] of Object.entries(snaps)) console.log(`--- ${check.id}:${k}\n${v.split('\n').filter((l) => l.trim()).join('\n')}`);
+    if (!json && process.env.TUI_REGRESS_DUMP === check.id) for (const [k, v] of Object.entries(snaps)) console.log(`--- ${check.id}:${k}\n${v.split('\n').filter((l) => l.trim()).join('\n')}`);
     return check.judge(snaps);
   } catch (error) {
     return { ok: false, reason: `실행 오류: ${String(error).slice(0, 120)}` };
@@ -67,5 +67,5 @@ for (const check of checks) {
 }
 const fail = results.filter((r) => !r.ok).length;
 if (json) console.log(JSON.stringify({ results, pass: results.length - fail, fail }));
-console.log(`tui-regress: pass ${results.length - fail} · fail ${fail}`);
+else console.log(`tui-regress: pass ${results.length - fail} · fail ${fail}`);
 process.exit(fail ? 1 : 0);