elanous 0.2.31 → 0.2.32

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/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/log-click-runtime.ts

@@ -1,6 +1,6 @@
 import type { Attachment, ContextRegistry } from '../context.js';
 import { debug } from '../debug/log.js';
-import type { FoldStack } from '../fold-stack.js';
+import type { FoldStack, FoldTarget } from '../fold-stack.js';
 import type { AttachmentRowMap } from '../log-pane/attachment-row-map.js';
 import type { LogClickDispatchDeps } from '../log-pane/click-dispatch.js';
 import type { AttachmentPopupAction } from '../log-pane/attachment-popup.js';
@@ -43,6 +43,113 @@ export interface DashboardLogClickRuntimeDeps {
    *  `toggleAtLine` decides). Hosts
    *  that omit it keep the legacy attachment/pill-only behavior. */
   foldStack?: FoldStack;
+  /** Keeps the viewport where the click happened while a click toggles a
+   *  fold (#81). Hosts that omit it keep FoldStack's own scroll policy. */
+  foldClickAnchor?: FoldClickScrollAnchor;
+}
+
+/** Scroll state the fold-click anchor reads and writes. Offsets are the
+ *  log pane's visual-row offsets (`-1` = pinned to the tail). */
+export interface FoldClickScrollState {
+  getScrollOffset: () => number;
+  setScrollOffset: (offset: number) => void;
+  /** Max visual-row offset for the current chatLines (after a splice). */
+  maxScroll: () => number;
+  getFrozenTail: () => number | null;
+  setFrozenTail: (index: number | null) => void;
+  /** chatLines length — tells new output from the fold's own splice. */
+  lineCount: () => number;
+}
+
+export interface FoldClickScrollAnchor {
+  /** Current top visual row and raw offset — the click's frame. */
+  viewport(): { top: number; scrollOffset: number };
+  /** Run a click toggle with the viewport top held in place. */
+  run<T>(toggle: () => T): T;
+  /** FoldStack `onAfterToggle` hook: inside `run` it keeps the top row;
+   *  outside (the `f` key, bulk toggles) it falls back to `otherwise`. */
+  onAfterToggle(target: FoldTarget, delta: number): void;
+  /** Call before each paint: a pane that was following the tail when the
+   *  click expanded a block goes back to the tail as soon as new output
+   *  arrives (the click must not leave the pane stuck off the tail). */
+  reconcile(): void;
+}
+
+/** #81 — the old `onAfterToggle` pinned every toggle to the tail, so a
+ *  click that expanded a block near the bottom pushed its header up the
+ *  screen and a second click on the same spot landed in the body (rejected
+ *  as `expanded-body`). A click toggle now keeps the top row; it only
+ *  returns to the tail when the kept top would be past the new bottom. */
+export function createFoldClickScrollAnchor(
+  state: FoldClickScrollState,
+  otherwise: (target: FoldTarget, delta: number) => void,
+): FoldClickScrollAnchor {
+  let heldTop: number | null = null;
+  // Set when a click moved a tail-following pane off the tail: the offset
+  // it set and the line count right after the splice.
+  let followTail: { offset: number; lineCount: number } | null = null;
+  const viewport = (): { top: number; scrollOffset: number } => {
+    const scrollOffset = state.getScrollOffset();
+    const max = state.maxScroll();
+    return { top: scrollOffset < 0 ? max : Math.min(scrollOffset, max), scrollOffset };
+  };
+  return {
+    viewport,
+    run<T>(toggle: () => T): T {
+      const prev = heldTop;
+      heldTop = viewport().top;
+      try {
+        return toggle();
+      } finally {
+        heldTop = prev;
+      }
+    },
+    onAfterToggle(target, delta) {
+      if (heldTop === null) {
+        otherwise(target, delta);
+        return;
+      }
+      // The splice moved every line after the block; a frozen tail past it
+      // must move with them or the pane would cut the expanded rows short.
+      const frozen = state.getFrozenTail();
+      if (frozen !== null && target.kind === 'static' && target.lineStart < frozen) {
+        state.setFrozenTail(frozen + delta);
+      }
+      const offsetBefore = state.getScrollOffset();
+      const wasFollowing = offsetBefore < 0 || followTail?.offset === offsetBefore;
+      const max = state.maxScroll();
+      const next = heldTop >= max ? -1 : heldTop;
+      state.setScrollOffset(next);
+      if (next < 0) state.setFrozenTail(null);
+      // No freeze here: the pane still follows the tail (see reconcile).
+      followTail = next >= 0 && wasFollowing ? { offset: next, lineCount: state.lineCount() } : null;
+      debug.log('log.fold', 'fold-click-anchor', {
+        lineStart: target.kind === 'static' ? target.lineStart : null,
+        delta,
+        topBefore: heldTop,
+        scrollOffsetAfter: next,
+        maxScrollAfter: max,
+        followTail: followTail !== null,
+      });
+    },
+    reconcile() {
+      if (followTail === null) return;
+      // Someone else moved the pane (scroll keys, search, tail pin) — theirs.
+      if (state.getScrollOffset() !== followTail.offset) {
+        followTail = null;
+        return;
+      }
+      if (state.lineCount() <= followTail.lineCount) return;
+      debug.log('log.fold', 'fold-click-follow-tail', {
+        offset: followTail.offset,
+        lineCountBefore: followTail.lineCount,
+        lineCountNow: state.lineCount(),
+      });
+      followTail = null;
+      state.setScrollOffset(-1);
+      state.setFrozenTail(null);
+    },
+  };
 }
 
 export function createDashboardLogClickDeps(
@@ -97,6 +204,13 @@ export function createDashboardLogClickDeps(
       ? {
           tryFoldToggle: (absIdx: number): boolean => {
             const fold = deps.foldStack!;
+            const anchor = deps.foldClickAnchor;
+            // Screen frame of the click — lets the log tell «same spot again»
+            // from «a different row» (#81 had no way to).
+            const frame = anchor ? (() => {
+              const v = anchor.viewport();
+              return { screenRow: absIdx - v.top, top: v.top, scrollOffset: v.scrollOffset };
+            })() : {};
             // Collapse from the first/last line of an expanded range or
             // the row whose click expanded it (#16 — same spot again folds).
             // Other lines of that range are rejected first so a body
@@ -114,6 +228,7 @@ export function createDashboardLogClickDeps(
                       reason: 'expanded-body',
                       lineStart: t.lineStart,
                       lineEnd: t.lineEnd,
+                      ...frame,
                     });
                     return false;
                   }
@@ -121,7 +236,8 @@ export function createDashboardLogClickDeps(
                 }
               }
             }
-            const toggled = fold.toggleAtLine(absIdx);
+            const toggle = (): boolean => fold.toggleAtLine(absIdx, frame);
+            const toggled = anchor ? anchor.run(toggle) : toggle();
             if (toggled) deps.draw();
             return toggled;
           },