elanous 0.2.35 → 0.2.37

package/src/dashboard/input/agent-wake.ts

@@ -13,6 +13,8 @@
 //   턴 중(NotIdle)·입력 중(HumanTyping)에 온 완료는 «대기»: 입력칸이 다시 뜰 때(`wrapAgentWakePort`) 그 결과가
 //   아직 큐에 남아 있으면(=어느 턴도 안 실었으면) 한 번만 다시 청한다. 이미 실렸으면(drain) 아무것도 안 한다.
 // ⛔ 같은 알림(taskId)은 한 번만 — 큐 `seen` 이 `clear()` 로 비워져도, 대시보드가 재진입해도 막는다.
+// ⭐ 생산 조립은 `installSeatedAgentWake` «하나» — `src/dashboard/index.ts` 의 `showDashboard` 가 그 함수만
+//   부르고, 이 파일의 무대 시험이 «같은 함수»를 지난다(문자열 배선 확인이 아니라 생산 호출 경로 증거).
 //
 // 세 얼굴:
 //   관측 = debug.log('tui.agent-wake', 'notified' | 'opened' | 'rejected' | 'deferred', { taskId, agent, state, seat, shown, reason })
@@ -172,7 +174,13 @@ export function createAgentWake(deps: AgentWakeDeps): AgentWakeController {
             return;
           }
           tryOpen(n, 'input-mounted');
-        } catch { /* fail-soft: 깨움은 입력을 막지 않는다 */ }
+        } catch (error) {
+          // fail-soft: 깨움은 입력을 막지 않는다 — 다만 «조용히 죽은» 이유는 TF 가 봐야 한다(거부는 사유 로그).
+          log('tui.agent-wake', 'rejected', {
+            taskId: n.taskId, agent: n.agentName, state: n.state, trigger: 'input-mounted', reason: 'error',
+            detail: error instanceof Error ? error.message : String(error),
+          });
+        }
       });
     },
   };
@@ -234,6 +242,47 @@ export function installAgentWake(deps: Omit<AgentWakeDeps, 'handled'>): AgentWak
   return own;
 }
 
