elanous 0.2.31 → 0.2.34

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

@@ -0,0 +1,242 @@
+// ── 배경 자식 완료 알림 `agent-wake` (TUI-AGENT-IDLE-WAKE 조각 1 · 0.2.31 · 2026-10-17) ─────────────────
+//
+// 🚨 무엇을 푸는가: `Agent(..., run_in_background)` 자식(⊕ RunShell bg 완료)이 끝나면
+//   `globalTaskNotificationQueue` 에 쌓이고 «다음 턴 시작»에 `<task-notification>` 으로 실린다
+//   (turn-preamble drain). 그런데 그 큐의 `onEnqueue` 를 비시험 코드가 아무도 구독하지 않아(구독 0),
+//   쉬는 TUI 는 자식이 끝나도 아무 신호가 없었다 — 10-16 #71 «백그라운드 리뷰 4건 끝나고 12분 방치».
+// ⭐ 이 모듈이 구독 «하나»다(구독 0 → 1). 완료 한 건마다 채팅 한 줄
+//   «✓ 위임 끝: <이름> — 다음 턴에 결과»(입력칸 무접촉). 결과 본문은 기존 preamble drain 이 다음 턴에 싣는다.
+// ⛔ 입력칸 버퍼·`injectKey`·`hostControl.submit`·pty 주입 0(대표 비침투 · 10-17 설계 정정).
+// ⭐ 조각 2(TUI-AGENT-IDLE-WAKE-TURN · 0.2.32): `openTurn` 을 넘기면 자리 TUI(`detectSeatTui` — H1·H3 와 같은
+//   판정)에서 H2 문(`startTurnIfIdle`, origin `child-complete`)으로 다음 턴을 연다. 사람 대화 TUI 는 알림만
+//   (대표 «다음 턴에 싣기»). 거부 사유는 H2 값 그대로(NotIdle·HumanTyping·Cap …) — 여기서 새 판정을 짓지 않는다.
+//   턴 중(NotIdle)·입력 중(HumanTyping)에 온 완료는 «대기»: 입력칸이 다시 뜰 때(`wrapAgentWakePort`) 그 결과가
+//   아직 큐에 남아 있으면(=어느 턴도 안 실었으면) 한 번만 다시 청한다. 이미 실렸으면(drain) 아무것도 안 한다.
+// ⛔ 같은 알림(taskId)은 한 번만 — 큐 `seen` 이 `clear()` 로 비워져도, 대시보드가 재진입해도 막는다.
+//
+// 세 얼굴:
+//   관측 = debug.log('tui.agent-wake', 'notified' | 'opened' | 'rejected' | 'deferred', { taskId, agent, state, seat, shown, reason })
+//          ⊕ H2 자체 관측 `tui.autoturn` opened|rejected { origin:'child-complete' }
+//   인지 = 배경 완료 도착(⊕ 이미 알린 taskId 인가) ⊕ 자리 TUI 인가 ⊕ H2 가 열어 주나
+//   힐링 = 채팅 한 줄로 사람·자리에게 «결과가 왔다»를 보인다 · 자리 TUI 면 H2 로 한 턴(화면 «↻ 자동 재개
+//          (child-complete): 위임 끝: <이름>») · 결과는 유실 0(큐 그대로 → 연 턴/다음 턴 preamble) ·
+//          그리기 실패는 shown:false · 거부는 사유 로그 → TF 가 본다(`eln logs --category tui.agent-wake`)
+
+import { homedir } from 'node:os';
+import type { TextInputInternalTurnYieldPort } from '../../chat/index.js';
+import { debug } from '../../debug/log.js';
+import type { PendingTaskNotification } from '../../agent/task-notification.js';
+import { detectSeatTui, type SeatDetection } from '../seat-boot-preamble.js';
+import type { InternalTurnRejectReason, StartTurnIfIdleOptions, StartTurnIfIdleResult } from './internal-turn.js';
+
+/** 자리 TUI 에서 다음 턴을 여는 길(조각 2). 없으면 알림만(조각 1 동작 그대로). */
+export interface AgentWakeOpenTurnDeps {
+  /** H2 문 — 대시보드의 `internalTurnGate.startTurnIfIdle`. */
+  startTurnIfIdle: (input: string, opts: StartTurnIfIdleOptions) => StartTurnIfIdleResult;
+  getCwd: () => string;
+  /** 그 완료가 아직 어느 턴에도 안 실렸나 — 대시보드는 `globalTaskNotificationQueue.has`. «대기» 재시도의 근거. */
+  isPending: (taskId: string) => boolean;
+  home?: string;
+  detectSeat?: (cwd: string) => SeatDetection | null;
+  /** 입력칸이 다시 뜬 뒤 재시도를 미루는 자리(마운트 «중»에 물러남을 청하지 않게). 기본 setTimeout 0 · unref. */
+  defer?: (fn: () => void) => void;
+}
+
+/** 이 모듈이 내는 거부 사유(H2 밖) — 나머지는 H2 `InternalTurnRejectReason` 그대로. */
+export type AgentWakeTurnSkipReason =
+  /** 사람 대화 TUI — 알림만, 턴은 안 연다. */
+  | 'not-seat'
+  /** 자리 판정 자체가 실패했다(권한 오류 등) — 모르면 열지 않는다. */
+  | 'seat-unknown';
+
+/** H2 가 «지금은 안 된다»로 거부한 것 — 입력칸이 다시 뜰 때 한 번 더 청한다. */
+const DEFERRABLE: ReadonlySet<InternalTurnRejectReason> = new Set(['NotIdle', 'HumanTyping']);
+
+export interface AgentWakeDeps {
+  /** 큐 구독 — 대시보드는 `globalTaskNotificationQueue.onEnqueue` 를 넘긴다. 해제 함수를 돌려준다. */
+  subscribe: (listener: (n: PendingTaskNotification) => void) => () => void;
+  /** 채팅 한 줄(입력칸 무접촉). */
+  notify: (line: string) => void;
+  /** 이미 알린 taskId — 설치를 가로질러 공유한다(기본: 이 컨트롤러만의 집합). */
+  handled?: Set<string>;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  /** 조각 2 — 자리 TUI 에서 H2 로 다음 턴을 연다. 없으면 알림만. */
+  openTurn?: AgentWakeOpenTurnDeps;
+}
+
+export interface AgentWakeController {
+  /** 이 컨트롤러의 구독만 푼다(여러 번 불러도 안전). */
+  dispose(): void;
+  /** 입력칸이 다시 떴다 — «대기» 중인 완료가 아직 안 실렸으면 H2 로 한 번 더 청한다. */
+  onInputMounted(): void;
+}
+
+function displayName(n: Pick<PendingTaskNotification, 'label' | 'agentName'>): string {
+  return ((n.label ?? '').trim() || n.agentName).replace(/\s+/g, ' ').slice(0, 60);
+}
+
+/** 채팅 한 줄 — «✓ 위임 끝: <이름> — 다음 턴에 결과»(실패·중단이면 ✗ ⊕ 상태). */
+export function formatAgentWakeNotice(n: Pick<PendingTaskNotification, 'label' | 'agentName' | 'state'>): string {
+  const name = displayName(n);
+  const glyph = n.state === 'done' ? '✓' : '✗';
+  const state = n.state === 'done' ? '' : ` (${n.state})`;
+  return `${glyph} 위임 끝: ${name}${state} — 다음 턴에 결과`;
+}
+
+/** 자리 TUI 에서 여는 내부 턴의 입력 — 결과 본문은 turn-preamble 이 `<task-notification>` 으로 싣는다. */
+export function formatAgentWakePrompt(n: Pick<PendingTaskNotification, 'label' | 'agentName' | 'state'>): string {
+  return `[자동 재개] 위임 끝: ${displayName(n)} (${n.state}) — <task-notification> 의 결과를 읽고 이어서 처리`;
+}
+
+export function createAgentWake(deps: AgentWakeDeps): AgentWakeController {
+  const log = deps.log ?? ((c, e, d) => debug.log(c, e, d));
+  const handled = deps.handled ?? new Set<string>();
+
+  const open = deps.openTurn;
+  const home = open?.home ?? homedir();
+  const detect = open?.detectSeat ?? ((cwd: string) => detectSeatTui(cwd, { home }));
+  const defer = open?.defer ?? ((fn: () => void) => {
+    const t = setTimeout(fn, 0);
+    (t as { unref?: () => void }).unref?.();
+  });
+  /** H2 가 «지금은 안 된다»로 거부한 마지막 완료 — 입력칸이 다시 뜰 때 한 번만 다시 청한다. */
+  let deferred: PendingTaskNotification | null = null;
+
+  const tryOpen = (n: PendingTaskNotification, trigger: 'enqueue' | 'input-mounted'): void => {
+    if (!open) return;
+    const base = { taskId: n.taskId, agent: n.agentName, state: n.state, trigger };
+    let seat: string | null = null;
+    try { seat = detect(open.getCwd())?.seat ?? null; } catch (error) {
+      log('tui.agent-wake', 'rejected', { ...base, reason: 'seat-unknown' satisfies AgentWakeTurnSkipReason,
+        detail: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    if (!seat) {
+      log('tui.agent-wake', 'rejected', { ...base, seat, reason: 'not-seat' satisfies AgentWakeTurnSkipReason });
+      return;
+    }
+    let result: StartTurnIfIdleResult;
+    try {
+      result = open.startTurnIfIdle(formatAgentWakePrompt(n), { origin: 'child-complete', reason: `위임 끝: ${displayName(n)}` });
+    } catch (error) {
+      log('tui.agent-wake', 'rejected', { ...base, seat, reason: 'error', detail: error instanceof Error ? error.message : String(error) });
+      return;
+    }
+    if (result.opened) {
+      deferred = null;
+      log('tui.agent-wake', 'opened', { ...base, seat, turnId: result.turnId });
+      return;
+    }
+    const wait = DEFERRABLE.has(result.reason) && trigger === 'enqueue';
+    if (wait) deferred = n;
+    log('tui.agent-wake', wait ? 'deferred' : 'rejected', { ...base, seat, reason: result.reason, ...(result.detail ? { detail: result.detail } : {}) });
+  };
+
+  const handle = (n: PendingTaskNotification): boolean => {
+    const base = { taskId: n.taskId, agent: n.agentName, state: n.state };
+    if (handled.has(n.taskId)) {
+      log('tui.agent-wake', 'rejected', { ...base, reason: 'duplicate' });
+      return false;
+    }
+    handled.add(n.taskId);
+    // 그리기 실패가 큐·형제 리스너를 막지 않는다 — 대신 관측에 남긴다(알림이 실제로 안 보였음을 볼 수 있게).
+    let notifyError: string | null = null;
+    try { deps.notify(formatAgentWakeNotice(n)); } catch (error) {
+      notifyError = error instanceof Error ? error.message : String(error);
+    }
+    log('tui.agent-wake', 'notified', { ...base, shown: notifyError === null, ...(notifyError !== null ? { notifyError } : {}) });
+    if (open) tryOpen(n, 'enqueue');
+    return true;
+  };
+
+  let unsubscribe: (() => void) | null = deps.subscribe((n) => { handle(n); });
+
+  return {
+    dispose() {
+      const off = unsubscribe;
+      unsubscribe = null;
+      deferred = null;
+      off?.();
+    },
+    onInputMounted() {
+      if (!open || !deferred || unsubscribe === null) return;
+      const n = deferred;
+      deferred = null; // 재시도는 «한 번» — 다시 거부돼도 쌓지 않는다(결과는 다음 턴 preamble 이 싣는다).
+      defer(() => {
+        try {
+          // 예약 뒤 이 대시보드가 닫혔다 → 옛 H2 문에 청하지 않는다.
+          if (unsubscribe === null) return;
+          // 그 사이 어느 턴이 «그» 결과를 이미 실었다(drain) → 열 이유가 없다(다른 결과는 자기 enqueue 가 청한다).
+          if (!open.isPending(n.taskId)) {
+            log('tui.agent-wake', 'rejected', { taskId: n.taskId, agent: n.agentName, state: n.state, trigger: 'input-mounted', reason: 'already-carried' });
+            return;
+          }
+          tryOpen(n, 'input-mounted');
+        } catch { /* fail-soft: 깨움은 입력을 막지 않는다 */ }
+      });
+    },
+  };
+}
+
+/** 대시보드 `notify` — 채팅 줄을 넣고 그린다. ⛔ 예외를 삼키지 않는다: 줄 넣기·그리기가 실패하면 던져서
+ *  `handle` 이 `notified{shown:false, notifyError}` 로 남기게 한다(삼키면 «보였다»고 거짓 관측). */
+export function createDashboardAgentWakeNotify(
+  pushLine: (line: string) => void,
+  draw: () => void,
+): (line: string) => void {
+  return (line) => {
+    pushLine(line);
+    draw();
+  };
+}
+
+// ── 대시보드 수명 ────────────────────────────────────────────────────────────────────
+// showDashboard 는 다시 들어올 수 있다. ① 구독은 언제나 하나 — 설치가 앞 설치를 먼저 푼다.
+// ② 각 대시보드는 «자기» 컨트롤러만 푼다(늦게 닫힌 앞 대시보드가 새 구독을 끊지 않는다).
+// ③ 이미 알린 taskId 는 설치를 가로질러 하나의 집합 — 재진입 뒤 큐 clear ⊕ 같은 taskId 도 다시 안 알린다
+//    (큐 `seen` 과 같은 수명·같은 크기 정책: 한 세션 O(100) 건).
+const sharedHandled = new Set<string>();
+let installed: AgentWakeController | null = null;
+// ④ 프로세스 종료 정리는 모듈에 «하나»만 — 재진입마다 beforeExit 리스너가 쌓이지 않게(설치 수와 무관하게 1개).
+let exitHookArmed = false;
+export function agentWakeBeforeExitHook(): void {
+  installed?.dispose();
+}
+
+/** 입력칸 문(H2 port)을 감싼다 — 입력칸이 뜰 때마다 «지금 설치된» 깨움에 알린다(port 는 설치보다 먼저 만들어진다). */
+export function wrapAgentWakePort(port: TextInputInternalTurnYieldPort): TextInputInternalTurnYieldPort {
+  return {
+    attach(requestYield) {
+      port.attach(requestYield);
+      try { installed?.onInputMounted(); } catch { /* fail-soft */ }
+    },
+    detach(opts) { port.detach(opts); },
+    declined(detail) { port.declined?.(detail); },
+  };
+}
+
+/** 대시보드용 설치 — 앞 설치를 먼저 풀고(구독 정확히 1) 공유 dedupe 집합을 쓴다. */
+export function installAgentWake(deps: Omit<AgentWakeDeps, 'handled'>): AgentWakeController {
+  installed?.dispose();
+  if (!exitHookArmed) {
+    exitHookArmed = true;
+    process.on('beforeExit', agentWakeBeforeExitHook);
+  }
+  const ctl = createAgentWake({ ...deps, handled: sharedHandled });
+  const own: AgentWakeController = {
+    dispose() {
+      ctl.dispose();
+      if (installed === own) installed = null;
+    },
+    onInputMounted() { ctl.onInputMounted(); },
+  };
+  installed = own;
+  return own;
+}
+
+/** 시험 격리용 — 설치·공유 dedupe 를 비운다. */
+export function resetAgentWakeForTest(): void {
+  installed?.dispose();
+  installed = null;
+  sharedHandled.clear();
+}

package/src/dashboard/input/chat-main-entry-runtime.ts

@@ -5,6 +5,7 @@ import type {
   TextInputHost,
 } from '../../chat/index.js';
 import type { PromptFrame } from '../../display/prompt-frame.js';
+import type { PromptRowOwner } from '../../display/prompt-row-owner.js';
 import type { SurfaceRegistry } from '../../surface/index.js';
 import { createChatMainInputHost } from './chat-main-host.js';
 import { createChatMainInputSession } from './chat-main-session.js';
@@ -24,6 +25,9 @@ export interface RunDashboardChatMainEntryDeps {
     insertAtCursor?: (text: string) => void;
     submit?: (request?: string | TextInputExternalSubmitRequest) => void;
   };
+  /** TUI-PROMPT-SINGLE-OWNER — the frame renderer draws the prompt band
+   *  from what textInput publishes here; textInput writes no prompt rows. */
+  promptRowOwner?: PromptRowOwner;
   setInputLines: (visibleLines: number) => boolean;
   redraw: () => void;
   dispatchGlobalAction: (action: TextInputGlobalAction) => void | Promise<void>;
@@ -84,6 +88,7 @@ export async function runDashboardChatMainEntry(
     textInputOpts: {
       ...deps.textInputOpts,
       host,
+      ...(deps.promptRowOwner ? { promptRowOwner: deps.promptRowOwner } : {}),
     },
   });
   // textInput has returned: its paint closure now holds the submitted buffer.

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

@@ -95,6 +95,7 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
     onText(chunk: string, accumulated: string): void;
     onToolCall(call: unknown): void;
     onToolResult(call: unknown): void;
+    onThought?(text: string): void;
     getAssistantStart(): number;
   };
   runTurnUsageRuntime: (usage: unknown) => void;
@@ -117,6 +118,7 @@ export interface DashboardChatMainPlainTurnRuntimeDeps {
       onToolCall: (call: unknown) => void;
       onToolResult: (call: unknown) => void;
       onUsage: (usage: unknown) => void;
+      onThought?: (text: string) => void;
     }): Promise<unknown>;
   };
   autoTts: {
@@ -483,6 +485,7 @@ export async function runDashboardChatMainPlainTurn(
       onUsage: (usage) => {
         deps.runTurnUsageRuntime(usage);
       },
+      onThought: (text) => { turnStreamRuntime.onThought?.(text); },
       autoTts: deps.autoTts,
       voiceChat: deps.voiceChat,
       drainCooldownMs: userConfig.voice.tts.drainCooldownMs,

package/src/dashboard/input/dashboard-plain-turn-stream.ts

@@ -39,6 +39,7 @@ export interface DashboardPlainTurnAcpSend {
     onToolCall: (call: unknown) => void;
     onToolResult: (call: unknown) => void;
     onUsage: (usage: unknown) => void;
+    onThought?: (text: string) => void;
   }): Promise<unknown>;
 }
 
