elanous 0.2.31 → 0.2.34

package/src/dashboard/turn-start-segments.ts

@@ -0,0 +1,222 @@
+// TURN-START-BLOCK-REST 2단계 — 턴 시작 덩어리 관측(`tui.turn-start segments`).
+//
+// 1단계(#28821)가 turn-preamble 빌더 전체 ≤10ms 인데 같은 창의 `tui.input-lag turn-start` loopDelayMs.max 는
+// 21~112ms 임을 보였다 — 막는 것은 preamble «밖»이다. 이 모듈은 턴 시작(대시보드 턴 본문 첫 콜백)에 트레이스를
+// 열고, 실제 호출 순서를 따라 심은 경계(`markTurnStartSegment`)마다 시계를 «한 번» 읽어 앞 경계와의 ms 를
+// 덩어리로 쌓는다. 첫 스트림 요청 경계(`endTurnStartSegments`)에서 닫고, 박동 두 번 간격 뒤 같은 창의 루프
+// 지연과 함께 debug.log('tui.turn-start', 'segments', …) 한 줄을 남긴다. 기존 `tui.input-lag` 줄은 창·칸 그대로다.
+//
+// - 턴 키: 경계는 트레이스를 연 «그 턴»의 키(ACP sessionId)를 같이 준다. 키가 다른 경계(다른 세션의 턴 ·
+//   서브 에이전트)는 문자열 비교 한 번으로 버린다 — 시계를 안 읽고 덩어리도 안 섞는다. 한 번에 열린 트레이스는
+//   하나(TUI 는 한 번에 한 턴)이고, 다른 키로 새로 열면 앞 것은 `superseded` 로 닫는다.
+// - 박동: 덩어리 안에서 박동이 돌았으면(`yielded`) 루프가 돌았다 = 순수 동기 아님. 박동 없이 이어진 덩어리 합의
+//   최대(`syncBlockMaxMs`)가 박동 하나가 본 막힘의 추정이다(오차 ≤ 박동 간격). 박동은 input-lag 프로브의 것을
+//   읽는다(`InputLagBeatView` — 새 타이머 0).
+// - debug 가 꺼진 턴은 트레이스를 안 연다 — 그 턴의 경계는 null 검사 한 번이고 시계를 안 읽는다.
+// - 줄을 내는 시점은 기존 turn-start 와 같은 «박동 두 번 간격» 타이머다(두 줄의 창이 같은 규칙으로 닫힌다).
+//   실제 박동 두 번을 센 뒤 내보내는 전환은 TURN-START-BLOCK-REST 3단계 앞 조각.
+// - 결선(대시보드·ACP·코어 턴·LLM 경계 한 줄씩)은 후속 PR — 이 모듈은 등록이 없으면 아무 일도 안 한다.
+
+import type { InputLagBeatView, LoopDelayMs } from '../tui/input-lag-probe.js';
+
+export const TURN_START_CATEGORY = 'tui.turn-start';
+export const TURN_START_SEGMENTS_EVENT = 'segments';
+/** 첫 스트림 요청 경계가 끝내 안 오면(원격 데몬 세션 · 중단 · 실패) 이만큼 뒤 쌓인 덩어리로 닫는다. */
+export const TURN_START_TRACE_CAP_MS = 15_000;
+
+export interface TurnStartSegments {
+  /** 덩어리 이름 → ms(0.1ms 반올림 · 앞 경계부터 이 경계까지의 벽시계). 같은 이름이 또 오면 `#2`… */
+  segmentsMs: Record<string, number>;
+  /** 경계가 온 순서. */
+  order: string[];
+  /** 그 덩어리 안에서 박동이 돌았다 — 루프가 돌았으니(await·I/O) 벽시계 ms 가 곧 막힘은 아니다. */
+  yielded: string[];
+  /** 덩어리 합(공개된 segmentsMs 값의 합 · 0.1ms). */
+  totalMs: number;
+  /** 트레이스 시작 → 닫힘. stream-open 이면 totalMs 와 같고, cap·superseded 면 마지막 경계 뒤 기다린 시간까지 든다
+   *  (debug 가 꺼진 새 턴이 닫으면 시계를 안 읽으므로 마지막 경계까지). */
+  closedAfterMs: number;
+  /** 트레이스를 열 때 마지막 박동부터 흐른 ms — 열기 «전» 동기 일이 이미 루프를 막고 있었으면 크다(평상시 ≤ 박동 간격). */
+  preTraceMs: number;
+  /** 박동 없이 이어진 덩어리 합의 최대 — 루프를 한 번에 막은 동기 덩어리의 추정(박동이 돈 덩어리는 마지막 박동 뒤
+   *  꼬리만 · 첫 덩어리까지 박동이 안 돌았으면 `preTrace` 를 머리로 포함). */
+  syncBlockMaxMs: number;
+  /** 그 최대 동기 덩어리를 이룬 덩어리 이름(순서대로). ⚠️ 첫 이름이 `yielded` 에 든 덩어리면 그 덩어리는 «마지막 박동 뒤
+   *  꼬리만» syncBlockMaxMs 에 들었다 — 그 덩어리 segmentsMs 전체가 동기 블록이라는 뜻이 아니다. */
+  syncBlockSegments: string[];
+  /** 트레이스 시작 → 닫힘 ⊕ 박동 두 번 간격 창의 루프 지연. */
+  loopDelayMs: LoopDelayMs;
+  endedBy: 'stream-open' | 'cap' | 'superseded';
+  /** 트레이스 키(ACP sessionId). */
+  key: string;
+  turnId?: string;
+  busy: boolean;
+}
+
+interface TimerLike { unref?: () => void }
+
+export interface TurnStartSegmentsOptions {
+  beats: InputLagBeatView;
+  log: (category: string, event: string, data: TurnStartSegments) => void;
+  isBusy: () => boolean;
+  /** 트레이스를 열지 — 대시보드는 `debug.enabled` 를 준다. 없으면 연다. */
+  isEnabled?: () => boolean;
+  now?: () => number;
+  setTimeoutFn?: (fn: () => void, ms: number) => TimerLike;
+  clearTimeoutFn?: (timer: TimerLike) => void;
+}
+
+export interface TurnStartSegmentsRecorder {
+  /** 키 `key` 의 턴 시작 트레이스를 연다(열린 것이 있으면 `superseded` 로 닫고). */
+  begin(key: string, turnId?: string): void;
+  /** 키가 같은 열린 트레이스에 덩어리 경계 하나 — 시계 한 번. 아니면 null 검사·비교뿐. */
+  mark(key: string, name: string): void;
+  /** 첫 스트림 요청 경계 — 마지막 덩어리를 찍고 닫는다(줄은 박동 두 번 간격 뒤). */
+  end(key: string, name: string): void;
+  dispose(): void;
+}
+
+const round1 = (ms: number): number => Math.round(Math.max(0, ms) * 10) / 10;
+
+interface Trace {
+  key: string;
+  turnId: string | undefined;
+  startAt: number;
+  lastAt: number;
+  preTraceMs: number;
+  /** 공개 덩어리(반올림 값)의 누적 합 — totalMs 가 segmentsMs 의 합과 어긋나지 않게. */
+  sumMs: number;
+  segmentsMs: Record<string, number>;
+  order: string[];
+  yielded: string[];
+  blockMs: number;
+  blockSegments: string[];
+  maxBlockMs: number;
+  maxBlockSegments: string[];
+  capTimer: TimerLike | null;
+}
+
+export function createTurnStartSegments(opts: TurnStartSegmentsOptions): TurnStartSegmentsRecorder {
+  const now = opts.now ?? (() => performance.now());
+  const isEnabled = opts.isEnabled ?? (() => true);
+  const setTimeoutFn = opts.setTimeoutFn ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimeoutFn = opts.clearTimeoutFn ?? ((t) => clearTimeout(t as ReturnType<typeof setTimeout>));
+  const beats = opts.beats;
+  let trace: Trace | null = null;
+  let disposed = false;
+
+  const markAt = (tr: Trace, name: string): void => {
+    const t = now();
+    let key = name;
+    for (let n = 2; key in tr.segmentsMs; n++) key = `${name}#${n}`;
+    const ms = round1(t - tr.lastAt);
+    tr.segmentsMs[key] = ms;
+    tr.sumMs += ms;
+    tr.order.push(key);
+    // 앞 경계 뒤에 박동이 돌았으면 루프가 돌았다 — 동기 덩어리는 마지막 박동 «뒤» 꼬리부터 다시 센다.
+    const lastBeatAt = beats.lastBeatAt();
+    if (lastBeatAt > tr.lastAt) {
+      tr.yielded.push(key);
+      tr.blockMs = t - lastBeatAt;
+      tr.blockSegments = [key];
+    } else {
+      tr.blockMs += t - tr.lastAt;
+      tr.blockSegments.push(key);
+    }
+    if (tr.blockMs >= tr.maxBlockMs) {
+      tr.maxBlockMs = tr.blockMs;
+      tr.maxBlockSegments = tr.blockSegments.slice();
+    }
+    tr.lastAt = t;
+  };
+
+  const close = (tr: Trace, endedBy: TurnStartSegments['endedBy'], closedAt: number): void => {
+    if (trace === tr) trace = null;
+    // 닫힌 트레이스를 상한 타이머가 붙잡지 않게 푼다.
+    if (tr.capTimer !== null) { clearTimeoutFn(tr.capTimer); tr.capTimer = null; }
+    const emit = (): void => {
+      if (disposed) return;
+      opts.log(TURN_START_CATEGORY, TURN_START_SEGMENTS_EVENT, {
+        segmentsMs: tr.segmentsMs,
+        order: tr.order,
+        yielded: tr.yielded,
+        totalMs: Math.round(tr.sumMs * 10) / 10,
+        closedAfterMs: round1(closedAt - tr.startAt),
+        preTraceMs: round1(tr.preTraceMs),
+        syncBlockMaxMs: round1(tr.maxBlockMs),
+        syncBlockSegments: tr.maxBlockSegments,
+        loopDelayMs: beats.loopDelaySince(tr.startAt),
+        endedBy,
+        key: tr.key,
+        ...(tr.turnId !== undefined ? { turnId: tr.turnId } : {}),
+        busy: opts.isBusy(),
+      });
+    };
+    // 방금 끝난 동기 막힘은 루프가 풀린 «뒤» 박동에 찍힌다 — 첫 스트림 요청이면 박동 두 번 간격 기다렸다 읽는다.
+    if (endedBy === 'stream-open') setTimeoutFn(emit, beats.heartbeatMs * 2).unref?.();
+    else emit();
+  };
+
+  return {
+    begin(key: string, turnId?: string): void {
+      if (disposed) return;
+      const open = trace;
+      if (!isEnabled()) {
+        // debug 가 꺼진 턴은 시계를 안 읽는다 — 열려 있던 트레이스는 마지막 경계 시각으로 닫는다.
+        if (open !== null) close(open, 'superseded', open.lastAt);
+        return;
+      }
+      const t = now();
+      if (open !== null) close(open, 'superseded', t);
+      // 열기 전 마지막 박동 뒤 흐른 시간 — 열기 전 동기 일이 같은 막힘의 머리다(시계는 이 한 번).
+      const preTraceMs = Math.max(0, t - beats.lastBeatAt());
+      const tr: Trace = {
+        key, turnId, startAt: t, lastAt: t, preTraceMs, sumMs: 0,
+        segmentsMs: {}, order: [], yielded: [],
+        blockMs: preTraceMs, blockSegments: ['preTrace'], maxBlockMs: preTraceMs, maxBlockSegments: ['preTrace'],
+        capTimer: null,
+      };
+      trace = tr;
+      tr.capTimer = setTimeoutFn(() => { tr.capTimer = null; if (trace === tr) close(tr, 'cap', now()); }, TURN_START_TRACE_CAP_MS);
+      tr.capTimer.unref?.();
+    },
+    mark(key: string, name: string): void {
+      const tr = trace;
+      if (tr !== null && tr.key === key) markAt(tr, name);
+    },
+    end(key: string, name: string): void {
+      const tr = trace;
+      if (tr === null || tr.key !== key) return;
+      markAt(tr, name);
+      close(tr, 'stream-open', tr.lastAt);
+    },
+    dispose(): void {
+      if (disposed) return;
+      disposed = true;
+      if (trace !== null && trace.capTimer !== null) { clearTimeoutFn(trace.capTimer); trace.capTimer = null; }
+      trace = null;
+    },
+  };
+}
+
+// ── 등록 자리 — 대시보드가 하나 등록하고, 경계(대시보드·ACP·코어 턴·LLM)는 부르기만 한다. ──
+let active: TurnStartSegmentsRecorder | null = null;
+
+export function setTurnStartSegments(recorder: TurnStartSegmentsRecorder | null): void {
+  active = recorder;
+}
+
+/** 키 `key`(ACP sessionId) 의 턴 시작 트레이스를 연다 — 대시보드 턴 본문의 첫 콜백. */
+export function beginTurnStartSegments(key: string, turnId?: string): void {
+  active?.begin(key, turnId);
+}
+
+/** 턴 시작 덩어리 경계 — 등록·트레이스가 없거나 키가 다르면 null 검사·비교뿐(시계를 안 읽는다). */
+export function markTurnStartSegment(key: string | undefined, name: string): void {
+  if (key !== undefined) active?.mark(key, name);
+}
+
+/** 첫 스트림 요청 경계 — 같은 키의 트레이스를 닫는다. */
+export function endTurnStartSegments(key: string | undefined, name: string): void {
+  if (key !== undefined) active?.end(key, name);
+}

