elanous 0.2.29 → 0.2.32

package/src/session/session-start.ts

@@ -0,0 +1,224 @@
+// 🧭 세션 시작 결정 — «인자 없음 = 깨끗한 새 세션», 이어하기는 명시 인자일 때만 (TUI-H8-SESSION-NEW-DEFAULT · 대표 10-16 #73).
+//
+// S: `elanous chat` · `agent` · `repl` 은 인자 없이 뜨면 «활성 세션»(~/.local/state/elanous/active)을 조용히 이어받았다.
+//    그래서 앞 프로세스가 도구 호출 도중 죽은 기록(호출·결과 짝이 깨진 꼬리)까지 이어받아 첫 턴이 400 으로 죽었다(#69).
+// C: 다른 에이전트(codex·claude·grok)는 인자 없음 = 새 세션 · 이어하기 = `--resume`/`--continue` 다.
+// A: 시작 결정을 이 함수 하나로 모으고, 결정마다 `session`/`start` 한 줄을 남긴다(관측).
+//    ⛔ 자리 맥락은 세션이 아니라 자리 문서(AGENTS.local.md · `.AGENTS.local.last-session.md` · 부트 카드)가 매 턴 싣는다 —
+//       새 세션이어도 맥락은 그대로다(`turn-preamble.ts` · `universal-preamble.ts`).
+
+import { debug } from '../debug/log.js';
+
+export type SessionStartOrigin = 'new' | 'resume';
+export type SessionStartReason =
+  | 'default-new'
+  | 'force-new'
+  | 'explicit-session'
+  | 'continue-active'
+  | 'continue-latest'
+  | 'continue-no-active';
+
+export interface SessionStartDecision {
+  origin: SessionStartOrigin;
+  reason: SessionStartReason;
+  /** 이어받을 세션 id(명시 id 는 호출부가 이미 풀어서 넘긴다). 새 세션이면 undefined. */
+  sessionIdHint?: string;
+}
+
+/** 단일 결정 — 명시 id > `--new` > `--continue`/`--resume`(활성 세션 ⊕ 표지가 낡았으면 최신 세션) > 기본 새 세션.
+ *  `sessionExists`·`latestSessionId` 를 주면 활성 표지가 «사라진 세션»을 가리킬 때 최신 세션으로 넘어간다
+ *  (TUI-H8-FOLLOW ① · #28509 리뷰 should-fix). 안 주면 옛 동작(표지를 그대로 믿는다). */
+export function decideSessionStart(input: {
+  explicitSessionId?: string;
+  continueActive: boolean;
+  forceNew: boolean;
+  activeSessionId: () => string | null;
+  sessionExists?: (id: string) => boolean;
+  latestSessionId?: () => string | null;
+}): SessionStartDecision {
+  if (input.explicitSessionId) {
+    return { origin: 'resume', reason: 'explicit-session', sessionIdHint: input.explicitSessionId };
+  }
+  if (input.forceNew) return { origin: 'new', reason: 'force-new' };
+  if (input.continueActive) {
+    const picked = pickContinueSession(input);
+    if (!picked) return { origin: 'new', reason: 'continue-no-active' };
+    return {
+      origin: 'resume',
+      reason: picked.from === 'active' ? 'continue-active' : 'continue-latest',
+      sessionIdHint: picked.id,
+    };
+  }
+  return { origin: 'new', reason: 'default-new' };
+}
+
+/** 존재 확인 — 확인 자체가 실패하면 «있다»고 보지 않는다(이어받을 수 없는 세션을 고르지 않는다). */
+function sessionAlive(exists: ((id: string) => boolean) | undefined, id: string): boolean {
+  if (!exists) return true;
+  try { return exists(id); } catch { return false; }
+}
+
+/** «이어하기» 대상 — 활성 표지 ⊕ (표지가 없거나 사라진 세션이면) 최신 세션. 낡은 표지는 `session`/`active-marker-stale` 로 남긴다. */
+function pickContinueSession(deps: {
+  activeSessionId: () => string | null;
+  sessionExists?: (id: string) => boolean;
+  latestSessionId?: () => string | null;
+}): { id: string; from: 'active' | 'latest' } | null {
+  let active: string | null = null;
+  try { active = deps.activeSessionId(); } catch { /* 활성 표지 읽기 실패 — 최신 세션으로 넘어간다 */ }
+  if (active && sessionAlive(deps.sessionExists, active)) return { id: active, from: 'active' };
+  const picked = pickLatest(deps, active);
+  if (active) {
+    // 관측은 «실제로 고른 결과»로 남긴다(r1 should-fix — 최신이 없어 새 세션이면 fallback:'none').
+    try {
+      debug.log('session', 'active-marker-stale', { activeSessionId: active, fallback: picked ? 'latest' : 'none' });
+    } catch { /* 관측 실패가 시작을 막지 않는다 */ }
+  }
+  return picked;
+}
+
+function pickLatest(deps: {
+  sessionExists?: (id: string) => boolean;
+  latestSessionId?: () => string | null;
+}, staleActive: string | null): { id: string; from: 'latest' } | null {
+  if (!deps.latestSessionId) return null;
+  let latest: string | null = null;
+  try { latest = deps.latestSessionId(); } catch { return null; }
+  if (!latest || latest === staleActive || !sessionAlive(deps.sessionExists, latest)) return null;
+  return { id: latest, from: 'latest' };
+}
+
+/** `elanous --resume`/`--continue` 처럼 id 없이 «이어하기»만 받은 표면이 이어받을 세션 — 활성 표지 ⊕ 없거나 사라졌으면 최신. */
+export function resolveLatestSessionId(deps: {
+  activeSessionId: () => string | null;
+  latestSessionId: () => string | null;
+  sessionExists?: (id: string) => boolean;
+}): string | null {
+  return pickContinueSession(deps)?.id ?? null;
+}
+
+/** 세션 id 꼴인가 — 세션 id 는 uuid v4(`randomUUID` · 8-4-4-4-12 hex)이고 «고유 접두»도 받는다.
+ *  uuid 의 «접두»(하이픈은 9·14·19·24번째 자리에만) 4~36자 ⊕ 숫자 하나 이상(«face»·«deadbeef» 같은 낱말을 id 로 먹지 않게).
+ *  숫자 없는 hex 접두를 id 로 쓰려면 `--session <id>` 를 쓴다. */
+export function looksLikeSessionId(value: string): boolean {
+  const v = value.trim().toLowerCase();
+  if (v.length < 4 || v.length > 36 || !/[0-9]/.test(v)) return false;
+  for (let i = 0; i < v.length; i += 1) {
+    const c = v[i]!;
+    const hyphenSlot = i === 8 || i === 13 || i === 18 || i === 23;
+    if (hyphenSlot ? c !== '-' : !/[0-9a-f]/.test(c)) return false;
+  }
+  return true;
+}
+
+/** `--resume [id]` 뒤 위치 인자 — Commander 는 값 선택형 옵션 뒤 첫 낱말을 값으로 먹는다.
+ *  그 값이 세션 id 꼴이 아니면 «id 없는 --resume ⊕ 프롬프트 낱말»로 되돌린다(TUI-H8-FOLLOW ②).
+ *  `argv` 를 주면 되돌린 낱말을 입력 «순서 그대로» 끼운다(`chat hello --resume world` → `hello world`);
+ *  안 주면 맨 앞에 놓는다. */
+export function splitResumeArgument(
+  resume: string | boolean | undefined,
+  parts: readonly string[],
+  surface: 'chat' | 'agent',
+  argv?: readonly string[],
+): { resume: string | boolean | undefined; parts: string[] } {
+  if (typeof resume !== 'string' || looksLikeSessionId(resume)) return { resume, parts: [...parts] };
+  const at = argv ? resumeInsertIndex(argv, parts, resume, surface) : 0;
+  try {
+    debug.log('session', 'resume-value-as-prompt', { surface, words: resume.split(/\s+/).filter(Boolean).length, at });
+  } catch { /* 관측 실패가 시작을 막지 않는다 */ }
+  return { resume: true, parts: [...parts.slice(0, at), resume, ...parts.slice(at)] };
+}
+
+/** chat·agent argv 를 «한 번» 토큰화한 결과 — 위치 인자(순서대로) ⊕ `--resume` 값이 몇 번째 위치 인자 «앞»에 왔나.
+ *  (r3 TF 결정: 한 지점 땜질 대신 토큰화로 일반화 — 리뷰 진동을 끊는다.)
+ *  규칙(Commander 와 같은 읽기):
+ *   - 명령 낱말(`chat`/`agent`) «뒤»부터 본다(앞은 루트 옵션).
+ *   - `--` 뒤는 전부 위치 인자.
+ *   - `--resume=X` → X 가 resume 값. `--resume X` → X 가 `-` 로 시작하지 않으면 resume 값(값 선택형).
+ *   - 값을 받는 옵션(`--session`)은 `--session X`·`--session=X` 모두 값을 건너뛴다.
+ *   - 그 밖의 `-` 로 시작하는 토큰은 값 없는 플래그(`--continue` 등 · `--continue=X` 는 Commander 가 거부한다).
+ *   - 나머지는 위치 인자. */
+export function tokenizeResumeArgv(
+  argv: readonly string[],
+  surface: 'chat' | 'agent',
+): { positionals: string[]; resumeValue: string | null; resumeValueAt: number | null } {
+  const VALUE_OPTIONS = new Set(['--session']);
+  const positionals: string[] = [];
+  let resumeValue: string | null = null;
+  let resumeValueAt: number | null = null;
+  let afterDoubleDash = false;
+  for (let i = argv.indexOf(surface) + 1; i < argv.length; i += 1) {
+    const token = argv[i]!;
+    if (afterDoubleDash) { positionals.push(token); continue; }
+    if (token === '--') { afterDoubleDash = true; continue; }
+    if (token.startsWith('--resume=')) {
+      resumeValue = token.slice('--resume='.length);
+      resumeValueAt = positionals.length;
+      continue;
+    }
+    if (token === '--resume') {
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith('-')) {
+        resumeValue = next;
+        resumeValueAt = positionals.length;
+        i += 1;
+      }
+      continue;
+    }
+    const eq = token.indexOf('=');
+    if (token.startsWith('--') && VALUE_OPTIONS.has(eq >= 0 ? token.slice(0, eq) : token)) {
+      if (eq < 0) i += 1;
+      continue;
+    }
+    if (token.startsWith('-')) continue;
+    positionals.push(token);
+  }
+  return { positionals, resumeValue, resumeValueAt };
+}
+
+/** 되돌린 낱말을 끼울 자리 — 토큰화 결과가 Commander 가 준 값·위치 인자와 «다르면» 맨 앞(옛 동작)으로 접고 남긴다. */
+function resumeInsertIndex(argv: readonly string[], parts: readonly string[], resume: string, surface: 'chat' | 'agent'): number {
+  const t = tokenizeResumeArgv(argv, surface);
+  const agrees = t.resumeValue === resume
+    && t.resumeValueAt !== null
+    && t.positionals.length === parts.length
+    && t.positionals.every((p, i) => p === parts[i]);
+  if (agrees) return t.resumeValueAt!;
+  try { debug.log('session', 'resume-argv-mismatch', { surface, positionals: t.positionals.length, parts: parts.length }); } catch { /* best-effort */ }
+  return 0;
+}
+
+/** 대시보드 TUI 루트 이어하기 — 우선순위 `--resume <id>` > `--continue`·id 없는 `--resume`(최신 세션) >
+ *  (폐기 예정) `ELANOUS_RESUME_SESSION`. ⛔ 명시 인자가 있으면 환경변수가 이기지 않는다. 아무것도 없으면 새 세션. */
+export function resolveRootResumeSessionId(input: {
+  flagId?: string;
+  continueLatest: boolean;
+  /** 폐기 예정 env 읽기 — 명시 인자가 하나도 없을 때만 «부른다»(읽기 자체가 폐기 경고를 낸다 · r2 must-fix). */
+  readEnvId: () => string | null | undefined;
+  latest: () => string | null;
+}): { sessionId?: string; source: 'flag' | 'continue' | 'continue-none' | 'env' | 'none' } {
+  const flagId = (input.flagId ?? '').trim();
+  if (flagId) return { sessionId: flagId, source: 'flag' };
+  if (input.continueLatest) {
+    const latest = input.latest();
+    return latest ? { sessionId: latest, source: 'continue' } : { source: 'continue-none' };
+  }
+  const envId = (input.readEnvId() ?? '').trim();
+  if (envId) return { sessionId: envId, source: 'env' };
+  return { source: 'none' };
+}
+
+/** 관측 — 세션이 «어떻게» 시작됐나. 실패해도 시작을 막지 않는다. */
+export function observeSessionStart(data: {
+  surface: 'chat' | 'agent' | 'repl' | 'tui' | 'ask';
+  origin: SessionStartOrigin;
+  reason: string;
+  sessionId?: string | null;
+  [key: string]: unknown;
+}): void {
+  try {
+    debug.log('session', 'start', data);
+  } catch {
+    // Observation must never block a session start.
+  }
+}