@@ -55,6 +56,8 @@ export interface DashboardPlainTurnStreamDeps {
   onToolCall: (call: unknown) => void;
   onToolResult: (call: unknown) => void;
   onUsage: (usage: unknown) => void;
+  /** TUI-TURN-NARRATION — 추론 요약 문단(선택). */
+  onThought?: (text: string) => void;
 
   /** Auto-TTS hooks. `pushChunk` is fired on every text delta;
    *  `commit` / `cancel` are called by the settle sink in the
@@ -173,6 +176,7 @@ export async function runDashboardPlainTurnStream(
         deps.onToolResult(call);
       },
       onUsage: (usage) => deps.onUsage(usage),
+      ...(deps.onThought ? { onThought: (text: string) => deps.onThought!(text) } : {}),
     });
     settled = deps.abortCtrl.signal.aborted ? 'cancelled' : 'end_turn';
     // Return the cumulative full response so commit / metrics / autocopy

package/src/dashboard/input/external-input-host.ts

@@ -16,12 +16,33 @@ export interface DashboardExternalInputHostDeps {
   };
   /** 채팅 로그에 한 줄(표지)을 남기고 다시 그린다. */
   pushNotice: (line: string) => void;
+  /** 외부 입력 대기열의 현재 상태 한 줄을 설정하거나(문면) 지운다(null). */
+  setQueueNotice: (line: string | null) => void;
   /** 지금 턴의 ESC 중단 경로(escGate) — 턴 밖이면 null. 외부 `/stop` 이 이것을 부른다. */
   getTurnStop?: () => (() => void) | null;
   /** 미소비 키 수 — 기본 tui.ts 키 큐. */
   pendingKeyCount?: () => number;
 }
 
