elanous 0.2.0 → 0.2.5

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

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+/**
+ * Release-loop ⑦ — boot the TUI of one commit in isolation and check it responds.
+ *
+ *   bun scripts/release-loop/tui-sim-node.ts --commit <sha> [--json]
+ *
+ * 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.
+ * 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).
+ */
+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';
+
+const log = (msg: string) => process.stderr.write(`[tui-node] ${msg}\n`);
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+function run(args: string[], cwd: string, timeoutMs = 60_000) {
+  const r = spawnSync('bun', args, { cwd, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 16 * 1024 * 1024 });
+  return { rc: r.status ?? -1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+}
+
+async function session(worktree: string, stateDir: string, id: string, work: string): Promise<{ checks: TuiCheck[]; png?: string }> {
+  const sim = (...a: string[]) => run(['scripts/tui-sim.ts', ...a], worktree, 60_000);
+  const startLog = join(work, `${id}.log`);
+  const child = spawn('bun', ['scripts/tui-sim.ts', 'start', '--id', id, '--test', '--state-dir', stateDir, '--boot', '10'], {
+    cwd: worktree, detached: true, stdio: ['ignore', openSync(startLog, 'a'), openSync(startLog, 'a')],
+  });
+  child.unref();
+  const t0 = Date.now();
+  let readyMs: number | null = null;
+  try {
+    while (Date.now() - t0 < 90_000) {
+      if (/"ready": true/.test(sim('status', id).stdout)) { readyMs = Date.now() - t0; break; }
+      await sleep(2000);
+    }
+    const text = () => sim('text', id).stdout;
+    const first = readyMs === null ? '' : text();
+    let help = '';
+    let afterEsc = '';
+    if (readyMs !== null) {
+      sim('send', id, '/help');
+      await sleep(3000);
+      help = text();
+      sim('key', id, 'esc');
+      await sleep(1500);
+      afterEsc = text();
+    }
+    const dump = readyMs === null ? '' : sim('dump', id, 'release-check').stderr;
+    const inTree = /files: .*?(\S+\.png)/.exec(dump)?.[1];
+    // The worktree is removed at the end — keep the screen next to it, in the temp work dir.
+    let png: string | undefined;
+    if (inTree && existsSync(inTree)) { png = join(work, basename(inTree)); copyFileSync(inTree, png); }
+    return { checks: tuiChecks({ readyMs, first, help, afterEsc }), png };
+  } finally {
+    sim('stop', id);
+    await sleep(3000);
+    sim('clean', id);
+  }
+}
+
+async function main(): Promise<number> {
+  const argv = process.argv.slice(2);
+  const commit = argv[argv.indexOf('--commit') + 1] ?? '';
+  const json = argv.includes('--json');
+  if (argv.indexOf('--commit') < 0 || !/^[0-9a-f]{7,40}$/i.test(commit)) { log('--commit <sha> is required'); return 2; }
+  if (process.platform !== 'darwin') { log('macOS only — this node runs on the mbp'); return 2; }
+
+  const repo = resolve('.');
+  const stateDir = join(repo, '.elanous-test');
+  const work = mkdtempSync(join(tmpdir(), 'tui-node-'));
+  const worktree = join(work, 'tree');
+  let attempts: Array<{ checks: TuiCheck[]; png?: string }> = [];
+  let failure: string | undefined;
+  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()}`);
+    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)}`;
+    log(`session 1 (${id})`);
+    attempts.push(await session(worktree, stateDir, id, work));
+    if (tuiVerdict(attempts[0]!.checks) === 'fail') {
+      log('session 2 (retry)');
+      attempts.push(await session(worktree, stateDir, `${id}-r`, work));
+    }
+  } catch (e) {
+    failure = e instanceof Error ? e.message : String(e);
+    log(`could not run: ${failure}`);
+    attempts = [];
+  } finally {
+    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 } : {}) };
+  if (json) console.log(JSON.stringify(out));
+  else {
+    console.log(`tui-node: ${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}`);
+    if (failure) console.log(`  error: ${failure}`);
+  }
+  return verdict === 'error' ? 2 : verdict === 'fail' ? 1 : 0;
+}
+
+process.exit(await main());

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

