elanous 0.2.36 → 0.2.38

package/src/task-orchestrator/surfaces/self-implement.ts

@@ -19,7 +19,8 @@
  * Cf. PLAN-parallel-self-dev-orchestrator-2026-07-21.
  */
 import { lstatSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import type { ReviewRework } from '../../self-dev/run-types.js';
+import type { ReviewRework, SelfDevJobResult } from '../../self-dev/run-types.js';
+import type { SelfImplementGateResult } from '../../self-implement/orchestrator.js';
 import type { WarmWorkerCommand } from './pod-warm-worker-protocol.js';
 import { oldDoorInternalEnv } from '../../self-dev/old-door.js';
 import { selfDevRunsDir } from '../../self-dev/run-store.js';
@@ -52,11 +53,15 @@ export interface SelfImplementJobDone {
 export interface SelfImplementDisposition {
   stage?: string;
   ok?: boolean;
+  /** Measured child gate receipt, forwarded only for a failed gate. */
+  gate?: SelfImplementGateResult;
   worktreePath?: string;
   branch?: string;
   harvestable?: true;
   prUrl?: string;
   prNumber?: number;
+  /** Parent-side observation carried from the child's run ledger when available. */
+  goalPlanRevision?: SelfDevJobResult['goalPlanRevision'];
   /** Head SHA checked by the Pod before host regate. */
   checkedHeadCommit?: string;
   /** Review verdict only when the child bound a real pass to a clean, unchanged worktree head. */
@@ -99,11 +104,30 @@ export interface SelfImplementDisposition {
   childEvidence?: PodChildEvidence;
 }
 
+function isGoalPlanRevisionObservation(value: unknown): value is NonNullable<SelfDevJobResult['goalPlanRevision']> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const row = value as Record<string, unknown>;
+  if (row.status === 'read') {
+    return Number.isSafeInteger(row.attempted) && Number(row.attempted) >= 0
+      && Number.isSafeInteger(row.applied) && Number(row.applied) >= 0
+      && Array.isArray(row.failureReasons) && row.failureReasons.every((reason) => typeof reason === 'string');
+  }
+  return row.status === 'read-failed'
+    && ['directory-missing', 'unreadable-directory', 'unreadable-files'].includes(String(row.reason))
+    && Number.isSafeInteger(row.scannedFiles) && Number(row.scannedFiles) >= 0
+    && Number.isSafeInteger(row.unreadableFiles) && Number(row.unreadableFiles) >= 0
+    && typeof row.ledgerDirectory === 'string';
+}
+
 export interface PodChildEvidence {
   /** Bounded, redacted diagnostics copied only from a failed child terminal result. */
   error?: string;
   detail?: string;
   stderr?: string;
+  /** Bounded, redacted complete Pod log tail. Separate from child stderr to avoid replacing stronger child facts. */
+  podLogTail?: string[];
+  podLogTailLines?: number;
+  podLogUnavailable?: string;
   exitCode?: number;
   classification?: string;
   scopeEscape?: true;
@@ -126,6 +150,10 @@ export interface PodChildEvidence {
     candidateCardId?: string;
     blockingCardId?: string;
   };
+  /** Harvest pointer and revision observation copied before the parent Pod stop is finalized. */
+  harvestable?: true;
+  prNumber?: number;
+  goalPlanRevision?: SelfDevJobResult['goalPlanRevision'];
 }
 
 const SCOPE_STOP_REASON_ORDER: readonly ScopeStopReason[] = SCOPE_STOP_REASONS;
@@ -204,6 +232,9 @@ export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChild
     ...(o.goalCauseObserved === true ? { goalCauseObserved: true } : {}),
     ...(o.terminationReason !== undefined ? { terminationReason: scrubValue(o.terminationReason) } : {}),
     ...(accountAvailability ? { accountAvailability } : {}),
+    ...(o.harvestable === true && typeof o.branch === 'string' && o.branch.trim() ? { harvestable: true } : {}),
+    ...(typeof o.prNumber === 'number' && Number.isSafeInteger(o.prNumber) && o.prNumber > 0 ? { prNumber: o.prNumber } : {}),
+    ...(isGoalPlanRevisionObservation(o.goalPlanRevision) ? { goalPlanRevision: o.goalPlanRevision } : {}),
   };
   if (o.ok === false && typeof o.error === 'string'
     && /draft PR 생성 실패|PR (?:gh|guard) 실패|same-cell reuse:/u.test(o.error)) {
@@ -621,11 +652,15 @@ export function parseSelfImplementJson(stdout: string): SelfImplementDisposition
       const mapped: SelfImplementDisposition = {
         ...(typeof o.stage === 'string' ? { stage: o.stage } : {}),
         ...(typeof o.ok === 'boolean' ? { ok: o.ok } : {}),
+        ...(o.stage === 'gate-failed' && o.ok === false && o.gate && typeof o.gate === 'object'
+          && !Array.isArray(o.gate) && (o.gate as { passed?: unknown }).passed === false
+          ? { gate: o.gate as SelfImplementGateResult } : {}),
         ...(typeof o.worktreePath === 'string' ? { worktreePath: o.worktreePath } : {}),
         ...(typeof o.branch === 'string' ? { branch: o.branch } : {}),
         ...(o.harvestable === true && typeof o.branch === 'string' && o.branch.trim() ? { harvestable: true } : {}),
         ...(typeof o.prUrl === 'string' ? { prUrl: o.prUrl } : {}),
-        ...(typeof o.prNumber === 'number' ? { prNumber: o.prNumber } : {}),
+        ...(Number.isSafeInteger(o.prNumber) && Number(o.prNumber) > 0 ? { prNumber: Number(o.prNumber) } : {}),
+        ...(isGoalPlanRevisionObservation(o.goalPlanRevision) ? { goalPlanRevision: o.goalPlanRevision } : {}),
         ...(typeof o.checkedHeadCommit === 'string' ? { checkedHeadCommit: o.checkedHeadCommit } : {}),
         ...(o.reviewedHeadCommit && typeof o.reviewedHeadCommit === 'string' && /^[0-9a-f]{40}$/i.test(o.reviewedHeadCommit)
           && o.review && typeof o.review === 'object' && !Array.isArray(o.review)

package/src/terminal/session-registry.ts

@@ -157,6 +157,7 @@ export class TerminalSessionRegistry {
         shell: spec.shell,
         shellArgs: spec.shellArgs,
         env: spec.env,
+        unsetEnv: spec.unsetEnv,
         termName: spec.termName,
         useRegistry: spec.useRegistry,
         registryKind: spec.registryKind,

package/src/terminal/terminal-modal-router.ts

@@ -0,0 +1,156 @@
+// Shared key routing for interactive terminal modals in dashboard and TUI.
+//
+// Holds singleton state for "which interactive terminal modal is
+// currently foregrounded" + the key-intercept policy:
+//
+//   • while a modal is present, ESC / Ctrl-G dispose it
+//   • all other keys forward to modal.surface.onKey(ev) so the PTY
+//     receives them without the chat readKey loop trying to
+//     interpret them
+//
+// Kept separate from either renderer so both can use the same routing policy.
+//
+// P10 will extend this with Ctrl-B prefix handling (d=detach,
+// s=switch, etc.) once a session registry exists to act on.
+
+import type { InteractiveTerminalModalHandle } from '../interactive-terminal-modal.js';
+import type { KeyEvent } from '../display/types.js';
+import { debug } from '../debug/log.js';
+
+export type KeyRouteResult = 'consumed' | 'passthrough' | 'closed';
+
+export interface TerminalModalRouter {
+  current(): InteractiveTerminalModalHandle | null;
+  /** Install a modal handle. Optional closePolicy controls what
+   *  ESC/Ctrl-G does: 'kill' disposes the modal + PTY (default);
+   *  'detach' calls handle.dispose({keepPreview:true}) so the PTY
+   *  survives for re-attach (session registry flow). An explicit
+   *  onClose hook wins over closePolicy — that's how dashboard
+   *  wires the owning session registry's detach action on Esc. */
+  set(
+    handle: InteractiveTerminalModalHandle | null,
+    opts?: { closePolicy?: 'kill' | 'detach'; onClose?: () => void },
+  ): void;
+  close(): void;
+  handleKey(ev: KeyEvent): KeyRouteResult;
+}
+
+// `exit` typed cleanly + Enter closes the popup. claude / codex don't
+// recognize plain `exit` (their command is /exit or /quit), so a user
+// typing `exit\n` would otherwise be stuck — the popup stays open
+// because the child never exits, and the typed text just becomes chat
+// input. elanous intercepts the exact sequence at the router so:
+//   • plain shell: same end result (we close before shell evaluates)
+//   • claude / codex: popup closes as the user expected
+// Sequence is reset on any non-letter key (other than backspace, which
+// rewinds), Ctrl/Alt modifiers, or any character outside `e/x/i/t` —
+// so genuine words containing "exit" (e.g. typing "exit this loop"
+// into a claude prompt without Enter) DON'T trigger the close. The
+// trigger is specifically `e`, `x`, `i`, `t`, Enter with nothing else.
+const EXIT_CHARS = ['e', 'x', 'i', 't'] as const;
+
+export function createTerminalModalRouter(): TerminalModalRouter {
+  let handle: InteractiveTerminalModalHandle | null = null;
+  let closePolicy: 'kill' | 'detach' = 'kill';
+  let onClose: (() => void) | null = null;
+  let exitProgress = 0; // how many of EXIT_CHARS have been typed in order
+
+  const close = (): void => {
+    if (!handle) return;
+    const h = handle;
+    const cb = onClose;
+    if (debug.enabled) debug.log('window.terminalModalRouter.close', h.id, { id: h.id, closePolicy, hasOnClose: !!cb });
+    handle = null;
+    onClose = null;
+    exitProgress = 0;
+    try {
+      if (cb) cb();
+      else if (closePolicy === 'detach') h.dispose({ keepPreview: true });
+      else h.dispose();
+    } catch { /* already disposed */ }
+    closePolicy = 'kill';
+  };
+
+  return {
+    current: () => handle,
+    set: (h, opts) => {
+      if (handle && h && handle.id !== h.id) close();
+      handle = h;
+      closePolicy = opts?.closePolicy ?? 'kill';
+      onClose = opts?.onClose ?? null;
+      exitProgress = 0;
+      if (debug.enabled) {
+        debug.log('window.terminalModalRouter.set', h?.id ?? '(null)', {
+          id: h?.id ?? null,
+          closePolicy,
+          hasOnClose: !!onClose,
+        });
+      }
+    },
+    close,
+    handleKey: (ev) => {
+      if (!handle) return 'passthrough';
+      const name = (ev.name ?? '').toLowerCase();
+      // ESC must NOT close the modal — claude / codex inside the popup
+      // use ESC to cancel an in-progress chat / tool turn. Closing the
+      // wrapper window on ESC made the only-way-to-cancel kill the
+      // whole popup. iTerm / ghostty don't close their own windows on
+      // ESC either; the wrapper should match. Modal close is reserved
+      // for: Ctrl+G (close + focus log), Ctrl+Shift+T (toggle off),
+      // typed `exit\n`, and the child's own `exit`. ESC just forwards.
+      if (ev.ctrl && (name === 'g' || name === 'ㅎ')) {
+        if (debug.enabled) debug.log('window.terminalModalRouter.handleKey.close', 'ctrl-g', { id: handle.id });
+        close();
+        return 'closed';
+      }
+
+      // Track typed `exit` followed by Enter so the user's natural
+      // mental model ("type exit to quit") works inside agent popups
+      // (claude / codex) where the child app doesn't recognize a bare
+      // `exit` command. See EXIT_CHARS comment above for false-positive
+      // avoidance.
+      const noMods = !ev.ctrl && !ev.alt;
+      if (noMods && name === 'enter' && exitProgress === EXIT_CHARS.length) {
+        if (debug.enabled) {
+          debug.log('window.terminalModalRouter.handleKey.close', 'typed-exit', {
+            id: handle.id,
+          });
+        }
+        close();
+        return 'closed';
+      }
+      if (noMods && name === 'backspace') {
+        if (exitProgress > 0) exitProgress--;
+      } else if (noMods && name.length === 1 && exitProgress < EXIT_CHARS.length && name === EXIT_CHARS[exitProgress]) {
+        exitProgress++;
+      } else if (noMods && name === 'enter') {
+        // Enter without a complete `exit` prefix — reset and forward.
+        exitProgress = 0;
+      } else if (name.length === 1 || name === 'space' || ev.ctrl || ev.alt) {
+        // Any other printable key OR a modifier keystroke breaks the
+        // streak. Multi-char named keys (arrow / fn / etc.) leave the
+        // streak alone — the child may consume them without affecting
+        // the user's typed prompt buffer.
+        exitProgress = 0;
+      }
+
+      if (debug.enabled) {
+        debug.log('window.terminalModalRouter.handleKey.forward', name || '(empty)', {
+          id: handle.id,
+          name,
+          ctrl: ev.ctrl ?? false,
+          shift: ev.shift ?? false,
+          alt: ev.alt ?? false,
+          exitProgress,
+        });
+      }
+      try {
+        handle.surface.onKey?.(ev);
+      } catch { /* surface disposed mid-event; treat as no-op */ }
+      return 'consumed';
+    },
+  };
+}
+
+/** Singleton used by renderers; the factory remains available for isolated tests. */
+export const terminalModalRouter = createTerminalModalRouter();

package/src/testing/linux-env.ts

@@ -0,0 +1,177 @@
+/**
+ * 🐧 LINUX-STAGE — 개발 머신 환경에 기대지 않는 «격리 무대».
+ *
+ * Situation: 같은 시험이 macOS(개발 머신)에서는 통과하고 Linux 에서는 실패하는 잔여 실패가 있다.
+ *   원인은 코드가 아니라 «환경»이다 — 개발 머신 HOME 의 글로벌 git user.* · PATH 에 있는 grok CLI ·
+ *   LANG/LC_ALL 이 정하는 콜레이션 · 로케일마다 달라지는 이모지 비교.
+ * Answer: 그 네 축을 «무대»로 고정한다 — 임시 HOME(글로벌 설정 없음), grok 이 없는 PATH,
+ *   저장소 로컬 identity 만 가진 git 작업 트리, C.UTF-8, 코드포인트 비교.
+ * ⛔ 이 무대는 «생산 진입점을 그대로 지나게» 하는 시험을 위한 것이다 — 소스 문자열 검사용이 아니다.
+ * ⛔ `withLinuxEnv` 는 끝나면 env 와 임시 디렉터리를 원상복구한다(같은 파일의 뒤 시험을 오염시키지 않는다).
+ */
+import { spawnSync, type SpawnSyncReturns } from 'node:child_process';
+import { accessSync, constants, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, join } from 'node:path';
+
+/** 무대 로케일 — Linux CI 의 기본값(LANG 미설정 · POSIX)을 넘긴다. */
+export const STAGE_LOCALE = 'C.UTF-8';
+
+/** 무대 git 신원 — 글로벌 설정이 아니라 저장소 로컬에만 박는다. */
+export const STAGE_GIT_IDENTITY = { name: 'Elanous Stage', email: 'stage@elanous.test', branch: 'main' } as const;
+
+export interface LinuxEnvStage {
+  /** 무대 루트(시험 끝에 통째로 지운다). */
+  readonly root: string;
+  /** 임시 HOME — `.gitconfig` 가 없다(글로벌 git 신원 없음). */
+  readonly home: string;
+  /** ELANOUS_STATE_DIR — config-dir 이 이 경로를 따라가므로 둘 다 격리된다. */
+  readonly state: string;
+  /** 무대 git 작업 트리(저장소 로컬 identity 만). */
+  readonly repo: string;
+  /** PATH 앞머리 — grok 이 없는 빈 디렉터리. */
+  readonly bin: string;
+  readonly env: Record<string, string>;
+}
+
+const ENV_KEYS = [
+  'HOME',
+  'ELANOUS_STATE_DIR',
+  'ELANOUS_STATE_DIR_SOURCE',
+  'ELANOUS_CONFIG_DIR',
+  'LANG',
+  'LC_ALL',
+  'TZ',
+  'PATH',
+  'GIT_CONFIG_GLOBAL',
+  'GIT_CONFIG_SYSTEM',
+  'GIT_AUTHOR_NAME',
+  'GIT_AUTHOR_EMAIL',
+  'GIT_COMMITTER_NAME',
+  'GIT_COMMITTER_EMAIL',
+] as const;
+
+/** 무대 PATH 의 시스템 꼬리 — grok 이 깔린 디렉터리는 «걸러낸다»(머신마다 설치 위치가 다르다). */
+const SYSTEM_PATH = ['/usr/local/bin', '/usr/bin', '/bin'];
+
+/** 무대를 만들기만 한다(env 적용은 `withLinuxEnv`). */
+export function createLinuxEnvStage(): LinuxEnvStage {
+  const root = mkdtempSync(join(tmpdir(), 'elanous-linux-env-'));
+  const home = join(root, 'home');
+  const repo = join(root, 'repo');
+  const bin = join(root, 'bin');
+  const state = join(repo, '.elanous');
+  for (const dir of [home, repo, bin, state]) mkdirSync(dir, { recursive: true });
+  const env: Record<string, string> = {
+    HOME: home,
+    // ELANOUS_CONFIG_DIR 는 state 를 따라가는 것이 정본이므로 따로 두지 않는다(무시 경고 방지).
+    ELANOUS_STATE_DIR: state,
+    ELANOUS_STATE_DIR_SOURCE: 'explicit',
+    LANG: STAGE_LOCALE,
+    LC_ALL: STAGE_LOCALE,
+    TZ: 'UTC',
+    PATH: [bin, ...SYSTEM_PATH.filter((dir) => !existsSync(join(dir, 'grok')))].join(delimiter),
+    // 글로벌·시스템 git 설정을 read 자체에서 끊는다 — 개발 머신 설정이 새어 들어올 길을 없앤다.
+    GIT_CONFIG_GLOBAL: '/dev/null',
+    GIT_CONFIG_SYSTEM: '/dev/null',
+  };
+  return { root, home, state, repo, bin, env };
+}
+
+/**
+ * 무대 env 로 `fn` 을 돌리고 원상복구한다.
+ * `ELANOUS_STATE_DIR` 가 정해지면 config-dir 도 그 아래로 오므로(config 정본 = state) 저장소·HOME 오염이 없다.
+ */
+export async function withLinuxEnv<T>(fn: (stage: LinuxEnvStage) => T | Promise<T>): Promise<T> {
+  const stage = createLinuxEnvStage();
+  const saved = ENV_KEYS.map((key) => [key, process.env[key]] as const);
+  delete process.env.ELANOUS_CONFIG_DIR;
+  for (const [key, value] of Object.entries(stage.env)) process.env[key] = value;
+  // 개발 머신이 물려준 author/committer env 가 저장소 로컬 identity 증명을 가리지 않게 걷어낸다.
+  for (const key of ['GIT_AUTHOR_NAME', 'GIT_AUTHOR_EMAIL', 'GIT_COMMITTER_NAME', 'GIT_COMMITTER_EMAIL']) delete process.env[key];
+  try {
+    return await fn(stage);
+  } finally {
+    for (const [key, value] of saved) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    rmSync(stage.root, { recursive: true, force: true });
+  }
+}
+
+/**
+ * 무대 env 를 «명시» 해서 자식 프로세스를 띄운다.
+ * ⛔ bun 1.4.2 는 `process.env.PATH` 를 바꾸는 순간 이후 spawn 한 자식의 environ 을 기동 시 스냅샷으로
+ * 재구성한다 — HOME 등 다른 키의 JS 측 변이가 자식에 새지 않는다(실측: PATH assign 뒤 `env` 자식의
+ * HOME 이 원래 값으로 되돌아감). ambient 상속에 기대지 말고 무대 안의 자식은 반드시 이 함수로 띄운다.
+ * in-process(process.env 를 직접 읽는 코드)는 `withLinuxEnv` 의 변이가 그대로 보인다.
+ */
+export function stageSpawnSync(
+  stage: LinuxEnvStage,
+  file: string,
+  args: string[],
+  opts: { cwd?: string } = {},
+): SpawnSyncReturns<string> {
+  return spawnSync(file, args, {
+    cwd: opts.cwd ?? stage.repo,
+    env: { ...process.env, ...stage.env },
+    encoding: 'utf8',
+  });
+}
+
+/** 무대 PATH 에서 그 명령이 실행 가능한가 — Linux CI 에 grok 이 없다는 사실을 «재는» 데 쓴다. */
+export function stageHasCommand(stage: LinuxEnvStage, name: string): boolean {
+  return (stage.env.PATH ?? '').split(delimiter).some((dir) => {
+    if (!dir) return false;
+    try {
+      accessSync(join(dir, name), constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+
+/** 무대 HOME 에 글로벌 git 신원이 있는가 — 무대에서는 false 여야 한다. */
+export function hasGlobalGitIdentity(stage: LinuxEnvStage): boolean {
+  return existsSync(join(stage.home, '.gitconfig')) || existsSync(join(stage.home, '.config', 'git', 'config'));
+}
+
+function gitInStage(stage: LinuxEnvStage, args: string[]): string {
+  const result = stageSpawnSync(stage, 'git', args);
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`git ${args.join(' ')} 실패(rc=${result.status}): ${result.stderr.trim()}`);
+  return result.stdout.trim();
+}
+
+/**
+ * 무대 작업 트리를 «저장소 로컬 identity 만» 으로 초기화하고 첫 커밋까지 만든다.
+ * 커밋이 성공했다는 것 자체가 user.name/user.email 이 로컬 설정으로 먹었다는 실물 증거다.
+ */
+export function initGitWithExplicitIdentity(stage: LinuxEnvStage): void {
+  gitInStage(stage, ['-c', `init.defaultBranch=${STAGE_GIT_IDENTITY.branch}`, 'init', '--quiet']);
+  gitInStage(stage, ['config', 'user.name', STAGE_GIT_IDENTITY.name]);
+  gitInStage(stage, ['config', 'user.email', STAGE_GIT_IDENTITY.email]);
+  gitInStage(stage, ['config', 'init.defaultBranch', STAGE_GIT_IDENTITY.branch]);
+  writeFileSync(join(stage.repo, 'README.md'), '# linux stage\n');
+  gitInStage(stage, ['add', 'README.md']);
+  gitInStage(stage, ['commit', '--quiet', '-m', 'stage: 초기 커밋']);
+}
+
+/** 무대 작업 트리의 실제 git 정체 — 로컬 설정과 현재 브랜치를 읽어 온다. */
+export function gitStageIdentity(stage: LinuxEnvStage): { name: string; email: string; branch: string } {
+  return {
+    name: gitInStage(stage, ['config', '--get', 'user.name']),
+    email: gitInStage(stage, ['config', '--get', 'user.email']),
+    branch: gitInStage(stage, ['symbolic-ref', '--short', 'HEAD']),
+  };
+}
+
+/**
+ * 문자열을 «코드포인트» 단위로 쪼갠다 — `'🎉party'.length` 는 7(UTF-16)이지만 코드포인트는 6이다.
+ * 로케일·인코딩에 따라 이모지 비교가 흔들리는 자리를 코드포인트로 고정한다.
+ */
+export function codePoints(value: string): string[] {
+  return [...value];
+}

package/src/tool-hints/gate.ts

@@ -171,17 +171,19 @@ export function evaluateGate(
 
   // ─── Step 6: model-tier budget cap ─────────────────────────────
   // Weak/cheap models pay a per-tool token tax. On codex/gpt-5 we
-  // cap the prompt at top-8 after boost sort to keep the per-call
-  // overhead bounded. Claude/Opus/Grok don't need this.
+  // cap the prompt after boost sort to keep per-call overhead bounded.
+  // Research already has an intent signal; it needs more source tools but
+  // still has a finite cap. Claude/Opus/Grok don't need this cap.
   let keep: string[] = [...enabled];
   const capped = signals.modelFamily === 'codex' || signals.modelFamily === 'gpt';
   if (capped) {
     const beforeModelFamilyCap = keep.length;
-    if (keep.length > 8) {
+    const cap = signals.researchAgent ? 16 : 8;
+    if (keep.length > cap) {
       keep = keep
         .map(id => ({ id, score: boost.get(id) ?? 0 }))
         .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
-        .slice(0, 8)
+        .slice(0, cap)
         .map(x => x.id);
     }
     stages.modelFamilyCap = executedStage(beforeModelFamilyCap, keep.length);

package/src/tool-hints/signals.ts

@@ -29,6 +29,8 @@ export interface SignalSnapshot {
 
   // Recent conversation
   intentResearch: boolean;
+  /** Deep multi-source research route; quick fact lookups remain capped. */
+  researchAgent?: boolean;
   intentDiagram: boolean;
   recentNetworkError: boolean;
 
@@ -116,6 +118,34 @@ const NETWORK_ERROR_RE = /\b(ETIMEDOUT|ENOTFOUND|ECONNREFUSED|ECONNRESET|EHOSTUN
 // positive rate is fine because these signals only nudge a boost.
 const RESEARCH_ASCII_RE = /\b(research|find out|look up|investigate|latest (on|news)|what (are|is|does))\b/i;
 const RESEARCH_KO_RE = /(최신|뉴스|찾아(?:줘|봐)|알아봐|조사|리서치)/;
+const RESEARCH_SKILL_RE = /\b(?:omni[ -]market|omni[ -]crawl|social[ -]pulse)\b/i;
+const RESEARCH_EXPLANATION_RE = /(?:왜|이유|원인|전망|분석|비교|조사|\bwhy\b|\bcause\b|\boutlook\b|\banalysis\b|\bcompare\b)/i;
+const RESEARCH_TOPIC_RE = /(?:금리|채권|시장|경제|물가|환율|주가|기업|산업|정책|선거|역사|기후|질병|의학|과학|\bbond\b|\byield\b|\bmarket\b|\beconomy\b|\binflation\b|\bstock\b|\bpolicy\b|\belection\b|\bhistory\b|\bclimate\b|\bhealth\b|\bscience\b)/i;
+const RESEARCH_CODING_RE = /(?:코드|함수|버그|테스트|빌드|커밋|하니스|설정|오류|구현|수리|고쳐|수정|저장소|\brepo\b|\bcode\b|\bfunction\b|\bbug\b|\btest\b|\bbuild\b|\bcommit\b|\bconfig\b|\bimplement\b|\bfix\b)/i;
+const DEEP_RESEARCH_INTENT_TERMS = [
+  'research', 'deep research', 'triangulate', 'compare sources',
+  'multiple sources', 'community reaction', 'reddit reaction',
+  'x reaction', 'trend', 'sentiment', '여러 소스', '깊게 조사',
+  '리서치', '반응', '트렌드', '여론', '비교 조사', '교차검증',
+] as const;
+
+function hasResearchTurnIntent(text: string | undefined): boolean {
+  if (!text) return false;
+  if (matchesIntent(text, RESEARCH_ASCII_RE, RESEARCH_KO_RE)) return true;
+  return isResearchAgentIntent(text);
+}
+
+/** Shared research/agent verdict for surface routing and the tool catalog.
+ *  Keep the historical deep-research words before the new coding veto so
+ *  existing explicit surface choices retain their meaning. */
+export function isResearchAgentIntent(text: string | undefined): boolean {
+  if (!text) return false;
+  const lower = text.toLowerCase();
+  if (DEEP_RESEARCH_INTENT_TERMS.some((term) => lower.includes(term))) return true;
+  if (RESEARCH_CODING_RE.test(text)) return false;
+  return RESEARCH_SKILL_RE.test(text)
+    || (RESEARCH_EXPLANATION_RE.test(text) && RESEARCH_TOPIC_RE.test(text));
+}
 const DIAGRAM_ASCII_RE = /\b(diagrams?|flowcharts?|sequence|mermaid|graphs?|charts?|visuali[sz]e|architecture)\b/i;
 const DIAGRAM_KO_RE = /(시퀀스|플로우|다이어그램|도식|그래프|시각화|아키텍처|구조도)/;
 
@@ -213,7 +243,8 @@ export function collectSignals(ctx: SignalContext = {}): SignalSnapshot {
     hasNodeProject: existsSync(joinPath(cwd, 'package.json')),
     hasGitRemote: detectGitRemote(cwd),
 
-    intentResearch: matchesIntent(ctx.recentUserText, RESEARCH_ASCII_RE, RESEARCH_KO_RE),
+    intentResearch: hasResearchTurnIntent(ctx.recentUserText),
+    researchAgent: isResearchAgentIntent(ctx.recentUserText),
     intentDiagram: matchesIntent(ctx.recentUserText, DIAGRAM_ASCII_RE, DIAGRAM_KO_RE),
     recentNetworkError: hasRecentNetworkError(ctx.recentToolResults),
 
@@ -284,6 +315,7 @@ function fingerprintOf(s: SignalSnapshot): string {
     s.hasNodeProject ? 'node' : '-',
     s.hasGitRemote ? 'git' : '-',
     s.intentResearch ? 'research' : '-',
+    s.researchAgent ? 'research-agent' : '-',
     s.intentDiagram ? 'diagram' : '-',
     s.recentNetworkError ? 'neterr' : '-',
     s.modelFamily ?? '-',

package/src/tui/chat/background-job-status.ts

@@ -13,13 +13,15 @@ function nonnegativeCount(value: unknown): value is number {
 export class BackgroundJobStatus {
   private sessionId: string | null;
   private current: BackgroundJobSnapshot | null = null;
+  private readonly bySession = new Map<string, BackgroundJobSnapshot>();
 
   constructor(sessionId: string | null) { this.sessionId = sessionId; }
 
   setSessionId(sessionId: string): void {
     if (this.sessionId === sessionId) return;
+    if (this.sessionId && this.current) this.bySession.set(this.sessionId, this.current);
     this.sessionId = sessionId;
-    this.current = null;
+    this.current = this.bySession.get(sessionId) ?? null;
   }
 
   accept(json: string): boolean {
@@ -35,12 +37,16 @@ export class BackgroundJobStatus {
       running: frame.running,
       pending: frame.pending,
     }) as BackgroundJobSnapshot;
+    this.bySession.set(frame.sessionId as string, this.current);
     return true;
   }
 
   snapshot(): BackgroundJobSnapshot | null { return this.current; }
 
-  clear(): void { this.current = null; }
+  clear(): void {
+    this.current = null;
+    if (this.sessionId) this.bySession.delete(this.sessionId);
+  }
 
   line(): string {
     const state = this.current;

package/src/tui/chat/goal-interim.ts

@@ -92,10 +92,14 @@ export type InterimDisplay =
   | { kind: 'folded'; line: string };
 
 /** 메시지 인덱스 → 그리기 바꿈. 내부 턴 입력은 출처 한 줄, 그 «바로 앞» 중간 보고 답은 한 줄로 접는다. */
-export function planInterimDisplay(messages: ReadonlyArray<{ role: string; content?: unknown }>): Map<number, InterimDisplay> {
+export function planInterimDisplay(messages: ReadonlyArray<{ role: string; content?: unknown; goalInterim?: boolean }>): Map<number, InterimDisplay> {
   const plan = new Map<number, InterimDisplay>();
   for (let i = 0; i < messages.length; i++) {
     const m = messages[i]!;
+    if (m.role === 'assistant' && m.goalInterim === true && typeof m.content === 'string') {
+      const verdict = classifyInterimReply(m.content.split('\n'));
+      if (verdict.interim) plan.set(i, { kind: 'folded', line: formatInterimFoldLine(verdict.summary) });
+    }
     if (m.role !== 'user' || typeof m.content !== 'string') continue;
     const origin = internalTurnOriginOfText(m.content);
     if (!origin) continue;