+export function updateDashboardExternalInputQueueNotice(
+  lines: string[],
+  previousNotice: string | null,
+  nextNotice: string | null,
+  formatNotice: (notice: string) => string = (notice) => notice,
+): boolean {
+  const previousLine = previousNotice === null ? null : formatNotice(previousNotice);
+  const nextLine = nextNotice === null ? null : formatNotice(nextNotice);
+  if (previousLine === nextLine) return false;
+  const previousIndex = previousLine === null ? -1 : lines.indexOf(previousLine);
+  if (previousIndex >= 0) {
+    if (nextLine === null) lines.splice(previousIndex, 1);
+    else lines[previousIndex] = nextLine;
+  } else if (nextLine !== null) {
+    lines.push(nextLine);
+  }
+  return true;
+}
+
 export function createDashboardExternalInputHost(deps: DashboardExternalInputHostDeps): ExternalInputHost {
   // ⚠️ submit/insertAtCursor 는 textInput 이 내려간 뒤에도 남아 있다 — «composer 가 떠 있나»는
   //    getBufferText 유무로만 판단한다(내려가면 undefined).
@@ -45,15 +66,8 @@ export function createDashboardExternalInputHost(deps: DashboardExternalInputHos
         : result === 'no-turn' ? '⏹ 외부 /stop — 도는 턴이 없어 무시했습니다'
         : '⏹ 외부 /stop — 이 턴의 중단 경로에 닿지 못했습니다(Esc 로 멈춰 주세요)');
     },