@@ -0,0 +1,26 @@
+#!/usr/bin/env bun
+import { existsSync } from 'node:fs';
+import { errorResult, finishNode, nodeOutput, readGraphContext, runCommand, type CommandRunner, type NodeOutcome } from './node-verdict.js';
+
+export function runUpgrade(run: CommandRunner = runCommand) {
+  const context = readGraphContext();
+  if (context.outputs.prepare?.outcome !== 'ok') throw new Error('prepare did not pass');
+  if (nodeOutput(context, 'prepare', 'commit') !== nodeOutput(context, 'version-release', 'commit')) throw new Error('prepare commit differs from release commit');
+  const candidate = nodeOutput(context, 'prepare', 'candidate');
+  if (!existsSync(candidate)) throw new Error(`candidate missing: ${candidate}`);
+  const output = run('bash', ['scripts/release-upgrade-check.sh', '--from', context.input.previousVersion, '--candidate', candidate]);
+  if (output.stderr) process.stderr.write(output.stderr);
+  const verdicts = output.stdout.split('\n').filter((line) => /\[upgrade\] verdict\b/.test(line));
+  // `release-upgrade-check.sh` appends `from=<v> to=«<v> <sha>»` after the verdict (0.2.4) — the verdict word is what counts.
+  const passed = verdicts.length === 2 && verdicts.some((line) => /^ubuntu:24\.04\s+\[upgrade\] verdict ok(?:\s|$)/.test(line))
+    && verdicts.some((line) => /^debian:12\s+\[upgrade\] verdict ok(?:\s|$)/.test(line));
+  const outcome: NodeOutcome = output.status === 0 && passed ? 'ok' : verdicts.length === 0 || output.status === null || output.status === 2 ? 'error' : 'fail';
+  return { outcome, verdict: outcome === 'ok' ? 'pass' as const : 'fail' as const,
+    summary: outcome === 'ok' ? `upgrade ${context.input.previousVersion} → ${context.input.version} · ${verdicts.length} images` : `upgrade failed (rc=${output.status}): ${output.stdout.trim().split('\n').at(-1) || output.stderr.trim() || 'no upgrade verdict'}` };
+}
+
+if (import.meta.main) {
+  let version = '';
+  try { version = readGraphContext().input.version; process.exitCode = finishNode('upgrade', version, runUpgrade()); }
+  catch (error) { process.exitCode = finishNode('upgrade', version, errorResult(error)); }
+}

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

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+import { errorResult, finishNode, lastResult, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
+
+export function runVerify(run: CommandRunner = runCommand) {
+  const context = readGraphContext();
+  if (context.outputs['docs-land']?.outcome !== 'ok') throw new Error('docs must land and deploy before verify');
+  if (nodeOutput(context, 'publish', 'tag') !== `v${context.input.version}`) throw new Error('published tag/version mismatch');
+  const output = run('bun', ['bin/elanous.mjs', 'release', 'verify', '--version', context.input.version, '--json']);
+  if (output.stderr) process.stderr.write(output.stderr);
+  const result = lastResult(output);
+  const passed = output.status === 0 && result?.ok === true && result.notesPage === 'ok';
+  if (output.status === null || output.status === 2 || !result) throw new Error(`release verify incomplete: ${output.stderr.trim()}`);
+  return { outcome: passed ? 'ok' as const : 'fail' as const, verdict: passed ? 'pass' as const : 'fail' as const,
+    summary: passed ? `verify v${context.input.version} · notes page ok` : `verify failed: ${result?.error ?? result?.notesPage ?? output.stderr.trim()}` };
+}
+
+if (import.meta.main) {
+  let version = '';
+  try { version = readGraphContext().input.version; process.exitCode = finishNode('verify', version, runVerify()); }
+  catch (error) { process.exitCode = finishNode('verify', version, errorResult(error)); }
+}

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

@@ -0,0 +1,147 @@
+#!/usr/bin/env bun
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+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 };
+
+export function nextDevVersion(version: string): string {
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(version);
+  if (!match) throw new Error(`invalid release version: ${version}`);
+  return `${match[1]}.${match[2]}.${BigInt(match[3]!) + 1n}-dev.0`;
+}
+
+function run(command: string, args: string[], cwd: string): string {
+  const result = spawnSync(command, args, { cwd, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+  if (result.status !== 0 || result.error) {
+    throw new Error(`${command} ${args[0]} failed (rc=${result.status ?? 'unknown'}): ${(result.stderr || result.error || result.stdout || 'no output').toString().trim()}`);
+  }
+  return result.stdout;
+}
+
+// git-spawn-allow: this isolated release checkout must read origin/main and create/remove its own worktree.
+function git(repo: string, ...args: string[]): string {
+  return run('git', args, repo).trim();
+}
+
+// Retry only failures that can clear without changing the release checkout.
+const TRANSIENT_FETCH_ERROR = /cannot lock ref|unable to create .*\.lock|another git process|could not resolve host|failed to connect|connection (?:timed out|reset)|network is unreachable|remote end hung up|early EOF|permission denied \(publickey\)|authentication failed|could not read Username/i;
+
+function fetchMain(repo: string): void {
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    const result = spawnSync('git', ['fetch', 'origin', 'main'], { cwd: repo, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
+    if (result.status === 0 && !result.error) return;
+    const stderr = (result.stderr || result.error?.message || result.stdout || 'no output').trim();
+    if (attempt < 3 && TRANSIENT_FETCH_ERROR.test(stderr)) {
+      Bun.sleepSync(100 * 2 ** (attempt - 1));
+      continue;
+    }
+    // Report the URL's transport, never its value (or the socket path).
+    const remote = spawnSync('git', ['remote', 'get-url', 'origin'], { cwd: repo, encoding: 'utf8' });
+    const url = remote.status === 0 ? remote.stdout.trim() : '';
+    const remoteKind = /^(?:ssh:\/\/|[^\s@]+@[^\s:]+:)/i.test(url) ? 'ssh'
+      : /^https:\/\//i.test(url) ? 'https' : 'unknown';
+    throw new Error(`git fetch origin main failed after ${attempt} attempt(s) (rc=${result.status ?? 'unknown'}): ${stderr} [remote URL kind: ${remoteKind}; SSH_AUTH_SOCK present: ${Boolean(process.env.SSH_AUTH_SOCK)}]`);
+  }
+}
+
+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');
+  return pkg.version;
+}
+
+function landing(repo: string, kind: Kind, releaseVersion: string): Output {
+  const target = kind === 'release' ? releaseVersion : nextDevVersion(releaseVersion);
+  const source = kind === 'release' ? `${releaseVersion}-dev.N` : releaseVersion;
+  fetchMain(repo);
+  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 (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})`);
+  }
+
+  const temp = mkdtempSync(join(tmpdir(), 'release-version-node-'));
+  const worktree = join(temp, 'tree');
+  try {
+    git(repo, 'worktree', 'add', '-b', `release-version-${kind}-${Date.now()}-${process.pid}`, worktree, 'origin/main');
+    const path = join(worktree, 'package.json');
+    const text = readFileSync(path, 'utf8');
+    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 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);
+    if (!root) throw new Error('bun.lock root workspace not found');
+    const lockedVersion = /"version"\s*:\s*"([^"]+)"/.exec(root[1]!);
+    if (lockedVersion) {
+      if (lockedVersion[1] !== current) throw new Error(`bun.lock root version ${lockedVersion[1]} is not ${current}`);
+      writeFileSync(lockPath, lock.replace(root[0], root[0].replace(lockedVersion[0], `"version": "${target}"`)));
+    }
+    run('bun', ['install', '--frozen-lockfile'], worktree);
+    const title = kind === 'release' ? `release: ${target}` : `version: ${target}`;
+    const land = spawnSync('bun', ['bin/elanous.mjs', 'pr', 'land', '--commit-message', title, '--title', title, '--body', `Set package.json version to ${target}.`], {
+      cwd: worktree, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024,
+    });
+    const transcript = `${land.stdout ?? ''}\n${land.stderr ?? ''}`;
+    if (land.status !== 0 || land.error || !transcript.includes('✓ merge:')) {
+      throw new Error(`pr land failed (rc=${land.status ?? 'unknown'}; merge marker ${transcript.includes('✓ merge:') ? 'present' : 'missing'}): ${transcript.trim() || land.error || 'no output'}`);
+    }
+    const mergeLine = transcript.split('\n').find((line) => line.includes('✓ merge:')) ?? '';
+    const pr = /(?:#|\/pull\/)(\d+)\b/.exec(mergeLine);
+    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 };
+    git(repo, 'worktree', 'remove', '--force', worktree);
+    rmSync(temp, { recursive: true, force: true });
+    return output;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${message} [worktree: ${worktree}]`);
+  }
+}
+
+function main(args: string[] = process.argv.slice(2), repo = process.cwd()): Output {
+  let kind: Kind | null = null;
+  let version: string | null = null;
+  try {
+    if (args[0] !== 'release' && args[0] !== 'dev-bump') throw new Error('usage: version-node.ts <release|dev-bump> [--version <v>] --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; }
+      throw new Error(`unknown or incomplete argument: ${args[i]}`);
+    }
+    if (!version) {
+      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 } };
+        if (typeof context.input?.version === 'string') version = context.input.version;
+      }
+    }
+    if (!version) throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version)');
+    nextDevVersion(version);
+    return landing(resolve(repo), kind, version);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const worktree = /\[worktree: ([^\]]+)\]$/.exec(message)?.[1];
+    const outputVersion = kind === 'dev-bump' && version && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(version)
+      ? nextDevVersion(version) : version;
+    return { outcome: 'error', kind, version: outputVersion,
+      commit: null, pr: null, ...(worktree ? { worktree } : {}), error: message };
+  }
+}
+
+if (import.meta.main) {
+  const output = main();
+  debug.log(`release-loop.version-${output.kind ?? 'unknown'}`, 'result', { version: output.version, outcome: output.outcome });
+  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/release-upgrade-check.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+# 업데이트(마이그레이션) 검증 — «이전 공개판을 쓰던 사용자»가 새 판으로 올려도 상태가 살아남는가 (대표 2026-09-27 · 릴리스 절차 한 칸).
+#   빈 배포판 컨테이너 → 이전 공개판 설치(공개 설치기 · ELANOUS_VERSION=<from>) → setup · 기억 · 설정 · 로그를 만든다
+#   → 후보 묶음으로 설치기를 다시 돈다(사용자가 업데이트하는 길) → 새 판 · 기억 · 설정 키 · 상태 파일 · 로그 · doctor 를 잰다.
+#
+#   bash scripts/release-upgrade-check.sh --from 0.2.2 [--candidate <elanous.tgz>] [BASE…]
+#     --candidate 없으면 이 체크아웃을 `bun pm pack` 한다(⚠️ 내부본 — 발행 전엔 prepare 산출의 공개 묶음을 준다).
+#     BASE 기본 = ubuntu:24.04 debian:12
+# ⛔ 컨테이너는 systemd·재부팅을 못 잰다(데몬 상주 마이그레이션은 베어 VM 몫). 판정은 줄마다 `[upgrade] <칸> ok|FAIL`.
+set -u
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+FROM=""; CAND=""; BASES=()
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    --from) FROM="${2:-}"; shift 2 ;;
+    --candidate) CAND="${2:-}"; shift 2 ;;
+    -h|--help) sed -n '2,11p' "$0"; exit 0 ;;
+    -*) echo "⛔ unknown option: $1" >&2; exit 2 ;;
+    *) BASES+=("$1"); shift ;;
+  esac
+done
+[ -n "$FROM" ] || { echo "⛔ --from <previous public version> is required" >&2; exit 2; }
+[ "${#BASES[@]}" -gt 0 ] || BASES=(ubuntu:24.04 debian:12)
+command -v docker >/dev/null 2>&1 || { echo "⛔ docker not on PATH" >&2; exit 127; }
+docker info >/dev/null 2>&1 || { echo "⛔ docker engine is not running" >&2; exit 1; }
+
+OUT="${ELANOUS_UPGRADE_CHECK_OUT:-$(mktemp -d "${TMPDIR:-/tmp}/elanous-upgrade-check.XXXXXX")}"
+CTX="$OUT/ctx"; mkdir -p "$CTX"
+if [ -n "$CAND" ]; then
+  [ -f "$CAND" ] || { echo "⛔ candidate not found: $CAND" >&2; exit 2; }
+  cp "$CAND" "$CTX/elanous.tgz"
+else
+  echo "▶ packing this checkout (internal) → $CTX" >&2
+  (cd "$ROOT" && bun pm pack --destination "$CTX" >/dev/null 2>&1) || { echo "⛔ bun pm pack failed" >&2; exit 1; }
+  mv "$(ls "$CTX"/*.tgz | head -1)" "$CTX/elanous.tgz"
+fi
+cp "$ROOT/scripts/install.sh" "$ROOT/docker/upgrade/Dockerfile" "$ROOT/docker/upgrade/upgrade-probe.sh" "$CTX/"
+
+rc=0
+for base in "${BASES[@]}"; do
+  tag="$(printf '%s' "$base" | tr ':/' '--')"
+  if docker build -t "elanous-upgrade:$tag" --build-arg BASE="$base" "$CTX" > "$OUT/build-$tag.log" 2>&1; then
+    docker run --rm -e FROM="$FROM" "elanous-upgrade:$tag" > "$OUT/run-$tag.log" 2>&1
+    grep '^\[upgrade\] .* FAIL' "$OUT/run-$tag.log" | sed "s/^/$base  /"
+    verdict="$(grep '^\[upgrade\] verdict' "$OUT/run-$tag.log" | tail -1)"
+    echo "$base  ${verdict:-[upgrade] no verdict — $OUT/run-$tag.log}"
+    case "$verdict" in *"verdict ok"*) ;; *) rc=1 ;; esac
+  else
+    echo "$base  build FAILED — $OUT/build-$tag.log"; rc=1
+  fi
+done
+echo "logs: $OUT" >&2
+exit $rc