+/** 대시보드가 넘기는 «생산 포트» — showDashboard 가 실제로 채우는 모양 그대로. */
+export interface DashboardAgentWakePorts {
+  /** 큐 구독 — `subscribeDashboardAgentResults(globalTaskNotificationQueue, …)` 가 여기로 들어온다. */
+  subscribe: AgentWakeDeps['subscribe'];
+  /** 채팅 한 줄 — `createDashboardAgentWakeNotify(pushLine, draw)`. */
+  notify: AgentWakeDeps['notify'];
+  /** H2 문 — `internalTurnGate.startTurnIfIdle`. 자리 TUI ∧ 유휴일 때만 실제로 열린다. */
+  startTurnIfIdle: AgentWakeOpenTurnDeps['startTurnIfIdle'];
+  /** 지금 화면의 cwd(자리 판정 입력) — `() => workingDir.cwd`. */
+  getCwd: () => string;
+  /** 그 완료가 아직 어느 턴에도 안 실렸나 — `globalTaskNotificationQueue.has`. «대기» 재시도의 근거. */
+  isPending: (taskId: string) => boolean;
+  /** 시험·주입 자리(생산은 안 넘긴다 — 기본 `homedir()`·`detectSeatTui`·`setTimeout 0`). */
+  home?: string;
+  detectSeat?: AgentWakeOpenTurnDeps['detectSeat'];
+  defer?: AgentWakeOpenTurnDeps['defer'];
+  log?: AgentWakeDeps['log'];
+}
+
+/**
+ * 대시보드 생산 조립 — `showDashboard` 는 이 함수 «하나»만 부른다.
+ * 알림(조각 1)과 «자리 TUI ∧ 유휴 → H2 한 턴(origin child-complete)»(조각 2)을 같은 큐 구독에서 낸다.
+ * 중복 거부(같은 taskId 한 번)·DEFERRABLE 대기→입력칸 재시도·수명은 `createAgentWake` 몫이다.
+ */
+export function installSeatedAgentWake(ports: DashboardAgentWakePorts): AgentWakeController {
+  const openTurn: AgentWakeOpenTurnDeps = {
+    startTurnIfIdle: ports.startTurnIfIdle,
+    getCwd: ports.getCwd,
+    isPending: ports.isPending,
+    ...(ports.home !== undefined ? { home: ports.home } : {}),
+    ...(ports.detectSeat !== undefined ? { detectSeat: ports.detectSeat } : {}),
+    ...(ports.defer !== undefined ? { defer: ports.defer } : {}),
+  };
+  return installAgentWake({
+    subscribe: ports.subscribe,
+    notify: ports.notify,
+    openTurn,
+    ...(ports.log !== undefined ? { log: ports.log } : {}),
+  });
+}
+
 /** 시험 격리용 — 설치·공유 dedupe 를 비운다. */
 export function resetAgentWakeForTest(): void {
   installed?.dispose();

package/src/dashboard/input/chat-main-acp-dispatch.ts

@@ -1,6 +1,7 @@
 import type { NormalizedAttachment } from '../../acp/content-blocks.js';
 import { debug } from '../../debug/log.js';
 import type { ControlSignalBus } from '../../input/control-signal.js';
+import { classifyInterimReply, formatInterimFoldLine } from '../../tui/chat/goal-interim.js';
 import {
   createTurnOutputBundle,
   runTurnOutputBundleSettle,
@@ -76,6 +77,8 @@ export function dispatchDashboardChatMainAcpSend(
   let firstChunk = true;
   let assistantTextActive = false;
   let assistantBodyStart = -1;
+  let assistantBodyEnd = -1;
+  const interimBodyRanges: Array<{ start: number; end: number }> = [];
   let assistantBodyText = '';
   let assistantRunUsesPrefix = false;
 
@@ -91,6 +94,7 @@ export function dispatchDashboardChatMainAcpSend(
         if (firstChunk) firstChunk = false;
         assistantBodyText = '';
         assistantBodyStart = -1;
+        assistantBodyEnd = -1;
         assistantTextActive = true;
       }
       assistantBodyText += delta;
@@ -110,7 +114,7 @@ export function dispatchDashboardChatMainAcpSend(
       deps.autoTtsHooks?.pushChunk(delta);
       const rendered = deps.formatAssistantLines(assistantBodyText);
       if (assistantBodyStart < 0) assistantBodyStart = deps.chatLines.length;
-      deps.chatLines.length = assistantBodyStart;
+      deps.chatLines.splice(assistantBodyStart, Math.max(0, assistantBodyEnd - assistantBodyStart));
       rendered.forEach((line, index) => {
         if (index === 0 && assistantRunUsesPrefix) {
           deps.chatLines.push(`${deps.formatAssistantPrefix(display)} ${line}`);
@@ -118,8 +122,24 @@ export function dispatchDashboardChatMainAcpSend(
           deps.chatLines.push(`  ${line}`);
         }
       });
+      assistantBodyEnd = assistantBodyStart + rendered.length;
+      if (interimBodyRanges.at(-1)?.start === assistantBodyStart) interimBodyRanges[interimBodyRanges.length - 1]!.end = assistantBodyEnd;
+      else interimBodyRanges.push({ start: assistantBodyStart, end: assistantBodyEnd });
       deps.setChatScrollToTail();
     },
+    foldGoalInterim: (text) => {
+      const verdict = classifyInterimReply(text.split('\n'));
+      if (verdict.interim && interimBodyRanges.length > 0) {
+        const first = interimBodyRanges[0]!.start;
+        for (const { start, end } of [...interimBodyRanges].reverse()) deps.chatLines.splice(start, end - start);
+        deps.chatLines.splice(first, 0, `  ${formatInterimFoldLine(verdict.summary)}`);
+        deps.setChatScrollToTail();
+      }
+      interimBodyRanges.length = 0;
+      assistantTextActive = false;
+      assistantBodyStart = -1;
+      assistantBodyEnd = -1;
+    },
     pushToolCall: (tool) => {
       deps.chatLines.push(deps.formatToolLine(tool));
       deps.setChatScrollToTail();

package/src/dashboard/input/chat-main-plain-turn-runtime.ts

@@ -15,6 +15,21 @@ import {
 import { isUnknownCodex400, repairCodexToolPairs, restoreRepairedHistory } from './compact-prepass-recovery.js';
 import type { LLMMessage } from '../../llm.js';
 import { isTuiRouteLine } from '../../core-turn/short-question.js';
+import {
+  AutohealExhaustedError, autohealProviderFallbackMeta, autohealSignatureFor, decideAutohealStep,
+  formatAutohealAttemptLine, formatAutohealExhaustedNotice, type AutohealAttemptRecord,
+} from '../../self-health/autoheal.js';
+
+/** TUI-400-AUTOHEAL-FALLBACK — 400(대화 기록 어긋남)이면 사람에게 넘기기 전에 스스로 회복한다.
+ *  ⛔ 없으면(호출부가 배선 안 함) 옛 동작 그대로 — 처방 한 줄만 보인다. */
+export interface DashboardTurnAutoheal {
+  /** ① 새 백엔드(ACP) 세션 — 새 세션 id. 실패해도 기록은 이미 새로 짰으니 재시도는 한다. */
+  renewBackendSession(): Promise<string>;
+  /** ① 직전 기록의 짧은 요약 — 이미 있는 압축 요약을 쓴다(`summarizeForAutoheal`). 빈 문자열 = 요약 없음. */
+  summarizeHistory(prior: readonly unknown[]): Promise<string>;
+  /** ② `llm.fallbackChain` 의 다음 공급자 이름(지금 쓸 수 있는 것) — 없으면 null(② 를 건너뛰고 멈춘다). */
+  peekFallbackProvider(): string | null;
+}
 
 export interface DashboardChatMainPlainTurnRuntimeDeps {
   userText: string;
@@ -119,6 +134,8 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
       onToolResult: (call: unknown) => void;
       onUsage: (usage: unknown) => void;
       onThought?: (text: string) => void;
+      /** ACP `_meta` — 자동 회복 ② 가 «다음 공급자로» 표지를 싣는다. */
+      meta?: Record<string, unknown>;
     }): Promise<unknown>;
   };
   autoTts: {
@@ -153,6 +170,8 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
   runActionEffects: (outcome: unknown) => Promise<void>;
   warningLine: (message: string) => string;
   pushErrorLine: (message: string) => void;
+  /** TUI-400-AUTOHEAL-FALLBACK — 자동 회복 배선(없으면 옛 동작). */
+  autoheal?: DashboardTurnAutoheal;
   /** 실패 지문이 맞은 오류: 화면엔 한국어 처방 한 줄, 원문은 여기(`/detail`)로. 없으면 원문을 그대로 낸다. */
   pushFailureNotice?: (notice: string, raw: string) => void;
   finalizeTurn: (status: 'completed' | 'interrupted' | 'failed', error?: string) => void;
@@ -178,6 +197,10 @@ export function selectDashboardChatErrorDetail(err: unknown): string {
  * without changing semantics. The orchestration stays dependency-
  * injected so future source flavors can reuse the same turn body.
  */
+function safePeekFallbackProvider(autoheal: DashboardTurnAutoheal): string | null {
+  try { return autoheal.peekFallbackProvider(); } catch { return null; }
+}
+
 export async function runDashboardChatMainPlainTurn(
   deps: DashboardChatMainPlainTurnRuntimeDeps,
 ): Promise<void> {
@@ -187,6 +210,13 @@ export async function runDashboardChatMainPlainTurn(
 
   let cleanupEsc = () => {};
   let stage = 'streaming-keys-attached';
+  // TUI-400-AUTOHEAL-FALLBACK — «자동 회복» 줄은 턴이 끝난 «뒤»에 기록에 남긴다:
+  //   스트림 중에 chatLines 에 넣으면 답 커밋(commitAssistantRenderState)이 답 구역째 덮어 지운다(라이브 실측 08:32).
+  //   도는 동안은 thinking 줄로 보인다.
+  const autohealLines: string[] = [];
+  const flushAutohealLines = (): void => {
+    for (const line of autohealLines.splice(0)) deps.pushChatLine(deps.warningLine(line));
+  };
 
   try {
     const abortCtrl = new AbortController();
@@ -350,6 +380,8 @@ export async function runDashboardChatMainPlainTurn(
           deps.debugLog?.('chat.compact-400-recovery', 'manual-recovery-required', {
             reason, historyMessages: deps.chat.history.length,
           });
+          // 자동 회복(TUI-400-AUTOHEAL-FALLBACK)이 배선돼 있으면 «손으로 /session new» 를 시키지 않는다 — 바깥 회복이 이어 한다.
+          if (deps.autoheal) return;
           deps.pushChatLine(deps.warningLine(
             'Codex 400으로 자동 복구를 멈췄습니다. 대화 이력을 확인한 뒤 /session new 로 새 세션을 시작하세요.',
           ));
@@ -466,10 +498,110 @@ export async function runDashboardChatMainPlainTurn(
         throw lastError;
       },
     };
+    // ⭐ TUI-400-AUTOHEAL-FALLBACK(대표 10-22) — 400(대화 기록 어긋남)으로 멈추지 않는다.
+    //   ① 새 백엔드 세션 ⊕ 직전 요약 → ② fallbackChain 다음 공급자 → 상한(2)에서 이유 한 줄.
+    //   ⛔ 답·도구 호출이 이미 흘렀으면 다시 보내지 않는다. 판정은 순수 `decideAutohealStep`.
+    const autohealSend: typeof deps.acpSession = {
+      send: async (opts) => {
+        const autoheal = deps.autoheal;
+        if (!autoheal) return recoverySend.send(opts);
+        let emitted = false;
+        let attemptIndex = 0;
+        const dispatchBefore = deps.readToolDispatchCount?.() ?? null;
+        const run = (meta?: Record<string, unknown>) => recoverySend.send({
+          ...opts,
+          ...(meta ? { meta: { ...(opts.meta ?? {}), ...meta } } : {}),
+          onText: (chunk) => {
+            if (isTuiRouteLine(chunk)) {
+              // 라우팅 줄은 모델 호출 «전»에 다리가 보낸다 — 재시도마다 또 그리지 않는다.
+              if (attemptIndex === 0) opts.onText(chunk);
+              return;
+            }
+            emitted = true;
+            opts.onText(chunk);
+          },
+          onToolCall: (call) => { emitted = true; opts.onToolCall(call); },
+          onToolResult: (call) => { emitted = true; opts.onToolResult(call); },
+        });
+        const attempts: AutohealAttemptRecord[] = [];
+        let lastError: unknown;
+        try { return await run(); } catch (err) { lastError = err; }
+        for (;;) {
+          const detail = selectDashboardChatErrorDetail(lastError);
+          const dispatchNow = deps.readToolDispatchCount?.() ?? null;
+          const decision = decideAutohealStep({
+            detail,
+            attemptsDone: attempts.length,
+            emitted,
+            toolDispatched: dispatchBefore !== null && dispatchNow !== null && dispatchNow !== dispatchBefore,
+            aborted: abortCtrl.signal.aborted,
+            fallbackProvider: attempts.length === 1 ? safePeekFallbackProvider(autoheal) : null,
+          });
+          if (decision.kind === 'stop') {
+            if (attempts.length === 0) {
+              if (decision.reason !== 'not-autoheal-signature') {
+                deps.debugLog?.('self-health.autoheal', 'skipped', { reason: decision.reason, signature: autohealSignatureFor(detail)?.id });
+              }
+              throw lastError;
+            }
+            deps.debugLog?.('self-health.autoheal', 'exhausted', {
+              attempts: attempts.length, reason: decision.reason, steps: attempts.map((a) => a.step),
+            }, { level: 'warn' });
+            throw new AutohealExhaustedError(lastError, attempts, decision.reason);
+          }
+          attemptIndex = decision.attempt;
+          let payload: Record<string, unknown> = { step: decision.step, attempt: decision.attempt };
+          let meta: Record<string, unknown> | undefined;
+          if (decision.step === 'new-session') {
+            const history = deps.chat.history;
+            const currentIndex = history.lastIndexOf(userMsg);
+            if (currentIndex < 0) {
+              deps.debugLog?.('self-health.autoheal', 'exhausted', { attempts: attempts.length, reason: 'history-changed', steps: [] }, { level: 'warn' });
+              throw lastError;
+            }
+            const prior = history.slice(0, currentIndex);
+            let summary = '';
+            try { summary = (await autoheal.summarizeHistory(prior)).trim(); } catch { /* 요약 없이도 새 세션으로 */ }
+            const system = prior.find((m) => (m as { role?: unknown })?.role === 'system');
+            history.splice(0, history.length,
+              ...(system ? [system] : []),
+              ...(summary ? [{ role: 'assistant', content: `Compacted conversation summary:
+
+${summary}` }] : []),
+              userMsg);
+            let sessionRenewed = false;
+            try { await autoheal.renewBackendSession(); sessionRenewed = true; } catch (error) {
+              deps.debugLog?.('self-health.autoheal', 'renew-failed', { error: redactSecretText(String(error)) }, { level: 'warn' });
+            }
+            payload = { ...payload, summaryChars: summary.length, priorMessages: prior.length, sessionRenewed };
+          } else {
+            payload = { ...payload, provider: decision.provider };
+            meta = autohealProviderFallbackMeta();
+          }
+          attempts.push({ step: decision.step, ...(decision.provider ? { provider: decision.provider } : {}) });
+          const attemptLine = formatAutohealAttemptLine(decision);
+          autohealLines.push(attemptLine);
+          try { deps.thinking.update(attemptLine); } catch { /* 표시가 회복을 막지 않는다 */ }
+          deps.draw();
+          deps.debugLog?.('self-health.autoheal', 'attempt', payload, { level: 'warn' });
+          if (abortCtrl.signal.aborted) throw lastError;
+          try {
+            const result = await run(meta);
+            deps.debugLog?.('self-health.autoheal', 'recovered', { step: decision.step, attempt: decision.attempt, ...(decision.provider ? { provider: decision.provider } : {}) });
+            return result;
+          } catch (err) {
+            lastError = err;
+          } finally {
+            // 시도 줄은 «도는 동안»만 — 끝 꼬리줄(✔/✘)이 그 문면을 물고 남지 않게 되돌린다(라이브 실측 08:36).
+            try { deps.thinking.update('Thinking'); } catch { /* 표시가 회복을 막지 않는다 */ }
+          }
+        }
+      },
+    };
     const streamResult = await runDashboardPlainTurnStream({
       userText,
       abortCtrl,
-      acpSession: recoverySend,
+      acpSession: autohealSend,
       onText: (chunk, accumulated) => {
         logFirstToken(chunk);
         turnStreamRuntime.onText(chunk, accumulated);
@@ -513,6 +645,7 @@ export async function runDashboardChatMainPlainTurn(
     deps.applyAssistantRenderState(
       deps.commitAssistantRenderState(fullResponse, assistantStart, deps.chatLines.length),
     );
+    flushAutohealLines();
     if (debug.enabled) {
       debug.log('dashboard.chat.stream', 'plain-turn.commit-render-state', {
         fullResponseChars: fullResponse.length,
@@ -548,7 +681,10 @@ export async function runDashboardChatMainPlainTurn(
     if (routeFooter) deps.chatFooterLine.current = routeFooter;
   } catch (err: any) {
     finalStatus = 'failed';
-    const detail = selectDashboardChatErrorDetail(err);
+    flushAutohealLines();
+    // TUI-ORPHAN-AUTO-RESUME-STOP E4 (10-23): autoheal wraps the provider error — its own message is the ACP
+    // «Internal error» shell, the real text (`Codex API 400 … call_id …`) lives on the original's RPC details.
+    const detail = selectDashboardChatErrorDetail(err instanceof AutohealExhaustedError ? err.original : err);
     const stackHead = typeof err?.stack === 'string'
       ? err.stack.split('\n').slice(0, 4).join('\n')
       : undefined;
@@ -564,7 +700,14 @@ export async function runDashboardChatMainPlainTurn(
       ? err?.message || String(err)
       : firstLine.length > 80 ? `${firstLine.slice(0, 80)}…` : firstLine;
     const failure = deps.pushFailureNotice ? matchFailureText(detail) : null;
-    if (failure && deps.pushFailureNotice) {
+    if (err instanceof AutohealExhaustedError) {
+      // 자동 회복이 상한까지 갔다 — «/session new» 처방은 이미 해 봤으니 무엇을 해 봤고 왜 멈췄는지를 한 줄로.
+      const notice = formatAutohealExhaustedNotice(err.attempts, err.reason, { rawHint: '/detail open' });
+      if (failure) recordFailureSignatureMatch(failure, 'turn-error');
+      finalError = `자동 회복 ${err.attempts.length}회 실패`;
+      if (deps.pushFailureNotice) deps.pushFailureNotice(notice, detail);
+      else deps.pushErrorLine(`${notice}\n${detail}`);
+    } else if (failure && deps.pushFailureNotice) {
       recordFailureSignatureMatch(failure, 'turn-error');
       finalError = failure.cause;
       deps.pushFailureNotice(formatFailureNotice(failure, { rawHint: '/detail open' }), detail);

package/src/dashboard/input/chat-main-slash-command.ts

@@ -19,8 +19,10 @@ export function resolveDashboardChatMainSlashCommand(
 
   // Top-level alias: `/resume <id>` → `/session load <id>`.
   // Reuses the existing /session subcommand handler so the resume
-  // flow stays in one place.
-  if (cmdLower === 'resume') {
+  // flow stays in one place. A bare `/resume` is NOT rewritten: it must reach
+  // the `resume` handler that opens the session picker — rewriting it gave
+  // «usage: /session load <id-prefix>» and no picker (TUI-RESUME-PICKER · backlog #16).
+  if (cmdLower === 'resume' && args.length > 0) {
     cmdLower = 'session';
     args = ['load', ...rawArgs.filter(Boolean)];
   }

package/src/dashboard/input/goal-continue.ts

@@ -0,0 +1,210 @@
+// ── 골 이어가기 `goal-continue` (TURN-END-BEFORE-GOAL · 0.2.36 · 2026-10-22 · 대표 P0 «classic·next 둘 다») ──────
+//
+// 🚨 무엇을 푸는가: 사용자가 목적·결과물을 준 일에서, 모델이 결과물 없이 «…하겠습니다 / …해야 합니다 /
+//   제가 멈췄습니다» 로 턴을 «✔ 완료» 처리하고 멈춘다 — 사람이 다시 밀 때까지 정지(10-22 n8n 세션 실물 2회).
+// ⭐ codex `on_thread_idle → continue_if_idle`(ext/goal extension.rs) 꼴: 턴이 끝났는데 «약속만 하고 끝난 답»이면
+//   H2 내부 턴 문(`startTurnIfIdle` · origin `goal-continue`)으로 스스로 다음 턴을 연다. 문은 새로 짓지 않는다.
+// ⛔ 사람에게 묻고 끝난 답(«…할까요?» · «확인해 주세요» · «원하시면»)은 정당한 멈춤 — 열지 않는다.
+// ⛔ 입력칸 버퍼·`injectKey`·pty 주입 0(대표 비침투). 판정은 화면에 그린 답 줄(classic `chatLines` · next 세션 답)만 읽는다.
+//
+// 켜짐: 기본 켜짐 · `ELANOUS_TUI_GOAL_CONTINUE=0|off|false` 면 끔 · 하니스 자식(ELANOUS_HARNESS_ROLE)은 끔.
+// 상한: 사람 입력 없이 연속 K=3 · 같은 답 끝 구절(지문)로는 1회 · 상한 → 화면 한 줄 «사람 확인 필요» ⊕ 'cap'.
+//
+// 세 얼굴:
+//   관측 = debug.log('tui.goal-continue', 'decided', { opened|rejected, reason, tail, consecutive }) · 'cap'
+//   인지 = 턴 끝 ∧ 답 끝 구절이 약속형 ∧ 질문형 아님 ∧ 상한 안
+//   힐링 = H2 로 «약속한 일을 지금 실행하라» 한 턴(화면 «↻ 자동 재개(goal-continue): …») · 상한 → 멈춤 ⊕ 'cap'
+
+import type { TextInputInternalTurnYieldPort } from '../../chat/index.js';
+import { debug } from '../../debug/log.js';
+import type { StartTurnIfIdleOptions, StartTurnIfIdleResult } from './internal-turn.js';
+import { classifyReplyTail, replyTailFromLines, type GoalContinueVerdict } from '../../chat/goal-continue-verdict.js';
+export { classifyReplyTail, replyTailFromLines } from '../../chat/goal-continue-verdict.js';
+export type { GoalContinueVerdict } from '../../chat/goal-continue-verdict.js';
+
+export const GOAL_CONTINUE_ENV = 'ELANOUS_TUI_GOAL_CONTINUE';
+export const DEFAULT_GOAL_CONTINUE_CAP = 3;
+const HUMAN_ACTION = /로그인(?:이 필요|해 주세요)|결제(?:가 필요|해 주세요|해야 합니다)|(?:사람|사용자)의\s*(?:결정|승인)|(?:결정|승인)(?:이 필요|해 주세요)|권한이 필요|비밀번호를 입력해 주세요|위험\s*(?:승인|감수)(?:가 필요|를 직접)|직접\s*(?:선택|확인|승인)(?:해 주세요|이 필요)|\bhuman\s+(?:approval|decision|login|payment)\s+(?:is )?(?:required|needed)\b/iu;
+const REMAINING_WORK = /(?:남은\s*(?:일|작업|것)|remaining work).{0,80}(?:아직|미완|남아\s*있|못\s*(?:했|하)|하지\s*못|not yet|unfinished|incomplete)/iu;
+const NO_REMAINING_WORK = /(?:남은\s*(?:일|작업|것)(?:은|이)?\s*(?:없|완료|끝)|(?:모두|전부)\s*(?:완료|끝났)|\bno remaining work\b|\ball remaining work\b.{0,16}\b(?:done|complete|finished)\b)/iu;
+
+function remainingWorkTail(tail: string | null): string | null {
+  if (!tail || NO_REMAINING_WORK.test(tail) || !REMAINING_WORK.test(tail)) return null;
+  const sentence = tail.split(/(?<=[.!?。？])\s+/u).reverse().find((part) => REMAINING_WORK.test(part));
+  return (sentence ?? tail).slice(-120);
+}
+
+export function goalContinueFingerprint(tail: string): string {
+  let h = 2166136261;
+  for (let i = 0; i < tail.length; i++) { h ^= tail.charCodeAt(i); h = Math.imul(h, 16777619); }
+  return (h >>> 0).toString(16);
+}
+
+/** next: 세션 메시지 중 «이번 턴이 만든» 마지막 답만.
+ *  ① 보통 턴 = 턴 시작 때 길이(startIndex) 뒤에서 찾는다 — 이번 턴 답이 없으면 빈 배열(앞 턴 답으로 안 연다 · r3).
+ *  ② 이번 턴에 자동 압축이 있었으면(startIndex 가 'after-last-user') 압축으로 줄어든 길이 대신
+ *     «마지막 사람 메시지 뒤» 의 답만 본다 — 이번 턴 사람 글은 압축 뒤에도 마지막 사람 글이다(r5 must-fix). */
+export function replyLinesOfThisTurn(messages: ReadonlyArray<{ role: string; content?: unknown }>, startIndex: number | 'after-last-user'): string[] {
+  let from: number;
+  if (startIndex === 'after-last-user') {
+    let lastUser = -1;
+    for (let i = messages.length - 1; i >= 0; i--) if (messages[i]!.role === 'user') { lastUser = i; break; }
+    if (lastUser < 0) return [];
+    from = lastUser + 1;
+  } else {
+    from = Math.max(0, startIndex);
+  }
+  const reply = messages.slice(from).filter((m) => m.role === 'assistant').at(-1);
+  return typeof reply?.content === 'string' ? reply.content.split('\n') : [];
+}
+
+export function formatGoalContinuePrompt(phrase: string): string {
+  return `[골 이어가기] 방금 답이 «${phrase}» 로 끝났다 — 약속만 하고 턴을 끝내지 말고, 그 일을 지금 도구로 실행해 결과물을 만든다. `
+    + '원래 사용자 요청 범위 안에서만 이어간다. 정말 사람 판단·권한이 필요하면 무엇이 필요한지 한 줄로 묻고 멈춘다.';
+}
+
+export function isGoalContinueEnabledByEnv(env: NodeJS.ProcessEnv = process.env): boolean {
+  if (env.ELANOUS_HARNESS_ROLE?.trim()) return false;
+  const v = (env[GOAL_CONTINUE_ENV] ?? '').trim().toLowerCase();
+  return !(v === '0' || v === 'off' || v === 'false');
+}
+
+// ── 배선 컨트롤러 ────────────────────────────────────────────────────────────────────
+
+export interface GoalContinueDeps {
+  /** H2 문 — classic `internalTurnGate.startTurnIfIdle` · next `wakeup.gate.startTurnIfIdle`. */
+  startTurnIfIdle: (input: string, opts: StartTurnIfIdleOptions) => StartTurnIfIdleResult;
+  isEnabled?: () => boolean;
+  consecutiveCap?: number;
+  notify?: (line: string) => void;
+  /** 사람 입력 직후 거부(HumanTyping)면 다시 잴 시각까지 미룬다(기본 setTimeout · unref). */
+  defer?: (fn: () => void, ms: number) => void;
+  /** HumanTyping 재시도 간격(기본 문 조용창 10초 + 여유). */
+  retryMs?: number;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export interface GoalContinueTurnEnd {
+  /** 화면에 그린 답 줄(classic `chatLines` 꼬리) — 또는 답 원문 한 줄(next). */
+  lines: readonly string[];
+  /** 턴이 실패(✘)·취소로 끝났으면 true — 이어가지 않는다. */
+  failed?: boolean;
+}
+
+export interface GoalContinueController {
+  /** 모델 턴이 끝났다 — 답 끝 구절을 판정해 둔다(여는 것은 check). */
+  noteTurnEnded(end: GoalContinueTurnEnd): void;
+  /** 판정된 턴 끝이 무장돼 있으면 H2 로 연다. 사람 입력이 먼저면 미뤘다가 다시 잰다. */
+  check(): { opened: boolean; reason: string };
+  /** 사람이 턴을 열었다 — 연속 카운터·지문을 비운다. */
+  noteHumanTurn(): void;
+  /** classic: H2 yield port 를 감싸 «입력칸 마운트 = 판정 시점»으로 잇는다(입력칸 무접촉). */
+  wrapPort(port: TextInputInternalTurnYieldPort): TextInputInternalTurnYieldPort;
+}
+
+function defaultDefer(fn: () => void, ms: number): void {
+  const t = setTimeout(fn, ms);
+  (t as { unref?: () => void }).unref?.();
+}
+
+export function createGoalContinue(deps: GoalContinueDeps): GoalContinueController {
+  const isEnabled = deps.isEnabled ?? (() => isGoalContinueEnabledByEnv());
+  const cap = deps.consecutiveCap ?? DEFAULT_GOAL_CONTINUE_CAP;
+  const defer = deps.defer ?? defaultDefer;
+  const retryMs = deps.retryMs ?? 10_500;
+  const log = deps.log ?? ((c, e, d) => debug.log(c, e, d));
+
+  let armed: { tail: string; phrase: string; fingerprint: string; mode: 'pledge' | 'remaining' } | null = null;
+  let consecutive = 0;
+  /** 사람 턴 이후 이미 이어간 답들의 지문 — A→B→A 에서도 같은 답으로 두 번 열지 않는다(r2 must-fix). */
+  const openedFingerprints = new Set<string>();
+  let capNotified = false;
+  let retryArmed = false;
+
+  const check: GoalContinueController['check'] = () => {
+    if (!armed) return { opened: false, reason: 'not-armed' };
+    const { tail, phrase, fingerprint, mode } = armed;
+    // 초기화는 실제 사람 턴(noteHumanTurn)에서만 — 키만 치고 안 보낸 것으로 상한을 우회하지 못한다(r2 must-fix).
+    if (openedFingerprints.has(fingerprint)) {
+      armed = null;
+      log('tui.goal-continue', 'decided', { rejected: true, reason: 'same-reply', tail, consecutive });
+      if (mode === 'remaining') {
+        log('tui.proactive', 'stop-no-progress', { reason: 'same-remaining', remainingDigest: fingerprint, autoTurn: consecutive });
+        return { opened: false, reason: 'no-progress' };
+      }
+      return { opened: false, reason: 'same-reply' };
+    }
+    if (consecutive >= cap) {
+      armed = null;
+      if (!capNotified) {
+        capNotified = true;
+        log('tui.goal-continue', 'cap', { cap, tail });
+        deps.notify?.(`⏸ 골 이어가기 상한(${cap}회 연속) — 사람 확인 필요 · 키 하나면 다시 이어간다`);
+      }
+      log('tui.goal-continue', 'decided', { rejected: true, reason: 'cap', tail, consecutive });
+      log('tui.proactive', 'stop-cap', { reason: mode === 'remaining' ? 'work-remaining' : 'pledge', remainingDigest: fingerprint, autoTurn: consecutive, cap });
+      return { opened: false, reason: 'cap' };
+    }
+    const result = deps.startTurnIfIdle(formatGoalContinuePrompt(phrase), { origin: 'goal-continue', reason: `«${phrase}» 뒤 이어서 실행` });
+    if (result.opened) {
+      armed = null;
+      consecutive += 1;
+      openedFingerprints.add(fingerprint);
+      log('tui.goal-continue', 'decided', { opened: true, reason: 'pledge-without-result', phrase, tail, consecutive, turnId: result.turnId });
+      log('tui.proactive', 'continue', { reason: mode === 'remaining' ? 'work-remaining' : 'pledge-without-result', remainingDigest: fingerprint, autoTurn: consecutive, turnId: result.turnId });
+      return { opened: true, reason: 'pledge-without-result' };
+    }
+    log('tui.goal-continue', 'decided', { rejected: true, reason: result.reason, ...(result.detail ? { detail: result.detail } : {}), tail, consecutive });
+    // 사람이 막 쳤거나(조용창) 아직 안 비켰다 — 무장은 남기고 조금 뒤 다시 잰다(그 사이 사람 턴이면 noteHumanTurn 이 푼다).
+    if ((result.reason === 'HumanTyping' || result.reason === 'NotIdle') && !retryArmed) {
+      retryArmed = true;
+      defer(() => { retryArmed = false; try { check(); } catch { /* fail-soft */ } }, retryMs);
+    } else if (result.reason !== 'HumanTyping' && result.reason !== 'NotIdle') {
+      armed = null;
+    }
+    return { opened: false, reason: result.reason };
+  };
+
+  return {
+    noteTurnEnded(end) {
+      armed = null;
+      if (!isEnabled()) return;
+      if (end.failed) {
+        log('tui.goal-continue', 'decided', { rejected: true, reason: 'turn-failed' });
+        return;
+      }
+      const tail = replyTailFromLines(end.lines);
+      const verdict = classifyReplyTail(tail);
+      const remaining = remainingWorkTail(tail);
+      if (tail && HUMAN_ACTION.test(tail)) {
+        log('tui.goal-continue', 'skipped', { reason: 'asks-human', tail: tail.slice(-80) });
+        log('tui.proactive', 'stop-human', { reason: 'human-action', remainingDigest: goalContinueFingerprint(tail), autoTurn: consecutive });
+        return;
+      }
+      if (!verdict.pledge && !remaining) {
+        // 평범한 끝(질문·결과 보고)은 관측만 — 대부분의 턴이 여기다.
+        log('tui.goal-continue', 'skipped', { reason: verdict.reason, ...(tail ? { tail: tail.slice(-80) } : {}) });
+        return;
+      }
+      const phrase = remaining ?? (verdict.pledge ? verdict.phrase : '');
+      armed = { tail: tail!, phrase, fingerprint: goalContinueFingerprint(remaining ?? tail!), mode: remaining ? 'remaining' : 'pledge' };
+    },
+    check,
+    noteHumanTurn() {
+      armed = null;
+      consecutive = 0;
+      openedFingerprints.clear();
+      capNotified = false;
+    },
+    wrapPort(port) {
+      return {
+        attach(requestYield) {
+          port.attach(requestYield);
+          if (armed) defer(() => { try { check(); } catch { /* fail-soft */ } }, 0);
+        },
+        detach(opts) { port.detach(opts); },
+        declined(detail) { port.declined?.(detail); },
+      };
+    },
+  };
+}

package/src/dashboard/input/goal-interim.ts

@@ -0,0 +1,2 @@
+// Dashboard compatibility entry; the pure display planner is shared with next TUI.
+export * from '../../tui/chat/goal-interim.js';

package/src/dashboard/input/internal-turn.ts

@@ -18,17 +18,11 @@
 import type { InputResult, TextInputInternalTurnYieldPort } from '../../chat/index.js';
 import { debug } from '../../debug/log.js';
 import type { SubmitTurnIntent } from '../../input/input-intent.js';
+import type { InternalTurnOrigin } from '../../chat/internal-turn-origin.js';
+export type { InternalTurnOrigin } from '../../chat/internal-turn-origin.js';
 import { lastHumanKeyAt as tuiLastHumanKeyAt, pendingKeyCount as tuiPendingKeyCount } from '../../tui.js';
 
 /** 내부 턴의 출처 — 화면 한 줄·관측·정책이 이 값으로 갈린다. 새 출처는 여기에 더한다. */
-export type InternalTurnOrigin =
-  | 'autowake'
-  | 'msg-wake'
-  | 'scheduled'
-  | 'child-complete'
-  | 'goal-continue'
-  | 'test';
-
 /** 거부 사유 — 에러가 아니라 값이다. 호출자는 이 값을 보고 다음 idle 에 다시 부를지 정한다. */
 export type InternalTurnRejectReason =
   /** 턴이 도는 중이거나, 입력칸이 안 떠 있거나(다른 창·모달), 앞 내부 턴이 아직 안 시작됐다. */

package/src/dashboard/input/seat-autowake.ts

@@ -331,21 +331,23 @@ export function createSeatAutowake(deps: SeatAutowakeDeps): SeatAutowakeControll
         lastFingerprint = null;
         consecutive = 0;
       }
-      // The production failed-turn path renders this exact 400 notice and
-      // stages its raw detail. Ordinary assistant text can quote the same API
-      // error, so it must never be parsed as a failed turn by itself.
-      const is400Notice = result.lastLine.includes('모델 API 가 요청을 400 으로 거절')
-        && result.lastLine.includes('원문 /detail open');
-      const match = is400Notice
-        ? /\bCodex API 400\b[^\n]*?No tool call found for function call output with call_id\s+([\w-]+)/iu.exec(result.errorDetail ?? '')
+      // Only the production failed-turn path stages `errorDetail` (pushFailureNotice), so its presence is what
+      // marks a failed turn — ordinary assistant text that quotes the same API error never carries it.
+      // TUI-ORPHAN-AUTO-RESUME-STOP E4 (10-23): the visible line is not a usable gate — this 400 goes through
+      // autoheal, whose notice reads «⚠ 자동 회복 N회 실패…», and the turn footer «✘ 실패 …» is the last line.
+      // The old gate («모델 API 가 요청을 400 으로 거절» in lastLine) therefore never matched in the live TUI.
+      const match = result.errorDetail !== undefined
+        ? /\bCodex API 400\b[^\n]*?No tool call found for function call output with call_id\s+([\w-]+)/iu.exec(result.errorDetail)
         : null;
       if (!match || !activeSessionId) {
+        if (result.errorDetail !== undefined) log('tui.autowake', 'turn-failure', { sessionId: activeSessionId, orphan400: false, count: 0, detailHead: result.errorDetail.slice(0, 160) });
         lastOrphanFailure = null;
         return;
       }
       const callId = match[1]!;
       lastOrphanFailure = lastOrphanFailure?.callId === callId
         ? { callId, count: lastOrphanFailure.count + 1 } : { callId, count: 1 };
+      log('tui.autowake', 'turn-failure', { sessionId: activeSessionId, orphan400: true, callId, count: lastOrphanFailure.count });
       if (lastOrphanFailure.count < 2 || terminalCallId) return;
       terminalCallId = callId;
       log('tui.autowake', 'terminal', {