elanous 0.2.41 → 0.2.43

package/src/self-implement/train-gate-remote.ts

@@ -3,8 +3,12 @@
  *  Unlike `dispatchHeavyCheck` it never falls back to a local run: a busy host or an infra failure is «unmeasured».
  *  The only local commands are git (cat-file · rev-parse · push · diff). */
 import { debug } from '../debug/log.js';
+import { spawnSync } from 'node:child_process';
 import { parseGateScenario, readGateScenarioFile } from './gate-scenario.js';
 import { getDefaultLogStore } from '../mss/logging/log-store.js';
+import { join } from 'node:path';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
+import { saveGateReceipt, type GateReceipt } from './gate-receipt-registry.js';
 import {
   gateRemoteHostCap, realGateRemoteRunner, resolveGateRemoteSettings, runOnRemote,
   type GateRemoteRunner, type GateRemoteSettings, type RemoteRunOutcome,
@@ -30,6 +34,51 @@ export interface TrainGateInput {
 
 export interface TrainGateResult { outcome: TrainGateOutcome; host: string; ms?: number; rc?: number; reason?: string }
 
+const GATE_RECEIPTS_MARKER = String.fromCharCode(10) + '__GATE_RECEIPTS__';
+
+function sharedGateReceiptPath(repo: string, runner: GateRemoteRunner): string | undefined {
+  try {
+    const result = runner.local('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], repo);
+    const commonDir = result.stdout.trim();
+    return result.rc === 0 && commonDir ? join(commonDir, 'elanous-host-regate', 'gate-receipts.json') : undefined;
+  } catch { return undefined; }
+}
+
+/** The exact persistent registry used by local train receipt merging. */
+export function gateReceiptRegistryPathForRepo(repo: string): string | undefined {
+  const result = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {
+    cwd: repo, encoding: 'utf8', timeout: 10_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER,
+  });
+  const commonDir = (result.stdout ?? '').trim();
+  return result.status === 0 && commonDir ? join(commonDir, 'elanous-host-regate', 'gate-receipts.json') : undefined;
+}
+
+/** Merge the existing remote-writer marker into the local common-dir registry. Invalid rows fail closed. */
+export function mergeGateReceiptRegistryPayload(payload: string, path: string): number {
+  let saved = 0;
+  try {
+    const rows = JSON.parse(Buffer.from(payload, 'base64').toString('utf8')) as Record<string, unknown>;
+    for (const [key, value] of Object.entries(rows)) {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) continue;
+      const receipt = value as GateReceipt;
+      if (receipt.key !== key) continue;
+      try { saveGateReceipt(path, receipt); saved++; }
+      catch { /* Invalid remote records are discarded; local gates remain fail-open. */ }
+    }
+  } catch { /* A malformed response never changes the measured gate verdict. */ }
+  return saved;
+}
+
+function mergeReturnedReceipts(outcome: RemoteRunOutcome, path: string | undefined): RemoteRunOutcome {
+  if (outcome.kind !== 'ran' || outcome.rc !== 0 || !path) return outcome;
+  const stdout = outcome.stdout.toString('utf8');
+  const marker = stdout.lastIndexOf(GATE_RECEIPTS_MARKER);
+  if (marker < 0) return outcome;
+  const payload = stdout.slice(marker + GATE_RECEIPTS_MARKER.length).trim();
+  mergeGateReceiptRegistryPayload(payload, path);
+  return { ...outcome, stdout: Buffer.from(stdout.slice(0, marker)) };
+}
+
 export interface TrainGateObservation {
   host: string; commit: string; baseSha: string; outcome: TrainGateOutcome;
   rc?: number; ms?: number; reason?: string; changedFiles: number;
@@ -42,22 +91,6 @@ export interface TrainGateDeps {
   observe?: (entry: TrainGateObservation) => void;
 }
 
-const quote = (value: string) => `'${value.replaceAll("'", `'\\''`)}'`;
-const TEST_FILE = /\.test\.[cm]?[jt]sx?$/;
-
-/** The host-side shell body: each step runs only if the one before it passed. Exported for tests. */
-export function trainGateScript(baseSha: string, changedFiles: readonly string[], deleted: ReadonlySet<string> = new Set(), scenarioTests: readonly string[] = []): string {
-  // A deleted test file is a changed path (tsc/PWA reach) but not something to run.
-  const changedTests = changedFiles.filter((file) => TEST_FILE.test(file) && !deleted.has(file));
-  const tests = scenarioTests.length ? [...new Set([...changedTests, ...scenarioTests])] : changedTests;
-  const steps = [
-    `TSC_BASE_REF=${quote(baseSha)} bun scripts/ci-typecheck-changed.ts --local`,
-    ...(tests.length ? [`bun run test:deterministic ${tests.map(quote).join(' ')}`] : []),
-    `bun scripts/ci-pwa-build-gate.ts --changed-files ${changedFiles.map(quote).join(' ')}`,
-  ];
-  return steps.join(' && ');
-}
-
 async function loadSettings(): Promise<GateRemoteSettings> {
   try {
     const { getUserConfig } = await import('../user-config.js');
@@ -76,6 +109,10 @@ export const TRAIN_GATE_HOST = 'node-b';
 
 export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemoteRunner = realGateRemoteRunner, deps: TrainGateDeps = {}): Promise<TrainGateResult> {
   const settings = input.settings ?? await loadSettings();
+  const receiptPath = sharedGateReceiptPath(input.repo, runner);
+  // Each remote full gate writes into a fresh scratch registry; returned rows merge into the local shared registry.
+  // No existing registry contents are needed for receipt registration.
+  const payloadFiles = receiptPath ? [{ env: 'ELANOUS_GATE_RECEIPT_REGISTRY_PATH', content: '{}' }] : undefined;
   const host = settings.host;
   const hostCap = gateRemoteHostCap(settings, host);
   let scenarioTests: string[] = [];
@@ -110,14 +147,21 @@ export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemo
   const sleep = deps.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
   const now = deps.now ?? Date.now;
   const deadline = now() + settings.slotWaitSeconds * 1000;
-  const script = trainGateScript(input.baseSha, input.changedFiles, new Set(input.deletedFiles ?? []), scenarioTests);
   let outcome: RemoteRunOutcome;
   for (;;) {
     try {
       outcome = runOnRemote({
         repo: input.repo, host, mirror: settings.mirror, commit: input.commit, refs: [input.baseSha],
-        argv: ['sh', '-c', script], installPwa: true, hostCap,
+        argv: ['bun', 'src/self-implement/train-gate-receipt.ts', JSON.stringify({
+          repo: input.repo,
+          commit: input.commit,
+          baseSha: input.baseSha,
+          changedFiles: input.changedFiles,
+          deletedFiles: input.deletedFiles ?? [],
+          scenarioTests,
+        })], installPwa: true, hostCap, ...(payloadFiles ? { payloadFiles } : {}),
       }, runner);
+      outcome = mergeReturnedReceipts(outcome, receiptPath);
     } catch (error) {
       outcome = { kind: 'infra', reason: `exception: ${error instanceof Error ? error.message : String(error)}` };
     }

package/src/session/chat.ts

@@ -42,9 +42,15 @@ import {
 // ⭐ substrate 통합(PLAN-unified-autonomous-agent-substrate-2026-07-20) — goal-loop 아밍 시
 // chat 툴루프를 canonical 엔진(runGoalLoop→runCoreTurn→streamLLMWithTools)으로 라우팅.
 // ACP bridge(core-turn-bridge.ts)·dashboard(runGoalLoopHook)와 동일 엔진 재사용(재발명 제거).
-import { runGoalLoop, type CoreTurnContext, type CoreTurnDispatchTool } from '../core-turn/index.js';
+import { runCoreTurn, runGoalLoop, type CoreTurnContext, type CoreTurnDispatchTool } from '../core-turn/index.js';
 import { composeChildContext, type ChildContextProfile } from '../self-implement/child-context-composition.js';
 import { getHarnessSpace } from '../harness/harness-space.js';
+import { isResearchAgentIntent } from '../tool-hints/signals.js';
+import {
+  buildSessionRuntimeTurnSystemMessages,
+  createSessionPostureState,
+  resolveSessionTurnProfileWithHistory,
+} from '../session-runtime/index.js';
 
 export interface RunTurnOpts {
   userConfig: UserConfig;
@@ -59,6 +65,8 @@ export interface RunTurnOpts {
   /** Optional callback for each streamed text delta — telegram uses this to
    *  accumulate; CLI uses it to render live. */
   onDelta?: (delta: string) => void;
+  /** Replace a provisional streamed answer after a grounded TUI synthesis completes. */
+  onReplaceText?: (fullText: string) => void;
   /** Optional transient stream recovery status for the originating UI. */
   onStatusLine?: (line: string) => void;
   /** Optional provider override — for tests. */
@@ -294,6 +302,24 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
   // just skip and continue.
   let memoryIds: string[] = [];
   let effectiveSystemPrompt = opts.systemPrompt;
+  // The Next TUI runs through this shared session adapter rather than the classic dashboard
+  // preamble. Give research turns the same verified-reconciliation instruction on this path.
+  if (meta.source === 'tui' && !effectiveSystemPrompt?.includes('## Proactive Reconciliation')) {
+    const priorUserTexts = messages
+      .filter(message => message.role === 'user' && typeof message.content === 'string')
+      .map(message => String(message.content));
+    const turnProfile = resolveSessionTurnProfileWithHistory({
+      userText: opts.userText,
+      priorUserTexts,
+      chatModeState: createSessionPostureState(),
+    });
+    const reconciliation = buildSessionRuntimeTurnSystemMessages(turnProfile, opts.userText)
+      .filter(message => String(message.content).includes('## Proactive Reconciliation'));
+    if (reconciliation.length > 0) {
+      const block = reconciliation.map(message => String(message.content)).join('\n\n');
+      effectiveSystemPrompt = effectiveSystemPrompt ? `${effectiveSystemPrompt}\n\n${block}` : block;
+    }
+  }
   if (!opts.skipMemoryInjection) {
     try {
       // LLM-judge recall(2026-07-19 · 기본 ON·대표 지시) — 키워드 대신 luna 의미판정으로 관련
@@ -485,7 +511,9 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     // streamLLMWithTools)으로 라우팅. 미아밍이면 아래 기존 single-turn 경로 그대로(회귀 0).
     const goalLoopCfg = opts.userConfig.llm.goalLoop;
     const armGoalLoop = opts.goalLoop === true || goalLoopCfg?.enabled === true;
-    if (armGoalLoop) {
+    const armResearchTurn = (opts.utteranceSurface === 'tui' || opts.utteranceSurface === 'ask')
+      && turnTools.length > 0 && isResearchAgentIntent(opts.userText);
+    if (armGoalLoop || armResearchTurn) {
       // ⭐ CHILD-CONTEXT-BUDGET(0.2.35 칸) — 구현 자식(self-implement 공간)의 첫 goal-loop
       //    턴에서 실제 effectiveSystemPrompt·turnTools 스키마·userText(골)의 구성 바이트를
       //    composeChildContext 로 계측해 child.context-composition 사건 1회로 남긴다.
@@ -520,6 +548,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
         signal: opts.signal ?? new AbortController().signal,
         callbacks: {
           onText: (delta) => { opts.onDelta?.(delta); },
+          onReplaceText: (fullText) => { opts.onReplaceText?.(fullText); },
           onGoalInterim: (interimText) => {
             appendMessage(opts.sessionId, {
               role: 'assistant', content: interimText, ts: new Date().toISOString(),
@@ -535,13 +564,20 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
           },
         },
         ...(turnLlmOpts?.model ? { modelOverride: turnLlmOpts.model } : {}),
+        ...(turnLlmOpts?.reasoningEffort ? { reasoningEffort: turnLlmOpts.reasoningEffort } : {}),
         ...(turnLlmOpts?.budgetGrant ? { budgetGrant: turnLlmOpts.budgetGrant } : {}),
         ...(guardedTurnLlmOpts?.requestSizeGuard
           ? { requestSizeGuard: guardedTurnLlmOpts.requestSizeGuard } : {}),
       };
       const maxIterations = opts.goalLoopMaxIterations ?? goalLoopCfg?.maxIterations;
-      const gl = await runGoalLoop(coreCtx, maxIterations !== undefined ? { maxIterations } : {});
-      text = gl.finalText;
+      if (armGoalLoop) {
+        const gl = await runGoalLoop(coreCtx, maxIterations !== undefined ? { maxIterations } : {});
+        text = gl.finalText;
+      } else {
+        const coreResult = await runCoreTurn(coreCtx);
+        text = coreResult.finalText;
+        if (coreResult.stopReason === 'auth_rejected') throw new Error(coreResult.errorMessage ?? 'Authentication was rejected');
+      }
     } else {
     text = await streamLLMWithTools(
       kept,

package/src/session/session-fanout.ts

@@ -224,6 +224,8 @@ export interface SessionChunkEvent {
   seq: number;
   /** 텍스트 델타(누적은 sink 의 라이브핸들이). */
   delta?: string;
+  /** Replace the current assistant text accumulated for this stream. */
+  textOperation?: 'replace';
   /** 툴 활동(⚙️…✓ inline 렌더용). */
   tool?: { id: string; name: string; phase: 'call' | 'result'; ok?: boolean };
   /** 🧠 추론(모드 gated·선택). */

package/src/session/streaming/acp-stream-sink.ts

@@ -36,7 +36,8 @@ export function createAcpStreamSink(broadcast: AcpBroadcast): StreamingSurfaceSi
       if (!sessionId) return;
       if (ev.delta) {
         // push(chunk) 등가 — agent_message_chunk(byte-identical).
-        void broadcast(sessionId, { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: ev.delta } });
+        void broadcast(sessionId, { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: ev.delta },
+          ...(ev.textOperation === 'replace' ? { _meta: { elanous: { textOperation: 'replace' } } } : {}) });
       }
       if (ev.reasoning) {
         // 🧠 추론 — agent_thought_chunk(ACP 의 thought 채널).

package/src/session/streaming/chunk-producer.ts

@@ -20,6 +20,7 @@ import { debug } from '../../debug/log.js';
  *  shadow 시엔 'acp' 구독자 부재 → tg/dc/pwa 미러만. reasoning 채널 추가 지원. */
 export interface AcpChunkProducer {
   delta: (text: string) => void;
+  replaceText: (text: string) => void;
   /** ⭐ `result` 는 «결과 단계»에서만 뜻이 있고, 주면 ACP `rawOutput` 으로 실려 나간다.
    *
    *  ⛔⭐⭐ **「안 줬다」의 «사유»를 여기서 만들지 않는다.**
@@ -53,6 +54,11 @@ export function makeAcpChunkProducer(sessionId: string, opts: { streamId?: strin
       fo({ streamId, seq: seq++, delta: text });
       deltas++;
     },
+    replaceText(text: string): void {
+      accum = text;
+      fo({ streamId, seq: seq++, delta: text, textOperation: 'replace' });
+      deltas++;
+    },
     tool(id, name, phase, ok, result): void {
       fo({ streamId, seq: seq++, tool: {
         id, name, phase,

package/src/session/streaming/stream-compositor.ts

@@ -46,9 +46,10 @@ export function createCompositorState(): CompositorState {
 /** 청크 이벤트를 상태에 반영(순수·in-place). delta/reasoning/tool 을 흡수. */
 export function applyChunk(
   state: CompositorState,
-  ev: { delta?: string; reasoning?: string; tool?: { id: string; name: string; phase: 'call' | 'result'; ok?: boolean } },
+  ev: { delta?: string; textOperation?: 'replace'; reasoning?: string; tool?: { id: string; name: string; phase: 'call' | 'result'; ok?: boolean } },
 ): void {
-  if (ev.delta) state.text += ev.delta;
+  if (ev.textOperation === 'replace') state.text = ev.delta ?? '';
+  else if (ev.delta) state.text += ev.delta;
   if (ev.reasoning) state.reasoning = ev.reasoning; // keep-latest(추론은 누적 아닌 최신 요약)
   if (ev.tool) {
     if (ev.tool.phase === 'call') {

package/src/session-runtime/index.ts

@@ -26,7 +26,7 @@ import type { ToolRunResult, ToolRuntime } from '../tool-runtime/types.js';
 import { blockWriteToolSearchHydration, type ToolSearchRunResult } from '../tool-runtime/tool-search-runtime.js';
 import { findNativeTool, isNativeToolModelExposed } from '../native-tool-catalog.js';
 import { hasAstGrep } from '../skills/tools/ast-grep.js';
-import { buildOmniSearchTool, omniSearchAvailable } from '../skills/tools/omni-search.js';
+import { buildOmniSearchTool, researchOmniSearchAvailable } from '../skills/tools/omni-search.js';
 import { buildWebSearchTool } from '../skills/tools/web-search.js';
 import { buildWebFetchTool } from '../skills/tools/webfetch.js';
 import { buildSelfImplementDaemonSpec } from '../boot/daemon-tools/self-implement.js';
@@ -170,6 +170,8 @@ export interface SessionPostureSnapshot {
 }
 
 export interface SessionRuntimeDispatchDeps {
+  /** Current conversation session; used to scope background Agent receipts. */
+  sessionId?: string;
   signal?: AbortSignal;
   /** Current LLM tool call, for correlating a foreground harness stop target with the TUI call. */
   toolCallId?: string;
@@ -183,6 +185,7 @@ export interface SessionRuntimeDispatchDeps {
     dispatch: (name: string, args: Record<string, unknown>) => Promise<unknown>;
     workingDirectory: string;
   };
+  inheritGeneralPurposeToolCatalog?: boolean;
   searchPlannerState?: SearchPlannerState;
   /** CC (2026-04-25) — forwarded from the LLM router's dispatch ctx
    *  (`turnIndex`). Lets the planner allow same-turn parallel fan-out
@@ -429,6 +432,7 @@ interface SessionNativeToolRule {
     signal?: AbortSignal,
     opts?: {
       pathPolicy?: PathPolicy;
+      sessionId?: string;
       agentHostTools?: LLMToolSpec[];
       agentDispatchTool?: (name: string, args: Record<string, unknown>) => Promise<unknown>;
       buildChildToolCatalog?: (cwd: string) => {
@@ -436,6 +440,7 @@ interface SessionNativeToolRule {
         dispatch: (name: string, args: Record<string, unknown>) => Promise<unknown>;
         workingDirectory: string;
       };
+      inheritGeneralPurposeToolCatalog?: boolean;
     },
   ): Promise<unknown>;
   /** ⛔ Opt-IN to the ToolRuntime registry path instead of `dispatch` above.
@@ -512,10 +517,12 @@ const SESSION_NATIVE_TOOL_RULES: SessionNativeToolRule[] = [
     build: () => buildAgentTool(),
     match: () => false,
     dispatch: async (args, signal, opts) => await dispatchAgent(args, {
+      parentSessionId: opts?.sessionId,
       signal,
       hostTools: opts?.agentHostTools,
       dispatchTool: opts?.agentDispatchTool,
       buildChildToolCatalog: opts?.buildChildToolCatalog,
+      inheritGeneralPurposeToolCatalog: opts?.inheritGeneralPurposeToolCatalog,
     }),
     preferRuntime: true,
   },
@@ -587,10 +594,10 @@ const SESSION_NATIVE_TOOL_RULES: SessionNativeToolRule[] = [
     description: 'Multi-source research and triangulation across external signals.',
     build: () => buildOmniSearchTool(),
     match: (text) => hasResearchSearchIntent(text),
-    isAvailable: () => omniSearchAvailable(),
+    isAvailable: () => researchOmniSearchAvailable(),
     dispatch: async (args) => {
-      const { dispatchOmniSearch } = await import('../skills/tools/omni-search.js');
-      return await dispatchOmniSearch(args);
+      const { dispatchResearchOmniSearch } = await import('../skills/tools/omni-search.js');
+      return await dispatchResearchOmniSearch(args);
     },
   },
   {
@@ -839,7 +846,7 @@ const SESSION_SURFACE_PROFILES: Record<SessionSurfaceId, Omit<SessionSurfaceProf
     baselineContexts: ['external-world-guidance'],
     defaultHostFamilyIds: ['self-ops'],
     defaultRuntimeFamilyIds: [],
-    defaultNativeFamilyIds: ['web-search'],
+    defaultNativeFamilyIds: ['web-search', 'deep-research', 'web-fetch'],
   },
   'control/agent': {
     id: 'control/agent',
@@ -969,9 +976,47 @@ export function buildSessionRuntimeTurnSystemMessages(
   if (scopedGuidance) {
     messages.push({ role: 'system', content: scopedGuidance });
   }
+  const reconcileGuidance = buildProactiveReconcileGuidance(userText);
+  if (turnProfile.surface.domain === 'research') {
+    if (reconcileGuidance) {
+      messages.push({ role: 'system', content: PROACTIVE_RECONCILIATION_GUIDANCE.join('\n') });
+    }
+  } else if (reconcileGuidance) {
+    messages.push({ role: 'system', content: reconcileGuidance });
+  }
   return messages;
 }
 
+/** A challenged tool/source claim is a request to repair the answer, not just
+ *  to narrate whether the earlier answer was grounded. Keep this guidance
+ *  scoped to explicit evidence challenges so ordinary turns stay unchanged. */
+function buildProactiveReconcileGuidance(userText?: string): string | null {
+  const text = String(userText ?? '').toLowerCase();
+  if (!text.trim()) return null;
+
+  const explicitChallenge = [
+    /\b(?:did you|have you|were you)\b.{0,80}\b(?:actually|really|use|used|run|check|verify|consult|cite)\b/,
+    /\b(?:you (?:did not|didn't|never)\s+(?:use|run|check|verify|consult))\b/,
+    /\b(?:verify|check|recheck|re-check|confirm)\b.{0,80}\b(?:previous|prior|original|earlier)\b/,
+    /\b(?:earlier|previous|prior|last)\b.{0,40}\b(?:skill|tool|source|evidence)\b.{0,40}\b(?:used|ran|checked|verified|cited)\b.{0,30}\b(?:actually|really|right|correct)\b/,
+    /(?:앞서|이전|직전|기존|그때).{0,40}(?:스킬|도구|툴).{0,40}(?:쓴|사용한|실행한).{0,30}(?:맞|했나|했는지)/,
+    /(?:스킬|도구|툴).{0,40}(?:제대로|실제로).{0,40}(?:찾았는지|찾았나|사용했는지|사용했나|썼는지|썼나)/,
+    /(?:라고\s*(?:했는데|했음에도|말했는데)|이야기했음에도).{0,80}(?:확인|결말|결론|답).{0,40}(?:조정|수정|바꾸|고치)/,
+    /(?:스킬|도구|근거|출처).{0,60}(?:실제로\s*사용|제대로\s*사용|확인했나|썼나|쓴\s*게\s*맞|안\s*썼|못\s*찾|재확인)/,
+  ];
+  if (!explicitChallenge.some(pattern => pattern.test(text))) return null;
+
+  return [
+    '## Proactive Reconciliation — Tool-use Correction — Reconcile the Original Request This Turn',
+    '',
+    'The user is challenging whether the prior answer used the requested tool, skill, source, or evidence.',
+    'Treat the original task as still open. Recover it and the prior conclusion from the conversation, then verify the challenged claim with an available capability.',
+    'If verification changes or invalidates the prior conclusion, shows the original task was not completed, or finds that evidence is missing, incomplete, or insufficient, continue the original task in this same user turn with verified available tools and give a corrected, evidence-grounded result.',
+    'If the requested capability is unavailable, say so plainly and continue the original task with another suitable available source when possible. Never claim a tool or skill ran when it did not.',
+    'Do not stop at an apology or verification-only report, do not ask the user to repeat the task, and do not emit a raw JSON dump unless explicitly requested. Answer in concise prose.',
+  ].join('\n');
+}
+
 function buildTurnScopedExplorationGuidance(userText?: string): string | null {
   if (isScopedAnalysisRequest(userText)) {
     return [
@@ -1239,6 +1284,7 @@ function buildSurfaceOperationalGuidance(surface: SessionSurfaceProfile): string
         'Bias toward multi-source external investigation: use WebSearch, WebFetch, and OmniSearch before concluding.',
         'WebSearch is provider-backed and may route through Grok live-search or Firecrawl; OmniSearch is the wider parallel path when you want triangulation across providers.',
         'Prefer cited, current, cross-checked findings over repo-local assumptions when the question reaches beyond the workspace.',
+        '',
       ].join('\n');
     case 'research/turn':
       return [
@@ -1247,6 +1293,7 @@ function buildSurfaceOperationalGuidance(surface: SessionSurfaceProfile): string
         'You are in `research/turn`.',
         'Handle the current turn as a lightweight external lookup. Prefer quick verification and concise sourced answers over deep autonomous exploration.',
         'Keep WebSearch ready by default. It is provider-backed and may use Grok live-search or Firecrawl; use WebFetch for full page bodies and OmniSearch when the user asks for deeper cross-provider research.',
+        '',
       ].join('\n');
     case 'control/agent':
       return [
@@ -1275,6 +1322,13 @@ function buildSurfaceOperationalGuidance(surface: SessionSurfaceProfile): string
   }
 }
 
+const PROACTIVE_RECONCILIATION_GUIDANCE = [
+  '## Proactive Reconciliation — Tool-use Correction — Reconcile the Original Request This Turn',
+  'When the user asks you to verify how an earlier answer was produced (tools, skills, or sources), check the actual results and compare them with the earlier conclusion.',
+  'Treat the original task as still open. If verification changes or invalidates that conclusion, shows the original task was not completed, or finds that the evidence is missing, incomplete, or insufficient to support the conclusion, treat it as unreliable and continue in this same user turn: redo the original task with verified available tools and answer the original task with the corrected, evidence-grounded result in ordinary prose.',
+  'Do not stop at an apology or verification-only report, do not ask the user to repeat the task, and do not emit a raw JSON dump unless explicitly requested. Answer in concise prose.',
+];
+
 export function createSessionPostureState(): SessionPostureState {
   return createChatModeState();
 }
@@ -1560,6 +1614,40 @@ export function resolveSessionTurnProfile(opts: {
   };
 }
 
+function isProactiveReconciliationFollowUp(userText: string): boolean {
+  const referencesPrior = /(?:earlier|previous|prior|last|앞선|앞서|이전|직전|기존|그때|라고\s*(?:했|말)|이야기했|요청했)/i.test(userText);
+  const referencesEvidence = /(?:answer|response|analysis|conclusion|tool|skill|source|evidence|답|응답|분석|결론|도구|툴|스킬|출처|근거)/i.test(userText);
+  const asksToVerify = /(?:verify|recheck|check|confirm|validate|challenge|correct|used|맞|확인|검증|재확인|사용|사실|실제)/i.test(userText);
+  return referencesPrior && referencesEvidence && asksToVerify;
+}
+
+/** Preserve an active research turn's surface when the user challenges its prior evidence. */
+export function resolveSessionTurnProfileWithHistory(opts: {
+  userText: string;
+  priorUserTexts?: readonly string[];
+  chatModeState: ChatModeState;
+  inputSource?: InputSourceRef | null;
+}): SessionTurnProfile {
+  const current = resolveSessionTurnProfile(opts);
+  if (current.surface.domain === 'research' || !isProactiveReconciliationFollowUp(opts.userText)) return current;
+  for (const priorUserText of [...(opts.priorUserTexts ?? [])].reverse()) {
+    const prior = resolveSessionTurnProfile({
+      userText: priorUserText,
+      chatModeState: opts.chatModeState,
+      inputSource: opts.inputSource,
+    });
+    if (prior.surface.domain === 'research') {
+      return resolveSessionTurnProfile({
+        userText: opts.userText,
+        chatModeState: opts.chatModeState,
+        preferredSurfaceId: prior.surface.id,
+        inputSource: opts.inputSource,
+      });
+    }
+  }
+  return current;
+}
+
 export function resolveSessionSurfaceStatus(opts: {
   userText?: string;
   chatModeState: ChatModeState;
@@ -1726,6 +1814,38 @@ function buildEssentialSessionRuntimeToolSpecs(opts: {
   return [...nativeSpecs, ...hostSpecs, ...runtimeSpecs, ...mcpProxySpecs, ...optionalSpecs];
 }
 
+/** Build the full TUI-visible catalog for Agent children. The parent model's
+ *  turn catalog is intentionally surface/tier narrowed; children inherit the
+ *  available TUI catalog instead, while `dispatchSessionRuntimeTool` remains
+ *  the policy boundary and `dispatchAgent` still strips recursive Agent. */
+export function buildSubagentSessionRuntimeToolSpecs(opts: {
+  hostTools: readonly LLMToolDef[];
+  runtimeTools: readonly ToolRuntime<Record<string, unknown>, ToolRunResult>[];
+  optionalTools: readonly LLMToolSpec[];
+  toolAvailability?: Readonly<Record<string, boolean>>;
+}): LLMToolSpec[] {
+  const nativeSpecs = SESSION_NATIVE_TOOL_RULES.flatMap(rule => {
+    const spec = rule.build();
+    const catalogEntry = findNativeTool(spec.name);
+    return (!catalogEntry || isNativeToolModelExposed(catalogEntry))
+      && isNativeToolAvailable(spec.name, rule, opts.toolAvailability)
+      ? [spec]
+      : [];
+  });
+  const hostSpecs = opts.hostTools
+    .filter(tool => isToolAvailable(tool.name, opts.toolAvailability))
+    .map(toSpec);
+  const runtimeSpecs = opts.runtimeTools
+    .filter(tool => isToolAvailable(tool.spec.name, opts.toolAvailability))
+    .map(tool => tool.spec);
+  const optionalSpecs = opts.optionalTools
+    .filter(tool => isToolAvailable(tool.name, opts.toolAvailability));
+  return [...new Map(
+    [...nativeSpecs, ...hostSpecs, ...runtimeSpecs, ...optionalSpecs]
+      .map(spec => [spec.name, spec] as const),
+  ).values()];
+}
+
 export function buildSessionRuntimeToolSpecs(opts: {
   userText: string;
   hostTools: readonly LLMToolDef[];
@@ -1736,6 +1856,7 @@ export function buildSessionRuntimeToolSpecs(opts: {
   preferredSurfaceId?: SessionSurfaceId;
   controlMode?: boolean;
 }): LLMToolSpec[] {
+  const catalogStartedAt = performance.now();
   // 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.
@@ -1799,6 +1920,13 @@ export function buildSessionRuntimeToolSpecs(opts: {
       userTextChars: opts.userText.length,
     });
   }
+  try {
+    debug.log('session-runtime.latency', 'tool-catalog-ready', {
+      elapsedMs: Math.round((performance.now() - catalogStartedAt) * 10) / 10,
+      toolCount: finalSpecs.length,
+      surfaceId: surface.id,
+    });
+  } catch { /* observation must never delay a turn */ }
   return finalSpecs;
 }
 
@@ -2025,9 +2153,11 @@ export async function dispatchSessionRuntimeTool(
       }
       result = await nativeRule.dispatch(normalizedArgs, deps.signal, {
         pathPolicy: deps.pathPolicy,
+        sessionId: deps.sessionId,
         agentHostTools: deps.agentHostTools,
         agentDispatchTool: deps.agentDispatchTool,
         buildChildToolCatalog: deps.buildChildToolCatalog,
+        inheritGeneralPurposeToolCatalog: deps.inheritGeneralPurposeToolCatalog,
       });
     }
     rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);

package/src/session-runtime/retry-policy.ts

@@ -226,7 +226,7 @@ export function providerNamesFromFallbackChain(chain: readonly string[]): string
   const seen = new Set<string>();
   for (const step of chain) {
     // `codex-credits`(체인 마지막 칸 · 크레딧)도 provider 는 openai-codex 다 — 이미 앞에 있으면 중복이라 빠진다.
-    const name = step === 'grok' ? 'grok' : step === 'zai' ? 'glm'
+    const name = step === 'grok' ? 'grok' : step === 'zai' ? 'glm' : step === 'openrouter' ? 'openrouter'
       : step === 'codex-rotate' || step === 'codex-credits' ? 'openai-codex' : undefined;
     if (!name || seen.has(name)) continue;
     seen.add(name);

package/src/session-runtime/tier-flip.ts

@@ -325,7 +325,7 @@ function joinWithBlankLine(prefix: string, block: string): string {
 
 function appendTextToMessage(msg: LLMMessage, block: string): LLMMessage {
   if (typeof msg.content === 'string') {
-    return { role: msg.role, content: joinWithBlankLine(msg.content, block) };
+    return { ...msg, content: joinWithBlankLine(msg.content, block) };
   }
   // ContentBlock[] — append to the LAST text block; if none exists,
   // push a fresh one. Other block kinds (image / tool_use / tool_result)
@@ -336,11 +336,11 @@ function appendTextToMessage(msg: LLMMessage, block: string): LLMMessage {
     if (b.type === 'text') {
       const text = (b as { text?: string }).text ?? '';
       blocks[i] = { ...b, text: joinWithBlankLine(text, block) };
-      return { role: msg.role, content: blocks };
+      return { ...msg, content: blocks };
     }
   }
   blocks.push({ type: 'text', text: block } as ContentBlock);
-  return { role: msg.role, content: blocks };
+  return { ...msg, content: blocks };
 }
 
 /** Wave 2 W2.4 + W2.5 convenience — split specs AND inject the

package/src/setup/llm-env-detect.ts

@@ -168,6 +168,9 @@ export const AUXILIARY_AI_ENV_VARS: readonly AuxiliaryAiEnvVar[] = [
   { name: 'UPSTAGE_API_KEY',    usedBy: 'document parse' },
 ] as const;
 
+export { SERVICE_KEY_CATALOG, renderServiceKeyCatalogMarkdown } from './service-key-catalog.js';
+export type { ServiceKeyCatalogEntry } from './service-key-catalog.js';
+
 export function summarizeAuxiliaryAiEnv(
   env: NodeJS.ProcessEnv = process.env,
 ): AuxiliaryAiEnvVar[] {

package/src/setup/service-key-catalog.ts

@@ -0,0 +1,46 @@
+/** Service setup metadata shared by the CLI, runtime key loader, and manual. */
+export interface ServiceKeyCatalogEntry {
+  id: string;
+  label: string;
+  kind: 'api-key' | 'subscription' | 'oauth' | 'cli' | 'local';
+  envNames: readonly string[];
+  setupUrl: string;
+  usedBy: string;
+  cost: 'account-plan' | 'usage-based' | 'plan-dependent' | 'local';
+  verification: string;
+  demoRequired: boolean;
+}
+
+export const SERVICE_KEY_CATALOG: readonly ServiceKeyCatalogEntry[] = [
+  { id: 'codex', label: 'OpenAI Codex', kind: 'subscription', envNames: [], setupUrl: 'https://platform.openai.com/docs/codex/auth', usedBy: '씬 1 리서치 · 사이드탭 미션', cost: 'account-plan', verification: 'elanous auth status', demoRequired: true },
+  { id: 'claude-code', label: 'Claude Code', kind: 'subscription', envNames: [], setupUrl: 'https://docs.anthropic.com/en/docs/claude-code/overview', usedBy: '씬 1 비교 · 사이드탭 미션', cost: 'account-plan', verification: 'claude auth status', demoRequired: true },
+  { id: 'exa', label: 'Exa', kind: 'api-key', envNames: ['EXA_API_KEY'], setupUrl: 'https://dashboard.exa.ai/api-keys', usedBy: '씬 1 리서치 · 씬 2 흡수', cost: 'usage-based', verification: 'POST /search · 상태 코드만', demoRequired: true },
+  { id: 'firecrawl', label: 'Firecrawl', kind: 'api-key', envNames: ['FIRECRAWL_API_KEY'], setupUrl: 'https://www.firecrawl.dev/app/api-keys', usedBy: '씬 2 흡수', cost: 'usage-based', verification: 'POST /v2/scrape · 상태 코드만', demoRequired: true },
+  { id: 'xai', label: 'xAI / Grok API', kind: 'api-key', envNames: ['XAI_API_KEY', 'GROK_API_KEY'], setupUrl: 'https://console.x.ai/', usedBy: '씬 2 흡수 · Grok API', cost: 'usage-based', verification: 'GET /v1/models · 상태 코드만', demoRequired: true },
+  { id: 'tavily', label: 'Tavily', kind: 'api-key', envNames: ['TAVILY_API_KEY', 'TAVILY_KEY'], setupUrl: 'https://app.tavily.com/home', usedBy: '웹 검색 대체 경로', cost: 'usage-based', verification: 'POST /search · 상태 코드만', demoRequired: false },
+  { id: 'openrouter', label: 'OpenRouter · GLM', kind: 'api-key', envNames: ['OPENROUTER_API_KEY'], setupUrl: 'https://openrouter.ai/keys', usedBy: 'GLM · OpenRouter 모델', cost: 'usage-based', verification: 'GET /api/v1/key · 상태 코드만', demoRequired: true },
+  { id: 'linear', label: 'Linear API', kind: 'api-key', envNames: ['LINEAR_API_KEY'], setupUrl: 'https://linear.app/settings/api', usedBy: '씬 2 능동 비서', cost: 'plan-dependent', verification: 'GraphQL viewer · 상태 코드만', demoRequired: true },
+  { id: 'telegram', label: 'Telegram bot', kind: 'api-key', envNames: ['ELANOUS_TELEGRAM_BOT_TOKEN'], setupUrl: 'https://t.me/BotFather', usedBy: '씬 2 · 씬 3 채널', cost: 'local', verification: 'getMe · 상태 코드만', demoRequired: true },
+  { id: 'telegram-chat', label: 'Telegram chat ID', kind: 'api-key', envNames: ['ELANOUS_TELEGRAM_CHAT_ID'], setupUrl: 'https://core.telegram.org/bots/features#botfather', usedBy: '데모 알림 대상', cost: 'local', verification: 'getChat · 상태 코드만 · 미발송', demoRequired: true },
+  { id: 'google-workspace', label: 'Google Workspace', kind: 'oauth', envNames: [], setupUrl: 'https://developers.google.com/workspace/guides/get-started', usedBy: 'Gmail · Drive 커넥터', cost: 'account-plan', verification: '로그인 상태 확인 · 토큰 미표시', demoRequired: false },
+  { id: 'aside', label: 'Aside browser', kind: 'cli', envNames: [], setupUrl: 'https://github.com/elanous-ai/aside', usedBy: '브라우저 자동화', cost: 'plan-dependent', verification: 'aside status', demoRequired: true },
+  { id: 'github', label: 'GitHub CLI', kind: 'cli', envNames: [], setupUrl: 'https://cli.github.com/', usedBy: '공개 저장소 · 개발 플러그인', cost: 'local', verification: 'gh auth status', demoRequired: true },
+  { id: 'video-render', label: 'Video render', kind: 'local', envNames: [], setupUrl: 'https://ffmpeg.org/download.html', usedBy: '데모 하이라이트 렌더', cost: 'local', verification: 'ffmpeg -version', demoRequired: false },
+  { id: 'openai-api', label: 'OpenAI API', kind: 'api-key', envNames: ['OPENAI_API_KEY'], setupUrl: 'https://platform.openai.com/api-keys', usedBy: 'OpenAI 모델 · Codex API-key 경로', cost: 'usage-based', verification: 'GET /v1/models · 상태 코드만', demoRequired: false },
+  { id: 'anthropic-api', label: 'Anthropic API', kind: 'api-key', envNames: ['ANTHROPIC_API_KEY'], setupUrl: 'https://console.anthropic.com/settings/keys', usedBy: 'Claude API', cost: 'usage-based', verification: 'GET /v1/models · 상태 코드만', demoRequired: false },
+  { id: 'gemini-api', label: 'Google Gemini API', kind: 'api-key', envNames: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'], setupUrl: 'https://aistudio.google.com/app/apikey', usedBy: 'Gemini 모델', cost: 'usage-based', verification: '모델 목록 · 상태 코드만', demoRequired: false },
+  { id: 'opengateway', label: 'OpenGateway', kind: 'api-key', envNames: ['OPENGATEWAY_API_KEY'], setupUrl: 'https://apis.opengateway.ai/', usedBy: 'OpenAI 호환 모델 대체 경로', cost: 'usage-based', verification: 'GET /v1/models · 상태 코드만', demoRequired: false },
+  { id: 'supadata', label: 'Supadata', kind: 'api-key', envNames: ['SUPADATA_API_KEY'], setupUrl: 'https://supadata.ai/', usedBy: 'YouTube 자막', cost: 'usage-based', verification: '자막 API · 상태 코드만', demoRequired: false },
+  { id: 'elevenlabs', label: 'ElevenLabs', kind: 'api-key', envNames: ['ELEVENLABS_API_KEY'], setupUrl: 'https://elevenlabs.io/app/settings/api-keys', usedBy: '음성 합성', cost: 'usage-based', verification: 'GET /v1/user · 상태 코드만', demoRequired: false },
+  { id: 'brave-search', label: 'Brave Search', kind: 'api-key', envNames: ['BRAVE_API_KEY'], setupUrl: 'https://brave.com/search/api/', usedBy: '웹 검색 대체 경로', cost: 'usage-based', verification: '검색 API · 상태 코드만', demoRequired: false },
+  { id: 'youtube-data', label: 'YouTube Data API', kind: 'api-key', envNames: ['YOUTUBE_API_KEY'], setupUrl: 'https://console.cloud.google.com/apis/credentials', usedBy: 'YouTube 메타데이터', cost: 'usage-based', verification: 'videos.list · 상태 코드만', demoRequired: false },
+  { id: 'apify', label: 'Apify', kind: 'api-key', envNames: ['APIFY_TOKEN'], setupUrl: 'https://console.apify.com/account/integrations', usedBy: 'X 수집', cost: 'usage-based', verification: '사용자 API · 상태 코드만', demoRequired: false },
+  { id: 'eodhd', label: 'EODHD', kind: 'api-key', envNames: ['EODHD_API_KEY'], setupUrl: 'https://eodhd.com/financial-apis/', usedBy: '시장 시세', cost: 'usage-based', verification: '시장 API · 상태 코드만', demoRequired: false },
+  { id: 'fds', label: 'FDS market data', kind: 'api-key', envNames: ['FDS_API_KEY'], setupUrl: 'https://elanous.ai', usedBy: '시장 시세', cost: 'plan-dependent', verification: '연결 미니 호출 · 상태 코드만', demoRequired: false },
+  { id: 'upstage', label: 'Upstage', kind: 'api-key', envNames: ['UPSTAGE_API_KEY'], setupUrl: 'https://console.upstage.ai/api-keys', usedBy: '문서 파싱', cost: 'usage-based', verification: '문서 API · 상태 코드만', demoRequired: false },
+] as const;
+
+export function renderServiceKeyCatalogMarkdown(): string {
+  const rows = SERVICE_KEY_CATALOG.map(item => `| ${item.id} | ${item.label} | ${item.kind} | ${item.envNames.join(', ') || '로그인/설치'} | ${item.setupUrl} | ${item.cost} | ${item.usedBy} | ${item.verification} | ${item.demoRequired ? '씬 사용' : '선택'} |`);
+  return ['| id | 서비스 | 인증 | 환경 이름 | 설정 위치 | 비용 유형 | 사용처 | 최소 확인 | 판정 |', '|---|---|---|---|---|---|---|---|---|', ...rows].join('\n');
+}