-    onQueueChange: (pending, event) => {
-      if (event === 'queued') {
-        const notice = renderExternalInputQueueNotice(pending);
-        if (notice) deps.pushNotice(notice);
-        return;
-      }
-      deps.pushNotice(pending.length > 0
-        ? `⤵ 외부 입력 1건 전송 · 남은 대기 ${pending.length}건`
-        : '⤵ 외부 입력 1건 전송');
+    onQueueChange: (pending) => {
+      deps.setQueueNotice(renderExternalInputQueueNotice(pending));
     },
   };
 }

package/src/dashboard/input/mouse-wiring.ts

@@ -21,7 +21,7 @@
 // cross-cutting concern. Unit-testable in isolation.
 
 import chalk from 'chalk';
-import { ctp, stripAnsi, visibleWidth } from '../../tui.js';
+import { ctp, stripAnsi, truncate, visibleWidth } from '../../tui.js';
 import { debug } from '../../debug/log.js';
 import {
   modalMoveThreshold,
@@ -77,6 +77,7 @@ import {
   modeSegment,
   ptyShellCountSegment,
   runningAgentsSegment,
+  backgroundJobsSegment,
   runningBuildSegment,
   controllerSegment,
   shellRollupSegment,
@@ -88,6 +89,7 @@ import {
   type GitSegmentState,
   type RunningBuildState,
   type ShellRollupSummary,
+  type BackgroundJobsSummary,
   type StatusBarRenderOptions,
   type VwSummary,
 } from '../../status/bar.js';
@@ -169,6 +171,9 @@ export interface DashboardStatusInput {
   elapsedSec?: number;
   /** Running registered child agents. Omit or pass zero to hide. */
   runningAgents?: number;
+  /** TUI-BG-JOB-VISIBILITY (#71) — turn-outliving shell jobs. Rendered as
+   *  `⧗ 백그라운드 N` after the agents/controller pills. Omit or 0 to hide. */
+  backgroundJobs?: BackgroundJobsSummary | null;
   /** External controller identity. Omit to hide. */
   controller?: string;
   shellCount?: number;
@@ -742,6 +747,62 @@ function createPopupAuthority(deps: {
   };
 }
 
+/** 상태줄 세그먼트를 폭 `budget` 안에 순서대로 놓는다 — 넘치는 세그먼트는 건너뛰고(뒤의 작은 것은
+ *  들어가면 넣는다) `required` 세그먼트(첫 칸 ⊕ 호출자가 지정한 필수 표시)는 늘 둔다: 선택 세그먼트는
+ *  «뒤에 남은 필수 세그먼트 몫» 을 남겨 둘 수 있을 때만 들어간다. 필수만으로 넘치면 `width > budget`
+ *  으로 드러나고 호출자가 잘라 낸다. tf-bg-ghost(10-17): 폭을 넘긴 마지막 줄이 화면을 스크롤해 유령 줄을 남겼다. */
+export function fitStatusSegments(
+  widths: readonly number[],
+  sepWidth: number,
+  budget: number,
+  required: readonly boolean[] = [],
+): { placed: Array<{ index: number; startCol: number; width: number }>; dropped: number[]; width: number } {
+  const isRequired = (i: number): boolean => i === 0 || required[i] === true;
+  const w = (i: number): number => Math.max(0, widths[i] ?? 0);
+  // reserve[i] = i 뒤(제외)에 남은 필수 세그먼트가 차지할 폭(구분자 포함).
+  const reserve: number[] = new Array(widths.length + 1).fill(0);
+  for (let i = widths.length - 1; i >= 0; i--) {
+    reserve[i] = reserve[i + 1]! + (isRequired(i + 1) && i + 1 < widths.length ? sepWidth + w(i + 1) : 0);
+  }
+  const placed: Array<{ index: number; startCol: number; width: number }> = [];
+  const dropped: number[] = [];
+  let col = 0;
+  for (let i = 0; i < widths.length; i++) {
+    const start = placed.length > 0 ? col + sepWidth : 0;
+    if (!isRequired(i) && start + w(i) + reserve[i]! > budget) {
+      dropped.push(i);
+      continue;
+    }
+    placed.push({ index: i, startCol: start, width: w(i) });
+    col = start + w(i);
+  }
+  return { placed, dropped, width: col };
+}
+
+/** 세그먼트 «종류» — 렌더 문자열의 첫 낱말(🐚 · ctx · 🖥 · ⧗ …). 관측 키에 값이 섞이지 않게. */
+export function statusSegmentKind(render: string): string {
+  return stripAnsi(render).trim().split(/\s+/)[0] ?? '';
+}
+
+/** `line` 을 실폭(visibleWidth) `budget` 이하가 될 때까지 자른다 — 상한 없는 축소 · 0 이면 빈 문자열.
+ *  `truncate` 는 코드포인트 폭(isWide)으로 세서 이모지에서 어긋날 수 있어 실폭으로 다시 잰다. */
+export function truncateToVisibleWidth(line: string, budget: number): string {
+  if (budget <= 0) return '';
+  if (visibleWidth(line) <= budget) return line;
+  for (let max = budget; max > 0; max--) {
+    const cut = truncate(line, max);
+    if (visibleWidth(cut) <= budget) return cut;
+  }
+  return '';
+}
+
+/** 잘린 상태줄에 맞춰 pill 경계를 보이는 폭 안으로 줄인다(화면 밖 pill 은 뺀다). */
+export function clampPillsToWidth(pills: readonly PillBound[], shown: number): PillBound[] {
+  return pills
+    .filter((p) => p.startCol < shown)
+    .map((p) => ({ ...p, endCol: Math.min(p.endCol, shown) }));
+}
+
 export function createDashboardMouseWiring(deps: DashboardMouseWiringDeps): DashboardMouseWiring {
   const toastStack = new ToastStack({
     placement: 'top-right',
@@ -871,6 +932,7 @@ export function createDashboardMouseWiring(deps: DashboardMouseWiringDeps): Dash
     }
   }
 
+  let lastStatusOverflowKey = '';
   const buildStatusLine = (input: DashboardStatusInput): string => {
     // 2026-05-05 — narrow-width gate. modelSegment honours
     // `compact: true` to truncate model id at the first parameter-size
@@ -879,7 +941,7 @@ export function createDashboardMouseWiring(deps: DashboardMouseWiringDeps): Dash
     // terminal" boundary; everything above stays full-width.
     const { cols } = deps.termSize();
     const opts: StatusBarRenderOptions = { theme: input.theme, compact: cols < 100 };
-    const segments: Array<{ name: PillName | null; render: string }> = [
+    const segments: Array<{ name: PillName | null; render: string; required?: boolean }> = [
       { name: 'workingDir', render: sessionCwdSegment(input.swd, opts) },
       { name: null,         render: gitSegment(input.swd, labelGitState(input.gitState, input.runningBuild ? '트리' : undefined), opts) },
     ];
@@ -890,6 +952,11 @@ export function createDashboardMouseWiring(deps: DashboardMouseWiringDeps): Dash
     if (runningAgentsRender) segments.push({ name: null, render: runningAgentsRender });
     const controllerRender = controllerSegment(input.controller, opts);
     if (controllerRender) segments.push({ name: null, render: controllerRender });
+    // TUI-BG-JOB-VISIBILITY (#71) — turn-outliving work sits with the agents/controller
+    // «activity» cluster (controller stays immediately after agents).
+    const backgroundJobsRender = backgroundJobsSegment(input.backgroundJobs ?? null, opts);
+    // 폭이 모자라도 이 표시는 건너뛰지 않는다(필수) — 다른 세그먼트를 먼저 건너뛴다.
+    if (backgroundJobsRender) segments.push({ name: null, render: backgroundJobsRender, required: true });
     // A1 — mode pill between model and elapsed. `'general'` yields
     // empty render so the pill disappears by default; only sync /
     // control get painted. Name 'mode' is always set so click still
@@ -945,20 +1012,50 @@ export function createDashboardMouseWiring(deps: DashboardMouseWiringDeps): Dash
     // Compute column positions as segments concatenate with the same
     // separator string the renderer uses. `visibleWidth` counts cells
     // (wide-char aware), so the pill bounds stay correct.
+    //
+    // TUI-BG-JOB-VISIBILITY 라이브 결함(tf-bg-ghost · 10-17) — 상태줄은 «마지막 줄» 이라 폭을 넘으면
+    //   터미널 자동 줄바꿈이 화면 전체를 한 줄 위로 «스크롤» 한다. 차분 렌더러(`render`)는 그걸 모르고
+    //   안 바뀐 줄을 다시 안 써서, 스피너 줄이 ChatLog 아래 유령으로 남고 머리 줄이 사라졌다.
+    //   ⇒ 프레임 폭(cols-1 · composeVertical 의 totalW)을 넘는 세그먼트는 «건너뛴다»(순서 유지 ·
+    //   뒤의 작은 세그먼트는 들어갈 수 있으면 넣는다). 관측 = status.bar/overflow-fit(건너뛴 집합이 바뀔 때만).
     const nextPills: PillBound[] = [];
     const parts: string[] = [];
-    let col = 0;
-    const sepW = visibleWidth(stripAnsi(STATUS_SEGMENT_SEPARATOR));
-    for (let i = 0; i < segments.length; i++) {
-      const seg = segments[i]!;
-      if (i > 0) col += sepW;
-      const width = visibleWidth(stripAnsi(seg.render));
-      if (seg.name) nextPills.push({ name: seg.name, startCol: col, endCol: col + width });
-      col += width;
+    const budget = Math.max(0, cols - 1);
+    const fit = fitStatusSegments(
+      segments.map((seg) => visibleWidth(stripAnsi(seg.render))),
+      visibleWidth(stripAnsi(STATUS_SEGMENT_SEPARATOR)),
+      budget,
+      segments.map((seg) => seg.required === true),
+    );
+    for (const placed of fit.placed) {
+      const seg = segments[placed.index]!;
+      if (seg.name) nextPills.push({ name: seg.name, startCol: placed.startCol, endCol: placed.startCol + placed.width });
       parts.push(seg.render);
     }
+    // 키 = 건너뛴 세그먼트 «종류»(첫 낱말 · 🐚·ctx·🖥 …)의 중복 없는 정렬 집합 — 폭·리사이즈·값(ctx 15k→16k)·같은 종류 수는 키가 아니다.
+    const droppedKinds = [...new Set(fit.dropped.map((i) => statusSegmentKind(segments[i]!.render)))].sort();
+    const droppedKey = droppedKinds.join(' ');
+    if (droppedKey !== lastStatusOverflowKey) {
+      lastStatusOverflowKey = droppedKey;
+      try {
+        debug.log('status.bar', 'overflow-fit', {
+          cols,
+          budget,
+          dropped: droppedKinds,
+          width: fit.width,
+        });
+      } catch { /* 관측 실패가 상태줄을 막지 않는다 */ }
+    }
     pills = nextPills;
-    return parts.join(STATUS_SEGMENT_SEPARATOR);
+    const line = parts.join(STATUS_SEGMENT_SEPARATOR);
+    // 첫 칸 하나만으로도 넘치는 아주 좁은 화면 — 잘라서라도 한 줄 안에 둔다.
+    if (fit.width <= budget) return line;
+    //   `truncate` 는 코드포인트 폭(isWide)으로 세서 이모지에서 한두 칸 어긋날 수 있다 — 실폭(visibleWidth)으로 다시 잰다.
+    const cut = truncateToVisibleWidth(line, budget);
+    // pill 경계도 실제로 보이는 범위로 줄인다(잘린 뒤의 클릭·호버가 화면 밖을 가리키지 않게).
+    const shown = visibleWidth(cut);
+    pills = clampPillsToWidth(nextPills, shown);
+    return cut;
   };
 
   const setStatusRow = (row: number | null): void => {

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

@@ -92,7 +92,16 @@ export type SeatAutowakeSkipReason =
   | 'nothing-pending'
   | 'human-recent'
   | 'same-order'
-  | 'cap';
+  | 'cap'
+  | 'terminal-codex-400';
+
+/** The rendered error line is captured before the turn footer shortens it. */
+export interface SeatAutowakeTurnResult {
+  sessionId: string | null;
+  lastLine: string;
+  /** Raw turn failure staged for /detail open when the visible line is condensed. */
+  errorDetail?: string;
+}
 
 export interface SeatAutowakeInput {
   /** 자리 TUI 의 자리(대문자) — 자리 아님이면 null. */
@@ -187,7 +196,7 @@ export interface SeatAutowakeDeps {
 
 export interface SeatAutowakeController {
   /** 모델 턴이 끝났다(스트리밍 정리 지점) — 다음 입력칸 마운트에서 한 번 잰다. */
-  noteTurnEnded(): void;
+  noteTurnEnded(result?: SeatAutowakeTurnResult): void;
   /** 입력칸이 마운트됐다 — 턴 끝이 무장돼 있으면 판정하고, 남은 일이 있으면 H2 로 연다. */
   check(): SeatAutowakeDecision & { opened?: boolean; rejected?: string };
   /** H2 의 yield port 를 감싸 «마운트 = 판정 시점»으로 잇는다(입력칸 무접촉). */
@@ -229,6 +238,9 @@ export function createSeatAutowake(deps: SeatAutowakeDeps): SeatAutowakeControll
   let lastOpenedAt = 0;
   let capNotified = false;
   let recheckArmed = false;
+  let activeSessionId: string | null = null;
+  let lastOrphanFailure: { callId: string; count: number } | null = null;
+  let terminalCallId: string | null = null;
 
   const check: SeatAutowakeController['check'] = () => {
     const detection = detect(deps.getCwd());
@@ -256,6 +268,14 @@ export function createSeatAutowake(deps: SeatAutowakeDeps): SeatAutowakeControll
       seat, enabled, turnEnded, unread, queue, now: t, lastHumanKeyAt: humanAt,
       humanQuietMs: quietMs, lastFingerprint, consecutive, consecutiveCap: deps.consecutiveCap,
     });
+    if (terminalCallId && activeSessionId) {
+      turnEnded = false;
+      log('tui.autowake', 'terminal-blocked', {
+        seat, sessionId: activeSessionId, errorKind: 'codex-orphan-tool-output-400',
+        callId: terminalCallId, recommendedAction: '/session new',
+      });
+      return { action: 'skip', reason: 'terminal-codex-400', unread: decision.unread, queue: decision.queue };
+    }
     if (decision.action === 'skip' && decision.reason === 'not-turn-end') return decision;
     const base = {
       seat,
@@ -301,7 +321,40 @@ export function createSeatAutowake(deps: SeatAutowakeDeps): SeatAutowakeControll
   };
 
   return {
-    noteTurnEnded() { turnEnded = true; },
+    noteTurnEnded(result) {
+      turnEnded = true;
+      if (!result) return;
+      if (result.sessionId !== activeSessionId) {
+        activeSessionId = result.sessionId;
+        lastOrphanFailure = null;
+        terminalCallId = null;
+        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 ?? '')
+        : null;
+      if (!match || !activeSessionId) {
+        lastOrphanFailure = null;
+        return;
+      }
+      const callId = match[1]!;
+      lastOrphanFailure = lastOrphanFailure?.callId === callId
+        ? { callId, count: lastOrphanFailure.count + 1 } : { callId, count: 1 };
+      if (lastOrphanFailure.count < 2 || terminalCallId) return;
+      terminalCallId = callId;
+      log('tui.autowake', 'terminal', {
+        seat: detect(deps.getCwd())?.seat ?? null,
+        sessionId: activeSessionId, errorKind: 'codex-orphan-tool-output-400',
+        callId, recommendedAction: '/session new',
+      });
+      deps.notify?.(`⏹ Codex 400 자동 재개 중단 · 세션 ${activeSessionId} · call_id ${callId} · /session new 로 새 세션을 시작하세요`);
+    },
     check,
     wrapPort(port) {
       return {