package/scripts/se-mission-prepare.ts

@@ -24,6 +24,7 @@ import { notifyMissionOrigin, notifyMissionHitl, notifyMissionDocument, resolveT
 import { proposalDraftPath } from '../src/autopilot/build/build-target.js';
 import { applyConfigDirFlagFromArgv } from '../src/cli/config-dir-flag.js';
 import { debug } from '../src/debug/log.js';
+import { inferPhaseTrack, loadTrackRegistry } from '../src/autopilot/mission-phase-track.js';
 import { reportDecomposeFailureHitl } from './se-mission-prepare-cause.js';
 
 // ★ 인스턴스 스코프 상속(ISO·2026-07-14) — 부모 데몬(mission-prepare-spawn)이 argv 로 넘긴
@@ -232,7 +233,13 @@ function collectDecompPhases(mid: string): { decompPhases: DecompPhase[]; phaseL
   const phases = new TaskStore();
   try {
     const t = phases.listTasks({ goalSlug: mid }).sort((a, b) => a.createdAt - b.createdAt);
-    const phaseLines = t.slice(0, 10).map((x, i) => `  ${i}. ${x.title}`).join('\n');
+    const registry = loadTrackRegistry();
+    const phaseLines = t.map((x, i) => {
+      const result = inferPhaseTrack(`${x.title}\n${x.surface.kind === 'subagent' ? x.surface.prompt : ''}`, registry);
+      try { debug.log('mission.prepare', 'phase-track', { missionId: mid, taskId: x.id, track: result.track, reason: result.reason, hits: result.hits }); } catch { /* fail-soft */ }
+      if (!registry.length) return `  ${i}. ${x.title}`;
+      return result.track ? `  ${i}. ${result.mark} ${x.title}` : `  ${i}. ❔ ${x.title} (트랙 미정 → 🅢)`;
+    }).slice(0, 10).join('\n');
     const decompPhases: DecompPhase[] = t.filter((x) => x.surface.kind === 'subagent').map((x) => ({
       id: x.id, title: x.title,
       prompt: x.surface.kind === 'subagent' ? x.surface.prompt : x.title,
@@ -423,20 +430,7 @@ const buildImpls: import('../src/autopilot/mission-build-orchestrate.js').StageI
     //   Opus 재분해). 실측: universal-content 분해가 sol 스키마 위반으로 실패했으나 Opus 면 성공 가능.
     const errStr = r.error ?? '';
     const transientFailed = !r.ok && !decomposeModelOverride && (isTransientLlmError(errStr) || /VALIDATION_FAILED|PARSE_FAILED|schema violation/i.test(errStr));
-    let phaseLines = '';
-    let decompPhases: { id: string; title: string; prompt: string; acceptance: string[]; dependsOn: string[] }[] = [];
-    const phases = new TaskStore();
-    try {
-      const t = phases.listTasks({ goalSlug: missionId }).sort((a, b) => a.createdAt - b.createdAt);
-      phaseLines = t.slice(0, 10).map((x, i) => `  ${i}. ${x.title}`).join('\n');
-      decompPhases = t.filter((x) => x.surface.kind === 'subagent').map((x) => ({
-        id: x.id, title: x.title,
-        prompt: x.surface.kind === 'subagent' ? x.surface.prompt : x.title,
-        acceptance: x.acceptance?.criteria ? [...x.acceptance.criteria] : [],
-        // ★ 사전정보(축③) — 비평기가 상류 계약 출처(dependsOn)를 알고 고립 판정 방지.
-        dependsOn: [...x.dependsOn],
-      }));
-    } finally { phases.close(); }
+    const { phaseLines, decompPhases } = collectDecompPhases(missionId);
     return { ok: r.ok, phaseCount, error: r.error ?? '', transientFailed, decompPhases, phaseLines };
   },
   // critique — D1 적대적 비평(heavy·decompPhases).

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

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

package/scripts/test-audit-meaningless.ts

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

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

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