elanous 0.2.27 → 0.2.29

package/src/hq/seats.ts

@@ -278,6 +278,18 @@ export function hqInit(options: { root?: string; home?: string } = {}): { root:
   return { root, created, cron };
 }
 
+// A skipped refresh leaves the seat looking idle to every other surface: one observation line carries the
+// reason and how far the kept HEAD trails the fetched origin/main. Observation never changes the verdict
+// (same rule as judgeLandedTip).
+function observeRefreshSkipped(path: string, role: HqSeatRole, reason: 'dirty' | 'unlanded-head', head?: string): void {
+  try {
+    const tip = head ?? git(path, 'rev-parse', 'HEAD');
+    const behind = runGitCommand(path, ['rev-list', '--count', 'HEAD..refs/remotes/origin/main'], { encoding: 'utf8' });
+    const count = behind.status === 0 && /^\d+$/.test(behind.stdout.trim()) ? Number(behind.stdout.trim()) : null;
+    debug.log('hq.seat', 'refresh-skipped', { role, path, reason, head: tip, behind: count });
+  } catch { /* observation must not change the verdict */ }
+}
+
 export function hqSeat(value: string, options: { root?: string; refresh?: boolean } = {}): { path: string; outcome: 'created' | 'unchanged' | 'refreshed' | 'dirty' } {
   const role = roleOf(value);
   const root = resolve(options.root ?? hqRoot());
@@ -301,16 +313,18 @@ export function hqSeat(value: string, options: { root?: string; refresh?: boolea
   const onBranch = runGitCommand(path, ['symbolic-ref', '--quiet', '--short', 'HEAD'], { encoding: 'utf8' });
   if (onBranch.status === 0) throw new Error(`not a seat: ${path} is on branch ${onBranch.stdout.trim()}; refusing to touch it`);
   // A dirty seat must be byte-for-byte untouched, including its detached HEAD.
-  if (options.refresh && !clean(path)) return { path, outcome: 'dirty' };
+  // The cron line fetches the mirror before refreshing, so `behind` counts against the fetched origin/main.
+  if (options.refresh && !clean(path)) { observeRefreshSkipped(path, role, 'dirty'); return { path, outcome: 'dirty' }; }
   if (!options.refresh) return { path, outcome: 'unchanged' };
   git(repo, 'fetch', 'origin');
   // Concurrent refreshes of one seat (cron and a person) serialize on the house lock; each re-checks first.
   return withLedgerLock(root, () => {
     assertRegisteredWorktree(repo, path);
     if (runGitCommand(path, ['symbolic-ref', '--quiet', 'HEAD'], { encoding: 'utf8' }).status === 0) throw new Error(`not a seat: ${path} is on a branch; refusing to touch it`);
-    if (!clean(path)) return { path, outcome: 'dirty' as const };
+    if (!clean(path)) { observeRefreshSkipped(path, role, 'dirty'); return { path, outcome: 'dirty' as const }; }
     // Commits made on the detached seat are not on origin/main; moving HEAD would orphan them. Treat as dirty.
-    if (!mergedIntoMain(repo, git(path, 'rev-parse', 'HEAD'))) return { path, outcome: 'dirty' as const };
+    const head = git(path, 'rev-parse', 'HEAD');
+    if (!mergedIntoMain(repo, head)) { observeRefreshSkipped(path, role, 'unlanded-head', head); return { path, outcome: 'dirty' as const }; }
     git(path, 'checkout', '--detach', 'refs/remotes/origin/main');
     return { path, outcome: 'refreshed' as const };
   });

package/src/index.ts

@@ -72,6 +72,7 @@ import { registerPodCommands } from './cli/pod-cli.js';
 import { registerBrowserAnnotateCommand } from './cli/browser-annotate-cli.js';
 import { registerPendingQuestionsCommand } from './cli/pending-questions-cli.js';
 import { registerUsageCommand } from './cli/usage-cli.js';
+import { registerUsageDailyCommand } from './cli/usage-daily-cli.js';
 import { registerLiveCommands } from './cli/live-cli.js';
 import { registerResearchCommand } from './cli/research-cli.js';
 import { registerReleaseCommands } from './cli/release-cli.js';
@@ -915,6 +916,7 @@ registerPodCommands(program);
 registerBrowserAnnotateCommand(program);
 registerPendingQuestionsCommand(program);
 registerUsageCommand(program);
+registerUsageDailyCommand(program);
 // main() → program.parseAsync() → live detail action; --test was applied before dispatch.
 registerLiveCommands(program);
 registerResearchCommand(program);
@@ -1473,6 +1475,8 @@ program
     '--test',
     '격리 테스트 인스턴스로 실행 — cwd 의 git 트리(worktree 포함)에서 `<트리>/.elanous-test` 를 루트로 잡고 state·config 두 축을 함께 격리한다. config 사본이 없으면 자동 물질화. `--test=<dir>` 로 루트 직접 지정 가능(값 문법은 `=` 형태 하나 — 모호함 없음). ELANOUS_STATE_DIR/--config-dir 을 손으로 줄 필요가 없다.',
   )
+  // Documentation-only — `readDashboardNameFlag` 가 Commander «전»에 argv 에서 걷어낸다.
+  .option('--name <name>', '대시보드 TUI 의 PTY 행(tui:<pid>)에 별명을 달고 뜬다 — `elanous pty list` 에 보이고 `pty snapshot <name>` 으로 부른다. 뜬 뒤 바꾸려면 `elanous pty rename <ref> <name>`.')
   .option('--help-all', '시스템 명령을 제외한 모든 최상위 명령 표시');
 program.addHelpText('after', acpServerHelpText());
 
@@ -2396,18 +2400,20 @@ harnessCmd
   .description('하니스 disposable worktree + 브랜치 정리(기본 접두는 만드는 쪽 상수에서 온다). ⚠️ 열린 PR 은 항상 보존. 기본 dry-run(계획만·--yes 로 실제 제거).')
   .option('--abandoned', 'PR 이력 없는 것(escalated/방치) 제거 [기본]')
   .option('--merged', 'PR 머지된 것 제거')
+  .option('--include-unowned-merged-clean', '미소유 merged-clean worktree 회수 허용(merged 모드 전용)')
   .option('--all', '열린 PR 외 전부 제거')
   .option('--force', '열린 PR 브랜치도 제거(위험)')
   .option('--yes', '실제 제거(생략 시 dry-run)')
   .option('--prefix <p>', `브랜치 prefix(기본 ${WORKTREE_BRANCH_PREFIX_HELP})`)
   .option('--repo <repo>', 'gh repo(기본 origin 추론)')
   .option('--json', '구조화 출력')
-  .action(async (opts: { abandoned?: boolean; merged?: boolean; all?: boolean; force?: boolean; yes?: boolean; prefix?: string; repo?: string; json?: boolean }) => {
+  .action(async (opts: { abandoned?: boolean; merged?: boolean; all?: boolean; force?: boolean; includeUnownedMergedClean?: boolean; yes?: boolean; prefix?: string; repo?: string; json?: boolean }) => {
     const { execHarnessClean } = await import('./harness/harness-clean.js');
     const mode = opts.all ? 'all' : opts.merged ? 'merged' : 'abandoned';
     const res = execHarnessClean({
       mode, dryRun: !opts.yes,
       ...(opts.force ? { force: true } : {}),
+      ...(opts.includeUnownedMergedClean ? { includeUnownedMergedClean: true } : {}),
       ...(opts.prefix ? { branchPrefix: opts.prefix } : {}),
       ...(opts.repo ? { repo: opts.repo } : {}),
     });
@@ -3354,6 +3360,19 @@ coordCmd.command('events')
   });
 
 const selfCmd = program.command('self').description('Self-awareness memory — 외부 도구(Claude Code/Codex)가 구현/변경 이력을 elanous 기억에 주입·회상');
+selfCmd.command('repair-commit-export <pr> <base-head> <child-output> <repo> <outbox>')
+  .description('Pod commit-only repair artifact exporter (installed CLI)')
+  .action(async (pr: string, baseHead: string, outputPath: string, repo: string, outbox: string) => {
+    const { readFileSync } = await import('node:fs');
+    const { writePodRepairCommit } = await import('./task-orchestrator/surfaces/pod-repair-commit.js');
+    try {
+      const result = writePodRepairCommit({ pr: Number(pr), baseHead, runId: process.env.ELANOUS_PARENT_RUN_ID ?? '', output: readFileSync(outputPath, 'utf8'), repo, outbox });
+      console.log(`ELANOUS_POD_REPAIR_COMMIT ${result.pr} ${result.baseHead} ${result.commit}`);
+    } catch (error) {
+      console.error(`ELANOUS_POD_REPAIR_FAILED ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 1;
+    }
+  });
 { const { registerSelfUtterancesCommand } = await import('./cli/self-utterances-cli.js'); registerSelfUtterancesCommand(selfCmd); }
 
 // M12 Claude Code 의존도 계기판 — `elanous self dependence [--since] [--until] [--json]`(읽기만).
@@ -4380,6 +4399,7 @@ selfCmd
   .option('--base <branch>', 'PR base 브랜치(생략 시 provider 기본)')
   .option('--no-draft', 'non-draft PR (기본 draft)')
   .option('--open-pr', 'gate 통과 후 push + draft PR open (기본: PR 안 열고 worktree 보존·fail-closed). 이 플래그가 HITL 명시 승인.')
+  .addOption(new Option('--no-open-pr', '수리 실행: PR 개설 없이 worktree-only로 종료').default(undefined))
   .option('--auto-merge', '★ 내부 리뷰가 clean(실제 리뷰 완료·verdict≠fail)이면 자동 병합(squash). must-fix 있으면 무시(hold·rework). outward-facing(main 병합)이라 명시 opt-in. 미지정=리뷰 후 HITL/draft.')
   .option('--merge-by-host', 'Pod 자식: 병합 직전 merge-ready 로 끝내 호스트가 재게이트한 뒤 병합')
   .option('--child-llm-provider <id>', '구현 자식 LLM provider(--child-llm-model 과 함께 · Pod 의 grok 폴백이 쓴다)')
@@ -4565,6 +4585,13 @@ const selfOrchestrateCmd = selfCmd
       ui.error(refused.message);
       process.exit(refused.exitCode);
     }
+    const repairRequested = (opts as { repairCommitOnly?: string }).repairCommitOnly;
+    if (repairRequested !== undefined && ((opts as { substrate?: string }).substrate !== 'pod'
+      || !/^pr:[1-9]\d*$/.test((opts as { podSource?: string }).podSource ?? '')
+      || !/^[0-9a-f]{40}$/.test(repairRequested) || opts.openPr || opts.autoMerge)) {
+      ui.error('--repair-commit-only: --substrate pod, --pod-source pr:N, 40-hex expected head, PR/자동 병합 없음이 필요합니다');
+      process.exit(2);
+    }
     // 위치 인자는 종전처럼 분리하고 파일 입력은 파일당 한 골이다.
     let inputGoals: ReturnType<typeof readSelfOrchestrateGoals>;
     try { inputGoals = readSelfOrchestrateGoals(parts, opts.goalFile); }
@@ -5014,6 +5041,10 @@ const selfOrchestrateCmd = selfCmd
         }
         const passEnv = podProvider === 'grok' ? requestedPassEnv.filter((key) => !grokKeyNames.includes(key)) : podProvider === 'openrouter' ? [...new Set([...requestedPassEnv, 'OPENROUTER_API_KEY'])] : podProvider === 'anthropic' ? [...new Set([...requestedPassEnv, 'ANTHROPIC_API_KEY'])] : requestedPassEnv;
         const podSourceSpec = (opts as { podSource?: string }).podSource;
+        const repairBaseHead = (opts as { repairCommitOnly?: string }).repairCommitOnly;
+        if (repairBaseHead && (!/^pr:[1-9]\d*$/.test(podSourceSpec ?? '') || !/^[0-9a-f]{40}$/.test(repairBaseHead) || opts.autoMerge || opts.openPr || goalTexts.length !== 1)) {
+          ui.error('--repair-commit-only: --pod-source pr:N, 40-hex expected head, 골 1개, PR/자동 병합 없음이 필요합니다'); process.exit(2);
+        }
         let podSource: import('./task-orchestrator/surfaces/pod-source-receive.js').PodSource | undefined;
         if (podSourceSpec) {
           const { parsePodSourceSpec, resolvePodSource } = await import('./task-orchestrator/surfaces/pod-source-spec.js');
@@ -5036,7 +5067,7 @@ const selfOrchestrateCmd = selfCmd
         if (childFlags.childLlmProvider?.trim()) debug.log('self-implement.pod', 'child-provider-named', { provider: childFlags.childLlmProvider.trim(), model: childFlags.childLlmModel ?? null, podProvider });
         // BEDROCK-POD-PROVIDER-DROP — provider·account 는 한 곳(podLaunchProviderOptions)에서 — 손 나열이 bedrock 을 떨궈 codex(team)로 돌았다(10-11).
         const podProviderOptions = (await import('./task-orchestrator/surfaces/pod-child-providers.js')).podLaunchProviderOptions(podProvider, { explicitPodAccount, grokApiKeyOptIn });
-        const podBase = { hostSupervised: opts.supervise === true, ...podChildLlm, ...(remoteOnlyPool ? { imageCommit: image.imageCommit } : {}), ...podProviderOptions, ...(accountBroker ? { accountBroker, rotationAccounts } : {}), passEnv, ...(pool ? { pool } : {}), ...((opts as { podSkillEnv?: boolean }).podSkillEnv ? { skillEnv: true } : {}), ...(podSource ? { source: podSource } : {}) };
+        const podBase = { hostSupervised: opts.supervise === true, ...podChildLlm, ...(remoteOnlyPool ? { imageCommit: image.imageCommit } : {}), ...podProviderOptions, ...(accountBroker ? { accountBroker, rotationAccounts } : {}), passEnv, ...(pool ? { pool } : {}), ...((opts as { podSkillEnv?: boolean }).podSkillEnv ? { skillEnv: true } : {}), ...(podSource ? { source: podSource } : {}), ...(repairBaseHead && podSource?.kind === 'pr' ? { repairCommitOnly: { pr: podSource.number, baseHead: repairBaseHead } } : {}) };
         if (benchArms) {
           const { benchPodSpawn } = await import('./task-orchestrator/surfaces/self-implement-pod.js');
           podSpawn = benchPodSpawn(benchArms, podBase);
@@ -5146,7 +5177,8 @@ selfOrchestrateCmd
   .addOption(new Option('--no-supervise', '⛔ 런 슈퍼바이저를 «끈다»(대표 2026-08-22 ***기본 ON***) — 켜져 있으면 런이 끝나면 실패를 «트리아지»해서 다시 걸 것이 있으면 «스스로» 재개한다(골루프처럼 끝까지). 정지 사유는 converged|needs-human|max-rounds|no-progress 로 각각 «다른 값»으로 말한다. 관측=elanous logs --category self-dev.supervisor').hideHelp())
   .addOption(new Option('--supervise-rounds <n>', '슈퍼바이저 재개 라운드 상한 (기본 3 · 끄려면 --no-supervise)').hideHelp())
   .addOption(new Option('--json', '구조화 출력 [{taskId, feature, status, stage?, prUrl?, merged?, error?}]').hideHelp())
-  .addOption(new Option('--pod-source <spec>', 'pod: 원천 — commit:<40자 sha> | pr:<정수> | worktree:<경로> | files:<경로>[,<경로>…] · 없으면 기본 clone').hideHelp());
+  .addOption(new Option('--pod-source <spec>', 'pod: 원천 — commit:<40자 sha> | pr:<정수> | worktree:<경로> | files:<경로>[,<경로>…] · 없으면 기본 clone').hideHelp())
+  .addOption(new Option('--repair-commit-only <expected-head>', 'pod: 기존 PR head에서 재작업하고 PR 생성 없이 커밋 bundle을 돌려준다').hideHelp());
 
 function formatRelativeAge(updatedAt: number, now = Date.now()): string {
   const seconds = Math.floor(Math.max(0, now - updatedAt) / 1000);
@@ -5649,7 +5681,8 @@ selfCmd
   .option('--context <path>', '리뷰어가 함께 판단할 레포 상대 파일 경로(반복 가능)', (value: string, previous: string[] = []) => [...previous, value])
   .option('--context-text <text>', '리뷰어가 함께 판단할 텍스트(반복 가능)', (value: string, previous: string[] = []) => [...previous, value])
   .option('--json', '구조화 출력 {pr, verdict, mustFix, shouldFix, reviewed}')
-  .action(async (prParts: string[], opts: { intent?: string; model?: string; acp?: boolean; acpModel?: string; acpBackend?: string; acpTimeout?: string; context?: string[]; contextText?: string[]; json?: boolean }) => {
+  .option('--save <name>', '리뷰 결과를 상태 디렉터리의 review-results/<name>-<PR>-<head12>.json에 저장')
+  .action(async (prParts: string[], opts: { intent?: string; model?: string; acp?: boolean; acpModel?: string; acpBackend?: string; acpTimeout?: string; context?: string[]; contextText?: string[]; json?: boolean; save?: string }) => {
     const prArgs = prParts.flatMap((p) => String(p).split(/[,\s]+/).filter(Boolean)); // 번호/#번호/URL·콤마목록.
     if (!prArgs.length) { ui.error('PR 필요: elanous self review <번호|URL> [..]'); process.exit(2); }
     // ⭐ 본문은 seam(`runSelfReviewCliCommand`)에 있다 — 이 액션은 **의존 배선만** 한다.
@@ -7723,7 +7756,7 @@ configCmd
   .action(async (path: string | undefined, opts: { reveal?: boolean }) => {
     const { resolveCurrentInstance } = await import('./instance/current.js');
     const instance = resolveCurrentInstance();
-    if (instance.kind === 'test' && instance.layer === 'tree-derived') {
+    if (instance.kind === 'test' && String(instance.layer) === 'tree-derived') {
       console.error('⚠️ test 우주의 config를 읽습니다 — 운영 값은 --config-dir ~/.elanous');
     }
     const cfg = getUserConfig() as unknown as Record<string, unknown>;
@@ -11579,6 +11612,15 @@ async function main(): Promise<void> {
   //    ⇒ 이제 규칙이 «문법»뿐이라(북마크 스토어를 안 본다) 인자도 없다.
   rawArgs = stripRemoteFlags(rawArgs);
 
+  // `elanous --name <name>` — 대시보드 TUI 의 자기 PTY 행(`tui:<pid>`) 별명. 루트 실행 플래그라
+  //   Commander «전»에 걷어낸다(하위 명령이 앞이면 손대지 않는다 — dashboard-name-flag.ts 머리말).
+  const dashboardName = (await import('./cli/dashboard-name-flag.js')).readDashboardNameFlag(rawArgs);
+  if (dashboardName.error) {
+    console.error(dashboardName.error);
+    process.exit(1);
+  }
+  rawArgs = dashboardName.args;
+
   // M2.4 — remote-daemon path. `ELANOUS_REMOTE=mbp.tailnet:31415` (or
   // a full ws:// URL) makes the dashboard attach to a remote daemon
   // instead of booting an in-process ACP pair. Token + no-auth
@@ -11755,7 +11797,7 @@ async function main(): Promise<void> {
   // dashboard the user is actually looking at. Off unless this boots
   // (no producer in headless/daemon paths). fail-soft·비블로킹.
   bootTimer.begin();
-  try { (await import('./capture/tui-self-report.js')).startTuiSelfReport(); } catch { /* fail-soft */ }
+  try { (await import('./capture/tui-self-report.js')).startTuiSelfReport(dashboardName.name ? { nickname: dashboardName.name } : {}); } catch { /* fail-soft */ }
   bootTimer.phase('self-report');
 
   // Dashboard handles sync inline — only returns on quit

package/src/input/external-input-queue.ts

@@ -0,0 +1,219 @@
+// ── 외부 주입 입력의 별도 대기열 (TUI OP 도그푸드 결함 #6 · 2026-10-14) ──────────────
+//
+// S: 바깥 프로세스가 `elanous pty text <tui:pid> "<글>" --enter` 로 넣은 입력은 TUI 제어 대상의
+//    `write()` → `injectKey` 로 «키보드와 같은» 키 큐에 들어간다.
+// C: 그래서 사용자가 치던 composer 버퍼·턴 중 typeahead 버퍼에 글자가 «이어 붙는다»
+//    (10-14 13:37 실측: 사용자가 치던 줄 끝에 외부 지시가 붙어 한 메시지로 나갔다).
+// A: 제어 대상의 `write()` 가 키 주입 «전»에 이 라우터를 먼저 묻는다.
+//    - 글 한 줄(제어 문자 없음 · 끝 CR 하나 허용)이 아니면 → 종전대로 키 주입(`pty key`·메뉴 몰기 무변경)
+//    - composer 가 안 떠 있음(턴 밖 패널·모달 모드) → 종전대로 키 주입(드라이버 회귀 방지)
+//    - Enter 가 붙은 글: 턴 중 · 사용자 버퍼에 글자가 있음 · 앞선 외부 항목이 대기 중 → «별도 항목»으로 대기열,
+//      composer 가 비어 있으면 출처(`terminal`/`pty`)를 단 «별도 제출»로 즉시 보냄
+//    - Enter 없는 글: 빈 composer 면 종전대로 채우고, 바쁘면(턴 중·버퍼에 글자) «거부»한다 —
+//      나중에 사용자 composer 에 채우면 다시 섞이므로 대기시키지 않는다(IPC 가 실패로 정산 → rc≠0).
+//    대기열은 «턴이 끝나고 composer 가 비었을 때» 한 건씩 나간다 — 사용자 버퍼는 건드리지 않는다.
+//
+// ⚠️ herdr/tmux 처럼 «터미널 자체»에 쓰는 길은 키보드와 구별할 수 없다 — 이 라우터는
+//    elanous 제어 IPC(`pty text`) 경로만 가른다.
+
+import { debug } from '../debug/log.js';
+import type { InputSourceRef } from './input-source-kind.js';
+
+export interface ExternalInputItem {
+  readonly text: string;
+  readonly at: number;
+}
+
+export interface ExternalInputHost {
+  /** 턴(스트리밍)이 도는 중인가. */
+  isTurnActive(): boolean;
+  /** 살아 있는 composer 의 현재 버퍼. composer 가 안 떠 있으면 undefined. */
+  composerText(): string | undefined;
+  /** 아직 소비되지 않은 키가 키 큐에 있나 — 있으면 composer 가 비어 보여도 사용자 키가 오는 중이다. */
+  hasPendingKeys(): boolean;
+  /** 별도 메시지로 제출한다. 못 보냈으면 false(항목은 대기열에 남는다). */
+  submit(text: string, source: InputSourceRef): boolean;
+  /** 대기열이 바뀌었다 — 화면 표지를 다시 그린다. */
+  onQueueChange?(pending: readonly ExternalInputItem[], event: 'queued' | 'delivered'): void;
+}
+
+export type ExternalInputRoute = 'passthrough' | 'submitted' | 'queued';
+export type ExternalInputDecision = 'passthrough' | 'submit-now' | 'queue' | 'reject';
+
+const EXTERNAL_INPUT_SOURCE: InputSourceRef = { kind: 'terminal', provider: 'pty' };
+export const EXTERNAL_INPUT_QUEUE_LIMIT = 50;
+const PUMP_MS = 250;
+/** 머리 항목이 turn-active 때문에 이만큼 못 나가면 한 번만 경고한다. 자동 해제는 하지 않는다. */
+export const STALE_TURN_SUSPECTED_MS = 10 * 60 * 1000;
+
+/** 글 한 줄인가 — 제어 문자 없음 · 끝 CR 하나만 허용. 아니면 null(키 주입 경로). */
+export function parseExternalTextLine(chars: string): { text: string; submit: boolean } | null {
+  const submit = chars.endsWith('\r');
+  const text = submit ? chars.slice(0, -1) : chars;
+  // ⚠️ 공백만 있는 글도 «글»이다 — trim 하면 대기열을 우회해 사용자 초안에 붙는다.
+  if (!text) return null;
+  // eslint-disable-next-line no-control-regex
+  if (/[\x00-\x1f\x7f]/.test(text)) return null;
+  return { text, submit };
+}
+
+/** 라우팅 판정(순수). */
+export function decideExternalInputRoute(input: {
+  line: { text: string; submit: boolean } | null;
+  hostRegistered: boolean;
+  pendingCount: number;
+  turnActive: boolean;
+  composerText: string | undefined;
+  pendingKeys?: boolean;
+}): { decision: ExternalInputDecision; reason: string } {
+  if (!input.line) return { decision: 'passthrough', reason: 'not-text-line' };
+  if (!input.hostRegistered) return { decision: 'passthrough', reason: 'no-host' };
+  // 턴 밖에서 composer 가 안 떠 있으면(패널·모달) 그 화면을 모는 키 입력이다 — 종전 경로.
+  if (!input.turnActive && input.composerText === undefined) return { decision: 'passthrough', reason: 'composer-not-live' };
+  const busyReason = input.turnActive ? 'turn-active'
+    // ⚠️ 공백만 있는 초안도 사용자 버퍼다 — trim 하지 않는다.
+    : input.composerText !== '' ? 'user-buffer-nonempty'
+    // composer 가 비어 보여도 키 큐에 사용자 키가 남아 있으면 그 키가 먼저다.
+    : input.pendingKeys ? 'user-keys-pending'
+    // FIFO — 앞선 외부 항목을 뒤 항목이 앞지르지 않는다.
+    : input.pendingCount > 0 ? 'queue-nonempty'
+    : null;
+  if (!input.line.submit) {
+    return busyReason ? { decision: 'reject', reason: `${busyReason}-no-enter` } : { decision: 'passthrough', reason: 'idle-empty-no-enter' };
+  }
+  return busyReason ? { decision: 'queue', reason: busyReason } : { decision: 'submit-now', reason: 'idle-empty' };
+}
+
+/** 대기열 머리를 지금 내보내도 되나(순수) — 턴 밖 ⊕ composer 가 떠 있고 비어 있음. */
+function canDeliverExternalInput(turnActive: boolean, composerText: string | undefined, pendingKeys: boolean): boolean {
+  return !turnActive && composerText === '' && !pendingKeys;
+}
+
+/** «외부 입력 N건 대기» 표지 문면. 비면 null. */
+export function renderExternalInputQueueNotice(pending: readonly ExternalInputItem[]): string | null {
+  if (pending.length === 0) return null;
+  const head = pending[0]!.text;
+  const shown = [...head].length > 40 ? `${[...head].slice(0, 40).join('')}…` : head;
+  return `⤵ 외부 입력 ${pending.length}건 대기 · "${shown}" · 턴이 끝나고 입력창이 비면 별도 메시지로 전송`;
+}
+
+export interface ExternalInputQueueDeps {
+  now?: () => number;
+  /** 펌프 스케줄러 — 정지 함수를 돌려준다. 시험이 손으로 돌린다. */
+  schedule?: (tick: () => void, ms: number) => () => void;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
+  const now = deps.now ?? Date.now;
+  const log = deps.log ?? ((event, data) => debug.log('tui.external-input', event, data));
+  const schedule = deps.schedule ?? ((tick, ms) => {
+    const t = setInterval(tick, ms);
+    (t as { unref?: () => void }).unref?.();
+    return () => clearInterval(t);
+  });
+  let host: ExternalInputHost | null = null;
+  let pending: ExternalInputItem[] = [];
+  let stopPump: (() => void) | null = null;
+  // 경고는 머리 항목 «하나»에 한 번 — 머리가 실제로 바뀔 때만 다시 경고할 수 있다(제출 실패로 남은 같은 머리는 유지).
+  let staleTurnWarnedHead: ExternalInputItem | null = null;
+
+  const notify = (event: 'queued' | 'delivered'): void => {
+    try { host?.onQueueChange?.(pending, event); } catch { /* fail-soft — 표지 실패가 입력을 막지 않는다 */ }
+  };
+  const ensurePump = (): void => {
+    if (pending.length > 0 && !stopPump) stopPump = schedule(pump, PUMP_MS);
+    if (pending.length === 0 && stopPump) { stopPump(); stopPump = null; }
+  };
+
+  /** 대기열 머리 한 건을 내보낸다(조건이 맞을 때만). 내보냈으면 true. */
+  function pump(): boolean {
+    const h = host;
+    const head = pending[0];
+    if (!h || !head) { ensurePump(); return false; }
+    let turnActive: boolean; let composer: string | undefined; let pendingKeys: boolean;
+    try { turnActive = h.isTurnActive(); composer = h.composerText(); pendingKeys = h.hasPendingKeys(); } catch { return false; }
+    if (!canDeliverExternalInput(turnActive, composer, pendingKeys)) {
+      if (turnActive && staleTurnWarnedHead !== head) {
+        const waitedMs = now() - head.at;
+        if (waitedMs >= STALE_TURN_SUSPECTED_MS) {
+          staleTurnWarnedHead = head;
+          log('stale-turn-suspected', { waitedMs, pending: pending.length });
+        }
+      }
+      return false;
+    }
+    let ok = false;
+    try { ok = h.submit(head.text, EXTERNAL_INPUT_SOURCE); } catch { ok = false; }
+    if (!ok) { log('deliver-failed', { length: head.text.length, pending: pending.length }); return false; }
+    pending = pending.slice(1);
+    log('delivered', { length: head.text.length, waitedMs: now() - head.at, pending: pending.length });
+    notify('delivered');
+    ensurePump();
+    return true;
+  }
+
+  return {
+    register(next: ExternalInputHost): () => void {
+      host = next;
+      log('host-registered', { pending: pending.length });
+      ensurePump();
+      return () => {
+        if (host !== next) return;
+        host = null;
+        log('host-unregistered', { pending: pending.length });
+      };
+    },
+    /** 제어 대상 `write()` 가 키 주입 «전»에 부른다. 'passthrough' 면 호출측이 종전대로 키를 넣는다. */
+    route(chars: string): ExternalInputRoute {
+      // `pty key`(input-key)는 «키»다 — 공백·`j` 처럼 출력 가능한 키도 종전대로 넣는다.
+      if (keyCommandDepth > 0) return 'passthrough';
+      const line = parseExternalTextLine(chars);
+      let turnActive = false; let composer: string | undefined; let pendingKeys = false;
+      if (host && line) {
+        try { turnActive = host.isTurnActive(); composer = host.composerText(); pendingKeys = host.hasPendingKeys(); }
+        catch { return 'passthrough'; }
+      }
+      const { decision, reason } = decideExternalInputRoute({
+        line, hostRegistered: host !== null, pendingCount: pending.length, turnActive, composerText: composer, pendingKeys,
+      });
+      const base = { reason, length: chars.length, submit: line?.submit ?? false, turnActive, pendingKeys, userBufferLength: composer?.length ?? null };
+      if (decision === 'passthrough') {
+        log('route', { ...base, route: 'passthrough', pending: pending.length });
+        return 'passthrough';
+      }
+      if (decision === 'reject') {
+        log('route', { ...base, route: 'rejected', pending: pending.length });
+        throw new Error('tui-busy-text-without-enter');
+      }
+      if (decision === 'submit-now' && line && host) {
+        let ok = false;
+        try { ok = host.submit(line.text, EXTERNAL_INPUT_SOURCE); } catch { ok = false; }
+        if (ok) { log('route', { ...base, route: 'submitted', pending: pending.length }); return 'submitted'; }
+      }
+      if (pending.length >= EXTERNAL_INPUT_QUEUE_LIMIT) {
+        log('queue-full', { ...base, pending: pending.length });
+        throw new Error('tui-external-input-queue-full');
+      }
+      pending = [...pending, { text: line!.text, at: now() }];
+      log('route', { ...base, route: 'queued', pending: pending.length });
+      notify('queued');
+      ensurePump();
+      return 'queued';
+    },
+    pump,
+    pending: (): readonly ExternalInputItem[] => pending,
+  };
+}
+
+let keyCommandDepth = 0;
+/** 제어 IPC 의 `input-key` 가 이 안에서 쓴다 — 라우터는 그 쓰기를 글이 아니라 키로 보고 그대로 통과시킨다. */
+export function withExternalKeyCommand<T>(fn: () => T): T {
+  keyCommandDepth++;
+  try { return fn(); } finally { keyCommandDepth--; }
+}
+
+const shared = createExternalInputQueue();
+
+export function registerExternalInputHost(host: ExternalInputHost): () => void { return shared.register(host); }
+export function routeExternalInput(chars: string): ExternalInputRoute { return shared.route(chars); }

package/src/intelligence-map/model-bench-scores.ts

@@ -0,0 +1,102 @@
+import { debug } from '../debug/log.js';
+import type { ModelCatalog, ModelEntry } from './types.js';
+
+const NUMERIC_COLUMNS = [
+  'ctx', 'in$/1M', 'out$/1M', 'cacheRead$/1M', 'est_run$',
+  'AA_intel', 'AA_coding', 'AA_agentic', 'SWE_verified', 'SWE_pro',
+  'TerminalBench', 'LiveCodeBench', 'tool_use',
+] as const;
+
+export type BenchNumericColumn = typeof NUMERIC_COLUMNS[number];
+export type BenchScore = 'AA_coding' | 'AA_agentic' | 'SWE_verified' | 'TerminalBench';
+
+export type BenchRow = {
+  id: string;
+  provider: string;
+  sources: string;
+  notes: string;
+  raw: Record<string, string>;
+} & Record<BenchNumericColumn, number | null>;
+
+export type ComparedBenchRow<T extends BenchRow = BenchRow> = T & {
+  value: number | null;
+  status: 'scored' | '미확인';
+};
+
+const UNKNOWN = new Set(['', '미확인', '미표기', '-']);
+const NUMBER = /[-+]?(?:\d+(?:,\d{3})*(?:\.\d+)?|\.\d+)(?:[eE][-+]?\d+)?/g;
+
+function parseNumber(raw: string): number | null {
+  const trimmed = raw.trim();
+  if (UNKNOWN.has(trimmed)) return null;
+  // A label may contain a version number ("AA TB4.0 33.3"); the final
+  // number is the measured value. Keep the full cell separately in raw.
+  const matches = [...trimmed.matchAll(NUMBER)];
+  const last = matches.at(-1)?.[0];
+  if (!last) return null;
+  const parsed = Number(last.replaceAll(',', ''));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+/** Parse a caller-supplied, offline TSV. Column positions come only from the header. */
+export function parseBenchScoresTsv(text: string): BenchRow[] {
+  const lines = text.replace(/^\uFEFF/, '').split(/\r?\n/);
+  const headers = (lines.shift() ?? '').split('\t').map((name) => name.trim());
+  if (!headers.includes('id')) throw new Error('bench scores TSV missing id header');
+  const rows: BenchRow[] = [];
+  let unknownCells = 0;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    const cells = line.split('\t');
+    const raw: Record<string, string> = {};
+    headers.forEach((header, index) => { raw[header] = cells[index] ?? ''; });
+    const numbers = {} as Record<BenchNumericColumn, number | null>;
+    for (const column of NUMERIC_COLUMNS) {
+      numbers[column] = parseNumber(raw[column] ?? '');
+      if (numbers[column] === null) unknownCells++;
+    }
+    rows.push({ id: raw.id?.trim() ?? '', provider: raw.provider ?? '',
+      sources: raw.sources ?? '', notes: raw.notes ?? '', raw, ...numbers });
+  }
+  debug.log('intelligence.bench-scores', 'parsed', { rows, unknownCells });
+  return rows;
+}
+
+/** An OpenRouter vendor/model id matches a catalog id only under its vendor.
+ * The builtin DeepSeek entries are `other`/`deepseek` but have the explicit
+ * OpenRouter route `deepseek/<id>` in their notes. */
+function catalogIds(model: ModelEntry): string[] {
+  const ids = [model.id];
+  const vendor = model.provider === 'openai-codex' ? 'openai'
+    : model.provider === 'gemini' ? 'google'
+    : model.provider === 'grok' ? 'x-ai'
+    : model.provider === 'kimi' ? 'moonshotai'
+    : model.provider === 'glm' ? 'z-ai'
+    : model.provider === 'other' && model.family === 'deepseek' && model.notes?.includes(`OpenRouter deepseek/${model.id}`) ? 'deepseek'
+    : model.provider;
+  if (!model.local) ids.push(`${vendor}/${model.id}`, `openrouter/${vendor}/${model.id}`);
+  return ids;
+}
+
+export function joinWithCatalog<T extends BenchRow>(rows: readonly T[], catalog: ModelCatalog): (T & { inCatalog: boolean })[] {
+  const ids = new Set(catalog.models.flatMap(catalogIds));
+  return rows.map((row) => ({ ...row, inCatalog: ids.has(row.id) }));
+}
+
+/** Sort by score per estimated run dollar. Missing scores always come last;
+ * a known score without a usable denominator has an unknown value. */
+export function compareRows<T extends BenchRow>(rows: readonly T[], opts: { score: BenchScore }): ComparedBenchRow<T>[] {
+  return rows.map((row) => {
+    const score = row[opts.score];
+    return { ...row,
+      value: score !== null && row.est_run$ !== null && row.est_run$ > 0
+        ? score / row.est_run$ : null,
+      status: score === null ? '미확인' as const : 'scored' as const,
+    };
+  }).sort((a, b) => {
+    if (a.status !== b.status) return a.status === '미확인' ? 1 : -1;
+    if (a.value === null) return b.value === null ? 0 : 1;
+    if (b.value === null) return -1;
+    return b.value - a.value;
+  });
+}

package/src/interactive-terminal-modal.ts

@@ -58,6 +58,13 @@ export interface InteractiveTerminalModalSpec {
   /** Ghostty-compatible terminfo name. Defaults via PreviewTerminal
    *  to xterm-256color. */
   termName?: string;
+  /** Register this popup in the shared PTY inventory. */
+  useRegistry?: boolean;
+  registryKind?: string;
+  registryNickname?: string;
+  registryOrigin?: { originRoot: string; controller?: string };
+  registryPurpose?: string;
+  registrySeat?: string;
   /** Override bounds. Default: 85% of termCols/termRows, centered. */
   bounds?: ModalBounds;
   /** MT1 — named size preset (mutually exclusive with `bounds`; when
@@ -206,6 +213,12 @@ export function createInteractiveTerminalModal(
     shellArgs: spec.shellArgs,
     env: spec.env,
     termName: spec.termName,
+    useRegistry: spec.useRegistry,
+    registryKind: spec.registryKind,
+    registryNickname: spec.registryNickname,
+    registryOrigin: spec.registryOrigin,
+    registryPurpose: spec.registryPurpose,
+    registrySeat: spec.registrySeat,
     onUpdate: () => {
       // First output → leave the placeholder state. Stops the
       // spinner timer + flushes a render so the real PTY frame

package/src/llm/route-decision.ts

@@ -46,6 +46,31 @@ export function currentRouteDecision(surface: string): RouteDecision | null {
   return lastBySurface.get(surface) ?? null;
 }
 
+/** A `/model` choice scoped to this process's surface (TUI-MODEL-SESSION-SCOPE · 10-14).
+ * It reaches the turn as `explicitModel`, so it wins over the Codex tier policy —
+ * a config-only `llm.model` change is ignored by that policy (10-14 OPT: `/model luna`
+ * wrote config, every turn still ran sol). Not persisted; `/model … --global` writes config. */
+export interface SessionModelPin {
+  provider: LLMProviderName;
+  model: string;
+}
+
+const pinBySurface = new Map<string, SessionModelPin>();
+
+export function setSessionModelPin(surface: string, pin: SessionModelPin | null): void {
+  if (pin) pinBySurface.set(surface, pin);
+  else pinBySurface.delete(surface);
+}
+
+/** The surface's pinned model, or null when none — or when the active provider
+ * has since changed (a pin only makes sense on the provider it was chosen for). */
+export function sessionModelPin(surface: string, activeProvider?: LLMProviderName): SessionModelPin | null {
+  const pin = pinBySurface.get(surface);
+  if (!pin) return null;
+  if (activeProvider !== undefined && pin.provider !== activeProvider) return null;
+  return pin;
+}
+
 export interface ResolveRouteDecisionInput {
   provider: LLMProviderName;
   configuredModel?: string;

package/src/llm-stream-retry-display.ts

@@ -0,0 +1,59 @@
+// TUI-STREAM-RETRY — 끊긴 스트림을 다시 걸 때 «이미 화면에 흘린 텍스트»를 두 번 보이지 않게 하는 관문.
+//
+// ⛔ 화면 쪽에는 «커밋하지 않고 지우는» 신호가 없다. TUI plain 경로는 `onText('', …)` 를 chunk 만 받아
+//   `('', '')` 로 바꾸고, `turn-stream-formatter` 는 그것을 «clear-and-commit»(지난 글을 영구 보존)으로 읽는다.
+//   ⇒ 되감기를 화면에 «알리는» 대신, 재시도 본문이 이미 보인 글과 겹치는 동안은 «안 내보내고»,
+//     넘어서는 순간 그 뒷부분만 이어 붙인다. 이력(turnText)은 늘 재시도 본문이 정본이다.
+//   ⚠️ 재시도 본문이 이미 보인 글과 «갈라지면» 지울 길이 없으니 커밋 경계(`onText('', '')`)를 한 번 내고
+//     새 본문을 처음부터 흘린다 — 옛 조각은 지난 서술로 남는다(관측: `llm.retry stream-retry-display-diverged`).
+
+export type RetryDisplayStep =
+  | { kind: 'emit'; delta: string }
+  | { kind: 'hold' }
+  | { kind: 'diverged'; text: string };
+
+export interface RetryDisplayGate {
+  /** 끊김 뒤 재시도 직전에 부른다 — 지금 화면에 보이는 이 턴의 글을 «확인 대기»로 둔다. */
+  arm(): void;
+  /** 텍스트 델타가 turnText 에 붙은 «뒤» 부른다. 무엇을 화면에 낼지 돌려준다. */
+  onText(delta: string, turnText: string): RetryDisplayStep;
+  /** 스트림이 끝났을 때 — 확인 대기 중인데 재시도 본문이 보인 글과 다르면 갈라짐으로 낸다. */
+  settle(turnText: string): RetryDisplayStep;
+  /** 확인 대기 중인 글자 수(관측용). */
+  heldChars(): number;
+}
+
+export function createRetryDisplayGate(): RetryDisplayGate {
+  let visible = '';
+  let replaying = false;
+  return {
+    arm() {
+      replaying = visible.length > 0;
+    },
+    onText(delta, turnText) {
+      if (!replaying) {
+        visible += delta;
+        return { kind: 'emit', delta };
+      }
+      if (visible.startsWith(turnText)) return { kind: 'hold' };
+      replaying = false;
+      if (turnText.startsWith(visible)) {
+        const rest = turnText.slice(visible.length);
+        visible = turnText;
+        return { kind: 'emit', delta: rest };
+      }
+      visible = turnText;
+      return { kind: 'diverged', text: turnText };
+    },
+    settle(turnText) {
+      if (!replaying) return { kind: 'hold' };
+      replaying = false;
+      if (visible === turnText) return { kind: 'hold' };
+      visible = turnText;
+      return { kind: 'diverged', text: turnText };
+    },
+    heldChars() {
+      return replaying ? visible.length : 0;
+    },
+  };
+}