elanous 0.2.28 → 0.2.31

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

@@ -41,6 +41,10 @@ import { attachLifecycleBridge } from '../signal/lifecycle-bridge.js';
 import { getChannelBus } from '../terminal-matrix/index.js';
 import type { ChannelBus } from '../terminal-matrix/channel-bus.js';
 import { startChildLivenessHeartbeat } from './child-liveness-heartbeat.js';
+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';
 
 export {
   CHILD_LIVENESS_HEARTBEAT_ENV,
@@ -164,6 +168,11 @@ export function buildUpdateGoalToolSpec(): LLMToolSpec {
   };
 }
 
+/** 반려·재요청은 모델에게만 가는 내부 지시다 — 사용자 답에 그 사정(«완료 주장이 거부됐다»·«죄송합니다»)이 새지 않게 한다
+ *  (10-14 OPT 점검: evidence·rejected 판정 14회가 사용자 답의 사과 문장으로 나왔다). */
+export const GOAL_INTERNAL_NOTICE_RULE =
+  '이 반려·재요청은 내부 지시다. 사용자에게 보이는 답에 «완료 주장이 거부됐다/어긋났다»·«죄송합니다» 같은 내부 사정을 쓰지 말고, 고친 결과와 사실만 말하라.';
+
 /** 목표 실행 계약 — 첫 turn 앞에 leading system 메시지로 주입. codex 자체 prompt.md /
  *  ext-goal continuation.md 의 지속·anti-shrink·증거완료 언어 이식. ASCII + 한국어. */
 export const GOAL_SYSTEM_PREAMBLE = [
@@ -173,6 +182,7 @@ export const GOAL_SYSTEM_PREAMBLE = [
   '- 완료는 증거로 판정한다. 모든 요구사항/산출물/검증에 대해 실제 현재 상태에서 증거를 확인하라. 불확실하거나 간접적인 증거는 미달성으로 보고 계속하라.',
   `- 목표가 실제로 완전히 끝났고 증거로 확인됐을 때만 ${UPDATE_GOAL_TOOL_NAME} 도구를 status="complete" 로 호출하고 evidence 에 그 증거를 적어 종료하라. 완료 신호는 이 도구 호출뿐이다(텍스트 문장이 아니다).`,
   '- 아직 할 일이 남았으면 멈추거나 허락을 구하지 말고 다음 최고가치 스텝을 바로 실행하라.',
+  `- [continue]·[finalize]·[evidence required]·[evidence mismatch]·[tool call rejected] 같은 반려·재요청은 내부 지시다. 사용자에게 보이는 답에 «완료 주장이 거부됐다/어긋났다»·«죄송합니다» 같은 내부 사정을 쓰지 말고, ${UPDATE_GOAL_TOOL_NAME} 호출도 답에서 설명하지 마라.`,
 ].join('\n');
 
 /** 미완 판정 시 재주입하는 continuation 프롬프트(user turn). */
@@ -186,6 +196,7 @@ export const GOAL_CONTINUATION_PROMPT = [
   '예산이 곧 소진된다거나 그만두고 싶다는 이유로 완료를 선언하지 마라.',
   `진짜로 진행이 막혔고(같은 장애가 반복) 대안도 없을 때만 ${UPDATE_GOAL_TOOL_NAME} 도구를 status="blocked" 로 호출하고 무엇이 왜 막혔는지 evidence 에 적어라. 단지 어렵거나 느리거나 불확실하다는 이유로는 쓰지 마라.`,
   `모든 요구사항이 증거로 충족됐다면, ${UPDATE_GOAL_TOOL_NAME} 도구를 status="complete" + evidence 로 호출해 종료하라.`,
+  GOAL_INTERNAL_NOTICE_RULE,
 ].join('\n');
 
 /** 감독 메모 블록의 머리말 — 자식이 「이것은 부모가 보낸 것」임을 «구별»하게 한다. */
@@ -198,6 +209,7 @@ export const GOAL_READBACK_PROMPT = [
   `완료를 텍스트로만 말했다. 텍스트 문장은 완료 신호가 아니다 — 완료가 사실이면 ${UPDATE_GOAL_TOOL_NAME} 도구를 status="complete" 로 호출하고 evidence 에 현재 상태에서 실제로 확인한 증거(파일·명령출력·테스트·PR)를 적어라.`,
   '아직 미충족 항목이 있으면 완료를 주장하지 말고 다음 스텝을 지금 실행하라.',
   '이미 사용자에게 한 답을 다시 쓰지 마라 — 새 사실이 없으면 텍스트 없이 update_goal 만 호출하라.',
+  GOAL_INTERNAL_NOTICE_RULE,
 ].join('\n');
 
 /** GOAL-LOOP-INTENT-STALL (0.2.24 · OP or-audit-1010) — 구현 자식이 «도구를 한 번도 안 부르고 말만 한 턴»에
@@ -222,6 +234,7 @@ export const GOAL_EVIDENCE_REQUIRED_PROMPT = [
   '[evidence required]',
   `${UPDATE_GOAL_TOOL_NAME}(status="complete") 를 호출했지만 evidence 가 비어 있어 완료로 인정하지 않는다.`,
   '현재 상태(파일·명령출력·테스트결과·PR)에서 실제로 확인한 증거를 evidence 에 채워 다시 호출하거나, 미충족 항목을 마저 실행하라.',
+  GOAL_INTERNAL_NOTICE_RULE,
 ].join('\n');
 
 /** evidence-mismatch 반려 재주입 (OH8 후속 PR-2) — update_goal(complete) 를 호출했으나 그 턴까지의
@@ -236,6 +249,7 @@ export function buildEvidenceMismatchPrompt(fail: number, unmatchedFilters: read
       `(fail=${fail}, unmatched=${unmatched}). 완료 증거와 실제 테스트 결과가 어긋난다 — 완료로 인정하지 않는다.`,
     '테스트를 실제로 통과시키거나(fail=0 · 모든 필터 매칭), 완료 주장을 철회하고 남은 작업을 마저 실행하라.',
     '통과한 run_tests 없이 complete 를 다시 주장하지 마라.',
+    GOAL_INTERNAL_NOTICE_RULE,
   ].join('\n');
 }
 
@@ -245,9 +259,41 @@ export function buildRejectedToolCompletionPrompt(rejectedTools: readonly string
     '[tool call rejected]',
     `${UPDATE_GOAL_TOOL_NAME}(status="complete") 를 호출했지만 이 turn 에 ${rejectedTools.join(', ')} 도구 호출이 거부되어 실행되지 않았다. 완료 증거와 실제 도구 결과가 어긋난다 — 완료로 인정하지 않는다.`,
     '거부된 작업을 실제로 다시 실행하거나 완료 주장을 철회하고 남은 작업을 마저 실행하라.',
+    GOAL_INTERNAL_NOTICE_RULE,
   ].join('\n');
 }
 
+/** TUI-GOAL-REPEAT-ANSWER(0.2.32) — goal loop 반복에서 모델이 이전 답을 다시 말할 때 화면에
+ * 같은 답이 두 번 그려지는 중복을 스트림 쪽에서 가려내는 «읽기-되돌림 인사(readback preface)»
+ * 문형. completion 판정의 readbackPreface(이 파일 하단 duplicate-answer 판정)와 같은 문형을
+ * 스트림 쪽에서도 쓴다 — 화면 중복 제거와 원장 중복 제거가 같은 모양을 같은 것으로 본다. 스트림은
+ * 문형이 한 글자씩 이어지는 중에도 판정해야 하므로(regex 전체 매칭이 아니라) 어구를 펼쳐둔 목록이다. */
+const GOAL_REPEAT_READBACK_VERBS = [
+  '', '했습니다', '했지만', '해보니', '해 보니', '해봤지만', '해 봤지만', '했으나', '했는데',
+] as const;
+const GOAL_REPEAT_READBACK_PHRASES: readonly string[] = [
+  '확인 결과',
+  ...GOAL_REPEAT_READBACK_VERBS.flatMap((verb) => (verb === ''
+    ? ['다시 확인', '방금 다시 확인']
+    : [`다시 확인${verb}`, `방금 다시 확인${verb}`])),
+];
+/** preface 뒤에 올 수 있는 구분자(여백·콜론·마침표 등) — 답 앞에 붙은 만큼 통째로 뗀다. */
+const GOAL_REPEAT_PREFACE_SEPS = /^[\s:：,.!?。！？-]+/u;
+/** TUI-GOAL-REPEAT-ANSWER — 스트림 쪽 답 비교 정규화: 여백 종류를 하나로 접고 끝여백을 뗀다. */
+function goalRepeatStreamNormalize(text: string): string {
+  return text.replace(/\s+/gu, ' ').trim();
+}
+
+/** TUI-GOAL-REPEAT-ANSWER — «읽기-되돌림 인사(readback preface) ⊕ 답»에서 인사+구분자를 뗀 나머지(답
+ * 부분)를 돌려준다. 인사가 없으면 원문 그대로. 골 루프의 화면 중복 제거(스트림 대기·버림)와 브리지의
+ * 재표면화 판정(이미 그린 답인가)이 같은 문형을 같은 것으로 보게 하려고 내보낸다. */
+export function stripGoalRepeatReadbackPreface(text: string): string {
+  for (const phrase of GOAL_REPEAT_READBACK_PHRASES) {
+    if (text.startsWith(phrase)) return text.slice(phrase.length).replace(GOAL_REPEAT_PREFACE_SEPS, '');
+  }
+  return text;
+}
+
 export interface GoalLoopOptions {
   /** 목표 문구(관측·프레이밍용). 생략 시 마지막 user 메시지에서 추출. */
   objective?: string;
@@ -285,8 +331,22 @@ export interface GoalLoopOptions {
    *  최대 2번 재촉한다. 생략하면 harness role 이 executor 인 프로세스에서만 활성 provider 로 푼다.
    *  null = 가드 꺼짐. 시험은 이 인자를 명시해 env 에 기대지 않는다. */
   intentStallProvider?: string | null;
+  /** TUI-H1-SEAT-GOALLOOP(#29 처방) — 자리 TUI 의 운영·읽기 지시를 goal loop 로 되돌린 턴에서만 참.
+   *  update_goal(complete) 의 evidence 가 비었을 때 «증거 없음» 반려(재주입) 대신 그 턴의 (비지 않은) 답을 증거로 받아 끝낸다
+   *  (10-14 OPT: 완료 선언 → 증거 부족 반려 → 재호출이 14회 · 사용자 답에 사과 문장). 시험 실패·거부된 도구 반려는 그대로다. */
+  lenientCompletionEvidence?: boolean;
+  /** TUI-SEAT-TURN-CAP — 자리 TUI 의 goal loop 에서만 준다(브리지가 route.reason 'seat-*' 로 판정). 없으면 상한·idle 판정 0(종전).
+   *  ⓐ core 턴 1회당 도구 수·벽시계 상한 — 닿으면 넘는 도구는 실행하지 않고 «한 줄 진행 요약 ⊕ 턴 마감» 을 안내,
+   *     턴이 끝나면 stopReason 을 max_turns 로 두고 다음 반복으로 잇는다(반복 하드캡 maxIterations 는 그대로).
+   *  ⓑ 같은 core 턴의 «새 항목 0» 우편 조회가 연속 idleEmptyMsgListLimit 번이면 «할 일 0» 으로 goal 을 완료한다(idle-no-work). */
+  seatTurnCap?: SeatTurnCapConfig & { seat: string };
+  /** Test seam — 벽시계(ms). 기본 Date.now. */
+  now?: () => number;
 }
 
+/** TUI-SEAT-TURN-CAP — 상한·idle 안내 «뒤» 에도 도구 호출이 이만큼 넘게 오면 그 core 턴을 끝낸다. */
+const SEAT_CAP_REFUSAL_BACKSTOP = 3;
+
 export type GoalLoopStopReason =
   | CoreTurnStopReason        // aborted | error | end_turn | max_turns (마지막 turn 것)
   | 'goal_complete'           // update_goal(complete)+evidence 로 완료 선언
@@ -301,6 +361,8 @@ export interface GoalLoopResult {
   stopReason: GoalLoopStopReason;
   /** 목표가 증거 기준 완료로 선언됐는지(update_goal(complete)+evidence 감지). */
   goalComplete: boolean;
+  /** `auth_rejected` 로 끝났을 때 — 마지막 코어 턴의 공급자 오류 원문(비밀값 가림). */
+  errorMessage?: string;
 }
 
 /** 완료 마커 감지(deprecated fallback) — 마커가 산문 안에 우연히 포함(예: "상수 값은
@@ -453,6 +515,8 @@ export async function runGoalLoop(
   const tools: LLMToolSpec[] = [...ctx.tools, updateGoalSpec];
 
   const noProgressLimit = opts.noProgressLimit ?? 2;
+  const now = opts.now ?? Date.now;
+  let seatCapHits = 0;
   let iterations = 0;
   let noProgress = 0;
   let blockedStreak = 0;
@@ -619,6 +683,57 @@ export async function runGoalLoop(
     let iterUsageMissing = 0;
     let postToolSoftStop = false;
     const turnAbortController = new AbortController();
+    // TUI-SEAT-TURN-CAP — 이번 core 턴의 상한·idle 상태(반복마다 새로).
+    const seatCap = opts.seatTurnCap;
+    const turnStartedAt = now();
+    let seatTools = 0;
+    let seatClosing: 'tools' | 'wall' | 'idle' | null = null;
+    let seatRefusedAfterClose = 0;
+    let seatCapAborted = false;
+    let emptyMailStreak = 0;
+    // 벽시계는 «다음 도구 호출» 에서 잰다 — 도는 스트림·도구는 끊지 않는다(끊고 멈춤이 아니라 마감 안내).
+    // ⛔ 상한이 없으면(사람 TUI·하니스 자식) caller dispatcher 의 Promise 를 «그대로» 돌려준다 — async 로 감싸면
+    //    새 Promise 가 되어 caller-side dispatch 동일성 계약(core-turn-goal-loop.test)이 깨진다(열차 r19d 회귀).
+    //    기본 실행기는 `ctx.dispatchTool(...)` 를 «메서드로» 부른다 — 꺼내 담아 부르면 수신자(this)가 빠진다(리뷰 r5).
+    const seatDispatch = (
+      name: string, args: Record<string, unknown>, dctx: Parameters<CoreTurnContext['dispatchTool']>[2],
+      execute?: CoreTurnContext['dispatchTool'],
+    ): Promise<unknown> => {
+      const run: CoreTurnContext['dispatchTool'] = execute ?? ((n, a, c) => ctx.dispatchTool(n, a, c));
+      if (!seatCap) return run(name, args, dctx);
+      return seatCappedDispatch(seatCap, name, args, dctx, run);
+    };
+    const seatCappedDispatch = async (
+      cap: SeatTurnCapConfig, name: string, args: Record<string, unknown>,
+      dctx: Parameters<CoreTurnContext['dispatchTool']>[2], execute: CoreTurnContext['dispatchTool'],
+    ): Promise<unknown> => {
+      if (seatClosing === null && now() - turnStartedAt >= cap.maxWallMs) seatClosing = 'wall';
+      if (seatClosing === null && seatTools >= cap.maxTools) seatClosing = 'tools';
+      if (seatClosing !== null) {
+        seatRefusedAfterClose += 1;
+        // 받침 — 안내를 받고도 도구를 계속 부르면 이 core 턴만 끝낸다(goal loop 는 다음 반복으로 잇는다).
+        if (seatRefusedAfterClose > SEAT_CAP_REFUSAL_BACKSTOP) {
+          seatCapAborted = true;
+          turnAbortController.abort();
+        }
+        return { error: seatClosing === 'idle'
+          ? SEAT_IDLE_NO_WORK_NOTICE(cap.idleEmptyMsgListLimit)
+          : SEAT_TURN_CAP_TOOL_NOTICE(seatClosing, cap) };
+      }
+      seatTools += 1;
+      const result = await execute(name, args, dctx);
+      if (isEmptyMailListResult(name, result)) {
+        emptyMailStreak += 1;
+        if (emptyMailStreak >= cap.idleEmptyMsgListLimit) {
+          seatClosing = 'idle';
+          return { ...(result as Record<string, unknown>), notice: SEAT_IDLE_NO_WORK_NOTICE(cap.idleEmptyMsgListLimit) };
+        }
+      } else if (!isIdleWaitCall(name, args)) {
+        // 새 우편이 왔거나(비지 않은 조회) 다른 일을 했다 — «할 일 0» 연속이 끊긴다. 대기용 sleep 은 끊지 않는다.
+        emptyMailStreak = 0;
+      }
+      return result;
+    };
     const abortForCaller = () => turnAbortController.abort(ctx.signal.reason);
     if (ctx.signal.aborted) abortForCaller();
     else ctx.signal.addEventListener('abort', abortForCaller, { once: true });
@@ -626,6 +741,34 @@ export async function runGoalLoop(
       postToolSoftStop = true;
       turnAbortController.abort();
     };
+    // TUI-GOAL-REPEAT-ANSWER(0.2.32) — goal loop 반복에서 모델이 이전 iteration 의 답을
+    // 다시 말하면 화면에 같은 답이 두 번 그려진다(관측 2026-10-14 05:37). 원장 쪽 중복은
+    // 아래 completion 판정이 이미 접는다 — 이 검은 화면 push 만 담당한다: 이번 iteration 의
+    // 스트림이 «읽기-되돌림 인사(preface) ⊕ 이전 답»의 접두사로만 진행되는 동안 caller 의
+    // onText 로 흘리지 않고 대기하다, 갈라지는 순간(새 내용) 모은 걸 한 번에 흘린 뒤 그대로
+    // 흘린다. iteration 마감의 순수 중복 판정·버림은 onTurnComplete 에서 한다.
+    const previousFinalText = lastResult.finalText;
+    const goalRepeatPreviousAnswer = goalRepeatStreamNormalize(previousFinalText);
+    let goalRepeatWithheld = '';
+    let goalRepeatWithholding = goalRepeatPreviousAnswer.length > 0;
+    const goalRepeatStreamConsistent = (text: string): boolean => {
+      if (previousFinalText.startsWith(text)) return true;
+      const normalized = goalRepeatStreamNormalize(text);
+      if (goalRepeatPreviousAnswer.startsWith(normalized)) return true;
+      for (const phrase of GOAL_REPEAT_READBACK_PHRASES) {
+        if (phrase.startsWith(normalized)) return true;
+        if (!normalized.startsWith(phrase)) continue;
+        const rest = normalized.slice(phrase.length).replace(GOAL_REPEAT_PREFACE_SEPS, '');
+        if (goalRepeatPreviousAnswer.startsWith(rest)) return true;
+      }
+      return false;
+    };
+    const flushGoalRepeatWithheld = (full: string): void => {
+      if (goalRepeatWithheld === '') return;
+      const withheld = goalRepeatWithheld;
+      goalRepeatWithheld = '';
+      ctx.callbacks?.onText?.(withheld, full);
+    };
     const turnCtx: CoreTurnContext = {
       ...ctx,
       messages,
@@ -633,6 +776,8 @@ export async function runGoalLoop(
       signal: turnAbortController.signal,
       // 진입 시 한 번 정한 사람 문장을 매 라운드에 그대로 내린다(위 주석 참조).
       ...(surfaceUserText !== undefined ? { userText: surfaceUserText } : {}),
+      // TUI-GOAL-LOOP-FRICTION(#46·#63) — update_goal 은 도구 예산 거부를 받지 않고, 답과 함께 오면 그 턴으로 마감한다.
+      terminalToolNames: [...(ctx.terminalToolNames ?? []), UPDATE_GOAL_TOOL_NAME],
       // update_goal 은 종결 신호 — 실 dispatcher 로 새지 않게 가로채 ack 만 돌려준다.
       dispatchTool: (name, args, dctx) => {
         dispatchCount += 1;
@@ -647,12 +792,34 @@ export async function runGoalLoop(
           // Observability must not prevent the selected tool from dispatching.
         }
         if (name === UPDATE_GOAL_TOOL_NAME) {
-          return Promise.resolve({ ok: true, recorded: (args as { status?: unknown }).status ?? null });
+          const ack = () => Promise.resolve({ ok: true, recorded: (args as { status?: unknown }).status ?? null });
+          // TUI-SEAT-TURN-CAP — 진행 선언도 «다른 일» 이다: 빈 우편 조회 연속을 끊는다(리뷰 r1).
+          emptyMailStreak = 0;
+          // 완료 신호(complete)는 상한 «뒤» 에도 받고 도구로 세지 않는다 — 상한 안내가 바로 «마감하라» 이고,
+          // 종결 신호는 예산 거부를 받지 않는다(#28503 terminalToolNames 계약과 같은 방향). 그 밖의 진행 선언
+          // (in_progress·blocked)은 도구 한 번으로 세고 상한 뒤엔 같은 안내로 거부한다(리뷰 r2 — 61번 넘게 불러도 안 막히던 구멍).
+          if ((args as { status?: unknown }).status === 'complete') return ack();
+          return seatDispatch(name, args, dctx, ack);
         }
-        return ctx.dispatchTool(name, args, dctx);
+        return seatDispatch(name, args, dctx);
       },
       callbacks: {
         ...ctx.callbacks,
+        // TUI-GOAL-REPEAT-ANSWER — 이번 iteration 의 스트림이 이전 답의 재방출로만 진행되는
+        // 동안은 caller 의 onText 로 흘리지 않고 대기한다(중복 후보). 갈라지는 순간 모은 걸
+        // 한 번에 흘리고 이후 그대로 흘린다. 빈 청크(라운드 경계·commit)는 상태와 무관하게
+        // 그대로 흘린다 — TUI 의 라운드 확정 신호를 끊지 않는다.
+        onText: (delta, full) => {
+          if (delta !== '' && goalRepeatWithholding) {
+            if (goalRepeatStreamConsistent(goalRepeatWithheld + delta)) {
+              goalRepeatWithheld += delta;
+              return;
+            }
+            goalRepeatWithholding = false;
+            flushGoalRepeatWithheld(full);
+          }
+          ctx.callbacks?.onText?.(delta, full);
+        },
         // OH8 후속 PR-2 — run_tests 결과를 캡처(last-wins). 텍스트 파싱이 아니라 구조체 ok 를 본다.
         onToolResult: (call) => {
           if (call.name === 'run_tests' && call.result && typeof call.result === 'object') {
@@ -693,6 +860,17 @@ export async function runGoalLoop(
           }
         },
         onTurnComplete: (msgs) => {
+          // TUI-GOAL-REPEAT-ANSWER — iteration 마감: 순수 중복이면(이전 답 ± preface 전부)
+          // 흴린 건 버린다 — 이전 답이 이미 화면에 그려져 있어 두 번째는 필요 없다. 아니면
+          // 모은 걸 한 번에 흘린 다음 마감을 넘긴다(브리지 재표면화 판정이 흘린 분량을 본다).
+          if (goalRepeatWithholding) {
+            goalRepeatWithholding = false;
+            const normalized = goalRepeatStreamNormalize(goalRepeatWithheld);
+            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);
+          }
           turnNewMessages = msgs;
           ctx.callbacks?.onTurnComplete?.(msgs);
         },
@@ -719,12 +897,20 @@ export async function runGoalLoop(
       },
     };
 
-    const previousFinalText = lastResult.finalText;
     try {
       lastResult = await runTurn(turnCtx);
     } finally {
       ctx.signal.removeEventListener('abort', abortForCaller);
     }
+    // TUI-SEAT-TURN-CAP — 상한·idle 안내 뒤 «정상 마감» 했거나 받침이 끊은 core 턴만 고쳐 읽는다.
+    //   사람 중단(caller signal)·error·auth_rejected 는 그대로 둔다 — 실제 오류를 상한으로 덮지 않는다(리뷰 r1).
+    const seatClosedTurn = seatCap !== undefined && !ctx.signal.aborted && seatClosing !== null
+      && (lastResult.stopReason === 'end_turn' || lastResult.stopReason === 'max_turns'
+        || (lastResult.stopReason === 'aborted' && seatCapAborted));
+    const seatCapHit = seatClosedTurn && (seatClosing === 'tools' || seatClosing === 'wall');
+    const seatIdleHit = seatClosedTurn && seatClosing === 'idle';
+    if (seatCapHit) lastResult = { ...lastResult, stopReason: 'max_turns' };
+    else if (seatIdleHit && lastResult.stopReason === 'aborted') lastResult = { ...lastResult, stopReason: 'end_turn' };
     messages.push(...turnNewMessages);
 
     const goalUpdate = findGoalUpdate(turnNewMessages);
@@ -744,6 +930,18 @@ export async function runGoalLoop(
       finalTextExcerpt: finalTextExcerpt.text, finalTextExcerptTruncated: finalTextExcerpt.truncated,
     }, { level: 'debug' });
 
+    // ①-0 #29 처방 — 자리 운영 턴은 빈 evidence 를 반려하지 않고 이 턴의 답을 증거로 받는다(관측 남김).
+    //      답도 비었으면 받을 증거가 없다 — 종전 반려(evidence required)로 그대로 간다.
+    const lenientAnswer = opts.lenientCompletionEvidence === true
+      ? boundReadableText(lastResult.finalText, 200).text.trim()
+      : '';
+    if (goalUpdate?.status === 'complete' && goalUpdate.evidence.trim().length === 0 && lenientAnswer.length > 0) {
+      goalUpdate.evidence = `(자리 운영 턴 — 답을 증거로 수용) ${lenientAnswer}`;
+      debug.log('goal.loop', 'complete-evidence-lenient', {
+        sessionId: ctx.sessionId, ...runAttribution, iterations, finalChars: lastResult.finalText.length,
+      }, { level: 'info' });
+    }
+
     // ① authoritative 완료 — update_goal(complete) + 비지 않은 evidence.
     if (goalUpdate?.status === 'complete') {
       if (goalUpdate.evidence.trim().length > 0) {
@@ -856,7 +1054,37 @@ export async function runGoalLoop(
         sessionId: ctx.sessionId, ...runAttribution, iterations, stopReason: lastResult.stopReason,
         finalChars: lastResult.finalText.length,
       }, { level: 'error' });
-      return finish({ finalText: lastResult.finalText, iterations, stopReason: lastResult.stopReason, goalComplete: false });
+      return finish({
+        finalText: lastResult.finalText, iterations, stopReason: lastResult.stopReason, goalComplete: false,
+        ...(lastResult.errorMessage !== undefined ? { errorMessage: lastResult.errorMessage } : {}),
+      });
+    }
+
+    // TUI-SEAT-TURN-CAP ⓑ — «할 일 0»(빈 우편 조회 연속): 이 반복을 완료로 보고 끝낸다(lenient · 대기는 H4/H5 몫).
+    if (seatIdleHit && seatCap) {
+      debug.log('goal.loop', 'idle-no-work', {
+        sessionId: ctx.sessionId, ...runAttribution, seat: seatCap.seat, iteration: iterations,
+        tools: seatTools, wallMs: now() - turnStartedAt, emptyMailStreak,
+      }, { level: 'info' });
+      return finish(
+        { finalText: lastResult.finalText, iterations, stopReason: 'goal_complete', goalComplete: true },
+        { summary: `idle-no-work — ${emptyMailStreak} consecutive empty mailbox checks (seat ${seatCap.seat})`, changedFiles: [] },
+      );
+    }
+    // TUI-SEAT-TURN-CAP ⓐ — 도구·벽시계 상한으로 마감한 core 턴: 요약을 이어받아 다음 반복으로(하드캡이 이긴다).
+    //    ⛔ 빈 근거 complete 가 함께 온 턴은 여기서 잇지 않고 아래 «근거 없는 완료» 판정에 맡긴다(리뷰 r3) —
+    //    적격 완료(lenient 답 수용)는 위 ① 에서 이미 끝났고, 남은 빈 근거 complete 는 종전 계약대로 근거를 다시 묻는다.
+    if (seatCapHit && seatCap && goalUpdate?.status !== 'complete') {
+      debug.log('goal.loop', 'seat-turn-cap', {
+        sessionId: ctx.sessionId, ...runAttribution, seat: seatCap.seat, reason: seatClosing, iteration: iterations,
+        tools: seatTools, wallMs: now() - turnStartedAt, maxTools: seatCap.maxTools, maxWallMs: seatCap.maxWallMs,
+        backstopAborted: seatCapAborted, maxIterations,
+      }, { level: 'info' });
+      seatCapHits += 1;
+      blockedStreak = 0;
+      readbackStreak = 0;
+      messages.push({ role: 'user', content: SEAT_TURN_CAP_CONTINUE_PROMPT });
+      continue;
     }
 
     // Evidence-less completion is not authoritative; only retry after stop and terminal outcomes
@@ -969,6 +1197,13 @@ export async function runGoalLoop(
   }
 
   debug.log('goal.loop', 'max-iterations', { sessionId: ctx.sessionId, ...runAttribution, iterations }, { level: 'warn' });
+  if (opts.seatTurnCap && seatCapHits > 0) {
+    // 실패 시 누구에게(상한에 한 번이라도 닿은 런만 — 일반 하드캡 종료와 섞지 않는다 · 리뷰 r3) — 자리 TUI 가 반복 하드캡까지 다 쓰고 멈췄다: 자리 OP 가 보는 경고 이벤트.
+    debug.log('goal.loop', 'seat-turn-cap-exhausted', {
+      sessionId: ctx.sessionId, ...runAttribution, seat: opts.seatTurnCap.seat, iterations, maxIterations, capHits: seatCapHits,
+      notify: 'seat-op',
+    }, { level: 'warn' });
+  }
   return finish({ finalText: lastResult.finalText, iterations, stopReason: 'max_iterations', goalComplete: false });
   } finally {
     stopLivenessHeartbeat();

package/src/core-turn/seat-turn-cap.ts

@@ -0,0 +1,79 @@
+// TUI-SEAT-TURN-CAP(0.2.31 · OP #9266) — 자리 TUI 의 goal loop 에서만 쓰는 «한 core 턴» 상한 ⊕ «할 일 0» 판정.
+//
+// 배경(10-16 실측): H1(#28487)로 자리 TUI 운영 지시가 goal loop 를 타면서 «1턴 정지» 는 풀렸지만, 반대로 한 core 턴이
+// 도구 121개·18분+ 이어졌다(운영 `llm.maxTurns.codex = null` = 무제한). 전역 config 는 하니스 자식까지 걸리므로
+// 자리 TUI 한정 손잡이를 둔다. 또 일이 떨어진 뒤 빈 MsgList 를 연달아 부르며 턴 안에서 폴링했다(«할 일 0 = 완료» 신호 부재).
+//
+// ⛔ 이 모듈은 import 0 — user-config 가 파서를 가져다 쓴다(순환 없음).
+
+export interface SeatTurnCapConfig {
+  /** core 턴 1회당 실행할 도구 수 상한. update_goal 진행 선언(in_progress·blocked)도 한 번으로 세고, 완료 신호(complete)만 뺀다.
+   *  넘는 호출은 실행하지 않는다. */
+  maxTools: number;
+  /** core 턴 1회당 벽시계 상한(ms). 넘으면 다음 도구 호출부터 실행하지 않는다. */
+  maxWallMs: number;
+  /** 같은 core 턴에서 «새 항목 0» 우편 조회(MsgList)가 연속 이만큼이면 «할 일 0» 으로 완료. */
+  idleEmptyMsgListLimit: number;
+}
+
+export const SEAT_TURN_CAP_DEFAULTS: SeatTurnCapConfig = {
+  maxTools: 60,
+  maxWallMs: 20 * 60_000,
+  idleEmptyMsgListLimit: 2,
+};
+
+function positiveInt(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+
+/** `chat.seatTurnCap` 원문을 읽는다. 객체가 아니거나 유효한 칸이 하나도 없으면 undefined(= 기본값). */
+export function parseSeatTurnCapConfig(raw: unknown): Partial<SeatTurnCapConfig> | undefined {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+  const r = raw as Record<string, unknown>;
+  const out: Partial<SeatTurnCapConfig> = {};
+  const maxTools = positiveInt(r.maxTools);
+  const maxWallMs = positiveInt(r.maxWallMs);
+  const idle = positiveInt(r.idleEmptyMsgListLimit);
+  if (maxTools !== undefined) out.maxTools = maxTools;
+  if (maxWallMs !== undefined) out.maxWallMs = maxWallMs;
+  if (idle !== undefined) out.idleEmptyMsgListLimit = idle;
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+export function resolveSeatTurnCap(override: Partial<SeatTurnCapConfig> | undefined): SeatTurnCapConfig {
+  return { ...SEAT_TURN_CAP_DEFAULTS, ...(override ?? {}) };
+}
+
+/** 우편 조회 도구 이름(카탈로그 aliases). */
+export const MAIL_LIST_TOOL_NAMES: ReadonlySet<string> = new Set(['MsgList', 'msg_list']);
+
+/** 결과가 «새 항목 0» 인 우편 조회인가. 구조체 `count === 0` 만 본다(문자열·messages 길이 추정 없음 — 리뷰 r1). */
+export function isEmptyMailListResult(name: string, result: unknown): boolean {
+  if (!MAIL_LIST_TOOL_NAMES.has(name)) return false;
+  if (!result || typeof result !== 'object') return false;
+  return (result as { count?: unknown }).count === 0;
+}
+
+/** 셸 도구 이름(카탈로그 aliases — RunShell·Bash 계열). */
+export const SHELL_TOOL_NAMES: ReadonlySet<string> = new Set(['RunShell', 'run_shell', 'exec_argv', 'Bash', 'shell']);
+
+/** 대기용 셸 호출(`sleep N`)인가 — 폴링 사이의 기다림은 «할 일 0» 연속을 끊지 않는다. 셸 도구에만 예외(리뷰 r2). */
+export function isIdleWaitCall(name: string, args: unknown): boolean {
+  if (!SHELL_TOOL_NAMES.has(name)) return false;
+  if (!args || typeof args !== 'object') return false;
+  const command = (args as { command?: unknown }).command;
+  return typeof command === 'string' && /^\s*sleep\s+\d+(?:\.\d+)?[smh]?\s*;?\s*$/.test(command);
+}
+
+export const SEAT_TURN_CAP_TOOL_NOTICE = (reason: 'tools' | 'wall', cap: SeatTurnCapConfig): string =>
+  `SEAT TURN CAP — this core turn reached its ${reason === 'tools' ? `tool limit (${cap.maxTools} tools)` : `wall-clock limit (${Math.round(cap.maxWallMs / 60_000)} min)`}; this call was NOT run. `
+  + 'Do not call more tools in this turn. Write a one-line progress summary now (what is done · what remains) and end the turn; '
+  + 'the goal loop starts the next iteration and you continue the remaining work there.';
+
+export const SEAT_IDLE_NO_WORK_NOTICE = (limit: number): string =>
+  `NO NEW WORK — ${limit} consecutive mailbox checks returned 0 new messages. Do not poll again in this turn. `
+  + 'Write a one-line status and end the turn; this goal is complete (waiting for new mail is handled outside the turn).';
+
+export const SEAT_TURN_CAP_CONTINUE_PROMPT =
+  '앞 core 턴이 자리 턴 상한(도구 수 또는 벽시계)에 닿아 마감됐다. 위의 진행 요약을 이어받아 남은 일을 계속하라. '
+  + '다 끝났으면 update_goal(status:"complete", evidence) 로 마감하라.';

package/src/core-turn/short-question.ts

@@ -23,7 +23,35 @@ const TASK = /(?:작업|파일|폴더|디렉터리|레포|저장소|커밋|브
 const PATH_OR_CODE = /(?:https?:\/\/|www\.|[\w.-]+\/[\w./-]+|\.(?:ts|tsx|js|py|md|json|yaml|swift|kt)\b|[`{};=<>])/i;
 const LIVE = /(?:오늘\s*(?:날짜|며칠|무슨\s*요일)|지금\s*몇\s*시|최신|뉴스|속보|주가|시세|환율|날씨|today'?s|latest|news|stock|weather|right now)/i;
 
-export type TuiChatRoute = '조회' | '설정 변경' | '조사' | '상시 일' | '코딩·구현';
+export type TuiChatRoute = '조회' | '설정 변경' | '조사' | '상시 일' | '읽기·분석' | '코딩·구현';
+const TUI_CHAT_ROUTES: readonly TuiChatRoute[] = ['조회', '설정 변경', '조사', '상시 일', '읽기·분석', '코딩·구현'];
+
+// goal loop 밖 턴이 답 앞에 먼저 보내는 «라우팅 줄»(core-turn-bridge) — 형식의 정본은 여기 하나다.
+export function formatTuiRouteLine(route: TuiChatRoute): string {
+  return `라우팅: ${route}\n`;
+}
+// 그 줄 «그대로»인 청크만 참이다 — 모델 출력의 시작으로 세지 않을 때 쓴다(compact-400 재시도 판정 · 0.2.29).
+export function isTuiRouteLine(chunk: string): boolean {
+  return TUI_CHAT_ROUTES.some((route) => chunk === formatTuiRouteLine(route));
+}
+
+// 읽기·분석(goal loop 밖 단일 턴 · 도구 전체) 자리에서도 goal 을 지키는 셋 — «해줘» 없는 쓰기 꼴 · 디버깅 · 목표 명시.
+// 쓰기 낱말은 «동사로 쓰일 때»만 문다(«추가 정보» · «갱신된 칸» · «기록된 결정» 은 읽기다).
+const WRITE_INTENT = /(?:(?:추가|작성|기록|반영|갱신|업데이트|개선|수정|변경|교체|생성|적용|도입|설계|연결|정정)(?=\s*(?:해|하|할|합|좀|$|[.!]))|적어|붙여|넣어|만들|고치|바꾸|올려|채워|\b(?:add|write|append|insert|implement)\b)/i;
+const DEBUG_INTENT = /(?:디버그|디버깅|에러|오류|크래시|깨져|깨짐|안\s*(?:돼|됨|되네|된다)|\b(?:debug|error|crash|broken|fails?|failing)\b)/i;
+const EXPLICIT_GOAL = /(?:^\/goal\b|목표\s*[:：]|\bgoal\s*:)/i;
+const REPO_NOUN = /(?:코드|스크립트|소스|브랜치|서버|파일|레포|저장소|\bPR\b|\b(?:code|script|branch|server|file|repo)\b)/i;
+// A named CLI command («(eln msg list --to OPT)» · «`git log`») or the seat mailbox is work the research
+// allowlist cannot do (no RunShell · no MsgList) — it is a full-tool read, not the «조사» quick route
+// (TUI-QUICK-ROUTE-EXPLICIT-CMD · 10-16 OPT: «우편 확인(eln msg list …) … 조사» answered «셸 도구가 없다»).
+const EXPLICIT_COMMAND = /(?:(?<![\w-])(?:eln|elanous|git|gh)\s+[a-z][\w-]*|우편)/i;
+
+function writeDebugOrGoal(q: string): 'write-intent' | 'debug' | 'explicit-goal' | null {
+  if (WRITE_INTENT.test(q)) return 'write-intent';
+  if (DEBUG_INTENT.test(q)) return 'debug';
+  if (EXPLICIT_GOAL.test(q)) return 'explicit-goal';
+  return null;
+}
 
 export interface TuiChatVerdict {
   route: TuiChatRoute;
@@ -31,8 +59,23 @@ export interface TuiChatVerdict {
   goalLoop: boolean;
 }
 
-/** Request verbs a quick lookup/settings/research/scheduling turn can carry out without the repository. */
-const QUICK_REQUEST_VERBS = /^(?:보여|알려|확인해|찾아|찾아봐|조사해|검색해|정리해|요약해|바꿔|변경해|전환해|설정해|맞춰|수정해|고쳐|만들어|등록해|예약해|추가해|보내)$/;
+/** 자리(무인) TUI 인가 — 호출부가 `detectSeatTui` 로 정한다. 없으면 사람 대화 TUI(종전 판정 그대로). */
+export interface TuiChatContext extends ShortQuestionContext {
+  seat?: boolean;
+}
+
+// TUI-H1-SEAT-GOALLOOP — 자리 앞으로 온 «운영 지시» 꼴: 우편·오더 · 이름 있는 CLI 명령 · «OP 13:14:» 머리 · «계속 —» · «다음 행».
+// (10-16 OPT 13:14 «OP 13:14: 계속 — draft 다음 행.» 이 읽기·분석 단일 턴으로 가 «다음 점검 13:20» 만 남기고 멈췄다.)
+const SEAT_OPS_DIRECTIVE = /(?:우편|오더|(?<![\w-])(?:eln|elanous|git|gh)\s+[a-z][\w-]*|^\[?OP\s*\d{1,2}:\d{2}|(?:^|[\s:：])계속(?:\s*[—–-]|\s*(?:해|하|진행)|[.!]?\s*$)|다음\s*행(?![가-힣]))/i;
+
+/** 자리 운영 지시 꼴인가(인지 · 관측용으로도 내보낸다). */
+export function isSeatOpsDirective(text: string): boolean {
+  return SEAT_OPS_DIRECTIVE.test(text.trim());
+}
+
+/** Request verbs a quick or read-only turn can carry out without writing to the repository.
+ *  «봐줘·봐 줘·들여다봐줘» are reads (TUI-INITIATIVE-S ④ — «로그 좀 봐줘» used to fall to coding as request-verb). */
+const QUICK_REQUEST_VERBS = /^(?:보여|알려|확인해|찾아|찾아봐|조사해|검색해|정리해|요약해|바꿔|변경해|전환해|설정해|맞춰|수정해|고쳐|만들어|등록해|예약해|추가해|보내|설명해|읽어|읽어봐|봐|봐봐|들여다봐|살펴|살펴봐|훑어봐|비교해|분석해|검토해|평가해|제안해)$/;
 
 /** True when the verb never appears, or each occurrence directly follows an allowed object. */
 function everyVerbTakes(text: string, verb: RegExp, object: RegExp): boolean {
@@ -42,16 +85,27 @@ function everyVerbTakes(text: string, verb: RegExp, object: RegExp): boolean {
   return true;
 }
 
-/** Uncertain or mixed requests retain the full coding goal-loop and tool surface. */
-export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext = {}): TuiChatVerdict {
+/** Write, debug, goal, mixed or attached requests retain the coding goal loop; a plain read question is one full-tool turn.
+ *  A seat (unattended) TUI reverts #27531 for its work: a read/analysis turn (except a fast short question) and any
+ *  operational directive (mail · order · named CLI command · «계속 —») ride the goal loop to completion evidence. */
+export function classifyTuiChatIntent(text: string, ctx: TuiChatContext = {}): TuiChatVerdict {
+  const verdict = classifyTuiChatIntentBase(text, ctx);
+  // A fast short question («다음 행이 뭐야?») stays one turn even in a seat — only work rides the goal loop.
+  if (!ctx.seat || verdict.goalLoop || verdict.reason.startsWith('short-')) return verdict;
+  if (verdict.route === '읽기·분석') {
+    return { route: verdict.route, reason: `seat-${verdict.reason}`, goalLoop: true };
+  }
+  if (isSeatOpsDirective(text)) return { route: verdict.route, reason: `seat-ops-${verdict.reason}`, goalLoop: true };
+  return verdict;
+}
+
+function classifyTuiChatIntentBase(text: string, ctx: ShortQuestionContext): TuiChatVerdict {
   const q = text.trim();
   const coding = (reason: string): TuiChatVerdict => ({ route: '코딩·구현', reason, goalLoop: true });
   if (!q || ctx.hasAttachments) return coding(ctx.hasAttachments ? 'attachment' : 'empty');
-  if (/(?:하니스|구현|코딩|코드|스크립트|버그|소스|리팩터|커밋|패치|테스트|시험\s*돌|빌드|배포|브랜치|서버|파일|레포|저장소|\bPR\b|\b(?:implement|coding|code|script|refactor|commit|patch|tests?|build|deploy|branch|server|file|repo)\b)/i.test(q)) return coding('coding');
+  if (/(?:하니스|구현|코딩|버그|리팩터|커밋|패치|테스트|시험\s*돌|빌드|배포|\b(?:implement|coding|refactor|commit|patch|tests?|build|deploy)\b)/i.test(q)) return coding('coding');
   // Destructive or executing verbs in any form (not only «…줘») are never a quick turn.
-  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(q)) return coding('write-verb');
-  // A file path or code shape means the request touches the repository, whatever else it asks.
-  if (PATH_OR_CODE.test(q)) return coding('path-or-code');
+  if (/(?:지워|지우|삭제|제거|옮겨|옮기|돌려|실행(?!\s*중(?:인)?(?:\s|[?!.~]|$))|설치|되돌려|롤백|재시작|죽여|\b(?:delete|remove|rm|rename|move|run|install|revert|rollback|drop|kill|restart)\b)/i.test(q)) return coding('write-verb');
   // Allowlist, not denylist: every «…줘» request verb must be one a quick turn can do; anything else
   // (지워줘 · 돌려줘 · 옮겨줘 …) keeps the coding goal loop.
   for (const match of q.matchAll(/([가-힣]+?)\s*(?:줘|주세요|줄래|주라)/g)) {
@@ -61,9 +115,17 @@ export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext =
   // («모델 설정 수정해줘» · «알림 만들어줘» stay quick; «… 그리고 화면 고쳐줘» does not).
   if (!everyVerbTakes(q, /(?:수정|고쳐|바꿔|변경|전환|교체|\b(?:edit|fix|modify|change|switch|replace)\b)/gi, /(?:모델|설정|config|provider|예약|일정|알림|리마인더|스케줄|reminder|schedule)\s*(?:을|를|로|으로)?\s*$/i)) return coding('edit');
   if (!everyVerbTakes(q, /(?:만들어|작성|추가해|생성|등록해|\b(?:create|write|make|add)\b)/gi, /(?:알림|일정|예약|리마인더|스케줄|reminder|schedule)\s*(?:을|를)?\s*$/i)) return coding('create');
+  // Debugging or a stated goal keeps the goal loop even on a quick-route word («오류 로그 요약» · «목표: 상태 요약»).
+  if (DEBUG_INTENT.test(q)) return coding('debug');
+  if (EXPLICIT_GOAL.test(q)) return coding('explicit-goal');
+  // A repository noun, file path, code shape or named command is no quick route; with no write, debug or goal intent it is a read.
+  if (REPO_NOUN.test(q) || PATH_OR_CODE.test(q) || EXPLICIT_COMMAND.test(q)) {
+    const intent = writeDebugOrGoal(q);
+    return intent ? coding(intent) : { route: '읽기·분석', reason: 'read-repo', goalLoop: false };
+  }
 
   const routes: Array<{ route: Exclude<TuiChatRoute, '코딩·구현'>; reason: string; pattern: RegExp }> = [
-    { route: '조회', reason: 'lookup', pattern: /(?:결정\s*카드|결정\s*대기|상태|현황|로그|알림\s*(?:왔|있|보여)|\b(?:status|logs?|pending decisions?)\b)/i },
+    { route: '조회', reason: 'lookup', pattern: /(?:결정\s*카드|결정\s*대기|상태|현황|로그|알림\s*(?:왔|있|보여)|돌고\s*있는|진행\s*중|실행\s*중|뭐\s*하고\s*있어|\b(?:status|logs?|pending decisions?|(?<![\w-])running(?![\w-])|in progress)\b)/i },
     { route: '설정 변경', reason: 'settings', pattern: /(?:(?:모델|설정|config|provider).*(?:바꿔|변경|전환|설정해|맞춰|수정|고쳐|써\s*줘|set|change|switch|edit|fix|modify)|(?:바꿔|변경|전환).*(?:모델|설정|config|provider)|답변.*빠른\s*모델)/i },
     { route: '조사', reason: 'research', pattern: /(?:조사|검색|찾아\s*봐|뉴스|업계\s*소식|\b(?:research|search|news)\b)/i },
     { route: '상시 일', reason: 'recurring', pattern: /(?:매일|매주|매달|매\s*아침|[가-힣]+마다|정기적|반복\s*일정|예약|리마인더|\b(?:daily|weekly|every|schedule|remind)\b)/i },
@@ -74,10 +136,13 @@ export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext =
     && matches.every(({ route }) => route === '상시 일' || route === '조사' || route === '조회')) {
     return { route: '상시 일', reason: matches.length > 1 ? 'recurring-research' : 'recurring', goalLoop: false };
   }
-  if (matches.length !== 1) {
-    if (matches.length) return coding('mixed');
+  if (matches.length > 1) return coding('mixed');
+  if (!matches.length) {
+    // 쓰기·디버깅·목표 의도가 없는 물음은 파일·상태를 읽고 답하는 한 턴이다 — 증거 게이트(update_goal)를 걸지 않는다.
+    const intent = writeDebugOrGoal(q);
+    if (intent) return coding(intent);
     const shortQuestion = classifyShortQuestion(q, ctx);
-    return coding(shortQuestion.fast ? `short-${shortQuestion.reason}` : 'ambiguous');
+    return { route: '읽기·분석', reason: shortQuestion.fast ? `short-${shortQuestion.reason}` : 'read', goalLoop: false };
   }
   const { route, reason } = matches[0]!;
   return { route, reason, goalLoop: false };

package/src/core-turn/types.ts

@@ -79,9 +79,14 @@ export type CoreTurnDispatchTool = (
 /** Events the hosting surface (dashboard chat pane, ACP push pipe,
  *  future web/iphone client) cares about. All optional. */
 export interface CoreTurnCallbacks {
+  /** Actual provider and model selected for this turn, including fallback attempts. */
+  onResolvedProvider?(provider: string, model: string): void;
   /** Streaming text delta — `full` is the accumulated text across the
    *  entire turn (not just the current round). */
   onText?(delta: string, full: 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;
   /** Fires just before a tool call is dispatched. */
   onToolCall?(call: CoreToolCall): void;
   /** Fires once the tool call resolves. */
@@ -150,6 +155,9 @@ export interface CoreTurnContext {
    *  named tools (e.g. the PtyShell family driving a headless coding
    *  agent) are actually being dispatched. Absent ⇒ no extension. */
   budgetGrant?: LLMOpts['budgetGrant'];
+  /** TUI-GOAL-LOOP-FRICTION — 종결 신호 도구 이름. `streamLLMWithTools` 의 `terminalToolNames` 로 그대로 간다
+   *  (예산 거부 면제 · 신호뿐인 턴 ⊕ 답 = 마감). goal loop 가 `update_goal` 을 넣는다. */
+  terminalToolNames?: LLMOpts['terminalToolNames'];
   /** Optional model override (forwarded to `streamLLMWithTools`). */
   modelOverride?: string;
 }
@@ -157,4 +165,6 @@ export interface CoreTurnContext {
 export interface CoreTurnResult {
   stopReason: CoreTurnStopReason;
   finalText: string;
+  /** `auth_rejected` 일 때만 — 공급자 오류 원문(비밀값 가림). 호스트가 처방 줄에 원문을 붙인다. */
+  errorMessage?: string;
 }