elanous 0.2.29 → 0.2.32

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,
@@ -259,6 +263,37 @@ export function buildRejectedToolCompletionPrompt(rejectedTools: readonly string
   ].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;
@@ -296,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 로 완료 선언
@@ -348,6 +397,10 @@ function findRejectedToolCalls(newMessages: readonly LLMMessage[]): string[] {
   return [...rejected];
 }
 
+/** `streamLLMWithTools` 의 빈 턴·예산 포기 경고(`buildNoFinalSynthesisNotice`) 문면 — 완료 판정 관측에서 «답 없음»으로 센다.
+ *  머리 표지만 보지 않고 런타임 문장까지 맞춰, 그 표지를 인용한 정상 답을 «경고»로 세지 않는다. */
+const NO_FINAL_SYNTHESIS_NOTICE = /\[NO FINAL SYNTHESIS\] The model (?:stopped after repeated empty turns|used the available tool-loop turns without writing a plain-text answer)\./;
+
 /** 이 turn 의 새 메시지에서 마지막 `update_goal` 도구 호출을 찾아 구조화 종결 상태를
  *  반환한다. status 가 enum 밖이면 무시(null). evidence/reason 은 문자열만 수용. */
 function findGoalUpdate(
@@ -466,6 +519,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;
@@ -508,6 +563,20 @@ export async function runGoalLoop(
   ): GoalLoopResult => {
     if (terminalPublished) return result;
     terminalPublished = true;
+    // TUI-H1-GOALLOOP-EMPTY-TAIL — 완료 판정 한 줄: 목표가 닫혔나(goal-complete) · 사람에게 보일 답이 있나
+    //   (answer-present) · 둘 다 아니다(none — 빈 답이거나 «[NO FINAL SYNTHESIS]» 경고가 최종 답).
+    try {
+      const finalTrimmed = result.finalText.trim();
+      const reason = result.goalComplete
+        ? 'goal-complete'
+        : finalTrimmed.length > 0 && !NO_FINAL_SYNTHESIS_NOTICE.test(finalTrimmed) ? 'answer-present' : 'none';
+      debug.log('goal.loop', 'completion-verdict', {
+        sessionId: ctx.sessionId, ...runAttribution,
+        iterations, reason, stopReason: result.stopReason, finalChars: result.finalText.length,
+      }, { level: 'info' });
+    } catch {
+      // Observability must not change the loop result.
+    }
     try {
       if (result.goalComplete) {
         publishGoalLifecycle(bus, 'complete', completePayload ?? {
@@ -632,6 +701,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 });
@@ -639,6 +759,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,
@@ -646,6 +794,11 @@ 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],
+      // TUI-H1-GOALLOOP-EMPTY-TAIL — 앞 iteration 의 답이 이미 화면에 있으면 «update_goal 만 → 빈 턴» 은 할 말이 없는
+      //   것이다 — 재촉·경고 없이 빈 답으로 끝내고 아래 완료 판정이 앞 답으로 마감한다(중복 접기와 같은 길).
+      ...(previousFinalText.trim().length > 0 ? { terminalPriorAnswerVisible: true } : {}),
       // update_goal 은 종결 신호 — 실 dispatcher 로 새지 않게 가로채 ack 만 돌려준다.
       dispatchTool: (name, args, dctx) => {
         dispatchCount += 1;
@@ -660,12 +813,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') {
@@ -706,6 +881,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);
         },
@@ -732,12 +918,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);
@@ -757,6 +951,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) {
@@ -875,6 +1081,33 @@ export async function runGoalLoop(
       });
     }
 
+    // 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
     // from this same turn have received priority.
     if (goalUpdate?.status === 'complete') {
@@ -985,6 +1218,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

@@ -41,6 +41,10 @@ const WRITE_INTENT = /(?:(?:추가|작성|기록|반영|갱신|업데이트|개
 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';
@@ -55,8 +59,23 @@ export interface TuiChatVerdict {
   goalLoop: boolean;
 }
 
-/** Request verbs a quick or read-only turn can carry out without writing to 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 {
@@ -66,8 +85,21 @@ function everyVerbTakes(text: string, verb: RegExp, object: RegExp): boolean {
   return true;
 }
 
-/** Write, debug, goal, mixed or attached requests retain the coding goal loop; a plain read question is one full-tool turn. */
-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');
@@ -86,8 +118,8 @@ export function classifyTuiChatIntent(text: string, ctx: ShortQuestionContext =
   // 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 or code shape 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)) {
+  // 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 };
   }

package/src/core-turn/types.ts

@@ -155,6 +155,12 @@ 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'];
+  /** TUI-H1-GOALLOOP-EMPTY-TAIL — 이 턴 «앞»에 사람에게 답을 이미 보였다. `streamLLMWithTools` 의
+   *  `terminalPriorAnswerVisible` 로 그대로 간다(종결 신호 뒤 빈 턴 = 경고 없이 빈 답). goal loop 가 넣는다. */
+  terminalPriorAnswerVisible?: LLMOpts['terminalPriorAnswerVisible'];
   /** Optional model override (forwarded to `streamLLMWithTools`). */
   modelOverride?: string;
 }

package/src/dashboard/acp-active-model.ts

@@ -6,7 +6,7 @@
 
 import { debug } from '../debug/log.js';
 import { effectiveReasoningLevel } from '../llm.js';
-import { recordCurrentRouteDecision, resolveRouteDecision, sessionModelPin } from '../llm/route-decision.js';
+import { clearSurfaceRouteDecision, currentRouteDecision, recordCurrentRouteDecision, recordRouteExecution, resolveRouteDecision, sessionModelPin } from '../llm/route-decision.js';
 import { inspectActiveProvider } from '../provider-summary.js';
 import { getUserConfig } from '../user-config.js';
 
@@ -38,3 +38,44 @@ export function resolveDashboardActiveModel(userText: string): string | null {
   });
   return decision.model || null;
 }
