elanous 0.2.4 → 0.2.5

package/scripts/landing-heal/run-mission.ts

@@ -1,9 +1,12 @@
 #!/usr/bin/env bun
 import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { githubAutomationToken } from '../../src/auth/github-app-token.js';
 import { debug } from '../../src/debug/log.js';
 import { emitDecision } from '../../src/live/detail-switch.js';
-import { matchMustFix, type MustFixVerdict } from './must-fix-match.js';
+import { parse } from '../../src/agent-substrate/pr-comment-meta.js';
+import { classifyReviewRounds, matchMustFix, type MustFixVerdict } from './must-fix-match.js';
 
 interface PullRequest {
   number: number;
@@ -13,11 +16,45 @@ interface PullRequest {
   headRefName: string;
   files: Array<{ path: string }>;
 }
-interface Match { pr: number; text: string; verdict: MustFixVerdict }
-interface GraphContext { runId?: string; input?: { windowMinutes?: number; mustFixByPr?: Record<string, string[]> }; outputs?: Record<string, unknown> }
+interface Match { pr: number; text: string; verdict: MustFixVerdict | 'rereviewed' | 'open'; run?: string; round?: number; resolvedIn?: number[] }
+interface GraphContext { runId?: string; input?: { windowMinutes?: number; mustFixByPr?: Record<string, string[]> }; outputs?: Record<string, unknown>; decision?: typeof emitDecision }
 export type RunCommand = (args: string[]) => string;
+// 상주 루프(30분마다)는 사람 계정 한도를 쓰지 않는다 — 부른 쪽이 GH_TOKEN 을 주지 않았으면 GitHub App 설치 토큰으로(09-29 한도 소진).
+// 발급 함수마다 한 번(프로세스 전역 한 칸이면 앞선 호출의 진짜 토큰이 주입한 가짜를 이긴다 — 09-29 시험 실패 출력에 토큰이 찍혔다).
+const minted = new WeakMap<() => string | null, string | null>();
+export function ghEnv(env: NodeJS.ProcessEnv = process.env, mint: () => string | null = githubAutomationToken): NodeJS.ProcessEnv {
+  if (Object.hasOwn(env, 'GH_TOKEN')) return env;
+  if (!minted.has(mint)) minted.set(mint, mint());
+  const appToken = minted.get(mint);
+  debug.log('landing-heal', 'gh-token', { source: appToken ? 'github-app' : 'caller' });
+  return appToken ? { ...env, GH_TOKEN: appToken } : env;
+}
+// 상주 루프는 설치본 폴더(git 저장소 아님)에서 돈다 — `gh` 가 저장소를 추론 못 해 첫 cron 바퀴가 collect 에서 죽었다(09-29 21:00).
+// 부른 쪽이 GH_REPO 를 주지 않았고 cwd 가 git 저장소가 아니면, App 설치의 저장소가 «정확히 하나»일 때 그것을 쓴다(모르면 멈춘다).
+export async function ghRepoEnv(env: NodeJS.ProcessEnv, cwd: string, list: (token: string) => Promise<string[]> = installationRepos): Promise<NodeJS.ProcessEnv> {
+  if (Object.hasOwn(env, 'GH_REPO') || insideGitCheckout(cwd)) return env;
+  const token = env.GH_TOKEN;
+  if (!token) throw new Error('GitHub repository unknown outside a git checkout — set GH_REPO');
+  const repos = await list(token);
+  if (repos.length !== 1) throw new Error(`GitHub repository unknown outside a git checkout — App installation has ${repos.length} repositories; set GH_REPO`);
+  debug.log('landing-heal', 'gh-repo', { source: 'github-app-installation', repo: repos[0] });
+  return { ...env, GH_REPO: repos[0] };
+}
+function insideGitCheckout(cwd: string): boolean {
+  for (let dir = resolve(cwd); ; dir = dirname(dir)) {
+    if (existsSync(join(dir, '.git'))) return true;
+    if (dirname(dir) === dir) return false;
+  }
+}
+async function installationRepos(token: string): Promise<string[]> {
+  const response = await fetch('https://api.github.com/installation/repositories?per_page=2', { headers: { Authorization: `Bearer ${token}`, Accept: 'application/vnd.github+json' } });
+  if (!response.ok) throw new Error(`GitHub App installation repositories: HTTP ${response.status}`);
+  const body = await response.json() as { repositories?: Array<{ full_name?: string }> };
+  return (body.repositories ?? []).flatMap((repo) => repo.full_name ? [repo.full_name] : []);
+}
+let resolvedEnv: NodeJS.ProcessEnv | undefined;
 const gh: RunCommand = (args) => {
-  const result = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+  const result = spawnSync('gh', args, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, env: resolvedEnv ?? ghEnv() });
   if (result.error || result.status !== 0) throw new Error(`gh ${args.slice(0, 2).join(' ')} failed: ${result.stderr || String(result.error)}`);
   return result.stdout;
 };
@@ -44,6 +81,18 @@ function pullRequests(ctx: GraphContext): PullRequest[] {
   return value as PullRequest[];
 }
 
