elanous 0.2.40 → 0.2.42

package/src/session/chat.ts

@@ -17,6 +17,7 @@ import {
   type SessionMeta, type SerializedMessage, type CreateSessionOpts,
 } from './index.js';
 import { debug } from '../debug/log.js';
+import { createRequestSizeGuard, formatRequestSizeStatus, type RequestSizeGuard } from './request-size-guard.js';
 import type { InputSourceKind } from '../input/input-source-kind.js';
 import {
   getProviderForConfig, streamLLMWithTools, type LLMMessage, type LLMOpts, type LLMProvider,
@@ -41,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;
@@ -58,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. */
@@ -293,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 의미판정으로 관련
@@ -400,65 +427,41 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     return trimToBudget(wire, opts.maxTokens ?? DEFAULT_TOKEN_BUDGET);
   };
 
-  let measuredProviderRequests = 0;
-  const requestSizeGuard: NonNullable<LLMOpts['requestSizeGuard']> | undefined =
+  const requestSizeGuard: RequestSizeGuard | undefined =
     meta.source === 'tui' && provider.name === 'openai-codex'
-      ? {
-          maxChars: 400_000,
-          compactMessages: async (currentMessages) => {
-            // The first request has only the persisted transcript plus this
-            // user turn, so use the shared session compactor and rebuild from
-            // the rewritten history. Later tool rounds compact their live
-            // message list so no just-produced tool context is lost.
-            if (measuredProviderRequests === 0) {
-              const { compactSessionHistory } = await import('./compact-session.js');
-              const result = await compactSessionHistory(opts.sessionId, {
-                config: opts.userConfig.chat.autoCompact,
-                force: true,
-                modelId: llmOpts?.model ?? provider.defaultModel,
-              });
-              if (result.fired) {
-                const refreshed = loadSession(opts.sessionId);
-                if (refreshed) {
-                  // The persisted compacted session includes this turn's
-                  // user message. Drop that final persisted row here, then
-                  // assembleTurnMessages re-adds the canonical userMsg and
-                  // any image blocks from opts.userImages exactly once.
-                  messages = refreshed.messages.slice(0, -1);
-                  const rebuilt = assembleTurnMessages(effectiveSystemPrompt).kept;
-                  return { messages: rebuilt, reason: `session-${result.reason}` };
-                }
-              }
-            }
-
-            const { runCompactPipeline } = await import('../compact/pipeline.js');
-            const { getDefaultCompactProvider } = await import('../compact/provider.js');
-            const compacted = await runCompactPipeline(currentMessages, {
-              sessionId: opts.sessionId,
-              provider: getDefaultCompactProvider(),
-              activeModelId: llmOpts?.model ?? provider.defaultModel,
-              policy: {
-                preserveLastN: opts.userConfig.chat.autoCompact.preserveLastN,
-                archiveEnabled: opts.userConfig.chat.compact.archiveEnabled,
-              },
+      ? createRequestSizeGuard({
+          compactOptions: () => ({
+            sessionId: opts.sessionId,
+            activeModelId: llmOpts?.model ?? provider.defaultModel,
+            preserveLastN: opts.userConfig.chat.autoCompact.preserveLastN,
+            archiveEnabled: opts.userConfig.chat.compact.archiveEnabled,
+          }),
+          // The first request has only the persisted transcript plus this
+          // user turn, so use the shared session compactor and rebuild from
+          // the rewritten history. Later tool rounds compact their live
+          // message list (shared guard) so no just-produced tool context is lost.
+          compactFirstRequest: async () => {
+            const { compactSessionHistory } = await import('./compact-session.js');
+            const result = await compactSessionHistory(opts.sessionId, {
+              config: opts.userConfig.chat.autoCompact,
+              force: true,
+              modelId: llmOpts?.model ?? provider.defaultModel,
             });
-            const diagnostics = compacted.diagnostics;
-            const changed = diagnostics.layer1ResponsesTrimmed > 0
-              || diagnostics.layer2MicrocompactCleared > 0
-              || diagnostics.layer3SummaryApplied === 1
-              || diagnostics.layer5FallbackTruncated === 1;
-            return changed
-              ? { messages: compacted.messages, reason: 'live-request-compact' }
-              : null;
+            if (!result.fired) return null;
+            const refreshed = loadSession(opts.sessionId);
+            if (!refreshed) return null;
+            // The persisted compacted session includes this turn's
+            // user message. Drop that final persisted row here, then
+            // assembleTurnMessages re-adds the canonical userMsg and
+            // any image blocks from opts.userImages exactly once.
+            messages = refreshed.messages.slice(0, -1);
+            const rebuilt = assembleTurnMessages(effectiveSystemPrompt).kept;
+            return { messages: rebuilt, reason: `session-${result.reason}` };
           },
           onMeasured: (measurement) => {
-            measuredProviderRequests += 1;
-            opts.onStatusLine?.(
-              `ctx ${measurement.requestChars.toLocaleString()} chars / ${measurement.maxChars.toLocaleString()}`
-              + (measurement.compacted ? ` · compact ${measurement.reason}` : ''),
-            );
+            opts.onStatusLine?.(formatRequestSizeStatus(measurement));
           },
-        }
+        })
       : undefined;
 
   let kept: LLMMessage[] = [];
@@ -508,7 +511,8 @@ 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 armTuiResearchTurn = opts.utteranceSurface === 'tui' && turnTools.length > 0 && isResearchAgentIntent(opts.userText);
+    if (armGoalLoop || armTuiResearchTurn) {
       // ⭐ CHILD-CONTEXT-BUDGET(0.2.35 칸) — 구현 자식(self-implement 공간)의 첫 goal-loop
       //    턴에서 실제 effectiveSystemPrompt·turnTools 스키마·userText(골)의 구성 바이트를
       //    composeChildContext 로 계측해 child.context-composition 사건 1회로 남긴다.
@@ -543,6 +547,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(),
@@ -563,8 +568,14 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
           ? { 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/request-size-guard.ts

@@ -0,0 +1,123 @@
+// TUI-TOKEN-GUARD-WIRE — shared request-size guard (#32254 cap).
+//
+// The 400k-char cap used to be built only inside `session/chat.ts runTurn`.
+// The production TUI does not run that function: it goes
+// DashboardSession → bridgeCoreTurnToAcp → runCoreTurn/runGoalLoop, so the
+// guard never reached `llm.ts` and no `request-size-compact` event fired
+// (root cause: seat-state/OP/tmp/TUI-TOKEN-BURN-ROOT-CAUSE-1028.md).
+//
+// This module owns the guard construction so both paths share one policy:
+//   - `createRequestSizeGuard` — the `LLMOpts.requestSizeGuard` object.
+//     The first measured request may use a caller hook (`compactFirstRequest`)
+//     that compacts the caller's *persisted* history; every other request
+//     (and a first request whose hook declines) compacts the live message list.
+//   - `compactLiveMessages` — the live compaction (Layer 1/2 + optional
+//     Layer 3 summarize) shared by the guard and by hosts that compact their
+//     own history store.
+//   - `estimateRequestChars` — cheap pre-send estimate (JSON chars of the
+//     messages plus tool specs) used by the ACP bridge preflight.
+//
+// ⚠️ `llm.ts` applies the compacted list with `messages.splice(...)`, but the
+// array it receives is a per-request copy (`mapProviderToolNamesInMessages`),
+// not `streamLLMWithTools`'s `history`. Compaction therefore does not survive
+// into the next tool round by itself — the guard re-measures each request —
+// and only a host write-back (chat.ts session rewrite / dashboard history
+// replace) makes it survive into the next prompt.
+
+import type { LLMMessage, LLMOpts, LLMToolSpec } from '../llm.js';
+import type { CompactProvider } from '../compact/provider.js';
+
+/** #32254 — the wire cap for Codex TUI requests (serialized body chars). */
+export const REQUEST_SIZE_MAX_CHARS = 400_000;
+
+export type RequestSizeGuard = NonNullable<LLMOpts['requestSizeGuard']>;
+export type RequestSizeMeasurement = Parameters<NonNullable<RequestSizeGuard['onMeasured']>>[0];
+export type RequestSizeCompactInfo = Parameters<RequestSizeGuard['compactMessages']>[1];
+export type RequestSizeCompactResult = Awaited<ReturnType<RequestSizeGuard['compactMessages']>>;
+
+type RunCompactPipeline = typeof import('../compact/pipeline.js').runCompactPipeline;
+
+export interface CompactLiveMessagesOptions {
+  sessionId?: string;
+  activeModelId?: string;
+  preserveLastN?: number;
+  archiveEnabled?: boolean;
+  /** Test seam — defaults to the real `runCompactPipeline` with the default compact provider. */
+  runCompactPipeline?: RunCompactPipeline;
+}
+
+/** Compact a live message list. Returns `null` when no layer changed anything. */
+export async function compactLiveMessages(
+  messages: LLMMessage[],
+  opts: CompactLiveMessagesOptions,
+): Promise<{ messages: LLMMessage[]; reason: string } | null> {
+  let run = opts.runCompactPipeline;
+  let provider: CompactProvider | undefined;
+  if (!run) {
+    run = (await import('../compact/pipeline.js')).runCompactPipeline;
+    provider = (await import('../compact/provider.js')).getDefaultCompactProvider();
+  }
+  const compacted = await run(messages, {
+    ...(opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {}),
+    ...(provider !== undefined ? { provider } : {}),
+    ...(opts.activeModelId !== undefined ? { activeModelId: opts.activeModelId } : {}),
+    policy: {
+      ...(opts.preserveLastN !== undefined ? { preserveLastN: opts.preserveLastN } : {}),
+      ...(opts.archiveEnabled !== undefined ? { archiveEnabled: opts.archiveEnabled } : {}),
+    },
+  });
+  const diagnostics = compacted.diagnostics;
+  const changed = diagnostics.layer1ResponsesTrimmed > 0
+    || diagnostics.layer2MicrocompactCleared > 0
+    || diagnostics.layer3SummaryApplied === 1
+    || diagnostics.layer5FallbackTruncated === 1;
+  return changed ? { messages: compacted.messages, reason: 'live-request-compact' } : null;
+}
+
+export interface CreateRequestSizeGuardOptions {
+  maxChars?: number;
+  /** Live-compaction options, resolved lazily at compaction time (config is
+   *  read only when a request is actually over the cap). */
+  compactOptions: () => CompactLiveMessagesOptions;
+  /** First measured request only: compact the caller's persisted history and
+   *  return the rebuilt request. `null` falls through to live compaction. */
+  compactFirstRequest?: (
+    currentMessages: LLMMessage[],
+    info: RequestSizeCompactInfo,
+  ) => Promise<RequestSizeCompactResult>;
+  onMeasured?: (measurement: RequestSizeMeasurement) => void;
+}
+
+export function createRequestSizeGuard(opts: CreateRequestSizeGuardOptions): RequestSizeGuard {
+  let measuredProviderRequests = 0;
+  return {
+    maxChars: opts.maxChars ?? REQUEST_SIZE_MAX_CHARS,
+    compactMessages: async (currentMessages, info) => {
+      if (measuredProviderRequests === 0 && opts.compactFirstRequest) {
+        const first = await opts.compactFirstRequest(currentMessages, info);
+        if (first) return first;
+      }
+      return compactLiveMessages(currentMessages, opts.compactOptions());
+    },
+    onMeasured: (measurement) => {
+      measuredProviderRequests += 1;
+      opts.onMeasured?.(measurement);
+    },
+  };
+}
+
+/** Cheap pre-send size estimate: JSON chars of the messages plus tool specs.
+ *  It tracks the Codex wire body closely (the wire also serializes both). */
+export function estimateRequestChars(messages: readonly LLMMessage[], tools: readonly LLMToolSpec[] = []): number {
+  try {
+    return JSON.stringify(messages).length + (tools.length > 0 ? JSON.stringify(tools).length : 0);
+  } catch {
+    return 0;
+  }
+}
+
+/** One-line status text shared by chat.ts and the ACP bridge. */
+export function formatRequestSizeStatus(measurement: RequestSizeMeasurement): string {
+  return `ctx ${measurement.requestChars.toLocaleString()} chars / ${measurement.maxChars.toLocaleString()}`
+    + (measurement.compacted ? ` · compact ${measurement.reason}` : '');
+}

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;
@@ -429,6 +431,7 @@ interface SessionNativeToolRule {
     signal?: AbortSignal,
     opts?: {
       pathPolicy?: PathPolicy;
+      sessionId?: string;
       agentHostTools?: LLMToolSpec[];
       agentDispatchTool?: (name: string, args: Record<string, unknown>) => Promise<unknown>;
       buildChildToolCatalog?: (cwd: string) => {
@@ -512,6 +515,7 @@ 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,
@@ -587,10 +591,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);
     },
   },
   {
@@ -969,9 +973,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 +1281,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 +1290,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 +1319,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 +1611,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;
@@ -1736,6 +1821,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 +1885,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,6 +2118,7 @@ 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,

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