elanous 0.2.38 → 0.2.41

package/src/control-plane/ledger.ts

@@ -29,6 +29,9 @@ interface PodWorkerLeaseAttrs {
   idleTtlMs: number;
   leaseId?: string;
   leaseOwner?: string;
+  /** The just-sanitized generation remains fenceable until the next acquisition. */
+  lastLeaseId?: string;
+  lastLeaseOwner?: string;
   runId?: string;
   attemptId?: string;
   reason?: string;
@@ -235,8 +238,11 @@ export class ResourceLedger {
     if (index < 0) throw new ResourceLedgerError(409, 'no-warm-worker');
     const row = rows[index]!;
     const attrs = workerAttrs(row);
-    const next: ResourceRecord = { ...row, attrs: { ...attrs, state: 'leased', generation: attrs.generation + 1,
-      leaseId: randomUUID(), leaseOwner: request.owner, runId: request.runId, attemptId: request.attemptId },
+    const nextAttrs: PodWorkerLeaseAttrs = { ...attrs, state: 'leased', generation: attrs.generation + 1,
+      leaseId: randomUUID(), leaseOwner: request.owner, runId: request.runId, attemptId: request.attemptId };
+    delete nextAttrs.lastLeaseId;
+    delete nextAttrs.lastLeaseOwner;
+    const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>,
       observedAt: at, ttlMs: request.ttlMs };
     rows[index] = next;
     this.write(rows);
@@ -252,9 +258,13 @@ export class ResourceLedger {
     if (index < 0) throw new ResourceLedgerError(404, 'not-found');
     const row = rows[index]!;
     const attrs = workerAttrs(row);
-    if (!request.leaseId || attrs.leaseId !== request.leaseId || attrs.generation !== request.generation) throw new ResourceLedgerError(409, 'stale-worker-lease');
+    const lateIdleQuarantine = request.action === 'quarantine' && attrs.state === 'idle'
+      && attrs.lastLeaseId === request.leaseId && attrs.generation === request.generation;
+    if (!request.leaseId || (attrs.leaseId !== request.leaseId && !lateIdleQuarantine)
+      || attrs.generation !== request.generation) throw new ResourceLedgerError(409, 'stale-worker-lease');
     const permitted = request.action === 'sanitize' ? row.owner === request.owner
       : request.action === 'quarantine' ? row.owner === request.owner || attrs.leaseOwner === request.owner
+        || (lateIdleQuarantine && attrs.lastLeaseOwner === request.owner)
       : attrs.leaseOwner === request.owner;
     if (!permitted) {
       throw new ResourceLedgerError(403, 'not-owner');
@@ -266,7 +276,14 @@ export class ResourceLedger {
     const state: PodWorkerState = request.action === 'renew' ? 'leased' : request.action === 'release' ? 'sanitizing'
       : request.action === 'sanitize' ? 'idle' : 'quarantined';
     const nextAttrs: PodWorkerLeaseAttrs = { ...attrs, state, ...(request.reason ? { reason: request.reason } : {}) };
-    if (state === 'idle') { delete nextAttrs.leaseId; delete nextAttrs.leaseOwner; delete nextAttrs.runId; delete nextAttrs.attemptId; delete nextAttrs.reason; }
+    if (state === 'idle') {
+      nextAttrs.lastLeaseId = attrs.leaseId;
+      nextAttrs.lastLeaseOwner = attrs.leaseOwner;
+      delete nextAttrs.leaseId; delete nextAttrs.leaseOwner; delete nextAttrs.runId; delete nextAttrs.attemptId; delete nextAttrs.reason;
+    } else if (state === 'quarantined') {
+      delete nextAttrs.lastLeaseId;
+      delete nextAttrs.lastLeaseOwner;
+    }
     const ttlMs = state === 'idle' ? attrs.idleTtlMs : request.ttlMs ?? row.ttlMs;
     const next: ResourceRecord = { ...row, attrs: nextAttrs as unknown as Record<string, unknown>, observedAt: now, ttlMs };
     rows[index] = next;

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

@@ -25,6 +25,7 @@ import { drainPendingUserInput } from '../session/pending-input.js';
 import type { StreamWithToolsHandlers } from '../llm.js';
 import { debug, redactSecretText, withAmbientSessionScope } from '../debug/log.js';
 import { applyDeferredTools } from '../session-runtime/tier-flip.js';
+import { isResearchAgentIntent } from '../tool-hints/signals.js';
 import { buildResearchDateSystemMessage, resolveSessionSurfaceProfile } from '../session-runtime/index.js';
 import type {
   CoreTurnContext,
@@ -32,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
@@ -101,6 +104,7 @@ function selectSurfaceUserText(ctx: CoreTurnContext): string | undefined {
  */
 export interface RunCoreTurnOptions {
   now?: () => number;
+  runResearch?: (request: string) => Promise<{ ok: boolean; output: string; error?: string }>;
 }
 
 export async function runCoreTurn(
@@ -127,12 +131,14 @@ export async function runCoreTurn(
 
     let accumulatedText = '';
     let dispatchCount = 0;
+    let finalPhaseAnswer = false;
 
     const handlers: StreamWithToolsHandlers = {
     onText: (delta, full) => {
       accumulatedText = full;
       ctx.callbacks?.onText?.(delta, full);
     },
+    ...(ctx.callbacks?.onStatus ? { onStatus: (line: string) => ctx.callbacks?.onStatus?.(line) } : {}),
     ...(ctx.callbacks?.onFinalAnswerSupplement
       ? { onFinalAnswerSupplement: (info: { answer: string; supplement: string; finalText: string }) => ctx.callbacks?.onFinalAnswerSupplement?.(info) }
       : {}),
@@ -213,7 +219,11 @@ export async function runCoreTurn(
     handlers.onUsage = (usage) => ctx.callbacks!.onUsage!(usage);
   }
   if (ctx.callbacks?.onTurnComplete) {
-    handlers.onTurnComplete = (msgs) => ctx.callbacks!.onTurnComplete!(msgs);
+    handlers.onTurnComplete = (msgs) => {
+      const lastAssistant = [...msgs].reverse().find((message) => message.role === 'assistant');
+      finalPhaseAnswer = lastAssistant?.phase === 'final_answer';
+      ctx.callbacks!.onTurnComplete!(msgs);
+    };
   }
   if (ctx.callbacks?.onReasoning) {
     handlers.onReasoning = (event) => ctx.callbacks!.onReasoning!(event);
@@ -240,17 +250,47 @@ export async function runCoreTurn(
   const recentUserText = extractRecentUserText(ctx.messages);
   const surfaceUserText = selectSurfaceUserText(ctx);
   const surface = ctx.surfaceProfile ?? resolveSessionSurfaceProfile({ userText: surfaceUserText });
+  // 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(
     ctx.messages,
     ctx.tools,
     { enabled: deferredEnabled, ...(recentUserText ? { userText: recentUserText } : {}) },
   );
-  if (surface.id === 'research/agent' && !messages.some((message) =>
+  if (researchTurn && !messages.some((message) =>
     message.role === 'system' && typeof message.content === 'string'
       && message.content.startsWith('Current local date:'))
   ) {
     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', {
+        sessionId: ctx.sessionId,
+        ok: result.ok,
+        outputChars: result.output.length,
+        fallbackReason: result.error,
+      });
+    } catch (error) {
+      debug.log('research.turn', 'tui-research-fallback', {
+        sessionId: ctx.sessionId,
+        reason: error instanceof Error ? error.message : String(error),
+      }, { level: 'warn' });
+    }
+  }
   if (debug.enabled) {
     debug.log('llm.request', 'tools-tier', {
       sessionId: ctx.sessionId,
@@ -288,8 +328,10 @@ export async function runCoreTurn(
       handlers,
       {
         tools,
-        researchTurn: surface.id === 'research/agent',
+        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
@@ -299,6 +341,7 @@ export async function runCoreTurn(
         ...(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 · 대표 지시 ②) — 도는 턴 «안»으로 들어오는 사용자 발화의 배수구.
         //   ⛔ 종전엔 스트리밍 중 친 발화가 ***턴이 끝난 뒤***에야 나갔다.
         //   ⭐ 이제 «다음 모델 요청을 만들기 직전»(루프 경계)에 이력으로 들어가고,
@@ -319,6 +362,7 @@ export async function runCoreTurn(
     return {
       stopReason: ctx.signal.aborted ? 'aborted' : 'end_turn',
       finalText,
+      ...(ctx.callbacks?.onTurnComplete ? { finalPhaseAnswer } : {}),
     };
     } catch (err) {
       const stopReason = classifyStopReason(err, ctx.signal);

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

@@ -46,6 +46,7 @@ import {
   SEAT_IDLE_NO_WORK_NOTICE, SEAT_TURN_CAP_CONTINUE_PROMPT, SEAT_TURN_CAP_TOOL_NOTICE,
   isEmptyMailListResult, isIdleWaitCall, type SeatTurnCapConfig,
 } from './seat-turn-cap.js';
+import type { TuiChatContext } from './short-question.js';
 
 export {
   CHILD_LIVENESS_HEARTBEAT_ENV,
@@ -186,10 +187,64 @@ export const GOAL_FINAL_ITERATION_NOTE =
 
 /** 중간 답이 «최종 보고형»(미완 목록)인가 — 관측 전용(행동을 바꾸지 않는다). */
 const INTERIM_REPORT_SHAPED = /(?:보고할 수 없|하지\s?못했습니다|못\s?했습니다|완료되지 않았|검증되지 않았|확인하지 못했|not (?:yet )?(?:verified|completed)|cannot report)/i;
+// TUI-FINAL-ANSWER-COMPLETION(S5 · 10-12 S5-01 실측) — «단순 상태·상황 질문 턴»의 결정론 판별.
+//   LLM 호출 0 — 질문 문면만으로 분류한다(AL-eb6797f3b7: 첫 조각은 결정론 분류만). 이 턴의 «완료»는
+//   파일·시험이 아니라 완결 답변 자체다. 그 밖의 실제 골 턴(코딩·자리 운영·쓰기 지시)은 기존대로
+//   update_goal 증거 게이트를 지킨다 — 필요한 작업 도구와 update_goal 을 같은 턴에 쓰는 경로는 그대로다.
+export async function isSimpleStatusQuestionTurn(
+  userText: string | undefined,
+  ctx: TuiChatContext = {},
+): Promise<boolean> {
+  if (!userText) return false;
+  const { classifyTuiChatIntent, isSeatOpsDirective } = await import('./short-question.js');
+  if (isSeatOpsDirective(userText)) return false;
+  const chat = classifyTuiChatIntent(userText, ctx);
+  if (chat.goalLoop || chat.route === '코딩·구현') return false;
+  if (chat.route === '조회') return true;
+  // 읽기·분석 은 «판정기가 잡지 못한 나머지 전부»의 기본 라우팅이기도 하다(reason 'read') —
+  // 작업 지시(예: 「네 편 영상 재촬영」)까지 상태 질문으로 들이면 진행 중인 골이
+  // 미완 진행 한 줄 답에 완결 답으로 끊긴다(TUI-GOAL-INTERIM-QUIET 반례). 물음 형태만 수용한다.
+  return chat.route === '읽기·분석' && chat.reason === 'short-question';
+}
+
 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 = [
@@ -316,6 +371,8 @@ export function stripGoalRepeatReadbackPreface(text: string): string {
 export interface GoalLoopOptions {
   /** 목표 문구(관측·프레이밍용). 생략 시 마지막 user 메시지에서 추출. */
   objective?: string;
+  /** ACP 대화형 호출자는 false로 기존 provider 재호출 유지; 비대화형·직접 실행은 기본 단축. */
+  terminalCompletionShortcut?: boolean;
   /** across-turn 최대 반복. 폭주 방지 하드캡. 기본 8. (ralph max_iterations 류) */
   maxIterations?: number;
   /** 연속 무진전(동일 tool 시그니처 반복) 허용 횟수 → 초과 시 no_progress 종료로 caller 가
@@ -524,6 +581,12 @@ export async function runGoalLoop(
   //   ✅ 진입 시점의 messages 에는 아직 그 기계 문장이 «없다» ⇒ 여기서 뽑은 값이 이 턴의 사람 문장이다.
   //   ⛔ 고정 prefix 사전으로 「기계 문장인지」를 판별하지 «않는다» — 미등록·변형 프롬프트를 오판하기 때문이다.
   const surfaceUserText = ctx.userText ?? extractRecentUserText(ctx.messages);
+  // TUI-FINAL-ANSWER-COMPLETION(S5) — 이 턴이 «단순 상태·상황 질문»인가(결정론 분류 · LLM 호출 0).
+  //   seatTurnCap 유무를 자리 TUI 판정 신호로 넘긴다 — 자리의 읽기·운영 지시는 기존대로 골 루프를 탄다.
+  const statusQuestionTurn = await isSimpleStatusQuestionTurn(
+    surfaceUserText,
+    { seat: opts.seatTurnCap != null },
+  );
   const harnessRunId = getHarnessRunId();
   const runAttribution = harnessRunId ? { runId: harnessRunId } : {};
 
@@ -570,6 +633,8 @@ export async function runGoalLoop(
   let intentStallReprompts = 0;
   // GOAL-LOOP-MIDRUN-STALL — 도구를 쓴 «뒤»의 말뿐인 턴 재촉은 런당 1회뿐이다.
   let intentStallMidrunUsed = false;
+  // TUI-FINAL-ANSWER-COMPLETION(S5) — 상태 질문 턴의 미완 보고형 답 재촉도 런당 1회뿐이다(④ 참조).
+  let statusQuestionInterimReprompted = false;
 
   debug.log('goal.loop', 'start', {
     sessionId: ctx.sessionId, ...runAttribution, objective, maxIterations, noProgressLimit,
@@ -638,7 +703,8 @@ export async function runGoalLoop(
         reportShaped, finalChars: lastResult.finalText.length,
       }, { level: 'debug' });
     } catch { /* 관측 실패가 루프를 막지 않는다 */ }
-    // Only a real continuation is interim; terminal and last-iteration answers stay visible.
+    // Every non-empty reply that crosses a real iteration boundary is display-only interim;
+    // the renderer's shared verdict decides whether it folds, independent of this loop's continuation reason.
     if (lastResult.finalText.trim()) ctx.callbacks?.onGoalInterim?.(lastResult.finalText, iterations);
     const nextIteration = iterations + 1;
     const toolBudget = ctx.maxToolTurns ?? TOOL_LOOP_MAX_TURNS_DEFAULT;
@@ -758,6 +824,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;
@@ -851,6 +941,17 @@ export async function runGoalLoop(
       goalRepeatWithheld = '';
       ctx.callbacks?.onText?.(withheld, full);
     };
+    const flushNovelGoalRepeatWithheld = (full: string): void => {
+      if (goalRepeatWithheld === '') return;
+      const readback = stripGoalRepeatReadbackPreface(goalRepeatWithheld);
+      const normalized = goalRepeatStreamNormalize(readback);
+      const prior = goalRepeatPreviousAnswer;
+      const novel = normalized.startsWith(prior)
+        ? normalized.slice(prior.length)
+        : normalized;
+      goalRepeatWithheld = '';
+      if (novel.length > 0) ctx.callbacks?.onText?.(novel, full);
+    };
     const turnCtx: CoreTurnContext = {
       ...ctx,
       messages,
@@ -860,8 +961,12 @@ export async function runGoalLoop(
       ...(surfaceUserText !== undefined ? { userText: surfaceUserText } : {}),
       // TUI-GOAL-LOOP-FRICTION(#46·#63) — update_goal 은 도구 예산 거부를 받지 않고, 답과 함께 오면 그 턴으로 마감한다.
       terminalToolNames: [...(ctx.terminalToolNames ?? []), UPDATE_GOAL_TOOL_NAME],
-      // TUI-H1-GOALLOOP-EMPTY-TAIL — 앞 iteration 의 답이 이미 화면에 있으면 «update_goal 만 → 빈 턴» 은 할 말이 없는
-      //   것이다 — 재촉·경고 없이 빈 답으로 끝내고 아래 완료 판정이 앞 답으로 마감한다(중복 접기와 같은 길).
+      ...(opts.terminalCompletionShortcut !== false ? {
+        terminalCompletionAccepted: (name: string, args: Record<string, unknown>) => name === UPDATE_GOAL_TOOL_NAME
+          && args.status === 'complete' && typeof args.evidence === 'string' && args.evidence.trim().length > 0,
+      } : {}),
+      // The visible-answer hint also guards ACP's legacy empty-tail path; only
+      // the validated completion shortcut is caller-scoped.
       ...(previousFinalText.trim().length > 0 ? { terminalPriorAnswerVisible: true } : {}),
       // update_goal 은 종결 신호 — 실 dispatcher 로 새지 않게 가로채 ack 만 돌려준다.
       dispatchTool: (name, args, dctx) => {
@@ -885,9 +990,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);
         }
-        return seatDispatch(name, args, dctx);
+        // 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 dispatchEffect(name, args, dctx);
       },
       callbacks: {
         ...ctx.callbacks,
@@ -902,6 +1035,13 @@ export async function runGoalLoop(
               return;
             }
             goalRepeatWithholding = false;
+            const combined = goalRepeatWithheld + delta;
+            if (opts.terminalCompletionShortcut !== false && previousFinalText
+              && stripGoalRepeatReadbackPreface(combined).startsWith(previousFinalText)) {
+              goalRepeatWithheld = combined;
+              flushNovelGoalRepeatWithheld(full);
+              return;
+            }
             flushGoalRepeatWithheld(full);
           }
           ctx.callbacks?.onText?.(delta, full);
@@ -955,7 +1095,17 @@ export async function runGoalLoop(
             const pureRepeat = normalized === goalRepeatPreviousAnswer
               || GOAL_REPEAT_READBACK_PHRASES.some((phrase) => normalized.startsWith(phrase)
                 && normalized.slice(phrase.length).replace(GOAL_REPEAT_PREFACE_SEPS, '') === goalRepeatPreviousAnswer);
-            if (!pureRepeat) flushGoalRepeatWithheld(normalized);
+            if (!pureRepeat) {
+              // A completion-only round may have skipped LLM onText because the prior
+              // answer is already visible. Keep only its genuinely new suffix.
+              if (opts.terminalCompletionShortcut !== false && previousFinalText
+                && stripGoalRepeatReadbackPreface(goalRepeatWithheld).startsWith(previousFinalText)) {
+                flushNovelGoalRepeatWithheld(goalRepeatWithheld);
+              } else {
+                // ACP keeps its legacy normalized iteration-flush behavior.
+                flushGoalRepeatWithheld(normalized);
+              }
+            }
           }
           turnNewMessages = msgs;
           ctx.callbacks?.onTurnComplete?.(msgs);
@@ -1018,13 +1168,22 @@ export async function runGoalLoop(
 
     // ①-0 #29 처방 — 자리 운영 턴은 빈 evidence 를 반려하지 않고 이 턴의 답을 증거로 받는다(관측 남김).
     //      답도 비었으면 받을 증거가 없다 — 종전 반려(evidence required)로 그대로 간다.
-    const lenientAnswer = opts.lenientCompletionEvidence === true
-      ? boundReadableText(lastResult.finalText, 200).text.trim()
-      : '';
+    //      TUI-FINAL-ANSWER-COMPLETION(S5) — 단순 상태 질문 턴도 같은 수용을 받는다: 이 턴의 «완료»는
+    //      완결 답변 자체다. 빈 evidence 로 반려·재주입하면 답 뒤 빈 턴이 [NO FINAL SYNTHESIS] 로
+    //      떨어져 최종 답이 비었다(10-12 S5-01 실측). 그 안내 문면 자체는 «증거»가 아니다.
+    const lenientScope: 'seat' | 'status-question' | null = opts.lenientCompletionEvidence === true
+      ? 'seat'
+      : statusQuestionTurn && !lastResult.finalText.includes('[NO FINAL SYNTHESIS]')
+        ? 'status-question'
+        : null;
+    const lenientAnswer = lenientScope === null
+      ? ''
+      : boundReadableText(lastResult.finalText, 200).text.trim();
     if (goalUpdate?.status === 'complete' && goalUpdate.evidence.trim().length === 0 && lenientAnswer.length > 0) {
-      goalUpdate.evidence = `(자리 운영 턴 — 답을 증거로 수용) ${lenientAnswer}`;
+      goalUpdate.evidence = `${lenientScope === 'status-question' ? '(상태 질문 턴 — 완결 답을 증거로 수용)' : '(자리 운영 턴 — 답을 증거로 수용)'} ${lenientAnswer}`;
       debug.log('goal.loop', 'complete-evidence-lenient', {
         sessionId: ctx.sessionId, ...runAttribution, iterations, finalChars: lastResult.finalText.length,
+        scope: lenientScope,
       }, { level: 'info' });
     }
 
@@ -1177,6 +1336,60 @@ export async function runGoalLoop(
       continue;
     }
 
+    // An explicit provider final phase is a bounded terminal signal for a
+    // substantial structured answer outside the coding executor. A finished
+    // report must not reopen tools solely because update_goal was omitted.
+    const structuredFinalAnswer = lastResult.finalPhaseAnswer === true
+      && getHarnessRole() !== 'executor'
+      && lastResult.finalText.trim().length >= 1_200
+      && (lastResult.finalText.match(/^#{1,3}\s+\S+/gm)?.length ?? 0) >= 2
+      && goalUpdate == null
+      && rejectedTools.length === 0
+      && !markerComplete
+      && !markerBlocked
+      && runTests.last?.ok !== false
+      && !seatCapHit;
+    if (structuredFinalAnswer) {
+      debug.log('goal.loop', 'complete', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations, via: 'structured-final-phase',
+        finalChars: lastResult.finalText.length,
+      }, { level: 'info' });
+      return finish(
+        { finalText: lastResult.finalText, iterations, stopReason: 'goal_complete', goalComplete: true },
+        { summary: 'Structured answer completed in the provider final phase.', changedFiles: [] },
+      );
+    }
+
+    // ③-5 TUI-FINAL-ANSWER-COMPLETION(S5) — 단순 상태 질문 턴의 완결한 최종 답 = 그 턴의 목표 달성이다.
+    //     structuredFinalAnswer 가 «대형 보고서»의 종결 신호라면, 이것은 그 «한 줄 답» 짝이다. «완료 신호는
+    //     update_goal 호출뿐»이라는 계약은 실제 골 턴(코딩·자리 운영·쓰기)의 것이다 — 상태 질문 턴에 그대로
+    //     밀면 완결 답 뒤에 불필요한 update_goal 재촉이 이어붙고 빈 턴이 [NO FINAL SYNTHESIS] 로 떨어져
+    //     최종 답이 비었다(10-12 S5-01 실측 · 0.2.28 TUI-NO-SYNTH-FALLBACK은 그 빈 답의 사람 말 안내일 뿐).
+    //     결정론 분류(statusQuestionTurn) 턴에서 이번 반복이 도구·신호 없이 완결 답으로 끝났으면 추가 골
+    //     도구 0으로 종결한다. 미완 보고형(isInterimReportShaped)과 [NO FINAL SYNTHESIS] 안내 문면은 완결 답이 아니다.
+    const statusQuestionFinalAnswer = statusQuestionTurn
+      && getHarnessRole() !== 'executor'
+      && goalUpdate == null
+      && rejectedTools.length === 0
+      && !markerComplete
+      && !markerBlocked
+      && runTests.last?.ok !== false
+      && !seatCapHit
+      && lastResult.stopReason === 'end_turn'
+      && lastResult.finalText.trim().length > 0
+      && !isInterimReportShaped(lastResult.finalText)
+      && !lastResult.finalText.includes('[NO FINAL SYNTHESIS]');
+    if (statusQuestionFinalAnswer) {
+      debug.log('goal.loop', 'complete', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations, via: 'status-question-final-answer',
+        finalChars: lastResult.finalText.length,
+      }, { level: 'info' });
+      return finish(
+        { finalText: lastResult.finalText, iterations, stopReason: 'goal_complete', goalComplete: true },
+        { summary: '상태 질문 턴 완결 답 종결 — 추가 골 도구 0 (TUI-FINAL-ANSWER-COMPLETION S5)', changedFiles: [] },
+      );
+    }
+
     // ② blocked(구조화 or 마커) — 3연속(hysteresis)일 때만 수용(조기 give-up 방지).
     if (goalUpdate?.status === 'blocked' || markerBlocked) {
       blockedStreak += 1;
@@ -1244,7 +1457,24 @@ export async function runGoalLoop(
 
     // ④ 순수 텍스트(도구 없음)로 끝났고 종결 신호도 없음 = 일상 답변(목표성 작업 아님).
     //    재주입하지 않고 그대로 수용해 trivial chat 을 이중 루프하지 않는다.
+    //    TUI-FINAL-ANSWER-COMPLETION(S5) — 단 하나의 예외: «단순 상태 질문» 턴의 미완 보고형 답
+    //    (예: 「아직 확인하지 못했습니다」)은 유효한 최종 답이 아니다. 런당 1회만 continuation 을
+    //    재주입해 답을 완성하게 한다(④-0b «런당 1회» 관례와 같은 상한). 두 번째에도 그 모양이면
+    //    이곳의 수용으로 그대로 끝난다 — 이중 루프 방지·maxIterations 하드캡 불변.
     if (!toolActivity) {
+      if (statusQuestionTurn
+        && !seatCapHit
+        && lastResult.finalText.trim().length > 0
+        && isInterimReportShaped(lastResult.finalText)
+        && !lastResult.finalText.includes('[NO FINAL SYNTHESIS]')
+        && !statusQuestionInterimReprompted) {
+        statusQuestionInterimReprompted = true;
+        debug.log('goal.loop', 'status-question-interim-reprompt', {
+          sessionId: ctx.sessionId, ...runAttribution, iterations, finalChars: lastResult.finalText.length,
+        }, { level: 'info' });
+        reinject(GOAL_CONTINUATION_PROMPT);
+        continue;
+      }
       debug.log('goal.loop', 'text-only-accept', { sessionId: ctx.sessionId, ...runAttribution, iterations }, { level: 'info' });
       return finish({ finalText: lastResult.finalText, iterations, stopReason: lastResult.stopReason, goalComplete: false });
     }

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;
+  /** Transient runtime status (for example, a stream retry notice). */
+  onStatus?(line: string): void;
   /** The final answer came back enriched with a runtime verification
    *  supplement — forwarded from `StreamWithToolsHandlers.onFinalAnswerSupplement`. */
   onFinalAnswerSupplement?(info: { answer: string; supplement: string; finalText: string }): void;
@@ -142,6 +144,9 @@ export interface CoreTurnContext {
   surfaceProfile?: import('../session-runtime/index.js').SessionSurfaceProfile;
   /** Full prompt (system + history + current user blocks). */
   messages: LLMMessage[];
+  /** Optional provider request-size hook. Only providers with a measured
+   *  serializer consume it; all others retain their existing request path. */
+  requestSizeGuard?: LLMOpts['requestSizeGuard'];
   /** Tool catalog the model may call this turn. Empty array means
    *  "text-only" — the loop delegates to plain `streamLLM`. */
   tools: LLMToolSpec[];
@@ -166,6 +171,8 @@ export interface CoreTurnContext {
   /** TUI-H1-GOALLOOP-EMPTY-TAIL — 이 턴 «앞»에 사람에게 답을 이미 보였다. `streamLLMWithTools` 의
    *  `terminalPriorAnswerVisible` 로 그대로 간다(종결 신호 뒤 빈 턴 = 경고 없이 빈 답). goal loop 가 넣는다. */
   terminalPriorAnswerVisible?: LLMOpts['terminalPriorAnswerVisible'];
+  /** Only a structurally valid goal completion may stop before the next provider request. */
+  terminalCompletionAccepted?: LLMOpts['terminalCompletionAccepted'];
   /** Optional model override (forwarded to `streamLLMWithTools`). */
   modelOverride?: string;
   /** TUI-400-AUTOHEAL-FALLBACK — 이 턴을 이 공급자부터 연다(`streamLLMWithTools` `initialProvider` · 폴백은 허용).
@@ -178,6 +185,8 @@ export interface CoreTurnContext {
 export interface CoreTurnResult {
   stopReason: CoreTurnStopReason;
   finalText: string;
+  /** The completed provider response explicitly marked its last assistant answer as final. */
+  finalPhaseAnswer?: boolean;
   /** `auth_rejected` 일 때만 — 공급자 오류 원문(비밀값 가림). 호스트가 처방 줄에 원문을 붙인다. */
   errorMessage?: string;
 }