+/** 착지 뒤 검증 표식 — 코멘트 «첫 줄»이 `landing-verified:` 로 시작하고 뒤에 무엇이든 한 글자는 있어야 한다(빈 표식은 표식이 아니다). */
+export function isLandingVerified(body: string | undefined): boolean {
+  return /^landing-verified:\s*\S/.test((body ?? '').trimStart().split('\n')[0] ?? '');
+}
+
+/** 코멘트 «첫 줄»이 `must-fix resolved in #N[, #M]` 이면 그 PR 번호들. */
+export function resolvedInPrs(body: string | undefined): number[] {
+  const first = (body ?? '').trimStart().split('\n')[0] ?? '';
+  const match = /^must[-\s]?fix resolved in (#\d+(?:\s*,\s*#\d+)*)/i.exec(first);
+  return match ? [...match[1]!.matchAll(/#(\d+)/g)].map((m) => Number(m[1])) : [];
+}
+
 export function runMission(mission: string, ctx: GraphContext, run: RunCommand = gh, now = new Date()): Record<string, unknown> {
   switch (mission) {
     case 'collect': {
@@ -66,34 +115,79 @@ export function runMission(mission: string, ctx: GraphContext, run: RunCommand =
         const pages = JSON.parse(run(['api', `repos/{owner}/{repo}/pulls/${pr.number}/comments`, '--paginate', '--slurp'])) as Array<Array<{ body?: string }>>;
         if (!Array.isArray(pages) || !pages.every(Array.isArray)) throw new Error(`invalid review comments for PR #${pr.number}`);
         const inline = pages.flat();
+        const comments = [...(details.reviews ?? []), ...(details.comments ?? []), ...inline];
+        const reviewRounds = comments.filter(({ body }) => {
+          const meta = body ? parse(body) : null;
+          return meta?.role === 'reviewer' && !!meta.run && meta.round !== undefined;
+        });
+        // 뒤 PR 로 고친 must-fix 는 원래 PR 에 첫 줄 `must-fix resolved in #N` 코멘트를 남긴다(🅞·🅣 09-29 합의) — 그 PR 의 «열린» 항목을 풀고, 그 코멘트 자체는 must-fix 로 세지 않는다.
+        const resolvedNotes = comments.filter(({ body }) => resolvedInPrs(body).length > 0);
+        const resolvedIn = [...new Set(resolvedNotes.flatMap(({ body }) => resolvedInPrs(body)))].sort((a, b) => a - b);
+        const classified = classifyReviewRounds(reviewRounds).map((item) => item.verdict === 'open' && resolvedIn.length
+          ? { ...item, verdict: 'resolved' as const, resolvedIn } : item);
         const mustFixes = [...(ctx.input?.mustFixByPr?.[String(pr.number)] ?? []),
-          ...[...(details.reviews ?? []), ...(details.comments ?? []), ...inline]
-            .flatMap((review) => review.body && /must[-\s]?fix/i.test(review.body) ? [review.body] : [])];
-        if (!mustFixes.length) continue;
-        const diff = run(['pr', 'diff', String(pr.number), '--patch']);
-        for (const text of mustFixes) matches.push({ pr: pr.number, text, verdict: matchMustFix(text, diff) });
+          ...comments.filter((comment) => !reviewRounds.includes(comment) && !resolvedNotes.includes(comment))
+            .flatMap(({ body }) => body && /must[-\s]?fix/i.test(body) ? [body] : [])];
+        const diff = mustFixes.length ? run(['pr', 'diff', String(pr.number), '--patch']) : '';
+        const prMatches: Match[] = [
+          ...classified.map((item) => ({ pr: pr.number, ...item })),
+          ...mustFixes.map((text) => ({ pr: pr.number, text, verdict: matchMustFix(text, diff) })),
+        ];
+        matches.push(...prMatches);
+        debug.log('landing-heal', 'must-fix-classified', {
+          pr: pr.number,
+          rereviewed: prMatches.filter((item) => item.verdict === 'rereviewed').length,
+          open: prMatches.filter((item) => item.verdict === 'open').length,
+          unknown: prMatches.filter((item) => item.verdict === 'unknown').length,
+        });
       }
       return { outcome: 'ok', matches };
     }
-    case 'verify-needed':
-      return { outcome: 'ok', verifyNeeded: pullRequests(ctx)
-        .filter((pr) => pr.state === 'MERGED' && pr.files.some((file) => file.path.startsWith('apps/pwa/') || file.path.startsWith('src/')))
-        .map((pr) => pr.number) };
+    case 'verify-needed': {
+      const candidates = pullRequests(ctx)
+        .filter((pr) => pr.state === 'MERGED' && pr.files.some((file) => file.path.startsWith('apps/pwa/') || file.path.startsWith('src/')));
+      // 착지 뒤 검증을 끝낸 쪽은 PR 코멘트 첫 줄 `landing-verified: <sha> · <무엇을 쟀나>` 를 남긴다(🅞·🅣 09-29 합의) — 그 PR 은 뺀다.
+      const verified: number[] = [];
+      const verifyNeeded = candidates.filter((pr) => {
+        const { comments } = JSON.parse(run(['pr', 'view', String(pr.number), '--json', 'comments'])) as { comments?: Array<{ body?: string }> };
+        const done = (comments ?? []).some((comment) => isLandingVerified(comment.body));
+        if (done) verified.push(pr.number);
+        return !done;
+      }).map((pr) => pr.number);
+      return { outcome: 'ok', verifyNeeded, verified };
+    }
     case 'report': {
-      const prs = pullRequests(ctx).length;
+      const collected = pullRequests(ctx);
+      const prs = collected.length;
       const matches = output(ctx, 'must-fix-match').matches as Match[];
-      const mustFixUnresolved = matches.filter((item) => item.verdict === 'unresolved' || item.verdict === 'unknown').length;
+      const mustFixOpen = matches.filter((item) => item.verdict === 'open' || item.verdict === 'unresolved').length;
+      const mustFixUnknown = matches.filter((item) => item.verdict === 'unknown').length;
+      const mustFixRereviewed = matches.filter((item) => item.verdict === 'rereviewed').length;
+      const mustFixUnresolved = mustFixOpen + mustFixUnknown;
       const verifyNeeded = output(ctx, 'verify-needed').verifyNeeded as number[];
-      debug.log('landing-heal', 'tick', { prs, mustFixUnresolved, verifyNeeded });
-      emitDecision({ kind: 'VERIFY', what: `착지·치유 관측: PR ${prs}건`, reason: `must-fix 미해결/미상 ${mustFixUnresolved}건 · 착지 뒤 검증 필요 ${verifyNeeded.length}건`, purpose: '착지 후속 작업 관측', target: 'landing-heal', ...(ctx.runId ? { runId: ctx.runId } : {}) });
-      return { outcome: 'ok', prs, mustFixUnresolved, verifyNeeded };
+      const mergedPrs = new Set(collected.filter((pr) => pr.state === 'MERGED').map((pr) => pr.number));
+      const landedOpen = matches.filter((item) => item.verdict === 'open' && mergedPrs.has(item.pr));
+      const unresolved = matches.filter((item) => item.verdict === 'unresolved').length;
+      const openPrs = [...new Set(landedOpen.map((item) => item.pr))].sort((a, b) => a - b);
+      const open = landedOpen.length;
+      debug.log('landing-heal', 'tick', { prs, mustFixUnresolved, mustFixOpen, mustFixUnknown, mustFixRereviewed, verifyNeeded });
+      (ctx.decision ?? emitDecision)({
+        kind: 'VERIFY',
+        what: `착지·치유 관측: PR ${prs}건${open ? ` — 열린 must-fix ${open}건(PR ${openPrs.map((pr) => `#${pr}`).join(', ')})` : ''}`,
+        reason: `열린 채 착지 ${open}건 · 미해결 ${unresolved}건 · 미상 ${mustFixUnknown}건 · 다시 봄 ${mustFixRereviewed}건 · 착지 뒤 검증 필요 ${verifyNeeded.length}건`,
+        purpose: '착지 후속 작업 관측', target: 'landing-heal', ...(ctx.runId ? { runId: ctx.runId } : {}),
+      });
+      return { outcome: 'ok', prs, mustFixUnresolved, mustFixOpen, mustFixUnknown, mustFixRereviewed, verifyNeeded };
     }
     default: throw new Error(`unknown landing-heal mission: ${mission}`);
   }
 }
 
 if (import.meta.main) {
-  try { process.stdout.write(`${JSON.stringify(runMission(process.argv[2] ?? '', context()))}\n`); }
+  try {
+    resolvedEnv = await ghRepoEnv(ghEnv(), process.cwd());
+    process.stdout.write(`${JSON.stringify(runMission(process.argv[2] ?? '', context()))}\n`);
+  }
   catch (error) {
     process.stderr.write(`${String(error)}\n`);
     process.exitCode = 1;

package/scripts/lib/front-route-measurement.ts

@@ -0,0 +1,131 @@
+import { classifyIntakeFrontRoute } from '../../src/intake-plane/front-route-classifier.js';
+import { INTAKE_FRONT_ROUTE_TRACKS, type IntakeFrontRouteDecision, type IntakeFrontRouteTrack } from '../../src/intake-plane/front-route-rules.js';
+import type { ResolveRoleProviderFn } from '../../src/intake-plane/runtime-callables.js';
+import { wilsonInterval, type WilsonInterval } from './nl-routing-measurement.js';
+
+export interface FrontRouteItem { id: string; text: string; expected: IntakeFrontRouteTrack }
+export interface FrontRouteCorpus { description: string; items: FrontRouteItem[] }
+export type FrontRouteConfusion = Record<IntakeFrontRouteTrack, Record<IntakeFrontRouteTrack, number>>;
+export interface FrontRouteProviderResult {
+  label: string;
+  runs: number;
+  agree: number;
+  agreement: number;
+  wilson: WilsonInterval | null;
+  askHuman: number;
+  confusion: FrontRouteConfusion;
+  meanLatencyMs: number;
+  perItem: { id: string; expected: IntakeFrontRouteTrack; got: IntakeFrontRouteTrack[] }[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isTrack(value: unknown): value is IntakeFrontRouteTrack {
+  return typeof value === 'string' && (INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(value);
+}
+
+export function loadFrontRouteCorpus(json: unknown): FrontRouteCorpus {
+  const parsed: unknown = typeof json === 'string' ? JSON.parse(json) : json;
+  if (!isRecord(parsed) || typeof parsed.description !== 'string' || !Array.isArray(parsed.items) || parsed.items.length === 0) {
+    throw new Error('Front-route corpus requires a description and nonempty items array');
+  }
+  const ids = new Set<string>();
+  const items: FrontRouteItem[] = parsed.items.map((raw: unknown, index: number) => {
+    if (!isRecord(raw) || typeof raw.id !== 'string' || !raw.id.trim() ||
+      typeof raw.text !== 'string' || !raw.text.trim() || !isTrack(raw.expected)) {
+      throw new Error(`Invalid front-route corpus item at index ${index} (id, text, expected track required)`);
+    }
+    if (ids.has(raw.id)) throw new Error(`Duplicate front-route corpus id at index ${index}`);
+    ids.add(raw.id);
+    return { id: raw.id, text: raw.text, expected: raw.expected };
+  });
+  return { description: parsed.description, items };
+}
+
+function emptyConfusion(): FrontRouteConfusion {
+  return Object.fromEntries(INTAKE_FRONT_ROUTE_TRACKS.map((expected) => [expected,
+    Object.fromEntries(INTAKE_FRONT_ROUTE_TRACKS.map((got) => [got, 0])),
+  ])) as FrontRouteConfusion;
+}
+
+export async function measureFrontRoute(
+  items: readonly FrontRouteItem[],
+  { providers, runs, classify = classifyIntakeFrontRoute, now = () => performance.now() }: {
+    providers: readonly { label: string; resolve: ResolveRoleProviderFn }[];
+    runs: number;
+    classify?: typeof classifyIntakeFrontRoute;
+    now?: () => number;
+  },
+): Promise<FrontRouteProviderResult[]> {
+  if (!Number.isSafeInteger(runs) || runs < 1) throw new Error('runs must be a positive integer');
+  if (!items.length || !providers.length) throw new Error('items and providers must not be empty');
+  if (new Set(providers.map(({ label }) => label)).size !== providers.length || providers.some(({ label }) => !label.trim())) {
+    throw new Error('provider labels must be unique and nonempty');
+  }
+  // An id can contain another item's text, too: sanitize against the whole corpus.
+  const texts = items.map(({ text }) => text);
+  const exposesText = (id: string) => texts.some((text) => id.includes(text));
+  const safeIds = new Set(items.filter(({ id }) => !exposesText(id)).map(({ id }) => id));
+  const reportIds = items.map(({ id }, index) => {
+    if (!exposesText(id)) return id;
+    let candidate = `item-${index + 1}`;
+    if (exposesText(candidate) || safeIds.has(candidate)) {
+      let codePoint = 0xe000;
+      while (texts.some((text) => text.includes(String.fromCodePoint(codePoint)))) codePoint++;
+      const unused = String.fromCodePoint(codePoint);
+      candidate = unused;
+      while (safeIds.has(candidate)) candidate += unused;
+    }
+    safeIds.add(candidate);
+    return candidate;
+  });
+  const results: FrontRouteProviderResult[] = [];
+  for (const { label, resolve } of providers) {
+    const confusion = emptyConfusion();
+    const perItem: FrontRouteProviderResult['perItem'] = [];
+    let agree = 0;
+    let askHuman = 0;
+    let latencyMs = 0;
+    for (const [index, item] of items.entries()) {
+      const got: IntakeFrontRouteTrack[] = [];
+      for (let repeat = 0; repeat < runs; repeat++) {
+        const started = now();
+        let decision: IntakeFrontRouteDecision;
+        try {
+          decision = await classify(item.text, { resolveRoleProvider: resolve });
+        } catch {
+          decision = { track: 'ask-human', confidence: 0, reason: 'classifier-failed:llm-error', decidedBy: 'classifier' };
+        } finally {
+          latencyMs += now() - started;
+        }
+        if (!isTrack(decision.track)) throw new Error(`Invalid classifier track for item ${reportIds[index]}`);
+        got.push(decision.track);
+        confusion[item.expected][decision.track]++;
+        if (decision.track === item.expected) agree++;
+        if (decision.track === 'ask-human' &&
+          (decision.reason.startsWith('classifier-low-confidence:') || decision.reason.startsWith('classifier-failed:'))) askHuman++;
+      }
+      perItem.push({ id: reportIds[index]!, expected: item.expected, got });
+    }
+    const total = items.length * runs;
+    results.push({ label, runs: total, agree, agreement: agree / total, wilson: wilsonInterval(agree, total), askHuman,
+      confusion, meanLatencyMs: latencyMs / total, perItem });
+  }
+  return results;
+}
+
+export function formatFrontRouteReport(result: readonly FrontRouteProviderResult[]): string {
+  const percent = (n: number) => `${(100 * n).toFixed(1)}%`;
+  const lines = ['Provider | Agreement | 95% Wilson | ask-human (low confidence/failure) | Mean latency ms'];
+  for (const provider of result) {
+    const interval = provider.wilson;
+    lines.push(`${provider.label} | ${provider.agree}/${provider.runs} (${percent(provider.agreement)}) | ${interval ? `${percent(interval.lower)}–${percent(interval.upper)}` : 'n/a'} | ${provider.askHuman} | ${provider.meanLatencyMs.toFixed(1)}`);
+    lines.push(`Confusion (${provider.label}): expected \\ got | ${INTAKE_FRONT_ROUTE_TRACKS.join(' | ')}`);
+    for (const expected of INTAKE_FRONT_ROUTE_TRACKS) {
+      lines.push(`${expected} | ${INTAKE_FRONT_ROUTE_TRACKS.map((got) => provider.confusion[expected][got]).join(' | ')}`);
+    }
+  }
+  return lines.join('\n');
+}

package/scripts/lib/tui-sim-keys.ts

@@ -0,0 +1,42 @@
+// Named tui-sim keys and raw PTY input bytes.
+const KEYS: Record<string, string> = {
+  enter: '\r', return: '\r', tab: '\t', 'shift-tab': '\x1b[Z', esc: '\x1b', escape: '\x1b',
+  space: ' ', backspace: '\x7f', delete: '\x1b[3~',
+  up: '\x1b[A', down: '\x1b[B', right: '\x1b[C', left: '\x1b[D',
+  pageup: '\x1b[5~', pagedown: '\x1b[6~', home: '\x1b[H', end: '\x1b[F',
+  'shift-enter': '\x1b[13;2u',
+};
+
+export function resolveKeyBytes(name: string): string | null {
+  const key = name.toLowerCase();
+  if (Object.hasOwn(KEYS, key)) return KEYS[key]!;
+  if (/^ctrl-[a-z]$/.test(key)) return String.fromCharCode(key.charCodeAt(5) - 96);
+  if (key === 'ctrl-\\') return '\x1c';
+  if (key === 'ctrl-]') return '\x1d';
+  if (key.startsWith('hex:')) {
+    const hex = key.slice(4);
+    return hex.length > 0 && hex.length % 2 === 0 && /^[0-9a-f]+$/.test(hex)
+      ? Buffer.from(hex, 'hex').toString('latin1')
+      : null;
+  }
+  if (key.startsWith('alt-')) {
+    const suffix = name.slice(4);
+    const bytes = Object.hasOwn(KEYS, suffix.toLowerCase()) ? KEYS[suffix.toLowerCase()]!
+      : suffix.toLowerCase().startsWith('ctrl-') ? resolveKeyBytes(suffix)
+      : [...suffix].length === 1 ? suffix : null;
+    return bytes === null ? null : `\x1b${bytes}`;
+  }
+  return null;
+}
+
+/** Keep raw hex as a Buffer: passing a latin1 string to the PTY would UTF-8 encode bytes >= 0x80. */
+export function resolveKeyInput(name: string): string | Buffer | null {
+  const bytes = resolveKeyBytes(name);
+  if (bytes === null) return null;
+  return name.toLowerCase().startsWith('hex:') ? Buffer.from(name.slice(4), 'hex') : bytes;
+}
+
+/** Bun's native PTY passes Buffer bytes through unchanged; its typed registry API only declares strings. */
+export function writeKeyInput(handle: { write(chars: string): void }, input: string | Buffer): void {
+  handle.write(input as string);
+}

package/scripts/measure-front-route-classifier.ts

@@ -0,0 +1,56 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { ResolveRoleProviderFn } from '../src/intake-plane/runtime-callables.js';
+import type { LLMProvider } from '../src/llm.js';
+import { formatFrontRouteReport, loadFrontRouteCorpus, measureFrontRoute } from './lib/front-route-measurement.js';
+
+interface RunnerOptions { providers: string[]; runs: number; json: boolean }
+
+export function parseFrontRouteArgs(args: readonly string[]): RunnerOptions {
+  const options: RunnerOptions = { providers: [], runs: 1, json: false };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') options.json = true;
+    else if (arg === '--provider') {
+      const value = args[++i];
+      if (!value || value.startsWith('--') || !/^[\w-]+(?:\/\S+)?$/.test(value)) throw new Error('--provider requires <name>[/<model>]');
+      options.providers.push(value);
+    } else if (arg === '--runs') {
+      const value = args[++i];
+      if (!value || !/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value))) throw new Error('--runs requires a positive integer');
+      options.runs = Number(value);
+    } else throw new Error(`Unknown option: ${arg}`);
+  }
+  return options;
+}
+
+export function frontRouteProviders(specs: readonly string[], registry: Record<string, LLMProvider>): { label: string; resolve: ResolveRoleProviderFn }[] {
+  return specs.map((label) => {
+    const slash = label.indexOf('/');
+    const name = slash < 0 ? label : label.slice(0, slash);
+    const model = slash < 0 ? undefined : label.slice(slash + 1);
+    const provider = registry[name];
+    if (!provider) throw new Error(`Unknown provider: ${name}`);
+    const selectedModel = model ?? provider.defaultModel;
+    const resolveRole: ResolveRoleProviderFn = (_role) => ({ provider: provider as unknown as ReturnType<ResolveRoleProviderFn>['provider'], ...(typeof selectedModel === 'string' ? { model: selectedModel } : {}) });
+    return { label, resolve: resolveRole };
+  });
+}
+
+export async function main(args: readonly string[] = process.argv.slice(2), env: NodeJS.ProcessEnv = process.env): Promise<void> {
+  const options = parseFrontRouteArgs(args);
+  if (!env.CORPUS_PATH?.trim()) throw new Error('CORPUS_PATH is required (path to front-route corpus JSON)');
+  const corpus = loadFrontRouteCorpus(readFileSync(resolve(process.cwd(), env.CORPUS_PATH), 'utf8'));
+  const { PROVIDERS } = await import('../src/llm.js');
+  let selected = options.providers;
+  if (!selected.length) {
+    const { resolveRoleLlm } = await import('../src/user-config.js');
+    const { provider, model } = resolveRoleLlm('classify');
+    selected = [model ? `${provider}/${model}` : provider];
+  }
+  const providers = frontRouteProviders(selected, PROVIDERS);
+  const result = await measureFrontRoute(corpus.items, { providers, runs: options.runs });
+  console.log(options.json ? JSON.stringify(result, null, 2) : formatFrontRouteReport(result));
+}
+
+if (import.meta.main) await main();

package/scripts/media/ocr-leak-scan.sh

@@ -0,0 +1,21 @@
+#!/bin/zsh
+# 공개 영상 누출 관문 — 1초 한 장(또는 --fps N) 전수 OCR → 금지 목록 → 초 단위 표(hits.tsv).
+# 사용: scripts/media/ocr-leak-scan.sh <영상> <산출 폴더> [--fps N]
+# 한계: tesseract eng — 한글 칸·이모지는 사람 눈으로 따로 본다(내부 문서 `TC` §2). 걸림은 오독이 많다 → 그 초 프레임을 눈으로 대조한다.
+V=$1; O=$2; FPS=1
+[ "${3:-}" = "--fps" ] && FPS=${4:-1}
+[ -f "$V" ] && [ -n "$O" ] || { echo "사용: $0 <영상> <산출 폴더> [--fps N]" >&2; exit 2; }
+command -v tesseract >/dev/null && command -v ffmpeg >/dev/null || { echo "tesseract·ffmpeg 가 필요하다" >&2; exit 2; }
+mkdir -p "$O/f" && ffmpeg -loglevel error -i "$V" -vf "fps=$FPS" "$O/f/%05d.png" || exit 2
+# 금지: 홈 경로 · 실명 계정 표지 · 사설 호스트 · tailnet · 금액 · 크레딧 수 · 메일 · 키·토큰 모양(elanous 단기 토큰 elt_ · bearer · GitHub 토큰 · 40자+ 연속)
+PAT='/Users/|msb[0-9]|\bmbp\b|tail[0-9a-f]{4,}|ts\.net|\$[0-9]|USD|credit[s]? *[0-9]|@gmail|api[_-]?key|sk-[A-Za-z0-9]{8}|elt_[A-Za-z0-9_-]{6}|bearer|ghs_|gh[po]_|[A-Za-z0-9_-]{40,}'
+[ -n "${OCR_EXTRA_PATTERN:-}" ] && PAT="$PAT|$OCR_EXTRA_PATTERN"   # 계정 실명 등은 저장소에 적지 않고 환경변수로 준다
+: > "$O/hits.tsv"
+for f in "$O"/f/*.png; do
+  n=${${f:t:r}#0*}; s=$(( (n - 1) / FPS ))
+  t=$(tesseract "$f" - -l eng --psm 11 2>/dev/null)
+  print -r -- "$t" > "$O/f/${f:t:r}.txt"
+  print -r -- "$t" | grep -inE "$PAT" | grep -vE '^[0-9]+:[^ ]*run-[0-9a-f]{8}-[0-9a-f-]{27}$' \
+    | while read -r line; do print -r -- "$s\t$line" >> "$O/hits.tsv"; done
+done
+print "frames=$(ls "$O"/f/*.png | wc -l | tr -d ' ') hits=$(wc -l < "$O/hits.tsv" | tr -d ' ')"

package/scripts/public-export.ts

@@ -23,6 +23,7 @@ import { userInfo } from 'node:os';
 import { dirname, join, posix, resolve } from 'node:path';
 import ts from 'typescript';
 import { parse } from 'yaml';
+import { spawnSyncText } from '../src/util/spawn-sync-output.js';
 
 export interface ExportTransform {
   readonly id: string;
@@ -369,9 +370,7 @@ export function summarizeLeaks(hits: readonly LeakHit[]): Record<string, { hits:
 }
 
 function trackedFiles(root: string): string[] {
-  const listed = spawnSync('git', ['-C', root, 'ls-files', '-z'], { encoding: 'utf8' });
-  if (listed.status !== 0) throw new Error(`git ls-files failed: ${listed.stderr.trim()}`);
-  return listed.stdout.split('\0').filter(Boolean);
+  return spawnSyncText('git', ['-C', root, 'ls-files', '-z']).split('\0').filter(Boolean);
 }
 
 export function run(argv: readonly string[], root = resolve(import.meta.dir, '..')): number {

package/scripts/public-import-pr.ts

@@ -1,10 +1,12 @@
 #!/usr/bin/env bun
-/** Import a public PR patch without fetching, committing, or publishing it. */
+/** Import a public PR patch without committing or publishing it. */
 import { spawnSync } from 'node:child_process';
 import { existsSync, lstatSync, mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, unlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, isAbsolute, join } from 'node:path';
 import { loadExportConfig, selectExportFiles, transformExportFiles } from './public-export.js';
+import { debug } from '../src/debug/log.js';
+import { spawnSyncText } from '../src/util/spawn-sync-output.js';
 
 export type ImportKind = 'clean' | 'renamed' | 'transformed' | 'outside-export';
 export interface ImportFile { publicPath: string; sourcePath?: string; kind: ImportKind; reason?: string }
@@ -83,9 +85,7 @@ function gitApply(root: string, patch: string, check = false): string | undefine
 }
 
 function trackedFiles(root: string): string[] {
-  const result = spawnSync('git', ['ls-files', '-z'], { cwd: root, encoding: 'utf8' });
-  if (result.status !== 0) throw new Error(`git ls-files failed: ${result.stderr}`);
-  return result.stdout.split('\0').filter(Boolean);
+  return spawnSyncText('git', ['ls-files', '-z'], { cwd: root, encoding: 'utf8' }).split('\0').filter(Boolean);
 }
 
 /** Classify against the real export, stage eligible edits, then write only on --apply. */
@@ -177,8 +177,82 @@ export function importPublicPatch(patch: string, root: string, apply = false, au
   } finally { rmSync(staging, { recursive: true, force: true }); }
 }
 
-/** CLI entrypoint: bun scripts/public-import-pr.ts [patch-file] --author 'Name <email>' [--apply]. */
-export function run(argv: readonly string[], root = process.cwd(), stdin?: string): number {
+interface GhResult { status: number | null; stdout: string; stderr?: string }
+interface RunDeps { gh?: (argv: readonly string[], root: string) => GhResult }
+
+function prAuthors(raw: string, databaseIdForLogin: (login: string) => number): string[] {
+  const parsed: unknown = JSON.parse(raw);
+  if (!parsed || typeof parsed !== 'object' || !('commits' in parsed) || !Array.isArray(parsed.commits) || !parsed.commits.length) {
+    throw new Error('PR has no commits');
+  }
+  const unique = new Map<string, string>();
+  const seenEmails = new Set<string>();
+  for (const commit of parsed.commits) {
+    const identities = commit?.authors ?? (commit?.author ? [commit.author] : []);
+    if (!Array.isArray(identities) || !identities.length) throw new Error('PR commit has no author');
+    for (const identity of identities) {
+      const name = identity?.name?.trim();
+      const email = identity?.email?.trim();
+      const login = identity?.login?.trim() ?? identity?.user?.login?.trim();
+      const key = login ? `login:${login.toLowerCase()}` : `email:${email?.toLowerCase()}`;
+      if (unique.has(key) || (email && seenEmails.has(email.toLowerCase()))) continue;
+      const id = identity?.user?.databaseId ?? identity?.id;
+      const numericId = /^[1-9]\d*$/.test(String(id)) ? Number(id) : undefined;
+      const address = email || (login && /^[A-Za-z0-9-]+$/.test(login)
+        ? `${numericId && Number.isSafeInteger(numericId) ? numericId : databaseIdForLogin(login)}+${login}@users.noreply.github.com`
+        : undefined);
+      if (typeof name !== 'string' || !/^[^<>\r\n]+$/.test(name) || !address || !/^[^<>\s@]+@[^<>\s@]+$/.test(address)) {
+        throw new Error('PR commit author lacks a valid name or email/identity');
+      }
+      unique.set(key, `${name} <${address}>`);
+      seenEmails.add(address.toLowerCase());
+    }
+  }
+  return [...unique.values()];
+}
+
+/** CLI entrypoint: patch + --author, or --pr <number> --repo <owner/name>. */
+export function run(argv: readonly string[], root = process.cwd(), stdin?: string, deps: RunDeps = {}): number {
+  const prMode = argv.includes('--pr') || argv.includes('--repo');
+  if (prMode) {
+    const prIndex = argv.indexOf('--pr');
+    const repoIndex = argv.indexOf('--repo');
+    const pr = argv[prIndex + 1];
+    const repo = argv[repoIndex + 1];
+    const flags = argv.filter((arg) => arg === '--apply' || arg === '--dry-run');
+    if (prIndex < 0 || repoIndex < 0 || !pr || !/^[1-9]\d*$/.test(pr) || !repo ||
+        !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo) ||
+        argv.length !== 4 + flags.length || flags.length > 1 ||
+        argv.some((arg, i) => (arg === '--pr' && i !== prIndex) || (arg === '--repo' && i !== repoIndex))) {
+      console.error('usage: bun scripts/public-import-pr.ts --pr <number> --repo <owner/name> [--dry-run|--apply]');
+      return 2;
+    }
+    try {
+      const gh = deps.gh ?? ((args: readonly string[], cwd: string) => spawnSync('gh', [...args], { cwd, encoding: 'utf8' }));
+      const fetch = (args: string[]): string => {
+        const result = gh(args, root);
+        if (result.status !== 0) throw new Error(result.stderr || `gh ${args[1]} failed`);
+        return result.stdout;
+      };
+      const patch = fetch(['pr', 'diff', pr, '--repo', repo]);
+      const authors = prAuthors(fetch(['pr', 'view', pr, '--repo', repo, '--json', 'commits']), (login) => {
+        const user: unknown = JSON.parse(fetch(['api', `users/${login}`]));
+        const id = user && typeof user === 'object' && 'id' in user ? user.id : undefined;
+        const resolvedLogin = user && typeof user === 'object' && 'login' in user ? user.login : undefined;
+        if (typeof id !== 'number' || !Number.isSafeInteger(id) || id <= 0 ||
+            typeof resolvedLogin !== 'string' || resolvedLogin.toLowerCase() !== login.toLowerCase()) {
+          throw new Error('GitHub user lacks a matching login or numeric database ID');
+        }
+        return id;
+      });
+      const result = importPublicPatch(patch, root, flags.includes('--apply'));
+      debug.log('public-import.pr', 'fetched', { repo, pr: Number(pr), files: result.files.length, authors: authors.length });
+      for (const file of result.files) console.log(`${file.kind}\t${file.publicPath}\t${file.sourcePath ?? '-'}${file.reason ? `\t${file.reason}` : ''}`);
+      console.log(`\nCommit message draft (not committed):\nImport public PR ${repo}#${pr}\n\nhttps://github.com/${repo}/pull/${pr}\n\n${authors.map((author) => `Co-Authored-By: ${author}`).join('\n')}`);
+      if (result.rc) console.error('import incomplete: one or more files were not applied');
+      return result.rc;
+    } catch (error) { console.error(`import failed: ${String(error)}`); return 1; }
+  }
   const apply = argv.includes('--apply');
   const authorIndex = argv.indexOf('--author');
   const author = authorIndex >= 0 ? argv[authorIndex + 1] : undefined;

package/scripts/publish-internal-dist.ts

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { spawnSyncText } from '../src/util/spawn-sync-output.js';
 
 export function publishInternalDist(checkout: string, out: string, keep = 3): { ok: true; version: string; commit: string; sha256: string; out: string; pwaBuild: 'present' | 'missing' } {
   checkout = resolve(checkout);
@@ -42,9 +43,7 @@ export function publishInternalDist(checkout: string, out: string, keep = 3): {
     const isBuildOutput = (path: string): boolean => path.startsWith('apps/pwa/out/') || path === 'src/version/packed-revision.json';
     const publishedPaths = [...new Set([...packedPaths, 'scripts/install.sh'])].filter((path) => !isBuildOutput(path));
     const pwaBuild: 'present' | 'missing' = packedPaths.includes('apps/pwa/out/index.html') ? 'present' : 'missing';
-    const tracked = spawnSync('git', ['ls-files', '--cached', '-z'], { cwd: checkout, encoding: 'utf8' });
-    if (tracked.status !== 0) throw new Error(`cannot list committed files: ${tracked.stderr}`);
-    const committed = new Set(tracked.stdout.split('\0').filter(Boolean));
+    const committed = new Set(spawnSyncText('git', ['ls-files', '--cached', '-z'], { cwd: checkout, encoding: 'utf8' }).split('\0').filter(Boolean));
     const uncommitted = publishedPaths.filter((path) => !committed.has(path));
     if (uncommitted.length) throw new Error(`packed files not committed at HEAD: ${uncommitted.join(', ')}`);
     const changed = spawnSync('git', ['diff', '--quiet', 'HEAD', '--', ...publishedPaths], { cwd: checkout, encoding: 'utf8' });

package/scripts/red-sweep-diff.ts

@@ -71,7 +71,7 @@ export async function main(argv: readonly string[]): Promise<number> {
   const grown = diffs.filter((d) => d.newRed.length > 0);
   if (argv.includes('--notify') && grown.length > 0) {
     const { sendOutbound } = await import('../src/domains/outbound-alert.js');
-    sendOutbound(`⚠️ **파일별 빨강 스윕 — 새 빨강**\n\n${grown.map(renderDiff).join('\n\n')}`, 'alert');
+    sendOutbound(`⚠️ **파일별 빨강 스윕 — 새 빨강**\n\n${grown.map(renderDiff).join('\n\n')}`, 'ops-alert');
   }
   return diffs.length === 0 ? 2 : 0;
 }