package/src/session-runtime/index.ts

@@ -1,6 +1,5 @@
 import { buildGitSnapshot } from '../git-fs/index.js';
 import { debug } from '../debug/log.js';
-import { getUserConfig } from '../user-config.js';
 import { resolve } from 'node:path';
 import type { ModelFamily } from '../models/prompts.js';
 import type { InputSourceKind, InputSourceRef } from '../input/input-source-kind.js';
@@ -411,46 +410,6 @@ const TOOL_NAME_TO_FAMILY = new Map<string, SessionToolFamilyRule>(
   SESSION_TOOL_FAMILY_RULES.flatMap(rule => rule.names.map(name => [name, rule] as const)),
 );
 
-/** Names belonging to the runtime-debug family — used by the
- *  exposeFullLlmTools=false post-filter to know which tools to drop. */
-const RUNTIME_DEBUG_FAMILY_NAMES: ReadonlySet<string> = new Set(
-  SESSION_TOOL_FAMILY_RULES.find(r => r.id === 'runtime-debug')?.names ?? [],
-);
-
-/** Read-only inspection tools kept alive when minimal mode is on.
- *  Roughly half of the 9-entry runtime-debug family — picked by
- *  chatlog-triage value and gated to read-only-and-safe operations.
- *  Excluded by design (LLM-mutating or UI-stealing):
- *    debug_setLevel    — would let the LLM crank logs to keytrace,
- *                        flooding the file sink during a triage.
- *    debug_openView    — server-side cousin of the user-pressed
- *                        Ctrl+digit shortcut that already annoyed
- *                        the user (incident 2026-05-04).
- *    debug_selectEvent — UI-cursor mutation; steals focus from the
- *                        human reviewer.
- *    input_history_list — redundant with input_history_search.
- *  Leaves the LLM with enough surface to triage chatlogs without
- *  the surface area that lets it disrupt the live session. */
-const RUNTIME_DEBUG_MINIMAL_KEEP: ReadonlySet<string> = new Set([
-  'debug_getLastLlm',     // last request/response pair
-  'debug_getState',       // event-buffer + stats dump
-  'debug_getCallStack',   // call-path triage
-  'debug_getAgentState',  // sub-agent queue inspection
-  'input_history_search', // self-lookup of prior user inputs
-]);
-
-/** Drop runtime-debug tools (except the single essential one) when
- *  the user has set debug.exposeFullLlmTools=false. Other host tool
- *  families pass through untouched. Called at the tail of every host
- *  tool resolver so the gate applies uniformly across surfaces. */
-function applyDebugMinimalFilter<T extends { name: string }>(tools: T[]): T[] {
-  if (getUserConfig().debug.exposeFullLlmTools !== false) return tools;
-  return tools.filter(t => {
-    if (!RUNTIME_DEBUG_FAMILY_NAMES.has(t.name)) return true;
-    return RUNTIME_DEBUG_MINIMAL_KEEP.has(t.name);
-  });
-}
-
 interface SessionNativeToolRule {
   id: string;
   description: string;
@@ -650,19 +609,6 @@ const HOST_TOOL_FAMILY_RULE_MAP = new Map<string, SessionToolFamilyRule>(
   SESSION_TOOL_FAMILY_RULES.map(rule => [rule.id, rule] as const),
 );
 
-function isCodeGroundingModelSurfaceEnabled(): boolean {
-  const config = getUserConfig();
-  const configured = (config.raw.tools as Record<string, unknown> | undefined)?.nativeStructure;
-  const source = configured
-    && typeof configured === 'object'
-    && typeof (configured as Record<string, unknown>).enabled === 'boolean'
-    ? 'config'
-    : 'default';
-  const enabled = config.tools.nativeStructure.enabled === true;
-  debug.log('tools.surface', 'code-grounding-exposure', { enabled, source });
-  return enabled;
-}
-
 const SESSION_RUNTIME_TOOL_FAMILY_RULES: SessionRuntimeToolFamilyRule[] = [
   {
     id: 'fleet-core',
@@ -979,8 +925,12 @@ function isSessionSurfaceId(value: string | null | undefined): value is SessionS
 
 export function buildSessionRuntimeSystemMessages(opts: {
   cwd: string;
+  /** Serve a snapshot up to this old and rebuild it asynchronously (TUI turn path). */
+  gitSnapshotStaleMs?: number;
 }): LLMMessage[] {
-  const snapshot = buildGitSnapshot(opts.cwd);
+  const snapshot = buildGitSnapshot(opts.cwd, opts.gitSnapshotStaleMs !== undefined
+    ? { staleWhileRevalidateMs: opts.gitSnapshotStaleMs }
+    : {});
   return snapshot
     ? [{ role: 'system', content: `## Git Snapshot\n\n${snapshot}` }]
     : [];
@@ -1694,45 +1644,6 @@ export function buildSessionSurfaceManualSections(
 
   return sections;
 }
-export function resolveDynamicSessionHostTools(opts: {
-  userText: string;
-  hostTools: readonly LLMToolDef[];
-  toolAvailability?: Readonly<Record<string, boolean>>;
-  defaultFamilyIds?: readonly string[];
-  surfaceId?: SessionSurfaceId;
-}): LLMToolDef[] {
-  const text = opts.userText.toLowerCase();
-  const available = new Map(opts.hostTools.map(tool => [tool.name, tool] as const));
-  const selected = new Set<string>();
-
-  for (const familyId of opts.defaultFamilyIds ?? []) {
-    for (const rule of SESSION_TOOL_FAMILY_RULES) {
-      if (rule.id !== familyId) continue;
-      for (const name of rule.names) {
-        if (available.has(name)) selected.add(name);
-      }
-    }
-  }
-
-  for (const tool of opts.hostTools) {
-    if (mentionsTool(text, tool.name)) selected.add(tool.name);
-  }
-  for (const rule of SESSION_TOOL_FAMILY_RULES) {
-    const surfaceMatch = matchesSurfaceAwareFamilyIntent(rule.id, text, opts.surfaceId);
-    if (!rule.match(text) && !surfaceMatch) continue;
-    for (const name of rule.names) {
-      if (available.has(name)) selected.add(name);
-    }
-  }
-
-  return applyDebugMinimalFilter(
-    [...selected]
-      .filter(name => isToolAvailable(name, opts.toolAvailability))
-      .map(name => available.get(name))
-      .filter((tool): tool is LLMToolDef => !!tool),
-  );
-}
-
 const ESSENTIAL_NATIVE_RULE_IDS = [
   'code-read', 'code-grep', 'code-glob', 'code-list-dir', 'code-edit', 'code-write',
   // Keep dev-harness in the assembly candidate set so the catalog policy below is the single model-exposure authority.
@@ -1740,7 +1651,8 @@ const ESSENTIAL_NATIVE_RULE_IDS = [
 ] as const;
 const ESSENTIAL_HOST_FAMILY_IDS = ['self-ops', 'release-read'] as const;
 // Keep this TUI essential addition out of the shared control/agent self-ops family.
-const ESSENTIAL_HOST_EXTRA_NAMES = ['logs_query'] as const;
+// ScheduleWakeup (H5) is a dashboard-only host tool — present only when the TUI registered it.
+const ESSENTIAL_HOST_EXTRA_NAMES = ['logs_query', 'ScheduleWakeup'] as const;
 const ESSENTIAL_RUNTIME_FAMILY_IDS = ['bash', 'run-shell', 'ops-ledger', 'pty-shell', 'run-tests', 'elanous_skills_list', 'skill_exec', 'code-grounding'] as const;
 const ESSENTIAL_OPTIONAL_TOOL_NAMES = [
   'GetDashboardState',
@@ -1802,76 +1714,35 @@ export function buildSessionRuntimeToolSpecs(opts: {
   userText: string;
   hostTools: readonly LLMToolDef[];
   runtimeTools?: readonly ToolRuntime<Record<string, unknown>, ToolRunResult>[];
-  pluginTools?: readonly LLMToolDef[];
-  schedulerTools?: readonly LLMToolSpec[];
   optionalTools?: readonly LLMToolSpec[];
   toolAvailability?: Readonly<Record<string, boolean>>;
   surface?: SessionSurfaceProfile;
   preferredSurfaceId?: SessionSurfaceId;
   controlMode?: boolean;
-  /** TUI --rich preserves the legacy userText-driven surface catalog. */
-  rich?: boolean;
 }): LLMToolSpec[] {
+  // TUI-DIET-D1-TAIL — the legacy userText-driven catalog (`rich !== false`) is gone;
+  // every caller already passed rich=false, so the essential catalog is the only path.
+  // The surface profile is still resolved for the always-on observation below.
   const surface = opts.surface ?? resolveSessionSurfaceProfile({
     userText: opts.userText,
     preferredSurfaceId: opts.preferredSurfaceId,
     controlMode: opts.controlMode,
   });
-  const dynamicHostTools = resolveDynamicSessionHostTools({
-    userText: opts.userText,
+  const essentialSpecs = buildEssentialSessionRuntimeToolSpecs({
     hostTools: opts.hostTools,
-    toolAvailability: opts.toolAvailability,
-    defaultFamilyIds: surface.defaultHostFamilyIds,
-    surfaceId: surface.id,
-  });
-  const dynamicRuntimeTools = resolveDynamicSessionRuntimeToolSpecs({
-    userText: opts.userText,
     runtimeTools: opts.runtimeTools ?? [],
-    defaultFamilyIds: surface.defaultRuntimeFamilyIds,
-    surfaceId: surface.id,
-  });
-  const dynamicNativeTools = resolveDynamicSessionNativeToolSpecs({
-    userText: opts.userText,
+    optionalTools: opts.optionalTools ?? [],
     toolAvailability: opts.toolAvailability,
-    defaultFamilyIds: surface.defaultNativeFamilyIds,
-    surfaceId: surface.id,
   });
-  const hostSpecs = dynamicHostTools.map(toSpec);
-  const pluginSpecs = (opts.pluginTools ?? []).map(toSpec);
-  const schedulerSpecs = opts.schedulerTools ?? [];
-  const optionalSpecs = opts.optionalTools ?? [];
-  // Native tools (Read/Bash/Grep/Edit/Write/...) come first so the
-  // catalog's leading slots are stable across surfaces. research/turn
-  // for example overrides hostSpecs with debug_*/input_history_*; if
-  // those landed in front of native, the LLM mis-recognizes its own
-  // toolset (incident 2026-05-04 — Opus replied "no file tools in this
-  // session" while Bash was actually exposed at position 7+).
-  const finalSpecs: LLMToolSpec[] = opts.rich === false
-    ? (() => {
-        const essentialSpecs = buildEssentialSessionRuntimeToolSpecs({
-          hostTools: opts.hostTools,
-          runtimeTools: opts.runtimeTools ?? [],
-          optionalTools: opts.optionalTools ?? [],
-          toolAvailability: opts.toolAvailability,
-        });
-        if (!hasDevHarnessIntent(opts.userText)) return essentialSpecs;
-        const droppedNames = new Set(['Edit', 'Write']);
-        const filteredSpecs = essentialSpecs.filter(spec => !droppedNames.has(spec.name));
-        if (filteredSpecs.length !== essentialSpecs.length) {
-          debug.log('session-runtime.tools', 'harness-phrase-write-tools-dropped', {
-            dropped: ['Edit', 'Write'],
-          });
-        }
-        return filteredSpecs;
-      })()
-    : [
-        ...dynamicNativeTools,
-        ...hostSpecs,
-        ...dynamicRuntimeTools,
-        ...pluginSpecs,
-        ...schedulerSpecs,
-        ...optionalSpecs,
-      ];
+  const droppedNames = new Set(['Edit', 'Write']);
+  const finalSpecs: LLMToolSpec[] = hasDevHarnessIntent(opts.userText)
+    ? essentialSpecs.filter(spec => !droppedNames.has(spec.name))
+    : essentialSpecs;
+  if (finalSpecs.length !== essentialSpecs.length) {
+    debug.log('session-runtime.tools', 'harness-phrase-write-tools-dropped', {
+      dropped: ['Edit', 'Write'],
+    });
+  }
   // Forensic — final tool list returned to streamLLMWithTools. Lets
   // us diff TUI vs JSON-test (`elanous repro`) tool exposure when codex
   // behavior diverges. Counts AND names so we can spot per-source
@@ -1903,18 +1774,10 @@ export function buildSessionRuntimeToolSpecs(opts: {
   // diag-gated (분석 레벨) 유지 — 매턴 detail 이라 always-on 이면 노이즈 독.
   // 노출 tool 셋을 보려면 `/debug diag` 후 elanous logs --category llm.tool-
   // exposure. always-on 은 이상탐지(surface tool 0개·core 누락) 전용 — 루틴
-  // per-turn 노출은 diag. (2026-07-17 규율: over-log 되돌림·runtime.resolve 는 유지.)
+  // per-turn 노출은 diag. (2026-07-17 규율: over-log 되돌림.)
   if (debug.enabled) {
     debug.log('llm.tool-exposure', 'session-runtime-tool-specs.return', {
       total: finalSpecs.length,
-      counts: {
-        host: hostSpecs.length,
-        runtime: dynamicRuntimeTools.length,
-        native: dynamicNativeTools.length,
-        plugin: pluginSpecs.length,
-        scheduler: schedulerSpecs.length,
-        optional: optionalSpecs.length,
-      },
       names: finalSpecs.map(s => s.name),
       surfaceId: surface.id,
       userTextChars: opts.userText.length,
@@ -1923,76 +1786,6 @@ export function buildSessionRuntimeToolSpecs(opts: {
   return finalSpecs;
 }
 
-function resolveDynamicSessionRuntimeToolSpecs(opts: {
-  userText: string;
-  runtimeTools: readonly ToolRuntime<Record<string, unknown>, ToolRunResult>[];
-  defaultFamilyIds?: readonly string[];
-  surfaceId?: SessionSurfaceId;
-}): LLMToolSpec[] {
-  const text = opts.userText.toLowerCase();
-  const available = new Map(opts.runtimeTools.map(tool => [tool.id, tool] as const));
-  const selected = new Set<string>();
-
-  // Pass 0 — T1 world-I/O substrate (RFC §3 · P2 상시화). Shell/PTY
-  // execution is domain-independent substrate: a coding agent needs to
-  // run what it builds on EVERY surface (research cross-check, ops
-  // triage, control), not only the coding surfaces. Mirrors the native
-  // 6-core Pass-0. Subject to availability — a surface that doesn't wire
-  // the shell runtimes (`available.has` false) simply skips them, so no
-  // phantom tools appear. Trade/financial dispatch is unaffected: these
-  // are exposure only; execution safety stays in bash sandbox / PtyShell
-  // approval (shell.allowDashboardPty) gates.
-  for (const familyId of CORE_RUNTIME_FAMILY_IDS) {
-    const rule = RUNTIME_TOOL_FAMILY_RULE_MAP.get(familyId);
-    if (!rule) continue;
-    for (const name of rule.names) {
-      if (available.has(name)) selected.add(name);
-    }
-  }
-
-  for (const familyId of opts.defaultFamilyIds ?? []) {
-    const rule = RUNTIME_TOOL_FAMILY_RULE_MAP.get(familyId);
-    if (!rule) continue;
-    // code-grounding belongs to coding defaults but remains opt-in to avoid carrying its spec on every coding turn.
-    // Its rule intentionally never dynamically matches: only coding profiles list it as a default family.
-    if (rule.id === 'code-grounding' && !isCodeGroundingModelSurfaceEnabled()) continue;
-    for (const name of rule.names) {
-      if (available.has(name)) selected.add(name);
-    }
-  }
-
-  for (const tool of opts.runtimeTools) {
-    if (mentionsTool(text, tool.id) || mentionsTool(text, tool.spec.name)) {
-      selected.add(tool.id);
-    }
-  }
-
-  for (const rule of SESSION_RUNTIME_TOOL_FAMILY_RULES) {
-    const surfaceMatch = matchesSurfaceAwareRuntimeIntent(rule.id, text, opts.surfaceId);
-    if (!rule.match(text) && !surfaceMatch) continue;
-    for (const name of rule.names) {
-      if (available.has(name)) selected.add(name);
-    }
-  }
-
-  const specs = [...selected]
-    .map(name => available.get(name))
-    .filter((tool): tool is ToolRuntime<Record<string, unknown>, ToolRunResult> => !!tool)
-    .map(tool => tool.spec);
-  // 관측 보강(2026-07-17) — native.resolve 미러. runtime 축(Bash·RunShell 등)이
-  // 어느 surface/family 로 노출됐는지 elanous logs --category llm.tool-exposure 로
-  // 조회 가능하게. runtime 축 로깅이 없어 "Bash 노출됐나" 를 로그로 못 봤던 갭.
-  if (debug.enabled) {
-    debug.log('llm.tool-exposure', 'runtime.resolve', {
-      surfaceId: opts.surfaceId ?? null,
-      defaultFamilyIds: [...(opts.defaultFamilyIds ?? [])],
-      availableCount: available.size,
-      selectedNames: specs.map(s => s.name),
-    });
-  }
-  return specs;
-}
-
 /** Six core file-IO tools that survive on EVERY surface regardless
  *  of the surface's `defaultNativeFamilyIds`. User-stated invariant
  *  (2026-05-04): "the 6 core tools must stay alive even in basic
@@ -2011,19 +1804,6 @@ const CORE_NATIVE_FAMILY_IDS: readonly string[] = [
   'code-write',
 ];
 
-/** T1 world-I/O substrate on the RUNTIME axis (RFC §3 · P2 상시화) —
- *  shell + interactive PTY execution that survives on EVERY surface,
- *  regardless of the surface's `defaultRuntimeFamilyIds`. Domain-
- *  independent: a coding agent must run what it builds on the research /
- *  control / ops surfaces too, not only the coding surfaces. The
- *  symmetric counterpart to `CORE_NATIVE_FAMILY_IDS`. Availability-gated
- *  (a surface that doesn't wire these runtimes just skips them). */
-const CORE_RUNTIME_FAMILY_IDS: readonly string[] = [
-  'bash',
-  'run-shell',
-  'pty-shell',
-];
-
 export function resolveDynamicSessionNativeToolSpecs(opts: {
   userText: string;
   toolAvailability?: Readonly<Record<string, boolean>>;
@@ -2263,13 +2043,6 @@ function toSpec(tool: LLMToolDef): LLMToolSpec {
   };
 }
 
-function mentionsTool(text: string, toolName: string): boolean {
-  const normalized = toolName.toLowerCase();
-  if (text.includes(normalized)) return true;
-  const humanized = normalized.replace(/[_]/g, ' ');
-  return humanized !== normalized && text.includes(humanized);
-}
-
 function hasAny(text: string, needles: readonly string[]): boolean {
   return needles.some(needle => text.includes(needle));
 }
@@ -2804,15 +2577,6 @@ function hasOpsUiIntent(text: string): boolean {
   return matchesIntentLexicon(text, OPS_UI_INTENT_TERMS);
 }
 
-function matchesSurfaceAwareFamilyIntent(
-  familyId: string,
-  text: string,
-  surfaceId?: SessionSurfaceId,
-): boolean {
-  if (!surfaceId) return false;
-  return SURFACE_AWARE_POLICIES[surfaceId]?.hostFamilyMatchers?.[familyId]?.(text) ?? false;
-}
-
 function matchesSurfaceAwareNativeIntent(
   familyId: string,
   text: string,
@@ -2822,15 +2586,6 @@ function matchesSurfaceAwareNativeIntent(
   return SURFACE_AWARE_POLICIES[surfaceId]?.nativeFamilyMatchers?.[familyId]?.(text) ?? false;
 }
 
-function matchesSurfaceAwareRuntimeIntent(
-  familyId: string,
-  text: string,
-  surfaceId?: SessionSurfaceId,
-): boolean {
-  if (!surfaceId) return false;
-  return SURFACE_AWARE_POLICIES[surfaceId]?.runtimeFamilyMatchers?.[familyId]?.(text) ?? false;
-}
-
 function isToolAvailable(
   name: string,
   overrides?: Readonly<Record<string, boolean>>,

package/src/session-runtime/parallel-dispatch.ts

@@ -93,31 +93,48 @@ export function partitionByParallelSafety<T extends { name: string }>(
  *
  *   When `safe.length < 2`, the helper degenerates into pure sequential
  *   dispatch in original order — no parallelism benefit for 0-1 safe
- *   calls so we keep behaviour identical to pre-P2. */
+ *   calls so we keep behaviour identical to pre-P2.
+ *
+ *   ⭐ `signal` (TUI-ESC-ABORT-TOOLS · 2026-10-15) — 턴 중단(Esc)이 걸리면 묶음 안
+ *   «남은» 호출을 새로 시작하지 않는다. 순차 갈래·unsafe 갈래에서 호출마다
+ *   `signal.aborted` 를 보고, 참이면 그 호출과 뒤의 호출을 부르지 않는다.
+ *   ⛔ 이미 시작한 호출은 끊지 않는다(진행 중 도구의 중단은 도구가 받는 신호의 몫).
+ *   ⛔ 병렬(safe) 묶음은 한꺼번에 시작되므로 시작 «전»에만 본다.
+ *   부르지 않은 호출의 결과 칸은 비어 있다 — 호출자가 «중단됨» 결과로 채워
+ *   공급자 이력의 tool_call/tool_result 짝을 지킨다(`skippedIndices`). */
 export async function dispatchWithParallelSafety<T extends { name: string }>(
   calls: readonly T[],
   dispatchOne: (call: T, index: number) => Promise<void>,
-): Promise<{ safeCount: number; unsafeCount: number; parallelActivated: boolean }> {
+  signal?: AbortSignal,
+): Promise<{ safeCount: number; unsafeCount: number; parallelActivated: boolean; skippedIndices: number[] }> {
   const { safe, unsafe } = partitionByParallelSafety(calls);
   const parallelActivated = safe.length >= 2;
+  const skippedIndices: number[] = [];
   if (!parallelActivated) {
     // Fall back to pure sequential in original order. Keeps pre-P2
     // behaviour bit-exact when only one read tool is in the batch
     // (common case — no benefit to firing Promise.all for a single
     // call).
     for (let i = 0; i < calls.length; i += 1) {
+      if (signal?.aborted) { skippedIndices.push(i); continue; }
       await dispatchOne(calls[i]!, i);
     }
-    return { safeCount: safe.length, unsafeCount: unsafe.length, parallelActivated };
+    return { safeCount: safe.length, unsafeCount: unsafe.length, parallelActivated, skippedIndices };
   }
   // Parallel kickoff for the safe group. Promise.all is safe here
   // because `dispatchOne` is expected to catch its own errors and
   // write an error result into the caller's storage — we never want
   // one failing Read to cancel two sibling Reads.
-  await Promise.all(safe.map(({ call, index }) => dispatchOne(call, index)));
+  if (signal?.aborted) {
+    for (const { index } of safe) skippedIndices.push(index);
+  } else {
+    await Promise.all(safe.map(({ call, index }) => dispatchOne(call, index)));
+  }
   // Unsafe group: sequential, in original order.
   for (const { call, index } of unsafe) {
+    if (signal?.aborted) { skippedIndices.push(index); continue; }
     await dispatchOne(call, index);
   }
-  return { safeCount: safe.length, unsafeCount: unsafe.length, parallelActivated };
+  skippedIndices.sort((a, b) => a - b);
+  return { safeCount: safe.length, unsafeCount: unsafe.length, parallelActivated, skippedIndices };
 }