+
+/** 턴 사용량(ACP `elanous/ui/usage`)이 실어 온 «실제» 공급자·모델을 이 표면의 실행으로 적는다
+ *  (TUI-MODEL-BADGE-ACTUAL · 10-16). 완료 배지가 결정과 다르면 «A → B» 로 보인다.
+ *  폴백(결정과 다른 모델)이면 관측 이벤트 `llm.route-decision` / `dashboard-executed-fallback` 를 «항상» 남긴다. */
+export function recordDashboardTurnExecution(
+  usage: { model?: string; routeProvider?: string } | null | undefined,
+  /** 필수 — 세션 위치를 모르면(null) 적지 않는다(원격 사용량을 로컬 실행으로 꾸미지 않게). */
+  session: { remote: boolean } | null,
+): void {
+  // ⛔ 순서: 원격·세션 미상 판정(⊕ 비우기)을 model 검사보다 «먼저» 한다 — 사용량 봉투의 model 은 선택 칸이라,
+  //   모델 없는 원격 사용량이 먼저 반환하면 지난 로컬 턴의 «A → B» 가 남는다(r6 리뷰).
+  const model = usage?.model?.trim() || null;
+  if (session === null) {
+    // 짝을 모르는 턴 — 지난 턴의 결정·실행이 이 턴의 배지로 «다시» 보이지 않게 비운다.
+    clearSurfaceRouteDecision('dashboard');
+    debug.log('llm.route-decision', 'dashboard-executed-session-unknown', { model }, { level: 'warn' });
+    return;
+  }
+  // ⛔ 원격 데몬 세션은 적지 않는다 — 결정은 데몬 쪽에서 서므로 이 프로세스의 결정과 짝이 안 맞는다.
+  //   후속 칸 TUI-MODEL-BADGE-REMOTE.
+  if (session.remote) {
+    // 원격 턴은 로컬 결정과 짝이 없다 — 지난 로컬 턴의 «A → B» 가 이 턴의 배지로 다시 나오지 않게 비운다(r5 리뷰).
+    clearSurfaceRouteDecision('dashboard');
+    if (debug.enabled) debug.log('llm.route-decision', 'dashboard-executed-remote-skipped', { model });
+    return;
+  }
+  if (!model) return;
+  const provider = usage?.routeProvider?.trim() || undefined;
+  const decision = currentRouteDecision('dashboard');
+  // 결정이 없는 실행은 짝이 없다 — 적지 않는다.
+  if (!decision) return;
+  recordRouteExecution('dashboard', { model, ...(provider ? { provider } : {}) });
+  if (decision.model !== '' && decision.model !== model) {
+    debug.log('llm.route-decision', 'dashboard-executed-fallback', {
+      planned: { provider: decision.provider, model: decision.model },
+      actual: { provider: provider ?? null, model },
+    }, { level: 'warn' });
+  } else if (debug.enabled) {
+    debug.log('llm.route-decision', 'dashboard-executed', { provider: provider ?? null, model });
+  }
+}

package/src/dashboard/acp-boot.ts

@@ -36,6 +36,7 @@ import {
 import type { AcpTransportConnection } from '../acp/transport/index.js';
 import { debug } from '../debug/log.js';
 import { recordDashboardToolCatalog } from './tool-catalog-observability.js';
+import { detectSeatTui } from './seat-boot-preamble.js';
 
 type DashboardAcpBootBranch = 'remote-daemon' | 'in-process';
 
@@ -232,6 +233,8 @@ export async function bootDashboardAcpSession(
       const model = deps.getActiveModel({ userText });
       return model ?? undefined;
     },
+    // TUI-H1-SEAT-GOALLOOP — 자리(무인) TUI 면 운영 지시를 goal loop 로(사람 대화 TUI 는 종전 그대로).
+    resolveSeat: () => detectSeatTui(deps.getCwd())?.seat ?? null,
     ...(deps.agentName !== undefined ? { agentName: deps.agentName } : {}),
     ...(deps.agentVersion !== undefined ? { agentVersion: deps.agentVersion } : {}),
     ...(gateway