elanous 0.2.42 → 0.2.44

package/src/core-turn/run-core-turn.ts

@@ -27,6 +27,19 @@ import { debug, redactSecretText, withAmbientSessionScope } from '../debug/log.j
 import { applyDeferredTools } from '../session-runtime/tier-flip.js';
 import { isResearchAgentIntent } from '../tool-hints/signals.js';
 import { buildResearchDateSystemMessage, resolveSessionSurfaceProfile } from '../session-runtime/index.js';
+import {
+  isResearchToolAllowed,
+  RESEARCH_DOCUMENT_WRITE_TOOLS,
+  requestsResearchDocumentWrite,
+  RESEARCH_TOOL_ALLOWLIST,
+  RESEARCH_TURN_DEEP_BUDGET_MS,
+  RESEARCH_TURN_DEADLINE_STOP_ERROR,
+  RESEARCH_TURN_FIRST_REPLY_BUDGET_MS,
+  RESEARCH_TURN_FINAL_ANSWER_DEADLINE_MS,
+  RESEARCH_TURN_MAX_TOOL_TURNS,
+  RESEARCH_TURN_SHALLOW_FINAL_ANSWER_DEADLINE_MS,
+  RESEARCH_TURN_SHALLOW_BUDGET_MS,
+} from './research-policy.js';
 import type {
   CoreTurnContext,
   CoreTurnResult,
@@ -35,6 +48,14 @@ import type {
 
 const CORE_TURN_TOOL_RESULT_INLINE_LIMIT_BYTES = 50 * 1024;
 
+// A deep, non-research prompt gets the same-call Bloom frame, but should not
+// silently grow into multi-source research just because the model can reach
+// generic skill/search tools. Explicit research turns and explicit named-skill
+// requests keep the normal tool surface.
+const DEEP_NON_RESEARCH_SEARCH_TOOLS = new Set([
+  'skill_exec', 'elanous_skills_list', 'websearch', 'web_search', 'omnisearch', 'omni_search', 'webfetch', 'web_fetch',
+]);
+
 /** Classify an error thrown out of `streamLLMWithTools` into the
  *  Core-turn stop-reason set. Abort wins over everything else;
  *  credential rejection (`isAuthRejectionError`) is distinct from a
@@ -82,8 +103,31 @@ function selectSurfaceUserText(ctx: CoreTurnContext): string | undefined {
  *  the research turn's text-only provisional answer. That provisional pass
  *  has no tools by design and otherwise tells the user the requested skill
  *  cannot be invoked, even when the skill router already resolved it. */
-function requestsNamedSkill(text: string | undefined): boolean {
+function requestedInstalledSkillName(text: string | undefined, installedSkillNames: readonly string[]): string | undefined {
+  if (!text) return undefined;
+  return installedSkillNames
+    .filter((name) => name.includes('-'))
+    .sort((a, b) => b.length - a.length)
+    .find((name) => {
+      const parts = name.trim().split(/[-\s]+/).filter(Boolean);
+      if (parts.length < 2 || !parts.every((part) => /^[a-z0-9]+$/i.test(part))) return false;
+      const slug = parts.join('[\\s-]*');
+      return new RegExp('(?:^|[^\\p{L}\\p{N}])' + slug + '(?=$|[^a-z0-9])\\s*(?:으로|로)(?=[^\\n!?]{0,120}(?:찾아|조사|정리))', 'iu').test(text);
+    });
+}
+
+export function requestsNamedSkill(text: string | undefined, installedSkillNames: readonly string[] = []): boolean {
   if (!text) return false;
+  const requestedInstalledSkill = installedSkillNames
+    .filter((name) => name.includes('-'))
+    .sort((a, b) => b.length - a.length)
+    .some((name) => {
+      const parts = name.trim().split(/[-\s]+/).filter(Boolean);
+      if (parts.length < 2 || !parts.every((part) => /^[a-z0-9]+$/i.test(part))) return false;
+      const slug = parts.join('[\\s-]*');
+      return new RegExp('(?:^|[^\\p{L}\\p{N}])' + slug + '(?=$|[^a-z0-9])\\s*(?:으로|로)(?=[^\\n!?]{0,120}(?:찾아|조사|정리))', 'iu').test(text);
+    });
+  if (requestedInstalledSkill) return true;
   const action = '(?:use|invoke|run|call|execute|launch|trigger|apply|start)';
   return new RegExp(`\\b${action}\\s+(?:(?:the|a|an)\\s+)?skill\\s+(?:named|called)\\s+['"“‘]([a-z0-9][a-z0-9 _-]{1,60}?)['"”’](?=$|[\\s.,;!?])`, 'i').test(text)
     || new RegExp(`\\b${action}\\s+(?:the\\s+)?['"“‘]([a-z0-9][a-z0-9 _-]{1,60}?)['"”’](?=$|[\\s.,;!?])`, 'i').test(text)
@@ -119,23 +163,36 @@ function requestsNamedSkill(text: string | undefined): boolean {
  */
 export interface RunCoreTurnOptions {
   now?: () => number;
-  runResearch?: (request: string, signal: AbortSignal) => Promise<{ ok: boolean; output: string; error?: string }>;
+  timers?: { setTimeout(callback: () => void, delayMs: number): ReturnType<typeof setTimeout>; clearTimeout(handle: ReturnType<typeof setTimeout>): void };
+  firstReplyBudgetMs?: number;
+  researchWallClockBudgetMs?: number;
+  runResearch?: (
+    request: string,
+    signal: AbortSignal,
+    admitToolCall?: (name: string) => boolean,
+    providerRouting?: Pick<CoreTurnContext, 'initialProvider' | 'skipProviders' | 'runId'>,
+  ) => Promise<{ ok: boolean; output: string; error?: string; axisCount?: number }>;
 }
 
+type ResearchTimer = ReturnType<typeof setTimeout>;
+
 type AbortRace<T> = { aborted: true } | { aborted: false; value: T };
 
 function settleBeforeAbort<T>(work: Promise<T>, signal: AbortSignal): Promise<AbortRace<T>> {
-  if (signal.aborted) return Promise.resolve({ aborted: true });
   return new Promise((resolve, reject) => {
+    let abortGraceTimer: ReturnType<typeof setTimeout> | undefined;
     const onAbort = () => {
       signal.removeEventListener('abort', onAbort);
-      resolve({ aborted: true });
+      // Let work handlers that synchronously settle in response to abort
+      // expose their final partial result before taking the deadline path.
+      abortGraceTimer = setTimeout(() => resolve({ aborted: true }), 50);
     };
-    signal.addEventListener('abort', onAbort, { once: true });
     work.then(
-      value => { signal.removeEventListener('abort', onAbort); resolve({ aborted: false, value }); },
-      error => { signal.removeEventListener('abort', onAbort); reject(error); },
+      value => { signal.removeEventListener('abort', onAbort); if (abortGraceTimer) clearTimeout(abortGraceTimer); resolve({ aborted: false, value }); },
+      error => { signal.removeEventListener('abort', onAbort); if (abortGraceTimer) clearTimeout(abortGraceTimer); reject(error); },
     );
+    if (signal.aborted) onAbort();
+    else signal.addEventListener('abort', onAbort, { once: true });
   });
 }
 
@@ -174,6 +231,41 @@ function commitProvisionalTurn(
   commitCompletion(messages, handlers, setFinalPhaseAnswer);
 }
 
+function completionWithFinalText(messages: TurnCompletion | undefined, text: string): TurnCompletion {
+  const completed = [...(messages ?? [])];
+  let lastAssistant = -1;
+  for (let index = completed.length - 1; index >= 0; index -= 1) {
+    if (completed[index]?.role === 'assistant') { lastAssistant = index; break; }
+  }
+  if (lastAssistant < 0) {
+    completed.push({ role: 'assistant', content: text, phase: 'final_answer' });
+  } else {
+    const previous = completed[lastAssistant]!;
+    let content: typeof previous.content;
+    if (typeof previous.content === 'string') {
+      content = text;
+    } else {
+      let lastText = -1;
+      for (let index = previous.content.length - 1; index >= 0; index -= 1) {
+        if (previous.content[index]?.type === 'text') { lastText = index; break; }
+      }
+      if (lastText < 0) {
+        // A tool-only assistant message must stay paired with its tool result;
+        // the synthesized prose is a separate final answer message.
+        completed.push({ role: 'assistant', content: text, phase: 'final_answer' });
+        return completed;
+      }
+      content = previous.content.map((block, index) => index === lastText && block.type === 'text'
+        ? { ...block, text }
+        : block);
+    }
+    completed[lastAssistant] = {
+      ...previous, content, phase: 'final_answer',
+    };
+  }
+  return completed;
+}
+
 function commitStagedTurn(
   messages: TurnCompletion | undefined,
   handlers: StreamWithToolsHandlers,
@@ -182,8 +274,25 @@ function commitStagedTurn(
   setFinalPhaseAnswer: (value: boolean) => void,
   onReplaceText?: (fullText: string) => void,
 ): void {
-  commitCompletion(messages, handlers, setFinalPhaseAnswer);
+  // Replacement must reach the stream bridge before completion: ACP tracks the
+  // visible tail in `onReplaceText` so its completion callback will not emit the
+  // same synthesized answer a second time.
   if (replaceVisibleText && text) onReplaceText?.(text);
+  commitCompletion(messages, handlers, setFinalPhaseAnswer);
+}
+
+function commitSynthesizedTurn(
+  staged: ReturnType<typeof createStagedHandlers>,
+  fallbackMessages: TurnCompletion | undefined,
+  handlers: StreamWithToolsHandlers,
+  finalText: string,
+  provisionalText: string,
+  setFinalPhaseAnswer: (value: boolean) => void,
+  onReplaceText?: (fullText: string) => void,
+): void {
+  const completion = staged.completion() ?? completionWithFinalText(fallbackMessages, finalText);
+  commitStagedTurn(completion, handlers, finalText, finalText !== provisionalText,
+    setFinalPhaseAnswer, onReplaceText);
 }
 
 export async function runCoreTurn(
@@ -191,6 +300,10 @@ export async function runCoreTurn(
   options: RunCoreTurnOptions = {},
 ): Promise<CoreTurnResult> {
   const now = options.now ?? Date.now;
+  const timers = options.timers ?? {
+    setTimeout: (callback: () => void, delayMs: number) => setTimeout(callback, delayMs),
+    clearTimeout: (handle: ReturnType<typeof setTimeout>) => clearTimeout(handle),
+  };
   let turnStartedAt: number | undefined;
   let researchStartedAt: number | undefined;
   let researchFirstTokenRecorded = false;
@@ -214,6 +327,62 @@ export async function runCoreTurn(
     let accumulatedText = '';
     let dispatchCount = 0;
     let finalPhaseAnswer = false;
+    let enforceResearchToolAllowlist = false;
+    let enforceResearchDocumentWrite = false;
+    const isAllowedResearchTool = (name: string): boolean => isResearchToolAllowed(name)
+      || (enforceResearchDocumentWrite && (RESEARCH_DOCUMENT_WRITE_TOOLS as readonly string[]).includes(name));
+    let enforceResearchToolBudget = false;
+    let researchToolCallCount = 0;
+    let researchAxisCount = 0;
+    let researchStopReason: string | undefined;
+    const loggedResearchStops = new Set<string>();
+    const logResearchStop = (reason: string, extra: Record<string, unknown> = {}): void => {
+      if (loggedResearchStops.has(reason)) return;
+      loggedResearchStops.add(reason);
+      debug.log('research.stop', 'stopped', { sessionId: ctx.sessionId, reason, ...extra });
+    };
+    const admitResearchToolCall = (name: string): boolean => {
+      if (!enforceResearchToolBudget) return true;
+      if (name === 'Agent' && researchAxisCount < 3) {
+        debug.log('research.turn', 'subagent-skipped', {
+          sessionId: ctx.sessionId, reason: 'insufficient-judgment-axes', axisCount: researchAxisCount, minimum: 3,
+        });
+        return false;
+      }
+      if (researchToolCallCount >= RESEARCH_TURN_MAX_TOOL_TURNS) {
+        // A prior denied tool is observable, but it must not mask the hard
+        // budget stop that requires tool-free synthesis. A wall-clock stop is
+        // already terminal and keeps its more specific reason.
+        if (researchStopReason !== 'wall-clock-budget') researchStopReason = 'tool-budget';
+        logResearchStop('tool-budget', { stage: 'tool-dispatch', tool: name, count: researchToolCallCount, limit: RESEARCH_TURN_MAX_TOOL_TURNS });
+        return false;
+      }
+      researchToolCallCount += 1;
+      return true;
+    };
+    const constrainResearchToolArgs = (name: string, args: Record<string, unknown>): Record<string, unknown> => {
+      if (!enforceResearchToolAllowlist || name !== 'Agent' || !args || typeof args !== 'object' || Array.isArray(args)) return args;
+      const raw = args;
+      const rawFilter = raw.tool_filter && typeof raw.tool_filter === 'object' && !Array.isArray(raw.tool_filter)
+        ? raw.tool_filter as { deny?: unknown }
+        : {};
+      const deny = Array.isArray(rawFilter.deny) ? rawFilter.deny.filter((tool): tool is string => typeof tool === 'string') : [];
+      return {
+        ...raw,
+        subagent_type: typeof raw.subagent_type === 'string' && raw.subagent_type.trim()
+          ? raw.subagent_type
+          : 'general-purpose',
+        run_in_background: false,
+        wait_for_slot: false,
+        max_turns: typeof raw.max_turns === 'number' && Number.isFinite(raw.max_turns)
+          ? Math.max(1, Math.min(RESEARCH_TURN_MAX_TOOL_TURNS, Math.floor(raw.max_turns)))
+          : RESEARCH_TURN_MAX_TOOL_TURNS,
+        tool_filter: {
+          allow: ['Read', 'WebFetch'],
+          deny: [...new Set([...deny, 'Bash', 'Edit', 'Grep'])],
+        },
+      };
+    };
 
     const handlers: StreamWithToolsHandlers = {
     onText: (delta, full) => {
@@ -254,9 +423,28 @@ export async function runCoreTurn(
 
       let success = false;
       try {
-        const result = await ctx.dispatchTool(
-          name,
-          args,
+        let result: unknown;
+        if (enforceResearchToolAllowlist && !isAllowedResearchTool(name)) {
+          researchStopReason ??= 'tool-not-allowed';
+          logResearchStop('tool-not-allowed', { stage: 'tool-dispatch', tool: name, allowedTools: [...RESEARCH_TOOL_ALLOWLIST, ...(enforceResearchDocumentWrite ? ['Edit', 'Write'] : [])] });
+          debug.log('core.turn', 'research-tool-denied', {
+            sessionId: ctx.sessionId,
+            tool: name,
+            dispatchCount: currentDispatchCount,
+          }, { level: 'warn' });
+          result = { error: enforceResearchDocumentWrite
+            ? 'This research turn may use research tools and Edit/Write only for the explicitly requested document.'
+            : 'This research turn may only use the research tool allowlist.' };
+        } else if (enforceResearchToolAllowlist && !admitResearchToolCall(name)) {
+          debug.log('core.turn', 'research-tool-budget-reached', {
+            sessionId: ctx.sessionId, tool: name, count: researchToolCallCount,
+            maxToolTurns: RESEARCH_TURN_MAX_TOOL_TURNS,
+          }, { level: 'warn' });
+          result = { error: 'Research tool budget reached. Answer with the evidence collected so far.' };
+        } else {
+          result = await ctx.dispatchTool(
+            name,
+            constrainResearchToolArgs(name, args),
           // Image-pipeline followup #1 (2026-05-05) — forward sessionId so
           // the dispatcher can auto-inject into session-keyed tool calls
           // (WebTerminal* etc.) when the LLM didn't supply one. `c` may
@@ -269,10 +457,20 @@ export async function runCoreTurn(
           c
             ? { ...c, sessionId: ctx.sessionId, signal: ctx.signal, ...(ctx.userText ? { userText: ctx.userText } : {}) }
             : { callId: '', sessionId: ctx.sessionId, signal: ctx.signal, ...(ctx.userText ? { userText: ctx.userText } : {}) },
-        );
+          );
+        }
         success = true;
         return result;
       } finally {
+        if (name === 'Agent' && enforceResearchToolAllowlist) {
+          debug.log('research.turn', 'subagent-completed', {
+            sessionId: ctx.sessionId,
+            dispatchCount: currentDispatchCount,
+            durationMs: now() - startedAt,
+            completionMode: 'awaited-tool-result',
+            success,
+          });
+        }
         try {
           debug.log('core.turn', 'dispatch-done', {
             sessionId: ctx.sessionId,
@@ -344,20 +542,140 @@ export async function runCoreTurn(
   // Use the shared #31663 research-intent verdict. Surface labels are a
   // presentation/routing result and may remain `chat` for a research turn.
   const researchTurn = isResearchAgentIntent(surfaceUserText);
-  const { messages, tools, stats } = applyDeferredTools(
+  const { selectDeepBloom } = await import('./deep-turn-bloom.js');
+  const deepBloomDecision = selectDeepBloom(surfaceUserText, {
+    researchIntent: researchTurn,
+    reasoningEffort: ctx.reasoningEffort,
+  });
+  const { messages, tools: tieredTools, stats } = applyDeferredTools(
     ctx.messages,
     ctx.tools,
     { enabled: deferredEnabled, ...(recentUserText ? { userText: recentUserText } : {}) },
   );
+  // Preserve the pre-routing contract: a named skill only skips the research
+  // prepass when skill_exec is actually active after the normal tier split.
+  // Resolve the installed skill name even if skill_exec is deferred/missing:
+  // a named request with no executor falls back to the unfiltered normal pool.
+  let installedSkillNames: string[] = [];
+  if (researchTurn && surfaceUserText?.trim()) {
+    const { getSkillIndex } = await import('../skills/index.js');
+    installedSkillNames = getSkillIndex().map(({ name }) => name);
+  }
+  const namedSkillRequest = requestsNamedSkill(surfaceUserText, installedSkillNames);
+  // A named skill only skips the research prepass when its executor is active.
+  const explicitSkillToolRequest = namedSkillRequest
+    && tieredTools.some((tool) => tool.name === 'skill_exec');
+  const constrainDeepNonResearchTools = deepBloomDecision.apply && !researchTurn;
+  // ToolSearch routes against the surface's full live pool, so hiding a tool
+  // from the model alone is insufficient. Remove the summoner from the
+  // model-visible tiered set while retaining original split stats/messages.
+  const bloomFilteredTools = constrainDeepNonResearchTools
+    ? tieredTools.filter((tool) => {
+      const name = tool.name.toLowerCase();
+      return name === 'skill_exec' && explicitSkillToolRequest
+        ? true
+        : name !== 'toolsearch' && !DEEP_NON_RESEARCH_SEARCH_TOOLS.has(name);
+    })
+    : tieredTools;
+  if (constrainDeepNonResearchTools) {
+    const suppressed = tieredTools.filter((tool) => !bloomFilteredTools.includes(tool)).map((tool) => tool.name);
+    debug.log('research.turn', 'deep-bloom-search-tools-suppressed', {
+      sessionId: ctx.sessionId, reason: deepBloomDecision.reason, suppressed,
+      explicitSkillToolRequest,
+    });
+  }
+  enforceResearchToolBudget = researchTurn;
+  enforceResearchToolAllowlist = researchTurn && !namedSkillRequest;
+  enforceResearchDocumentWrite = enforceResearchToolAllowlist && requestsResearchDocumentWrite(surfaceUserText);
+  // Codex Responses only supports tool_choice="required" (not a named
+  // function choice). Make the first request deterministic by exposing only
+  // skill_exec there; streamLLMWithTools restores the full pool on later turns.
+  const routedSkillTools = explicitSkillToolRequest
+    ? bloomFilteredTools.filter((tool) => tool.name === 'skill_exec')
+    : [];
+  const tools = enforceResearchToolAllowlist
+    ? bloomFilteredTools.filter((tool) => isAllowedResearchTool(tool.name))
+    : bloomFilteredTools;
+  // Preserve the ordinary pool if a later filter removes the executor.
+  const firstTurnTools = routedSkillTools.length > 0 ? routedSkillTools : undefined;
+  const maxToolTurns = researchTurn
+    ? Math.min(ctx.maxToolTurns ?? RESEARCH_TURN_MAX_TOOL_TURNS, RESEARCH_TURN_MAX_TOOL_TURNS)
+    : ctx.maxToolTurns;
   if (researchTurn && !messages.some((message) =>
     message.role === 'system' && typeof message.content === 'string'
       && message.content.startsWith('Current local date:'))
   ) {
     messages.unshift(buildResearchDateSystemMessage());
+  }
+  if (researchTurn) {
+    messages.unshift({
+      role: 'system',
+      content: [
+        '<research-answer-guidance>',
+        '작은 후속 작업은 추가 질문 없이 현재 턴에서 먼저 처리한다.',
+        '답은 결론(무엇을 찾았고 무엇을 해 두었는지)을 먼저 말하고, 근거를 짧게 덧붙인다.',
+        '비용·외부 노출·되돌리기 어려움이 큰 다음 단계만 그 하나를 확인한다. 그 밖에는 묻지 않는다.',
+        '다음 할 일 목록을 형식으로 요구하지 않는다.',
+        '본문은 질문이 요구한 범위만 답하고, 가정 나열과 반복 설명을 줄인다.',
+        '근거는 출처 링크로 짧게 붙인다.',
+        '질문에 필요한 만큼 읽기 좋게 설명하며, 고정 줄 수나 글자 수로 자르지 않는다.',
+        '</research-answer-guidance>',
+      ].join('\n'),
+    });
+  }
+  if (deepBloomDecision.apply) {
+    const { buildDeepBloomInstruction } = await import('./deep-turn-bloom.js');
+    const instruction = await buildDeepBloomInstruction(surfaceUserText ?? '', deepBloomDecision.reason);
+    messages.unshift({ role: 'system', content: instruction.prompt! });
+    debug.log('research.turn', 'deep-bloom-applied', {
+      sessionId: ctx.sessionId, levels: instruction.levels, trigger: instruction.reason,
+      questionCount: instruction.questionCount, stage: researchTurn ? 'first-answer' : 'answer',
+      exemplarDomain: instruction.exemplarDomain,
+      exemplarLevels: instruction.exemplarLevels,
+    });
+  } else if (!deepBloomDecision.apply) {
+    debug.log('research.turn', 'deep-bloom-skipped', {
+      sessionId: ctx.sessionId, reason: deepBloomDecision.reason,
+    });
   }
     let researchResultPromise: Promise<{ ok: boolean; output: string; error?: string } | null> | undefined;
-    const explicitSkillToolRequest = requestsNamedSkill(surfaceUserText)
-      && tools.some((tool) => tool.name === 'skill_exec');
+    let researchDeadlineSignal: AbortSignal | undefined;
+    let requestedSkillName: string | undefined;
+    if (researchTurn && surfaceUserText?.trim() && explicitSkillToolRequest) {
+      // Resolve a display name only for the research opening plan; ordinary
+      // turns and unrequested research keep the core startup lean.
+      requestedSkillName = requestedInstalledSkillName(surfaceUserText, installedSkillNames);
+      const selectedTool = firstTurnTools?.find((tool) => tool.name === 'skill_exec');
+      if (requestedSkillName && selectedTool) {
+        debug.log('research.turn', 'named-skill-route-first', {
+          sessionId: ctx.sessionId,
+          requestedSkillName,
+          selectedTool: selectedTool.name,
+          availableToolNames: firstTurnTools?.map((tool) => tool.name) ?? [],
+        });
+      }
+    }
+    if (researchTurn && surfaceUserText?.trim()) {
+      // `tools` is the active post-tier-flip pool; use the shared research
+      // allowlist order so the plan names only currently callable tools.
+      const availableResearchTools = RESEARCH_TOOL_ALLOWLIST
+        .filter((name) => tools.some((tool) => tool.name === name));
+      const planTools = requestedSkillName && firstTurnTools?.some((tool) => tool.name === 'skill_exec')
+        ? [`${requestedSkillName} (skill_exec)`]
+        : availableResearchTools;
+      const plan = planTools.length > 0
+        ? [
+          `${planTools.join(' → ')}로 질문에 나온 주제와 요구 조건의 근거를 찾습니다.`,
+          '출처의 주장과 제약을 비교해 확인된 사실을 가립니다.',
+          '확인한 결론과 짧은 근거로 답합니다.',
+        ].join('\n')
+        : [
+          '현재 사용할 수 있는 조사 도구가 없습니다.',
+          '근거를 확인할 수 없어 결론을 단정하지 않습니다.',
+          '도구가 활성화되면 출처를 확인해 답합니다.',
+        ].join('\n');
+      try { ctx.callbacks?.onStatus?.(plan); } catch { /* UI feedback is fail-soft. */ }
+    }
     if (researchTurn && surfaceUserText?.trim() && !explicitSkillToolRequest) {
       turnStartedAt = now();
       researchStartedAt = turnStartedAt;
@@ -365,17 +683,61 @@ export async function runCoreTurn(
         sessionId: ctx.sessionId,
         sinceTurnStartMs: researchStartedAt - turnStartedAt,
       });
-      // Start evidence collection beside the first answer. The user gets an
-      // immediate, visible status and an initial answer while research runs;
-      // a second text-only synthesis then reconciles that answer with evidence.
-      try { ctx.callbacks?.onStatus?.('먼저 답변을 시작하고 근거를 확인합니다.'); } catch { /* UI feedback is fail-soft. */ }
+      // The opening plan was already emitted above. Do not add a generic
+      // answer-first status that contradicts that plan; stream the provisional
+      // answer while evidence collection runs, then reconcile in the second pass.
+      const researchController = new AbortController();
+      researchDeadlineSignal = researchController.signal;
+      const abortResearchFromParent = (): void => {
+        if (researchStopReason !== 'wall-clock-budget') researchStopReason = 'parent-abort';
+        researchController.abort(ctx.signal.reason);
+      };
+      if (ctx.signal.aborted) abortResearchFromParent();
+      else ctx.signal.addEventListener('abort', abortResearchFromParent, { once: true });
+      const defaultResearchWallClockBudgetMs = deepBloomDecision.apply
+        ? RESEARCH_TURN_DEEP_BUDGET_MS
+        : RESEARCH_TURN_SHALLOW_BUDGET_MS;
+      const researchWallClockBudgetMs = options.researchWallClockBudgetMs ?? defaultResearchWallClockBudgetMs;
+      let researchDeadlineTimer: ResearchTimer | undefined;
+      if (!researchController.signal.aborted) {
+        researchDeadlineTimer = timers.setTimeout(() => {
+          if (researchController.signal.aborted) return;
+          researchStopReason = 'wall-clock-budget';
+          logResearchStop('wall-clock-budget', {
+            stage: 'research-prepass',
+            elapsedMs: researchStartedAt === undefined ? undefined : now() - researchStartedAt,
+            limitMs: researchWallClockBudgetMs,
+          });
+          researchController.abort(new Error('Research wall-clock budget reached'));
+        }, researchWallClockBudgetMs);
+      }
       researchResultPromise = (async () => {
         try {
-          const result = await (options.runResearch ?? (async (request, signal) => {
+          const work = (options.runResearch ?? (async (request, signal, admitToolCall, providerRouting) => {
             // Keep the Bloom/skill pipeline out of ordinary and packaged TUI startup graphs.
             const { researchTurnForGrounding, runResearchQuestionLadder } = await import('../auto-research/research-turn.js');
-            return researchTurnForGrounding(await runResearchQuestionLadder(request, { signal }));
-          }))(surfaceUserText, ctx.signal);
+            return researchTurnForGrounding(await runResearchQuestionLadder(request, {
+              ...providerRouting,
+              signal, admitToolCall, allowPartialOnAbort: true, allowOutputSkill: false,
+              deadlineMs: deepBloomDecision.apply
+                ? RESEARCH_TURN_FINAL_ANSWER_DEADLINE_MS
+                : Math.min(RESEARCH_TURN_SHALLOW_FINAL_ANSWER_DEADLINE_MS, Math.max(1, researchWallClockBudgetMs - 1)),
+            }));
+          }))(surfaceUserText, researchController.signal, admitResearchToolCall, {
+            ...(ctx.initialProvider ? { initialProvider: ctx.initialProvider } : {}),
+            ...(ctx.skipProviders ? { skipProviders: ctx.skipProviders } : {}),
+            ...(ctx.runId ? { runId: ctx.runId } : {}),
+          });
+          const result = await work;
+          researchAxisCount = result?.axisCount ?? 0;
+          if (researchController.signal.aborted && !researchStopReason) researchStopReason = ctx.signal.aborted ? 'parent-abort' : 'research-aborted';
+          if (researchStopReason) logResearchStop(researchStopReason, {
+            stage: 'research-prepass',
+            elapsedMs: researchStartedAt === undefined ? undefined : now() - researchStartedAt,
+          });
+          logResearchStop(result.ok ? 'evidence-complete' : 'evidence-incomplete', {
+            stage: 'research-prepass', outputChars: result.output.length,
+          });
           debug.log('research.turn', 'tui-research-completed', {
             sessionId: ctx.sessionId,
             ok: result.ok,
@@ -385,23 +747,30 @@ export async function runCoreTurn(
           });
           return result;
         } catch (error) {
+          logResearchStop('research-error', { stage: 'research-prepass', error: error instanceof Error ? error.message : String(error) });
           debug.log('research.turn', 'tui-research-fallback', {
             sessionId: ctx.sessionId,
             reason: error instanceof Error ? error.message : String(error),
             elapsedMs: researchStartedAt === undefined ? undefined : now() - researchStartedAt,
           }, { level: 'warn' });
           return null;
+        } finally {
+          if (researchDeadlineTimer !== undefined) timers.clearTimeout(researchDeadlineTimer);
+          ctx.signal.removeEventListener('abort', abortResearchFromParent);
         }
       })();
     }
-    const streamOptions = (turnTools: typeof tools) => ({
+    const streamOptions = (turnTools: typeof tools, signal: AbortSignal = ctx.signal) => ({
       tools: turnTools,
+      ...(firstTurnTools ? { firstTurnTools } : {}),
       researchTurn,
-      signal: ctx.signal,
+      ...(firstTurnTools ? { toolChoice: { name: 'skill_exec' } } : {}),
+      signal,
       ...(ctx.requestSizeGuard ? { requestSizeGuard: ctx.requestSizeGuard } : {}),
+      ...(ctx.reasoningEffort !== undefined ? { reasoningEffort: ctx.reasoningEffort } : {}),
       toolResultInlineLimitBytes: CORE_TURN_TOOL_RESULT_INLINE_LIMIT_BYTES,
       ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
-      ...(ctx.maxToolTurns !== undefined ? { maxTurns: ctx.maxToolTurns } : {}),
+      ...(maxToolTurns !== undefined ? { maxTurns: maxToolTurns } : {}),
       ...(ctx.initialProvider !== undefined
         ? { initialProvider: ctx.initialProvider, ...(ctx.skipProviders ? { skipProviders: ctx.skipProviders } : {}) }
         : ctx.modelOverride !== undefined ? { model: ctx.modelOverride } : {}),
@@ -431,12 +800,34 @@ export async function runCoreTurn(
       surfaceSelectionReason: surface.selectionReason,
       activeCount: stats.activeCount,
       deferredCount: stats.deferredCount,
-      immediateCount: stats.activeCount,
+      immediateCount: tools.length,
       immediate: tools.map((tool) => tool.name),
       warmPreloaded: stats.warmPreloaded,
       deferred: stats.deferredNames,
       unhydratable: stats.unhydratableNames,
     }, { compact: { arrayMax: Number.MAX_SAFE_INTEGER } });
+    const activeToolNames = new Set(tools.map((tool) => tool.name));
+    const immediateToolNames = new Set(tieredTools.map((tool) => tool.name));
+    const bloomToolNames = new Set(bloomFilteredTools.map((tool) => tool.name));
+    const excludedTools = ctx.tools
+      .filter((tool) => !activeToolNames.has(tool.name))
+      .map((tool) => ({
+        name: tool.name,
+        reason: !immediateToolNames.has(tool.name)
+          ? stats.deferredNames.includes(tool.name) ? 'deferred-tool-tier' : 'not-in-immediate-tier'
+          : !bloomToolNames.has(tool.name) ? 'deep-bloom-non-research-suppression'
+            : enforceResearchToolAllowlist && !isAllowedResearchTool(tool.name) ? 'research-tool-allowlist'
+              : 'not-active-after-turn-filtering',
+      }));
+    debug.log('capability.resolve', 'tier-split', {
+      sessionId: ctx.sessionId,
+      surfaceId: surface.id,
+      researchTurn,
+      activeTools: [...activeToolNames],
+      excludedTools,
+      deferredTools: stats.deferredNames,
+      unhydratableTools: stats.unhydratableNames,
+    }, { compact: { arrayMax: Number.MAX_SAFE_INTEGER } });
     if (stats.unhydratableCount > 0) {
       debug.log('capability.resolve', 'unhydratable-capabilities', {
         sessionId: ctx.sessionId,
@@ -447,8 +838,13 @@ export async function runCoreTurn(
 
     try {
       let provisionalTurnMessages: Parameters<NonNullable<StreamWithToolsHandlers['onTurnComplete']>>[0] | undefined;
-      const firstPassHandlers: StreamWithToolsHandlers = researchResultPromise && handlers.onTurnComplete
-        ? { ...handlers, onTurnComplete: (newMessages) => { provisionalTurnMessages = newMessages; } }
+      let firstPassTimedOut = false;
+      const firstPassHandlers: StreamWithToolsHandlers = researchResultPromise
+        ? {
+          ...handlers,
+          onText: (delta, full) => { if (!firstPassTimedOut) handlers.onText?.(delta, full); },
+          onTurnComplete: (newMessages) => { if (!firstPassTimedOut) provisionalTurnMessages = newMessages; },
+        }
         : handlers;
       const firstPassMessages = researchResultPromise
         ? [...messages, {
@@ -457,7 +853,38 @@ export async function runCoreTurn(
         }]
         : messages;
       const firstPassStartedAt = researchResultPromise ? now() : undefined;
-      finalText = await streamLLMWithTools(firstPassMessages, firstPassHandlers, streamOptions(researchResultPromise ? [] : tools));
+      if (researchResultPromise && firstPassStartedAt !== undefined) {
+        const firstPassController = new AbortController();
+        const abortFirstPassFromParent = (): void => firstPassController.abort(ctx.signal.reason);
+        if (ctx.signal.aborted) abortFirstPassFromParent();
+        else ctx.signal.addEventListener('abort', abortFirstPassFromParent, { once: true });
+        const firstReplyBudgetMs = options.firstReplyBudgetMs ?? RESEARCH_TURN_FIRST_REPLY_BUDGET_MS;
+        let firstReplyTimer: ResearchTimer | undefined;
+        const deadline = new Promise<{ timedOut: true }>(resolve => {
+          firstReplyTimer = timers.setTimeout(() => resolve({ timedOut: true }), firstReplyBudgetMs);
+        });
+        try {
+          const firstPass = streamLLMWithTools(firstPassMessages, firstPassHandlers, streamOptions(tools, firstPassController.signal))
+            .then(text => ({ timedOut: false as const, text }));
+          const outcome = await Promise.race([firstPass, deadline]);
+          if (outcome.timedOut) {
+            firstPassTimedOut = true;
+            firstPassController.abort(new Error('First answer budget reached'));
+            logResearchStop('first-reply-budget', { stage: 'first-response', limitMs: firstReplyBudgetMs, elapsedMs: now() - firstPassStartedAt });
+            const partial = accumulatedText.trim();
+            finalText = partial || '질문을 확인하고 있습니다. 근거를 조사한 뒤 제한 시간 안에 답을 정리하겠습니다.';
+            if (!partial) handlers.onText?.(finalText, finalText);
+            provisionalTurnMessages = [{ role: 'assistant', content: finalText, phase: 'final_answer' }];
+          } else {
+            finalText = outcome.text;
+          }
+        } finally {
+          if (firstReplyTimer !== undefined) timers.clearTimeout(firstReplyTimer);
+          ctx.signal.removeEventListener('abort', abortFirstPassFromParent);
+        }
+      } else {
+        finalText = await streamLLMWithTools(firstPassMessages, firstPassHandlers, streamOptions(tools));
+      }
       if (researchResultPromise && firstPassStartedAt !== undefined) {
         debug.log('research.turn', 'first-pass-answer-ready', {
           sessionId: ctx.sessionId,
@@ -468,17 +895,29 @@ export async function runCoreTurn(
         });
       }
       if (researchResultPromise) {
-        const racedResearch = await settleBeforeAbort(researchResultPromise, ctx.signal);
-        if (racedResearch.aborted) {
+        const racedResearch = await settleBeforeAbort(researchResultPromise, researchDeadlineSignal ?? ctx.signal);
+        if (racedResearch.aborted && ctx.signal.aborted) {
           commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
           return { stopReason: 'aborted', finalText };
         }
-        const result = racedResearch.value;
+        // A native research tool can ignore cancellation and leave its promise
+        // pending. The deadline must still end the prepass and enter the
+        // no-tools synthesis path with the provisional answer.
+        const result = racedResearch.aborted
+          ? { ok: false, output: '', error: RESEARCH_TURN_DEADLINE_STOP_ERROR }
+          : racedResearch.value;
         if (ctx.signal.aborted) {
           commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
           return { stopReason: 'aborted', finalText };
         }
-        if (result?.ok && result.output.trim() && !ctx.signal.aborted) {
+        const forcedSynthesis = researchStopReason === 'wall-clock-budget' || researchStopReason === 'tool-budget';
+        const hasUsableResearch = Boolean(result?.output.trim())
+          && (result?.ok === true || result?.error === RESEARCH_TURN_DEADLINE_STOP_ERROR);
+        if (forcedSynthesis) {
+          logResearchStop('forced-synthesis', { stage: 'synthesis', trigger: researchStopReason, toolCalls: researchToolCallCount });
+          try { ctx.callbacks?.onStatus?.('조사 한도에 도달해 확인된 근거만으로 답을 정리합니다.'); } catch { /* UI feedback is fail-soft. */ }
+        }
+        if (hasUsableResearch && result && !ctx.signal.aborted) {
           try { ctx.callbacks?.onStatus?.('근거를 반영해 답변을 보강합니다.'); } catch { /* UI feedback is fail-soft. */ }
           const synthesisStartedAt = now();
           debug.log('research.turn', 'synthesis-started', {
@@ -492,9 +931,11 @@ export async function runCoreTurn(
           messages.push(
             { role: 'assistant', content: provisionalText.trim() },
             { role: 'system', content: `<bloom-research>\n${result.output.trim()}\n</bloom-research>` },
-            { role: 'system', content: 'Revise the answer above using this research evidence. Correct any unsupported or contradicted claims, preserve uncertainty, and answer in natural prose. Do not output JSON or a tool transcript. If the evidence does not materially change the answer, state the answer directly.' },
+            { role: 'system', content: forcedSynthesis
+              ? 'The research budget has ended. Synthesize now using only the partial evidence above. State uncertainty and gaps clearly. Do not call tools or continue research.'
+              : 'Revise the answer above using this research evidence. Correct any unsupported or contradicted claims, preserve uncertainty, and answer in natural prose. Do not output JSON or a tool transcript. If the evidence does not materially change the answer, state the answer directly.' },
           );
-          const synthesisTools = tools.filter(tool => !['WebSearch', 'OmniSearch'].includes(tool.name));
+          const synthesisTools = forcedSynthesis ? [] : tools.filter(tool => !['WebSearch', 'OmniSearch'].includes(tool.name));
           try {
             const synthesizedText = await streamLLMWithTools(messages, staged.handlers, streamOptions(synthesisTools));
             if (ctx.signal.aborted) {
@@ -509,12 +950,9 @@ export async function runCoreTurn(
               sinceTurnStartMs: turnStartedAt === undefined ? undefined : now() - turnStartedAt,
               outputChars: finalText.length,
             });
-            if (staged.completion()) {
-              commitStagedTurn(staged.completion(), handlers, finalText, finalText !== provisionalText,
-                value => { finalPhaseAnswer = value; }, ctx.callbacks?.onReplaceText);
-            } else {
-              commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
-            }
+            logResearchStop('synthesis-complete', { stage: 'synthesis', outputChars: finalText.length });
+            commitSynthesizedTurn(staged, provisionalTurnMessages, handlers, finalText, provisionalText,
+              value => { finalPhaseAnswer = value; }, ctx.callbacks?.onReplaceText);
           } catch (error) {
             commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
             const stopReason = classifyStopReason(error, ctx.signal);
@@ -529,15 +967,18 @@ export async function runCoreTurn(
             try { ctx.callbacks?.onStatus?.('근거 반영에 실패해 첫 답변을 유지합니다.'); } catch { /* UI feedback is fail-soft. */ }
             return { stopReason: 'end_turn', finalText: provisionalText, ...(handlers.onTurnComplete ? { finalPhaseAnswer } : {}) };
           }
-        } else if (tools.some(tool => !['WebSearch', 'OmniSearch'].includes(tool.name))) {
-          try { ctx.callbacks?.onStatus?.('근거 검색은 실패해 사용할 수 있는 도구로 답변을 마무리합니다.'); } catch { /* UI feedback is fail-soft. */ }
+        } else if (forcedSynthesis || tools.some(tool => !['WebSearch', 'OmniSearch'].includes(tool.name))) {
+          try { ctx.callbacks?.onStatus?.(forcedSynthesis ? '조사 한도에 도달해 첫 답변을 근거 없이 확장하지 않고 마무리합니다.' : '근거 검색은 실패해 사용할 수 있는 도구로 답변을 마무리합니다.'); } catch { /* UI feedback is fail-soft. */ }
           const provisionalText = finalText;
           const staged = createStagedHandlers(handlers);
           messages.push(
             { role: 'assistant', content: provisionalText.trim() },
-            { role: 'system', content: 'Research evidence was unavailable. Continue answering the user using available non-search tools as needed. Do not invoke web search.' },
+            ...(result?.output.trim() ? [{ role: 'system' as const, content: `<partial-research>\n${result.output.trim()}\n</partial-research>` }] : []),
+            { role: 'system', content: forcedSynthesis
+              ? 'The research budget has ended. Synthesize now without tools. Use any partial evidence above and clearly state uncertainty; do not continue research.'
+              : 'Research evidence was unavailable. Continue answering the user using available non-search tools as needed. Do not invoke web search.' },
           );
-          const fallbackTools = tools.filter(tool => !['WebSearch', 'OmniSearch'].includes(tool.name));
+          const fallbackTools = forcedSynthesis ? [] : tools.filter(tool => !['WebSearch', 'OmniSearch'].includes(tool.name));
           try {
             const fallbackText = await streamLLMWithTools(messages, staged.handlers, streamOptions(fallbackTools));
             if (ctx.signal.aborted) {
@@ -546,12 +987,8 @@ export async function runCoreTurn(
             }
             finalText = fallbackText || staged.text() || provisionalText;
             accumulatedText = finalText;
-            if (staged.completion()) {
-              commitStagedTurn(staged.completion(), handlers, finalText, finalText !== provisionalText,
-                value => { finalPhaseAnswer = value; }, ctx.callbacks?.onReplaceText);
-            } else {
-              commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
-            }
+            commitSynthesizedTurn(staged, provisionalTurnMessages, handlers, finalText, provisionalText,
+              value => { finalPhaseAnswer = value; }, ctx.callbacks?.onReplaceText);
           } catch (error) {
             commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
             const stopReason = classifyStopReason(error, ctx.signal);