package/src/dashboard/turn-stream-formatter.ts

@@ -18,6 +18,8 @@ import { debug } from '../debug/log.js';
 import { renderToolBlock } from '../chat/tool-render/block.js';
 import type { ToolRenderModel } from '../chat/tool-render/types.js';
 import { toolOperationKind, type FoldMode } from '../log-entry.js';
+import { sep } from 'node:path';
+import { toolResultsRoot } from '../tool-runtime/truncation-store.js';
 import { stripAnsi } from '../tui.js';
 import type { TurnStreamPresentationEvent } from './turn-stream-presentation-applier.js';
 import { buildFoldedTailLine, splitNoSynthesisTail } from './chat-fold.js';
@@ -161,6 +163,24 @@ export interface TurnStreamFormatter {
   onText(chunk: string, accumulated: string): void;
   onToolCall(call: TurnStreamCall): void;
   onToolResult(call: TurnStreamCall): void;
+  /** TUI-TURN-NARRATION — 추론 요약 한 문단을 흐린 💭 한 줄로 남긴다(결함 #87). */
+  onThought?(text: string): void;
+}
+
+/** 잡무 도구를 접을 때의 종류 이름 — `… (N 내부)`. */
+export const BOOKKEEPING_KIND = '내부';
+const BOOKKEEPING_TOOLS = new Set(['MsgList', 'MsgAck', 'ScheduleWakeup']);
+/** 도구 결과가 길어 넘침 파일로 빠진 것을 다시 읽는 Read — 사람에게는 «같은 결과를 이어 읽음» 이다.
+ *  ⛔ 부분 문자열이 아니라 «실제 넘침 뿌리» 아래인지로 가린다(#28968 리뷰 FU-5 — 남의 같은 이름 경로를 접지 않게). */
+export function isBookkeepingTool(
+  kind: string,
+  args: Record<string, unknown>,
+  spillRoot: string = toolResultsRoot(),
+): boolean {
+  if (BOOKKEEPING_TOOLS.has(kind)) return true;
+  if (kind !== 'Read') return false;
+  const path = args.file_path ?? args.path;
+  return typeof path === 'string' && path.startsWith(`${spillRoot}${sep}`);
 }
 
 export function createTurnStreamFormatter(
@@ -168,6 +188,9 @@ export function createTurnStreamFormatter(
 ): TurnStreamFormatter {
   const groupingKind = (name: string, args: Record<string, unknown>): string | undefined => {
     const kind = toolOperationKind(name, args);
+    // TUI-TURN-NARRATION 조각 3 — 사람이 볼 필요 없는 잡무 도구(우편 확인·깨움 예약 · 넘침 파일 읽기)는
+    //   «내부» 한 종류로 묶어, 연달아 오면 «… (N 내부)» 한 줄로 접는다(결함 #87 화면 소음).
+    if (deps.foldMode && deps.foldMode !== 'line' && isBookkeepingTool(kind, args)) return BOOKKEEPING_KIND;
     return deps.foldMode === 'kind-unit' || (deps.foldMode === 'task-unit' && kind === 'RunShell')
       ? kind
       : undefined;
@@ -189,6 +212,7 @@ export function createTurnStreamFormatter(
   const nonGenericCallIds = new Set<string>();
   let toolCallCount = 0;
   let noSynthesisTailCount = 0;
+  let thoughtCount = 0;
 
   const emitAssistantBlock = (): void => {
     deps.thinking.update('Streaming');
@@ -265,6 +289,13 @@ export function createTurnStreamFormatter(
       }
       emitAssistantBlock();
     },
+    onThought(text: string): void {
+      const line = text.replace(/\s+/g, ' ').trim();
+      if (line.length === 0) return;
+      // 생각 줄은 답 글 «사이»에 끼지 않게 지금까지의 라운드 글을 닫고 붙인다.
+      closeRound();
+      deps.emit({ type: 'tool.appendLine', callId: `thought-${++thoughtCount}`, line: deps.muted(`💭 ${line}`) });
+    },
     onToolCall(call: TurnStreamCall): void {
       toolCallCount += 1;
       deps.thinking.update(`Streaming ${call.name} (${toolCallCount} ${toolCallCount === 1 ? 'tool' : 'tools'})`);
@@ -338,7 +369,9 @@ export function createTurnStreamFormatter(
         collapsedLines: variants.collapsed,
         expandedLines: variants.expanded,
         ...(groupingKind(call.name, args)
-          ? { operationKind: deps.foldMode === 'task-unit'
+          ? { operationKind: groupingKind(call.name, args) === BOOKKEEPING_KIND
+            ? BOOKKEEPING_KIND
+            : deps.foldMode === 'task-unit'
             ? 'RunShell'
             : ('operationKind' in variants ? variants.operationKind : undefined) ?? toolOperationKind(call.name, args) }
           : {}),

package/src/dashboard/turn-stream-runtime.ts

@@ -66,6 +66,7 @@ export interface DashboardTurnStreamRuntime {
   onText(chunk: string, accumulated: string): void;
   onToolCall(call: DashboardTurnStreamCall): void;
   onToolResult(call: DashboardTurnStreamCall): void;
+  onThought?(text: string): void;
 }
 
 export function createDashboardTurnStreamRuntime(
@@ -102,5 +103,6 @@ export function createDashboardTurnStreamRuntime(
     onText: formatter.onText,
     onToolCall: formatter.onToolCall,
     onToolResult: formatter.onToolResult,
+    ...(formatter.onThought ? { onThought: formatter.onThought } : {}),
   };
 }

package/src/dashboard/turn-typeahead-prompt-zone.ts

@@ -0,0 +1,67 @@
+import { debug } from '../debug/log.js';
+import type { LayoutZone } from '../layout/composer.js';
+import {
+  drawTurnTypeaheadPromptRows,
+  type TurnTypeaheadPromptPaintSink,
+  type TurnTypeaheadPromptRowsInput,
+} from './input/turn-typeahead-prompt.js';
+
+/** Dashboard draw entry for the input-prompt zone. Streaming redraws reach
+ * this production binding through the zone renderer below. */
+export function drawDashboardTurnTypeaheadPromptRows(
+  input: TurnTypeaheadPromptRowsInput,
+  sink?: TurnTypeaheadPromptPaintSink,
+): string[] {
+  return drawTurnTypeaheadPromptRows(input, sink);
+}
+
+/** Essential frames own the fallback prompt caret; Z-axis state only wins
+ * when a modal has made a visible claim. */
+export function buildDashboardTurnTypeaheadPromptZone(input: TurnTypeaheadPromptRowsInput & {
+  suppressPromptArea: boolean;
+}): LayoutZone {
+  return {
+    id: 'input-prompt',
+    height: input.frame.inputHeight,
+    render: (height, width) => {
+      if (input.suppressPromptArea) return Array.from({ length: height }, () => ' '.repeat(width));
+      return drawDashboardTurnTypeaheadPromptRows({ ...input, height, width });
+    },
+  };
+}
+
+/** 프롬프트 zone 에 관측만 덧입힌다 — 렌더 산출은 `inner` 가 소유한다.
+ *
+ *  ⭐ **왜 뽑았나**(무인 리뷰 must-fix · 2026-08-01): 종전엔 이 래퍼가 `zones.push({...})` 안에
+ *  인라인이라, 테스트가 `inner`(=`buildDashboardTurnTypeaheadPromptZone`)만 불러도 통과했다.
+ *  ⇒ ***래퍼가 `inner.render` 를 부르는 것을 끊어도 검사가 침묵***했다. 이제 그 결선이 검사된다.
+ *
+ *  ⛔⚠️ **여전히 검사 밖인 한 겹**: 이 함수의 반환이 실제로 `zones` 배열에 **push 되는지**는
+ *  `showDashboard` 안의 지역 조립부라 단위 검사가 닿지 않는다. ***무한 후퇴이므로 여기서 경계를 긋는다*** —
+ *  그 한 겹은 **라이브 검증**(`dev --elanous --hold` ⊕ `pty snapshot`)이 맡는다. */
+export function observeDashboardTurnTypeaheadPromptZone(
+  inner: LayoutZone,
+  deps: {
+    promptBottomRow: number;
+    state: { buffer: string; queuedSubmissions: string[] };
+    isDebugEnabled?: () => boolean;
+    log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  },
+): LayoutZone {
+  return {
+    ...inner,
+    render: (height, width) => {
+      const rows = inner.render(height, width);
+      const enabled = deps.isDebugEnabled ? deps.isDebugEnabled() : debug.enabled;
+      if (deps.state.buffer && enabled) {
+        (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('dashboard.turn-typeahead-prompt', 'dashboard-draw-prompt', {
+          row: deps.promptBottomRow,
+          text: rows.at(-1) ?? '',
+          bufferLength: deps.state.buffer.length,
+          queuedSubmissionCount: deps.state.queuedSubmissions.length,
+        });
+      }
+      return rows;
+    },
+  };
+}

package/src/display/prompt-row-owner.ts

@@ -0,0 +1,146 @@
+/** 대기 중 프롬프트 띠의 «주인 하나» (TUI-PROMPT-SINGLE-OWNER · 2026-10-17).
+ *
+ *  종전엔 띠를 둘이 그렸다 — frame 렌더러 zone 은 `❯ ` 를, textInput `drawInput` 은
+ *  실제 버퍼를 직접 stdout 에 썼다. 직접 쓰기가 행 캐시를 무효화하므로 대기 중 매 draw
+ *  (2Hz 상태줄 틱 포함)가 «zone 이 `❯ ` 로 지움 → afterRender 덧칠이 버퍼로 다시 씀»을
+ *  되풀이했고, 프롬프트·구분선·상태줄이 매 프레임 `\x1b[2K` 로 다시 나갔다.
+ *
+ *  ⭐ 이제 textInput 은 그릴 줄을 여기 **올리기만** 하고(publish), 실제 쓰기는 frame
+ *  렌더러 zone 하나가 한다. 행 캐시 diff 가 바뀐 줄만 내보내므로 대기 중 재출력은 0 이다. */
+import { debug } from '../debug/log.js';
+import type { LayoutZone } from '../layout/composer.js';
+import type { CursorState } from './cursor-state.js';
+
+export interface PromptRowPaint {
+  /** 위→아래 순서의 보이는 프롬프트 줄(접두·패딩 포함 · 행 지움 없음). */
+  rows: string[];
+  /** 프롬프트 아래 둘째 줄의 일시 힌트(Ctrl+C 등). 없으면 null. */
+  hint: string | null;
+  caret: CursorState | null;
+  source: 'text-input' | 'reverse-search';
+}
+
+export interface PromptRowOwner {
+  /** 같은 그림이면 false(프레임 요청 없음) — 대기 중 외부 repaint 가 no-op 이 되는 자리. */
+  publish(paint: PromptRowPaint): boolean;
+  clear(): void;
+  current(): PromptRowPaint | null;
+}
+
+export type PromptRowOwnerLog = (category: string, event: string, data: Record<string, unknown>) => void;
+
+const CATEGORY = 'dashboard.prompt-owner';
+
+const paintKey = (paint: PromptRowPaint): string => JSON.stringify(paint);
+
+export function createPromptRowOwner(deps: {
+  requestFrame: () => void;
+  isDebugEnabled?: () => boolean;
+  log?: PromptRowOwnerLog;
+}): PromptRowOwner {
+  let paint: PromptRowPaint | null = null;
+  let key = '';
+  const enabled = (): boolean => (deps.isDebugEnabled ? deps.isDebugEnabled() : debug.enabled);
+  const log: PromptRowOwnerLog = deps.log ?? ((c, e, d) => debug.log(c, e, d));
+  return {
+    publish(next) {
+      const nextKey = paintKey(next);
+      if (nextKey === key) return false;
+      paint = next;
+      key = nextKey;
+      if (enabled()) {
+        log(CATEGORY, 'publish', {
+          source: next.source,
+          rows: next.rows.length,
+          hint: next.hint !== null,
+          caretRow: next.caret?.row ?? null,
+          caretCol: next.caret?.col ?? null,
+        });
+      }
+      deps.requestFrame();
+      return true;
+    },
+    clear() {
+      if (!paint) return;
+      paint = null;
+      key = '';
+      if (enabled()) log(CATEGORY, 'clear', {});
+      deps.requestFrame();
+    },
+    current: () => paint,
+  };
+}
+
+/** 바닥 기준으로 `height` 줄에 맞춘다 — 입력 줄이 늘면 위로 자란다(textInput 과 같은 앵커). */
+export function renderPromptOwnerRows(paint: PromptRowPaint, height: number): string[] {
+  // ⚠️ `slice(-0)` is the whole array — a zero-height zone must paint nothing.
+  if (height <= 0) return [];
+  const visible = paint.rows.slice(-height);
+  return [...Array.from({ length: height - visible.length }, () => ''), ...visible];
+}
+
+export type PromptBandOwner = 'text-input' | 'turn-typeahead' | 'suppressed';
+
+/** 누가 띠를 그렸나 — 주인·그림(줄·힌트·caret)이 바뀔 때 한 줄, 같은 상태(대기)는 10초에 한 줄로 샘플링. */
+export function createPromptBandRenderObserver(deps: {
+  isDebugEnabled?: () => boolean;
+  log?: PromptRowOwnerLog;
+  now?: () => number;
+  sampleMs?: number;
+} = {}): (owner: PromptBandOwner, frameKey: string) => void {
+  const now = deps.now ?? Date.now;
+  const sampleMs = deps.sampleMs ?? 10_000;
+  let lastOwner: PromptBandOwner | null = null;
+  let lastFrameKey = '';
+  let lastLoggedAt = 0;
+  let renders = 0;
+  return (owner, frameKey) => {
+    renders++;
+    const enabled = deps.isDebugEnabled ? deps.isDebugEnabled() : debug.enabled;
+    if (!enabled) return;
+    const changed = owner !== lastOwner || frameKey !== lastFrameKey;
+    const at = now();
+    if (!changed && at - lastLoggedAt < sampleMs) return;
+    (deps.log ?? ((c, e, d) => debug.log(c, e, d)))(CATEGORY, 'frame-render', {
+      owner,
+      changed,
+      rendersSinceLast: renders,
+    });
+    lastOwner = owner;
+    lastFrameKey = frameKey;
+    lastLoggedAt = at;
+    renders = 0;
+  };
+}
+
+/** 프롬프트 zone 을 주인 하나로 감싼다 — textInput 이 그림을 올렸으면 그것을, 아니면(턴 중)
+ *  `inner`(turn-typeahead 에코·placeholder)를 그린다. caret 도 같은 그림에서 나온다. */
+export function withPromptRowOwner(inner: LayoutZone, owner: PromptRowOwner, opts: {
+  suppressPromptArea: boolean;
+  onCaret?: (caret: CursorState | null) => void;
+  /** `frameKey` covers everything the band paints — rows, hint and caret. */
+  observe?: (owner: PromptBandOwner, frameKey: string) => void;
+}): LayoutZone {
+  return {
+    ...inner,
+    render: (height, width) => {
+      const paint = opts.suppressPromptArea ? null : owner.current();
+      if (!paint) {
+        const rows = inner.render(height, width);
+        opts.observe?.(opts.suppressPromptArea ? 'suppressed' : 'turn-typeahead', rows.join('\n'));
+        return rows;
+      }
+      const rows = renderPromptOwnerRows(paint, height);
+      opts.onCaret?.(paint.caret);
+      opts.observe?.('text-input', JSON.stringify({ rows, hint: paint.hint, caret: paint.caret }));
+      return rows;
+    },
+  };
+}
+
+/** 프롬프트 아래 둘째 줄(status-gap-top) — textInput 힌트가 있으면 그것, 아니면 빈 줄.
+ *  프롬프트가 억제된 프레임(전면 모달 등)에는 힌트도 내지 않는다. */
+export function renderPromptOwnerHintRow(owner: PromptRowOwner, opts: { suppressPromptArea: boolean }): string {
+  if (opts.suppressPromptArea) return '';
+  return owner.current()?.hint ?? '';
+}

package/src/display/resize-listener.ts

@@ -10,14 +10,31 @@
 // overlays catch up too. Both calls are wrapped in try/catch so a
 // transient paint error doesn't kill the listener.
 //
+// (3) TUI-PICKER-RESIZE-SHRINK (#76 · 2026-10-17) — then ask the
+// coordinator for one FORCED frame. Steps (1)+(2) bypass the
+// coordinator flush, so the prompt chrome repaint in (2) writes the
+// input divider straight over the bottom row of an open overlay (the
+// slash picker's `╰` sits on the divider row) and nothing re-emits the
+// overlay afterwards — the picker lost its bottom border until it was
+// closed and reopened. A coordinator frame runs onRender → afterRender
+// (chrome) → flushOverlay (modals on top), so the overlay lands last.
+// `force` matters: the overlay byte-equality cache would otherwise
+// skip a re-emit whose bytes match the last coordinator frame
+// (e.g. 80 → 120 → 80 with no coordinator flush in between).
+//
 // Non-goals (stay out of IDX-1 territory):
-//   - Do NOT touch coordinator.flushOverlay cache state.
-//   - Do NOT recompute modal bounds (mount-time snapshot preserved).
+//   - Do NOT touch coordinator.flushOverlay cache state directly.
 //   - Do NOT reach into chat.ts textInput loop internals.
 
+import { debug } from '../debug/log.js';
+
 export interface ResizeListenerDeps {
   draw: (opts?: { force?: boolean }) => void;
   promptCtl: { repaint: () => void };
+  /** Request one forced coordinator frame so modal overlays are
+   *  re-emitted on top of the chrome the prompt repaint just wrote.
+   *  Optional: hosts without a coordinator keep the legacy two-step. */
+  requestOverlayFrame?: () => void;
 }
 
 /** Registers the resize listener and returns a dispose fn that
@@ -28,6 +45,20 @@ export function installResizeListener(deps: ResizeListenerDeps): () => void {
   const handler = (): void => {
     try { deps.draw({ force: true }); } catch { /* swallow — paint errors shouldn't break resize */ }
     try { deps.promptCtl.repaint(); } catch { /* swallow */ }
+    let overlayFrame: 'requested' | 'absent' | 'failed' = 'absent';
+    if (deps.requestOverlayFrame) {
+      try {
+        deps.requestOverlayFrame();
+        overlayFrame = 'requested';
+      } catch {
+        overlayFrame = 'failed';
+      }
+    }
+    debug.log('display.resize', 'repaint', {
+      cols: process.stdout.columns ?? null,
+      rows: process.stdout.rows ?? null,
+      overlayFrame,
+    });
   };
   process.stdout.on('resize', handler);
   return (): void => {

package/src/domains/guardian-tick.ts

@@ -1,4 +1,5 @@
 import type { Database } from 'bun:sqlite';
+import { hostname } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { debug } from '../debug/log.js';
 import { calendarFields, resolveTimeZone } from '../time/format.js';
@@ -16,6 +17,43 @@ export interface GuardianDeps {
   config?: { guardian?: { mode?: 'shadow' | 'live' } };
   /** Inject a cron-run-compatible executor in tests; shadow never calls it. */
   execute?: (command: string) => Promise<SpawnOutcome>;
+  /** Injected only for deterministic expiry-alert tests. Production reads the local Grok auth file. */
+  grokExpiry?: () => string | null;
+  hostName?: string;
+}
+
+export const GROK_EXPIRY_ALERT_WINDOW_MS = 4 * 60 * 60 * 1000;
+
+function durationLabel(ms: number): string {
+  const minutes = Math.max(0, Math.ceil(ms / 60_000));
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return hours ? `${hours}h${String(rest).padStart(2, '0')}m` : `${rest}m`;
+}
+
+/** Return a token-free alert line only when expiry is within four hours (or already past). */
+export function grokExpiryAlertLine(opts: {
+  now: Date; expiresAt: string | null; host?: string;
+}): string | null {
+  if (!opts.expiresAt) return null;
+  const expiresAtMs = Date.parse(opts.expiresAt);
+  if (!Number.isFinite(expiresAtMs)) return null;
+  const remainingMs = expiresAtMs - opts.now.getTime();
+  if (remainingMs > GROK_EXPIRY_ALERT_WINDOW_MS) return null;
+  return `Grok 자격 만료 경보 · host=${opts.host ?? hostname()} · expires=${new Date(expiresAtMs).toISOString()} · remaining=${remainingMs <= 0 ? '만료됨' : durationLabel(remainingMs)} · device-auth=https://accounts.x.ai/oauth2/device · 코드 생성/Allow는 OP(grok login --device-auth)`;
+}
+
+export function grokExpiryStatusLine(opts: {
+  now: Date; expiresAt: string | null; host?: string;
+}): string {
+  const host = opts.host ?? hostname();
+  if (!opts.expiresAt) return `Grok 자격 만료 확인 · host=${host} · expires=unknown · alert=not-set`;
+  const expiresAtMs = Date.parse(opts.expiresAt);
+  if (!Number.isFinite(expiresAtMs)) return `Grok 자격 만료 확인 · host=${host} · expires=invalid · alert=not-set`;
+  const remainingMs = expiresAtMs - opts.now.getTime();
+  const remaining = remainingMs <= 0 ? '만료됨' : durationLabel(remainingMs);
+  const alert = remainingMs <= GROK_EXPIRY_ALERT_WINDOW_MS ? 'active' : `in ${durationLabel(remainingMs - GROK_EXPIRY_ALERT_WINDOW_MS)}`;
+  return `Grok 자격 만료 확인 · host=${host} · expires=${new Date(expiresAtMs).toISOString()} · remaining=${remaining} · 4h-alert=${alert}`;
 }
 
 function shellQuote(value: string): string {
@@ -45,9 +83,23 @@ function liveCommand(jobId: string, raw: string): string {
 }
 
 /** One five-minute guardian observation. No schedule state or crontab is mutated in shadow mode. */
-export async function guardianTick(now: Date, plan: GuardianPlan, deps: GuardianDeps = {}): Promise<{ mode: 'shadow' | 'live'; wouldRun: string[]; executed: number }> {
+export async function guardianTick(now: Date, plan: GuardianPlan, deps: GuardianDeps = {}): Promise<{ mode: 'shadow' | 'live'; wouldRun: string[]; executed: number; credentialAlert?: string }> {
   if (!Number.isFinite(now.getTime())) throw new RangeError('invalid tick time');
   const mode = deps.config?.guardian?.mode === 'live' ? 'live' : 'shadow';
+  let expiryLine: string | null = null;
+  try {
+    const expiryAt = deps.grokExpiry ? deps.grokExpiry() : (await import('../grok/credential.js')).readGrokSubscriptionExpiry();
+    expiryLine = grokExpiryAlertLine({
+      now,
+      expiresAt: expiryAt,
+      ...(deps.hostName ? { host: deps.hostName } : {}),
+    });
+    if (expiryLine) debug.log('guardian.credential-expiry', 'warning', { line: expiryLine });
+  } catch (error) {
+    debug.log('guardian.credential-expiry', 'read-failed', {
+      errorName: error instanceof Error ? error.name : 'unknown',
+    });
+  }
   const timeZone = plan.timeZone ?? resolveTimeZone().timeZone;
   const wouldRun: string[] = [];
   let executed = 0;
@@ -64,7 +116,7 @@ export async function guardianTick(now: Date, plan: GuardianPlan, deps: Guardian
       if (outcome.code !== 0) throw new Error(`guardian job ${job.id} exited ${outcome.code}`);
     }
   }
-  return { mode, wouldRun, executed };
+  return { mode, wouldRun, executed, ...(expiryLine ? { credentialAlert: expiryLine } : {}) };
 }
 
 export interface GuardianDayDeps {