elanous 0.2.40 → 0.2.42

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

@@ -33,6 +33,8 @@ import type {
   CoreTurnStopReason,
 } from './types.js';
 
+const CORE_TURN_TOOL_RESULT_INLINE_LIMIT_BYTES = 50 * 1024;
+
 /** 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
@@ -76,6 +78,21 @@ function selectSurfaceUserText(ctx: CoreTurnContext): string | undefined {
   return ctx.userText;
 }
 
+/** An explicit named-skill request must reach the normal tool loop before
+ *  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 {
+  if (!text) return false;
+  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)
+    || new RegExp(`\\b${action}\\s+(?:the\\s+)?([a-z0-9][a-z0-9-]{1,40})\\s+skill\\b`, 'i').test(text)
+    || /스킬\s+(?:이름(?:은|이)?\s*)?['"“‘「]([\p{L}\p{N}][\p{L}\p{N}\p{M}_ -]{1,60}?)['"”’」]\s*(?:을|를)?\s*(?:사용|호출|실행)/iu.test(text)
+    || /['"“‘「]([\p{L}\p{N}][\p{L}\p{N}\p{M}_ -]{1,60}?)['"”’」]\s*스킬?\s*(?:을|를)?\s*(?:사용|호출|실행)/iu.test(text)
+    || /([\p{L}\p{N}_-]{2,60})\s+스킬\s*(?:을|를)?\s*(?:사용|호출|실행)/iu.test(text);
+}
+
 /**
  * Execute one agent turn against the configured LLM provider using
  * the tool catalog and dispatcher the caller injected. Returns when
@@ -102,7 +119,71 @@ function selectSurfaceUserText(ctx: CoreTurnContext): string | undefined {
  */
 export interface RunCoreTurnOptions {
   now?: () => number;
-  runResearch?: (request: string) => Promise<{ ok: boolean; output: string; error?: string }>;
+  runResearch?: (request: string, signal: AbortSignal) => Promise<{ ok: boolean; output: string; error?: string }>;
+}
+
+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) => {
+    const onAbort = () => {
+      signal.removeEventListener('abort', onAbort);
+      resolve({ aborted: true });
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    work.then(
+      value => { signal.removeEventListener('abort', onAbort); resolve({ aborted: false, value }); },
+      error => { signal.removeEventListener('abort', onAbort); reject(error); },
+    );
+  });
+}
+
+type TurnCompletion = Parameters<NonNullable<StreamWithToolsHandlers['onTurnComplete']>>[0];
+
+function createStagedHandlers(handlers: StreamWithToolsHandlers) {
+  let text = '';
+  let completion: TurnCompletion | undefined;
+  return {
+    handlers: {
+      ...handlers,
+      onText: (_delta: string, full: string) => { text = full; },
+      onTurnComplete: (messages: TurnCompletion) => { completion = messages; },
+    } satisfies StreamWithToolsHandlers,
+    text: () => text,
+    completion: () => completion,
+  };
+}
+
+function commitCompletion(
+  messages: TurnCompletion | undefined,
+  handlers: StreamWithToolsHandlers,
+  setFinalPhaseAnswer: (value: boolean) => void,
+): void {
+  if (!messages) return;
+  const lastAssistant = [...messages].reverse().find(message => message.role === 'assistant');
+  setFinalPhaseAnswer(lastAssistant?.phase === 'final_answer');
+  handlers.onTurnComplete?.(messages);
+}
+
+function commitProvisionalTurn(
+  messages: TurnCompletion | undefined,
+  handlers: StreamWithToolsHandlers,
+  setFinalPhaseAnswer: (value: boolean) => void,
+): void {
+  commitCompletion(messages, handlers, setFinalPhaseAnswer);
+}
+
+function commitStagedTurn(
+  messages: TurnCompletion | undefined,
+  handlers: StreamWithToolsHandlers,
+  text: string,
+  replaceVisibleText: boolean,
+  setFinalPhaseAnswer: (value: boolean) => void,
+  onReplaceText?: (fullText: string) => void,
+): void {
+  commitCompletion(messages, handlers, setFinalPhaseAnswer);
+  if (replaceVisibleText && text) onReplaceText?.(text);
 }
 
 export async function runCoreTurn(
@@ -110,6 +191,9 @@ export async function runCoreTurn(
   options: RunCoreTurnOptions = {},
 ): Promise<CoreTurnResult> {
   const now = options.now ?? Date.now;
+  let turnStartedAt: number | undefined;
+  let researchStartedAt: number | undefined;
+  let researchFirstTokenRecorded = false;
   // ⭐⭐⭐ 스코프를 열기 **전에** 간선을 남긴다 — 열고 나서 찍으면 그 행마저 코어 세션으로 귀속돼
   //   ***채팅 세션 조회에 안 걸리고, 이 수리가 고치려는 결함을 그대로 반복한다***(원장 `MEAS-S14`).
   //   ⚠️ 세션 값은 바꾸지 않는다. 없던 **간선**만 는다.
@@ -134,6 +218,15 @@ export async function runCoreTurn(
     const handlers: StreamWithToolsHandlers = {
     onText: (delta, full) => {
       accumulatedText = full;
+      if (researchStartedAt !== undefined && !researchFirstTokenRecorded && delta.length > 0) {
+        researchFirstTokenRecorded = true;
+        debug.log('research.turn', 'first-token', {
+          sessionId: ctx.sessionId,
+          sinceTurnStartMs: turnStartedAt === undefined ? undefined : now() - turnStartedAt,
+          sinceResearchStartMs: now() - researchStartedAt,
+          outputChars: full.length,
+        });
+      }
       ctx.callbacks?.onText?.(delta, full);
     },
     ...(ctx.callbacks?.onStatus ? { onStatus: (line: string) => ctx.callbacks?.onStatus?.(line) } : {}),
@@ -262,105 +355,236 @@ export async function runCoreTurn(
   ) {
     messages.unshift(buildResearchDateSystemMessage());
   }
-  if (researchTurn && surfaceUserText?.trim()) {
-    debug.log('research.turn', 'tui-research-started', { sessionId: ctx.sessionId });
-    try {
-      const result = await (options.runResearch ?? (async (request) => {
-        // 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));
-      }))(surfaceUserText);
-      if (result.output.trim()) {
-        messages.unshift({
-          role: 'system',
-          content: `<bloom-research>\n${result.output.trim()}\n</bloom-research>\nUse this axis evidence and counterevidence in the answer; preserve uncertainty and distinguish sourced facts from inference.`,
-        });
-      }
-      debug.log('research.turn', 'tui-research-completed', {
+    let researchResultPromise: Promise<{ ok: boolean; output: string; error?: string } | null> | undefined;
+    const explicitSkillToolRequest = requestsNamedSkill(surfaceUserText)
+      && tools.some((tool) => tool.name === 'skill_exec');
+    if (researchTurn && surfaceUserText?.trim() && !explicitSkillToolRequest) {
+      turnStartedAt = now();
+      researchStartedAt = turnStartedAt;
+      debug.log('research.turn', 'tui-research-started', {
         sessionId: ctx.sessionId,
-        ok: result.ok,
-        outputChars: result.output.length,
-        fallbackReason: result.error,
+        sinceTurnStartMs: researchStartedAt - turnStartedAt,
       });
-    } catch (error) {
-      debug.log('research.turn', 'tui-research-fallback', {
+      // 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. */ }
+      researchResultPromise = (async () => {
+        try {
+          const result = await (options.runResearch ?? (async (request, signal) => {
+            // 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);
+          debug.log('research.turn', 'tui-research-completed', {
+            sessionId: ctx.sessionId,
+            ok: result.ok,
+            outputChars: result.output.length,
+            fallbackReason: result.error,
+            elapsedMs: researchStartedAt === undefined ? undefined : now() - researchStartedAt,
+          });
+          return result;
+        } catch (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;
+        }
+      })();
+    }
+    const streamOptions = (turnTools: typeof tools) => ({
+      tools: turnTools,
+      researchTurn,
+      signal: ctx.signal,
+      ...(ctx.requestSizeGuard ? { requestSizeGuard: ctx.requestSizeGuard } : {}),
+      toolResultInlineLimitBytes: CORE_TURN_TOOL_RESULT_INLINE_LIMIT_BYTES,
+      ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
+      ...(ctx.maxToolTurns !== undefined ? { maxTurns: ctx.maxToolTurns } : {}),
+      ...(ctx.initialProvider !== undefined
+        ? { initialProvider: ctx.initialProvider, ...(ctx.skipProviders ? { skipProviders: ctx.skipProviders } : {}) }
+        : ctx.modelOverride !== undefined ? { model: ctx.modelOverride } : {}),
+      ...(ctx.callbacks?.onResolvedProvider !== undefined ? { onResolvedProvider: ctx.callbacks.onResolvedProvider } : {}),
+      ...(ctx.budgetGrant !== undefined ? { budgetGrant: ctx.budgetGrant } : {}),
+      ...(ctx.terminalToolNames !== undefined ? { terminalToolNames: ctx.terminalToolNames } : {}),
+      ...(ctx.terminalPriorAnswerVisible !== undefined ? { terminalPriorAnswerVisible: ctx.terminalPriorAnswerVisible } : {}),
+      ...(ctx.terminalCompletionAccepted !== undefined ? { terminalCompletionAccepted: ctx.terminalCompletionAccepted } : {}),
+      ...(ctx.sessionId !== undefined ? { drainPendingUserInput: () => drainPendingUserInput(ctx.sessionId!) } : {}),
+    });
+
+    let finalText = '';
+    if (debug.enabled) {
+      debug.log('llm.request', 'tools-tier', {
         sessionId: ctx.sessionId,
-        reason: error instanceof Error ? error.message : String(error),
-      }, { level: 'warn' });
+        totalSpecs: ctx.tools.length,
+        activeCount: stats.activeCount,
+        deferredCount: stats.deferredCount,
+        warmPreloaded: stats.warmPreloaded,
+        injected: stats.injected,
+        mode: deferredEnabled ? 'always' : 'off',
+      });
     }
-  }
-  if (debug.enabled) {
-    debug.log('llm.request', 'tools-tier', {
+    debug.log('capability.resolve', 'tool-tier-split', {
       sessionId: ctx.sessionId,
-      totalSpecs: ctx.tools.length,
+      surfaceId: surface.id,
+      surfaceSelectionReason: surface.selectionReason,
       activeCount: stats.activeCount,
       deferredCount: stats.deferredCount,
+      immediateCount: stats.activeCount,
+      immediate: tools.map((tool) => tool.name),
       warmPreloaded: stats.warmPreloaded,
-      injected: stats.injected,
-      mode: deferredEnabled ? 'always' : 'off',
-    });
-  }
-  debug.log('capability.resolve', 'tool-tier-split', {
-    sessionId: ctx.sessionId,
-    surfaceId: surface.id,
-    surfaceSelectionReason: surface.selectionReason,
-    activeCount: stats.activeCount,
-    deferredCount: stats.deferredCount,
-    immediateCount: stats.activeCount,
-    immediate: tools.map((tool) => tool.name),
-    warmPreloaded: stats.warmPreloaded,
-    deferred: stats.deferredNames,
-    unhydratable: stats.unhydratableNames,
-  }, { compact: { arrayMax: Number.MAX_SAFE_INTEGER } });
-  if (stats.unhydratableCount > 0) {
-    debug.log('capability.resolve', 'unhydratable-capabilities', {
-      sessionId: ctx.sessionId,
-      unhydratableCount: stats.unhydratableCount,
+      deferred: stats.deferredNames,
       unhydratable: stats.unhydratableNames,
-    }, { level: 'warn' });
-  }
-
-  try {
-    const finalText = await streamLLMWithTools(
-      messages,
-      handlers,
-      {
-        tools,
-        researchTurn,
-        signal: ctx.signal,
-        ...(ctx.requestSizeGuard ? { requestSizeGuard: ctx.requestSizeGuard } : {}),
-        ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}),
-        ...(ctx.maxToolTurns !== undefined ? { maxTurns: ctx.maxToolTurns } : {}),
-        ...(ctx.initialProvider !== undefined
-          ? { initialProvider: ctx.initialProvider, ...(ctx.skipProviders ? { skipProviders: ctx.skipProviders } : {}) }
-          : ctx.modelOverride !== undefined ? { model: ctx.modelOverride } : {}),
-        ...(ctx.callbacks?.onResolvedProvider !== undefined ? { onResolvedProvider: ctx.callbacks.onResolvedProvider } : {}),
-        ...(ctx.budgetGrant !== undefined ? { budgetGrant: ctx.budgetGrant } : {}),
-        ...(ctx.terminalToolNames !== undefined ? { terminalToolNames: ctx.terminalToolNames } : {}),
-        ...(ctx.terminalPriorAnswerVisible !== undefined ? { terminalPriorAnswerVisible: ctx.terminalPriorAnswerVisible } : {}),
-        ...(ctx.terminalCompletionAccepted !== undefined ? { terminalCompletionAccepted: ctx.terminalCompletionAccepted } : {}),
-        // ⭐⭐⭐ `B3`(2026-08-19 · 대표 지시 ②) — 도는 턴 «안»으로 들어오는 사용자 발화의 배수구.
-        //   ⛔ 종전엔 스트리밍 중 친 발화가 ***턴이 끝난 뒤***에야 나갔다.
-        //   ⭐ 이제 «다음 모델 요청을 만들기 직전»(루프 경계)에 이력으로 들어가고,
-        //     문면이 「기존 작업을 마저 끝내라」를 같이 준다(`chat/interjection.ts`).
-        ...(ctx.sessionId !== undefined
-          ? { drainPendingUserInput: () => drainPendingUserInput(ctx.sessionId!) }
-          : {}),
-      },
-    );
-    try {
-      debug.log('core.turn', 'dispatch-summary', {
+    }, { compact: { arrayMax: Number.MAX_SAFE_INTEGER } });
+    if (stats.unhydratableCount > 0) {
+      debug.log('capability.resolve', 'unhydratable-capabilities', {
         sessionId: ctx.sessionId,
-        dispatchCount,
-      });
-    } catch {
-      // Observability must not prevent a completed turn from returning.
+        unhydratableCount: stats.unhydratableCount,
+        unhydratable: stats.unhydratableNames,
+      }, { level: 'warn' });
     }
-    return {
-      stopReason: ctx.signal.aborted ? 'aborted' : 'end_turn',
-      finalText,
-      ...(ctx.callbacks?.onTurnComplete ? { finalPhaseAnswer } : {}),
-    };
+
+    try {
+      let provisionalTurnMessages: Parameters<NonNullable<StreamWithToolsHandlers['onTurnComplete']>>[0] | undefined;
+      const firstPassHandlers: StreamWithToolsHandlers = researchResultPromise && handlers.onTurnComplete
+        ? { ...handlers, onTurnComplete: (newMessages) => { provisionalTurnMessages = newMessages; } }
+        : handlers;
+      const firstPassMessages = researchResultPromise
+        ? [...messages, {
+          role: 'system' as const,
+          content: 'This is a provisional first response while source evidence is being gathered. Answer concisely from available context, mark uncertainty, and do not claim current facts are verified. A later evidence-reconciliation phase can use tools; do not claim a requested tool or skill is unavailable in this provisional response.',
+        }]
+        : messages;
+      const firstPassStartedAt = researchResultPromise ? now() : undefined;
+      finalText = await streamLLMWithTools(firstPassMessages, firstPassHandlers, streamOptions(researchResultPromise ? [] : tools));
+      if (researchResultPromise && firstPassStartedAt !== undefined) {
+        debug.log('research.turn', 'first-pass-answer-ready', {
+          sessionId: ctx.sessionId,
+          durationMs: now() - firstPassStartedAt,
+          sinceTurnStartMs: turnStartedAt === undefined ? undefined : now() - turnStartedAt,
+          sinceResearchStartMs: researchStartedAt === undefined ? undefined : now() - researchStartedAt,
+          outputChars: finalText.length,
+        });
+      }
+      if (researchResultPromise) {
+        const racedResearch = await settleBeforeAbort(researchResultPromise, ctx.signal);
+        if (racedResearch.aborted) {
+          commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
+          return { stopReason: 'aborted', finalText };
+        }
+        const result = 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) {
+          try { ctx.callbacks?.onStatus?.('근거를 반영해 답변을 보강합니다.'); } catch { /* UI feedback is fail-soft. */ }
+          const synthesisStartedAt = now();
+          debug.log('research.turn', 'synthesis-started', {
+            sessionId: ctx.sessionId,
+            sinceTurnStartMs: turnStartedAt === undefined ? undefined : synthesisStartedAt - turnStartedAt,
+            researchElapsedMs: researchStartedAt === undefined ? undefined : synthesisStartedAt - researchStartedAt,
+          });
+          const provisionalText = finalText;
+          accumulatedText = provisionalText;
+          const staged = createStagedHandlers(handlers);
+          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.' },
+          );
+          const synthesisTools = tools.filter(tool => !['WebSearch', 'OmniSearch'].includes(tool.name));
+          try {
+            const synthesizedText = await streamLLMWithTools(messages, staged.handlers, streamOptions(synthesisTools));
+            if (ctx.signal.aborted) {
+              commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
+              return { stopReason: 'aborted', finalText: provisionalText };
+            }
+            finalText = synthesizedText || staged.text() || provisionalText;
+            accumulatedText = finalText;
+            debug.log('research.turn', 'synthesis-completed', {
+              sessionId: ctx.sessionId,
+              elapsedMs: now() - synthesisStartedAt,
+              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; });
+            }
+          } catch (error) {
+            commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
+            const stopReason = classifyStopReason(error, ctx.signal);
+            if (stopReason === 'aborted') return { stopReason, finalText: provisionalText };
+            if (stopReason === 'auth_rejected') {
+              return {
+                stopReason,
+                finalText: provisionalText,
+                errorMessage: redactSecretText(error instanceof Error ? error.message : String(error)),
+              };
+            }
+            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. */ }
+          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.' },
+          );
+          const fallbackTools = tools.filter(tool => !['WebSearch', 'OmniSearch'].includes(tool.name));
+          try {
+            const fallbackText = await streamLLMWithTools(messages, staged.handlers, streamOptions(fallbackTools));
+            if (ctx.signal.aborted) {
+              commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
+              return { stopReason: 'aborted', finalText: provisionalText };
+            }
+            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; });
+            }
+          } catch (error) {
+            commitProvisionalTurn(provisionalTurnMessages, handlers, value => { finalPhaseAnswer = value; });
+            const stopReason = classifyStopReason(error, ctx.signal);
+            if (stopReason === 'aborted') return { stopReason, finalText: provisionalText };
+            if (stopReason === 'auth_rejected') {
+              return {
+                stopReason,
+                finalText: provisionalText,
+                errorMessage: redactSecretText(error instanceof Error ? error.message : String(error)),
+              };
+            }
+            try { ctx.callbacks?.onStatus?.('도구 fallback이 실패해 첫 답변을 유지합니다.'); } catch { /* UI feedback is fail-soft. */ }
+            return { stopReason: 'end_turn', finalText: provisionalText, ...(handlers.onTurnComplete ? { finalPhaseAnswer } : {}) };
+          }
+        } else if (provisionalTurnMessages && ctx.callbacks?.onTurnComplete) {
+          const lastAssistant = [...provisionalTurnMessages].reverse().find(message => message.role === 'assistant');
+          finalPhaseAnswer = lastAssistant?.phase === 'final_answer';
+          ctx.callbacks.onTurnComplete(provisionalTurnMessages);
+        }
+      }
+      try {
+        debug.log('core.turn', 'dispatch-summary', {
+          sessionId: ctx.sessionId,
+          dispatchCount,
+        });
+      } catch {
+        // Observability must not prevent a completed turn from returning.
+      }
+      return {
+        stopReason: ctx.signal.aborted ? 'aborted' : 'end_turn',
+        finalText,
+        ...(ctx.callbacks?.onTurnComplete ? { finalPhaseAnswer } : {}),
+      };
     } catch (err) {
       const stopReason = classifyStopReason(err, ctx.signal);
       if (stopReason === 'aborted') {

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

@@ -211,6 +211,40 @@ export function isInterimReportShaped(text: string): boolean {
   return INTERIM_REPORT_SHAPED.test(text);
 }
 
+// TUI-FACT-TOOL-REPEAT — 턴 안에서 같은 값을 보장하는 안정 read-only 도구만 억제한다.
+//   Registry-wide readOnly metadata는 없다(FU). Live/poll·stream-consuming 조회(MsgList,
+//   ChecklistList, PtyShellPoll, AgentOutput), 외부 조회와 쓰기 동작은 이 좁은 목록 밖이다.
+const GOAL_LOOP_READ_ONLY_TOOL_NAMES: ReadonlySet<string> = new Set([
+  'Read', 'Grep', 'Glob', 'ListDir', 'release_status', 'self_recall', 'ops_seats', 'decisions_pending', 'proact_meter',
+]);
+
+/** TUI-FACT-TOOL-REPEAT — 중복 판정 키: 도구명 + 인자의 stable 직렬화(키 순서와 무관하게 같은 내용=같은 키). */
+function goalLoopReadOnlyCallKey(name: string, args: Record<string, unknown>): string {
+  return `${name}:${stableSerializeToolArgs(args)}`;
+}
+
+function stableSerializeToolArgs(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? String(value);
+  if (Array.isArray(value)) return `[${value.map(stableSerializeToolArgs).join(',')}]`;
+  const entries = Object.entries(value as Record<string, unknown>)
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([key, entry]) => `${JSON.stringify(key)}:${stableSerializeToolArgs(entry)}`);
+  return `{${entries.join(',')}}`;
+}
+
+type ReadOnlyRepeatCacheEntry =
+  | { kind: 'inflight'; pending: Promise<unknown> }
+  | { kind: 'ok'; result: unknown }
+  | { kind: 'error'; error: unknown };
+
+/** TUI-FACT-TOOL-REPEAT — 오류 캐시 적중 시 재호출 없이 돌려주는 억제 안내: 실패 근거를 실어
+ *  이 도구를 다시 호출하지 말고, 이 실패를 설명하는 최종 답으로 종결하게 유도한다. */
+function buildReadOnlyRepeatSuppressedNotice(name: string, error: unknown): string {
+  const reason = error instanceof Error ? error.message : String(error);
+  return `[tool repeat suppressed] ${name} 은(는) 이 턴에서 이미 같은 인자로 실패했습니다(오류: ${reason}). `
+    + `재시도는 억제되어 실제로 실행하지 않았습니다 — 이 도구를 다시 호출하지 말고, 이 실패 근거를 설명하는 최종 답을 지금 작성하세요.`;
+}
+
 /** 목표 실행 계약 — 첫 turn 앞에 leading system 메시지로 주입. codex 자체 prompt.md /
  *  ext-goal continuation.md 의 지속·anti-shrink·증거완료 언어 이식. ASCII + 한국어. */
 export const GOAL_SYSTEM_PREAMBLE = [
@@ -355,6 +389,8 @@ export interface GoalLoopOptions {
   contextPressureRatio?: number;
   /** 테스트 seam — runCoreTurn 주입(모듈 mock 오염 회피). 기본 = 실제 runCoreTurn. */
   runTurn?: (ctx: CoreTurnContext) => Promise<CoreTurnResult>;
+  /** Drain evidence that arrived while the previous iteration was running. */
+  drainIterationMessages?: () => readonly LLMMessage[];
   /** Test seam — process-owned lifecycle bridge attach. */
   attachLifecycleBridge?: (bus: ChannelBus, runId: string) => () => void;
   /** Test seam — snapshot the child worktree at successful completion. */
@@ -783,6 +819,22 @@ export async function runGoalLoop(
         }, { level: 'info' });
       }
     }
+    // Child results can arrive while runCoreTurn is active. Harvest them at this live
+    // iteration boundary so the next model call sees them without waiting for a new turn.
+    try {
+      const arrived = opts.drainIterationMessages?.() ?? [];
+      if (arrived.length > 0) {
+        messages.push(...arrived);
+        debug.log('goal.loop', 'iteration-messages-drained', {
+          sessionId: ctx.sessionId, ...runAttribution, iteration: iterations + 1, count: arrived.length,
+        }, { level: 'info' });
+      }
+    } catch (error) {
+      debug.log('goal.loop', 'iteration-message-drain-failed', {
+        sessionId: ctx.sessionId, ...runAttribution, iteration: iterations + 1,
+        error: error instanceof Error ? error.message : String(error),
+      }, { level: 'warn' });
+    }
     iterations += 1;
 
     // 이 turn 이 누적한 메시지(assistant 텍스트 + tool_use/result)를 회수해 다음
@@ -790,6 +842,30 @@ export async function runGoalLoop(
     let turnNewMessages: LLMMessage[] = [];
     let dispatchCount = 0;
     toolCallsThisIteration = 0;
+    // TUI-FACT-TOOL-REPEAT — 이번 core 턴의 read-only 중복 억제 캐시. 턴 시작마다 새로 만든다
+    //   (캐시는 현재 턴 밖으로 유지하지 않는다 — 다음 반복은 새 턴이라 같은 조회도 다시 실제 실행된다).
+    const readOnlyRepeatCache = new Map<string, ReadOnlyRepeatCacheEntry>();
+    let readOnlyRepeatGeneration = 0;
+    const invalidateReadOnlyRepeatCache = () => {
+      readOnlyRepeatGeneration += 1;
+      readOnlyRepeatCache.clear();
+    };
+    const dispatchEffect = (
+      name: string, args: Record<string, unknown>, dctx: Parameters<CoreTurnContext["dispatchTool"]>[2],
+      ack?: () => Promise<unknown>,
+    ) => {
+      // A write or external effect can change a later read in this same turn. Clear before dispatch,
+      // then clear again on settlement so an in-flight read cannot repopulate stale data.
+      invalidateReadOnlyRepeatCache();
+      let dispatched: Promise<unknown>;
+      try {
+        dispatched = Promise.resolve(seatDispatch(name, args, dctx, ack ? (() => ack()) : undefined));
+      } catch (error) {
+        invalidateReadOnlyRepeatCache();
+        return Promise.reject(error);
+      }
+      return dispatched.finally(invalidateReadOnlyRepeatCache);
+    };
     let iterInputTokens = 0;
     let iterOutputTokens = 0;
     let iterCacheReadTokens = 0;
@@ -932,9 +1008,37 @@ export async function runGoalLoop(
           // 종결 신호는 예산 거부를 받지 않는다(#28503 terminalToolNames 계약과 같은 방향). 그 밖의 진행 선언
           // (in_progress·blocked)은 도구 한 번으로 세고 상한 뒤엔 같은 안내로 거부한다(리뷰 r2 — 61번 넘게 불러도 안 막히던 구멍).
           if ((args as { status?: unknown }).status === 'complete') return ack();
-          return seatDispatch(name, args, dctx, ack);
+          return dispatchEffect(name, args, dctx, ack);
+        }
+        // TUI-FACT-TOOL-REPEAT — update_goal 가로채기 판정 «뒤» read-only 실 실행 직전:
+        //   동일 read-only tool+args 는 이 턴에서 실제 실행 1회 이하(성공 결과 재사용 · 오류 재시도 억제).
+        //   쓰기·외부 효과 도구는 허용목록 밖이라 억제 없이 매번 실제 실행된다(경계 보존).
+        if (GOAL_LOOP_READ_ONLY_TOOL_NAMES.has(name)) {
+          const repeatKey = goalLoopReadOnlyCallKey(name, args);
+          const cachedRepeat = readOnlyRepeatCache.get(repeatKey);
+          if (cachedRepeat !== undefined) {
+            try {
+              debug.log('goal.loop', 'readonly-tool-repeat-suppressed', {
+                sessionId: ctx.sessionId, ...runAttribution, iteration: iterations,
+                tool: name, dispatch: dispatchCount, outcome: cachedRepeat.kind,
+              }, { level: 'info' });
+            } catch {
+              // Observability must not change the suppressed result.
+            }
+            if (cachedRepeat.kind === 'inflight') return cachedRepeat.pending;
+            if (cachedRepeat.kind === 'ok') return Promise.resolve(cachedRepeat.result);
+            return Promise.resolve(buildReadOnlyRepeatSuppressedNotice(name, cachedRepeat.error));
+          }
+          const generation = readOnlyRepeatGeneration;
+          const dispatchedRead = Promise.resolve(seatDispatch(name, args, dctx));
+          readOnlyRepeatCache.set(repeatKey, { kind: 'inflight', pending: dispatchedRead });
+          dispatchedRead.then(
+            (result) => { if (generation === readOnlyRepeatGeneration) readOnlyRepeatCache.set(repeatKey, { kind: 'ok', result }); },
+            (error) => { if (generation === readOnlyRepeatGeneration) readOnlyRepeatCache.set(repeatKey, { kind: 'error', error }); },
+          );
+          return dispatchedRead;
         }
-        return seatDispatch(name, args, dctx);
+        return dispatchEffect(name, args, dctx);
       },
       callbacks: {
         ...ctx.callbacks,

package/src/core-turn/types.ts

@@ -84,6 +84,8 @@ export interface CoreTurnCallbacks {
   /** Streaming text delta — `full` is the accumulated text across the
    *  entire turn (not just the current round). */
   onText?(delta: string, full: string): void;
+  /** Replace a provisional visible answer after staged synthesis succeeds. */
+  onReplaceText?(full: string): void;
   /** Transient runtime status (for example, a stream retry notice). */
   onStatus?(line: string): void;
   /** The final answer came back enriched with a runtime verification