elanous 0.2.29 → 0.2.32

package/src/capture/tui-self-report.ts

@@ -39,10 +39,11 @@ import { createTuiScreenMirror } from './tui-screen-mirror.js';
 import { getChannelBus } from '../terminal-matrix/index.js';
 import { publishSelfReportFrame } from './self-report-frame.js';
 import {
-  upsertPtyManifest, updatePtyManifestFrame, touchLivePtyManifest, markPtyManifestClosed, removePtyManifest,
+  upsertPtyManifest, updatePtyManifestFrame, touchLivePtyManifest, markPtyManifestClosed, removePtyManifest, getPtyManifest,
+  updatePtyManifestBuild,
 } from '../pty-shell/pty-manifest.js';
 import { writeHarnessScreen } from '../harness/harness-screen.js';
-import { startTuiRunStateRecorder } from '../pty-shell/tui-run-state.js';
+import { runningBuild, startTuiRunStateRecorder } from '../pty-shell/tui-run-state.js';
 import { debug } from '../debug/log.js';
 import { routeExternalInput, type ExternalInputRoute } from '../input/external-input-queue.js';
 
@@ -185,6 +186,48 @@ export interface TuiSelfReportDeps {
   reportControlCleanupFailure?: (stage: TuiControlCleanupStage, error: unknown) => void;
   /** 행 등록 직후 실행 판 ⊕ 턴(idle) 기록을 연다 — `elanous pty state` 가 읽는다. 반환 = 정리. */
   startRunState?: (surfaceId: string) => (() => void);
+  /** 미룬 우편 깨움 폴러(TUI-H4)를 연다 — 반환 = 정리. 기본은 실 행 등록과 짝일 때만 늦게 불러온 `startPendingWakePoller`. */
+  startWakePoller?: (surfaceId: string) => (() => void);
+  /** 박동마다 자기 행을 본다 — 없으면 null · ⛔ 조회 실패는 «던진다»(없다로 읽지 않는다). 기본 = `getPtyManifest(id, { strict })`. */
+  lookupRow?: (surfaceId: string) => TuiOwnRowView | null;
+  /** 재등록 뒤 실행 판(build) 칸을 다시 적는다 — 기본 = 기동 때 판(`runningBuild`). */
+  restoreBuild?: (surfaceId: string) => void;
+  /** 박동 스케줄러 — 기본 setInterval(unref). 시험이 박동을 손으로 돌린다. */
+  driveHeartbeat?: (tick: () => void, ms: number) => (() => void);
+  /** SIGCONT 수신 훅(행 상실 단서) — 반환 = 해제. 기본 = process.on('SIGCONT'). */
+  onSigcont?: (fn: () => void) => (() => void);
+  /** 행 상실 관측 — 기본 = debug.log('tui.self-report', 'row-missing', data). */
+  logRowMissing?: (data: TuiRowMissingEvent) => void;
+}
+
+/** 박동이 보는 자기 행 — `PtyManifestRow` 의 부분(재등록 뒤 frame·build 복원 확인에도 쓴다). */
+export interface TuiOwnRowView {
+  readonly alive: boolean;
+  readonly frameAt?: number;
+  readonly build?: unknown;
+}
+
+/** `tui.self-report` · `row-missing` 한 줄 — 살아 있는 TUI 의 manifest 행이 사라졌을 때(재등록 시도 결과 ⊕ 원인 단서). */
+export interface TuiRowMissingEvent {
+  readonly surfaceId: string;
+  readonly pid: number;
+  /** 'absent' = 행이 없다 · 'closed' = 행은 있는데 alive=0 · 'lookup-failed' = 조회 자체가 실패(재등록 안 함). */
+  readonly state: 'absent' | 'closed' | 'lookup-failed';
+  /** 마지막으로 자기 행을 «본» 시각(등록·재등록 포함). */
+  readonly lastSeenAt: number;
+  readonly sinceMs: number;
+  /** 직전 박동과의 간격 — 박동 주기보다 훨씬 크면 그 사이 프로세스가 멈췄다(SIGSTOP·SIGTTIN·이벤트 루프 정체). */
+  readonly gapMs: number;
+  readonly heartbeatMs: number;
+  /** 마지막 SIGCONT 시각(없으면 null) — `lastSeenAt` 뒤면 «정지 → 재개» 사이에 걷혔다는 단서. */
+  readonly sigcontAt: number | null;
+  readonly sigcontSinceLastSeen: boolean;
+  readonly reRegistered: boolean;
+  /** 재등록이 비운 frame 칸에 마지막 화면을 다시 적었나(`pty snapshot` 이 바로 닿는다). */
+  readonly frameRestored: boolean;
+  /** 재등록이 비운 실행 판(build) 칸을 다시 적었나(다시 읽어 확인). */
+  readonly buildRestored: boolean;
+  readonly error?: string;
 }
 
 export type TuiControlInitStage = 'create-target' | 'register-target' | 'start-poller' | 'publish-manifest';
@@ -263,6 +306,17 @@ export function startTuiSelfReport(deps: TuiSelfReportDeps = {}): () => void {
   // 행 등록을 갈아 끼운 호출자(시험)는 실 manifest 를 안 건드린다 — 기본 녹음기는 기본 행 등록과 짝일 때만.
   const startRunState = deps.startRunState ?? (deps.registerRow ? () => () => {} : startTuiRunStateRecorder);
   try { stopRunState = startRunState(surfaceId); } catch { /* fail-soft — recorder logs its own write failures */ }
+  // 미룬 우편 깨움(TUI-H4) — 이 TUI 가 턴 중·5분 창이라 못 받은 깨움을 idle 로 «기록»된 뒤 한 번 다시 두드린다.
+  // 실 행 등록과 짝일 때만(시험이 행 등록을 갈아 끼우면 0) · 무거운 모듈은 늦게 불러온다.
+  let stopWakePoller: () => void = () => {};
+  let wakePollerStopped = false;
+  if (deps.startWakePoller) {
+    try { stopWakePoller = deps.startWakePoller(surfaceId); } catch { /* fail-soft */ }
+  } else if (!deps.registerRow) {
+    void import('../loops/msg-wake.js').then(mod => {
+      if (!wakePollerStopped) stopWakePoller = mod.startPendingWakePoller(surfaceId);
+    }).catch(() => { /* fail-soft — the post-time wake still runs */ });
+  }
   const driveTicks = deps.driveTicks ?? ((tick, ms) => {
     const t = setInterval(tick, ms);
     (t as { unref?: () => void }).unref?.();
@@ -279,8 +333,11 @@ export function startTuiSelfReport(deps: TuiSelfReportDeps = {}): () => void {
   // The manifest row is published only after both input capabilities are
   // live. A listed TUI therefore always has a registered target and poller.
 
+  // 마지막으로 내보낸 화면 — 재등록이 frame 칸을 비우면 다시 적는다(거울은 바뀐 화면만 내보내 idle 이면 영영 빈 칸).
+  let lastEmittedText: string | null = null;
   const emitText = (text: string, cols: number, rows: number): void => {
     const at = now();
+    lastEmittedText = text;
     const frame: SelfReportFrame = { surfaceId, instance, kind: 'tui', mode: 'self-report', text, cols, rows, at, ...(runId ? { runId } : {}) };
     try { publishFrame(frame); } catch { /* fail-soft */ }
     // `at` is shared with the manifest write → its internal throttle keys
@@ -327,17 +384,103 @@ export function startTuiSelfReport(deps: TuiSelfReportDeps = {}): () => void {
   }
 
   // Heartbeat so a live-but-idle TUI isn't culled by reapStale.
-  const hb = setInterval(() => { try { heartbeat(surfaceId, now()); } catch { /* fail-soft */ } }, heartbeatMs);
-  (hb as { unref?: () => void }).unref?.();
-
+  // ⭐ 박동마다 자기 행을 본다 — 남이 걷어 간 행(정지 중 stale 수거 등)을 같은 박동에서 다시 세운다.
+  //   행이 없으면 pty text/key/snapshot·우편 깨움이 이 TUI 에 영영 안 닿는다(#75 · #84).
+  // 행 등록을 갈아 끼운 호출자(시험)는 실 manifest 를 안 읽는다 — 기본 조회는 기본 행 등록과 짝일 때만.
+  const lookupRow: (id: string) => TuiOwnRowView | null = deps.lookupRow
+    ?? (deps.registerRow ? () => ({ alive: true }) : (id: string) => getPtyManifest(id, { strict: true }));
+  const restoreBuild = deps.restoreBuild ?? (deps.registerRow ? () => {} : (id: string) => { updatePtyManifestBuild(id, runningBuild()); });
+  const logRowMissing = deps.logRowMissing ?? ((data: TuiRowMissingEvent) => debug.log('tui.self-report', 'row-missing', data));
+  const rowNickname = deps.nickname?.trim() || undefined;
+  let lastSeenAt = now();
+  let lastBeatAt = lastSeenAt;
+  let sigcontAt: number | null = null;
+  let stopSigcont: () => void = () => {};
+  try {
+    stopSigcont = (deps.onSigcont ?? ((fn) => {
+      process.on('SIGCONT', fn);
+      return () => { process.off('SIGCONT', fn); };
+    }))(() => { sigcontAt = now(); });
+  } catch { /* fail-soft — 단서일 뿐 */ }
   let stopped = false;
+  const beat = (): void => {
+    if (stopped) return;
+    const at = now();
+    const prevSeenAt = lastSeenAt;
+    const gapMs = at - lastBeatAt;
+    lastBeatAt = at;
+    let state: TuiRowMissingEvent['state'] | null = null;
+    let error: string | undefined;
+    try {
+      const row = lookupRow(surfaceId);
+      if (!row) state = 'absent';
+      else if (!row.alive) state = 'closed';
+    } catch (e) {
+      state = 'lookup-failed';
+      error = e instanceof Error ? e.message : String(e);
+    }
+    if (state === null) {
+      lastSeenAt = at;
+      try { heartbeat(surfaceId, at); } catch { /* fail-soft */ }
+      return;
+    }
+    let reRegistered = false;
+    let frameRestored = false;
+    let buildRestored = false;
+    if (state === 'lookup-failed') {
+      // ⛔ 실패를 «없다»로 읽지 않는다 — 재등록 없이 평소 박동만.
+      try { heartbeat(surfaceId, at); } catch { /* fail-soft */ }
+    } else {
+      try {
+        registerRow(surfaceId, at, rowNickname);
+        // 기본 행 등록은 fail-soft(조용히 삼킨다) — «다시 세웠다» 는 다시 읽어서만 말한다.
+        reRegistered = lookupRow(surfaceId)?.alive === true;
+        if (!reRegistered) throw new Error('row-still-missing-after-register');
+        lastSeenAt = at;
+        // 재등록은 실행 판·턴 칸을 비운다 — 판은 기동 때 값으로 다시 적는다. 턴은 비운 채(unknown) 둔다:
+        // 녹음기를 다시 열면 «idle» 을 적는데, 턴 도중이면 거짓 idle 이 깨움을 끼어들게 한다. 다음 턴 변화가 채운다.
+        const restoreErrors: string[] = [];
+        try { restoreBuild(surfaceId); } catch (e) { restoreErrors.push(`build: ${e instanceof Error ? e.message : String(e)}`); }
+        if (lastEmittedText !== null) {
+          try { writeFrame(surfaceId, lastEmittedText, at); } catch (e) { restoreErrors.push(`frame: ${e instanceof Error ? e.message : String(e)}`); }
+        }
+        // 기본 쓰기도 fail-soft — «복원했다» 는 다시 읽어서만 말한다.
+        try {
+          const after = lookupRow(surfaceId);
+          frameRestored = lastEmittedText !== null && (after?.frameAt ?? 0) >= at;
+          buildRestored = after?.build != null;
+        } catch (e) { restoreErrors.push(`verify: ${e instanceof Error ? e.message : String(e)}`); }
+        if (restoreErrors.length) error = restoreErrors.join('; ');
+      } catch (e) {
+        error = e instanceof Error ? e.message : String(e);
+      }
+    }
+    try {
+      logRowMissing({
+        surfaceId, pid: process.pid, state, lastSeenAt: prevSeenAt, sinceMs: at - prevSeenAt, gapMs, heartbeatMs,
+        sigcontAt, sigcontSinceLastSeen: sigcontAt !== null && sigcontAt >= prevSeenAt,
+        reRegistered, frameRestored, buildRestored, ...(error ? { error } : {}),
+      });
+    } catch { /* fail-soft diagnostic */ }
+  };
+  const stopHeartbeat = (deps.driveHeartbeat ?? ((tick, ms) => {
+    // setImmediate 로 한 칸 미룬다 — 정지(SIGSTOP·SIGTTIN)에서 풀리면 밀린 타이머가 SIGCONT 처리기보다 «먼저» 돈다
+    // (WSL bun 실측). 미뤄야 같은 박동의 row-missing 이 sigcontAt 을 본다.
+    const t = setInterval(() => { setImmediate(tick); }, ms);
+    (t as { unref?: () => void }).unref?.();
+    return () => clearInterval(t);
+  }))(beat, heartbeatMs);
+
   const stop = (): void => {
     if (stopped) return;
     stopped = true;
     try { stopSource(); } catch { /* fail-soft — unregisters observer / clears tick timer */ }
     try { mirror?.stop(); } catch { /* fail-soft — restores stdout.write */ }
-    clearInterval(hb);
+    try { stopHeartbeat(); } catch { /* fail-soft */ }
+    try { stopSigcont(); } catch { /* fail-soft */ }
     try { stopRunState(); } catch { /* fail-soft */ }
+    wakePollerStopped = true;
+    try { stopWakePoller(); } catch { /* fail-soft */ }
     try { markClosed(surfaceId, now()); } catch { /* fail-soft */ }
     try { activeControlTarget?.deactivate(); } catch { /* fail-soft */ }
     try { stopControlPoller(); } catch { /* fail-soft */ }

package/src/chat/chat-cli.ts

@@ -17,6 +17,10 @@ import type { DevChatOpts } from '../self-dev/dev-pipeline.js';
 export interface ChatCliOpts {
   session?: string;
   new?: boolean;
+  /** `--continue` — 활성 세션 이어하기(명시). 대표 #73: 기본은 새 세션. */
+  continue?: boolean;
+  /** `--resume [id]` — id 면 그 세션, 값 없이(true) 면 활성 세션. */
+  resume?: string | boolean;
   json?: boolean;
   tools?: boolean;
   goalLoop?: boolean;
@@ -29,13 +33,17 @@ export interface ChatCliDeps {
   runDevPipeline?: typeof runDevPipeline;
 }
 
-/** CLI 옵션 → DevChatOpts(--new→forceNew·나머지 boolean 정규화). reuseActive 는 dispatch 클로저에서 !forceNew 파생.
+/** CLI 옵션 → DevChatOpts(--new→forceNew·--continue/--resume→continueActive·나머지 boolean 정규화).
+ *  대표 #73 — reuseActive 는 dispatch 클로저에서 continueActive 로만 켠다(인자 없음 = 새 세션).
  *  session 은 `!== undefined` 로 통과(원 액션 explicitSessionId:opts.session 과 정확 등가 — 빈 문자열도 그대로,
  *  runChatTurnCli 가 falsy 처리해 결과는 동일하나 중간값까지 무손실 유지). */
 export function toDevChatOpts(opts: ChatCliOpts): DevChatOpts {
   return {
-    ...(opts.session !== undefined ? { session: opts.session } : {}),
+    ...(opts.session !== undefined
+      ? { session: opts.session }
+      : typeof opts.resume === 'string' ? { session: opts.resume } : {}),
     forceNew: opts.new === true,
+    continueActive: opts.continue === true || opts.resume === true,
     json: opts.json === true,
     enableTools: opts.tools === true,
     goalLoop: opts.goalLoop === true,

package/src/chat/index.ts

@@ -2,7 +2,7 @@
 // Integrates into the dashboard log pane as an inline chat
 
 import { getGrokApiKey, GROK_MODEL, GROK_API_URL } from '../config.js';
-import { C, ansi, KeyStreamParser, readKey, traceKey, traceKeyListener, termSize, pad, visibleWidth, stripAnsi, truncate, render, hLine, closeTui, resetRenderCache, invalidateRenderCacheFromRow, injectKey } from '../tui.js';
+import { C, ansi, KeyStreamParser, readKey, traceKey, traceKeyListener, termSize, pad, visibleWidth, stripAnsi, truncate, render, hLine, closeTui, resetRenderCache, invalidateRenderCacheFromRow, injectKey, takeInjectedKeys, cancelPendingReadKey } from '../tui.js';
 import { paintCursorMove, paintCursorVisibility, type CursorState } from '../display/cursor-state.js';
 import { firstVisibleInputLineIdx, inputLineWindow } from '../display/prompt-frame.js';
 import { createChatPickerFamilySource, createChatPickerFamilySources } from './pickers/modals.js';
@@ -10,6 +10,7 @@ import type { ChatPickerKind } from './pickers/kinds.js';
 import { createPickerState, type BufferAction, type PickerBufferView } from './pickers/state.js';
 import { createChatPickerModalRuntime } from './pickers/modal-runtime.js';
 import type { ModalSurface } from '../display/modal-stack.js';
+import type { PromptRowOwner } from '../display/prompt-row-owner.js';
 // Type-only import: avoids the runtime circular dep that streamGrok
 // below sidesteps with a dynamic `await import('../llm.js')`. Keeping
 // ChatMessage structurally compatible with LLMMessage lets the
@@ -35,6 +36,7 @@ import {
 } from '../input-core/index.js';
 import { applyInlineEditorKey } from '../input-core/inline-editor-key.js';
 import type { InputSourceRef } from '../input/input-source-kind.js';
+import { routeRawPtyStop } from '../input/external-input-queue.js';
 import {
   multilineEditorBackspace,
   multilineEditorInsertLineBreak,
@@ -70,6 +72,7 @@ export interface ModalSink {
  *  DisplayCoordinator that satisfies both. */
 export interface DisplaySink extends CursorSink, ModalSink {}
 import type { Key } from '../tui.js';
+import { noteInputLagKey, noteInputLagPaint } from '../tui/input-lag-probe.js';
 import {
   createSpinner,
   createToolLoader,
@@ -173,6 +176,8 @@ function writeTerminal(chunk: string): void {
   process.stdout.write(chunk);
   // viaCoordinator=false — this is the bypass path /perf highlights.
   perf.recordStdoutWrite(chunk.length, false);
+  // 입력칸 키 echo 는 render() 가 아니라 이 직접 쓰기로 칠해진다 — 키→칠 관측의 칠 지점.
+  noteInputLagPaint();
 }
 
 /** textInput reports the current prompt's top row so writeTerminal
@@ -248,6 +253,8 @@ export interface TextInputRenderActions {
   repaintUserMutation: () => void;
 }
 
+/** Prefix painted in place of the prompt on input continuation rows. */
+const TEXT_INPUT_CONTINUATION_PREFIX = '  \u00B7 ';
 const TEXT_INPUT_CURSOR_PROTOCOL_ENABLE = '\x1b[>1u\x1b[>4;2m';
 const TEXT_INPUT_CURSOR_PROTOCOL_DISABLE = '\x1b[<u\x1b[>4;0m';
 const SYNCHRONIZED_OUTPUT_BEGIN = '\x1b[?2026h';
@@ -322,11 +329,16 @@ export function createTextInputRenderActions(opts: {
    *  coordinator-owned cursor sinks re-show it at the final position. */
   hideCursorBeforePaint?: boolean;
   beforePaint?: () => void;
+  /** The frame renderer owns the prompt band (TUI-PROMPT-SINGLE-OWNER):
+   *  `paint` only publishes, so there are no direct writes to wrap in
+   *  synchronized output. */
+  frameOwned?: boolean;
   modalSink?: ModalSink;
   shouldRequestModalRender?: () => boolean;
 }): TextInputRenderActions {
-  const paintAll = (synchronizedOutput = false) => {
+  const paintAll = (requestSynchronizedOutput = false) => {
     if (opts.shouldPaint?.() === false) return false;
+    const synchronizedOutput = requestSynchronizedOutput && !opts.frameOwned;
     if (synchronizedOutput) writeTerminal(SYNCHRONIZED_OUTPUT_BEGIN);
     try {
       if (opts.beforePaint) {
@@ -678,6 +690,20 @@ export interface InputResult {
    *  similar. textInput itself doesn't act on the chord beyond
    *  returning — the host decides. */
   saved?: boolean;
+  /** H2 내부 턴 문 — 입력칸이 «비켜 줬다»(버퍼가 비어 있었다). 텍스트 없음 · 제출 아님. 호스트는
+   *  내부 턴 문(`InternalTurnGate.takePending`)에서 실행할 턴을 꺼낸다. */
+  yieldedToInternalTurn?: true;
+}
+
+/** H2 내부 턴 문이 마운트된 textInput 에 «비켜 달라»를 청하는 자리.
+ *  ⛔ 입력칸 버퍼·합성 키를 쓰지 않는다 — textInput 은 버퍼가 «비었을 때만» 스스로 물러난다. */
+export interface TextInputInternalTurnYieldPort {
+  /** textInput 이 마운트되면 부른다. 넘긴 함수는 버퍼가 비었으면 true(물러남 예약), 아니면 false. */
+  attach(requestYield: () => boolean): void;
+  /** textInput 이 내려가면 부른다. `yielded` 가 아니면 열린 내부 턴은 거둬진다(사람이 먼저 끝냈다). */
+  detach(opts?: { yielded?: boolean }): void;
+  /** 물러남을 예약한 뒤 그 사이 사람이 글자를 넣어 «물러나지 않았다». */
+  declined?(detail: string): void;
 }
 
 export interface TextInputExternalSubmitRequest {
@@ -821,6 +847,10 @@ export async function textInput(opts: {
      *  input is idle. */
     insertAtCursor?: (text: string) => void;
   };
+  /** TUI-PROMPT-SINGLE-OWNER — when supplied, the frame renderer owns
+   *  the prompt band: drawInput publishes its rows/hint/caret here and
+   *  writes nothing to the prompt rows itself (no direct `\x1b[2K`). */
+  promptRowOwner?: PromptRowOwner;
   /** P2.2.c — sink for cursor placement. When supplied, drawInput
    *  routes its caret-position decision through this instead of
    *  emitting `\\x1b[r;cH` directly. The coordinator owns the
@@ -895,6 +925,8 @@ export async function textInput(opts: {
    *  side-effect boundary instead of a flat callback bag. Legacy
    *  fields above remain supported for compatibility/tests. */
   host?: TextInputHost;
+  /** H2 내부 턴 문 — 버퍼가 비었을 때 입력 루프가 물러나 호스트가 내부 턴을 실행하게 한다. */
+  internalTurnYield?: TextInputInternalTurnYieldPort;
 }): Promise<InputResult> {
   const { row: initialRow, col, width, maxLines = 5, prompt = '\u276f ', placeholder = '' } = opts;
   const getWidth = (): number => opts.getWidth?.() ?? width;
@@ -907,7 +939,8 @@ export async function textInput(opts: {
   setInputPromptStartRow(row);
   const commands = opts.commands ?? SLASH_COMMANDS;
   const history = opts.history ?? [];
-  let lines: string[] = [opts.initialText ?? ''];
+  // 턴 중 typeahead 가 Shift+Enter 로 만든 여러 줄 prefill 은 줄 단위로 연다.
+  let lines: string[] = (opts.initialText ?? '').split('\n');
   // Line-count reporting: only fires when the visible count actually
   // changes, so hosts don't re-render on every keystroke.
   const resolvedHost = resolveTextInputHost(opts);
@@ -915,8 +948,8 @@ export async function textInput(opts: {
   const onLinesChangeHandler = resolvedHost.onLinesChange;
   const dispatchGlobalAction = resolvedHost.dispatchGlobalAction;
   let lastReportedLines = -1;
-  let lineIdx = 0;   // current line
-  let colIdx = lines[0]!.length;  // cursor at end of initial text
+  let lineIdx = lines.length - 1;   // current line
+  let colIdx = lines[lineIdx]!.length;  // cursor at end of initial text
   let ctrlCArmedAt: number | null = null;
   let ctrlCHintTimer: ReturnType<typeof setTimeout> | null = null;
   let ctrlCHint: string | null = null;
@@ -1134,7 +1167,12 @@ export async function textInput(opts: {
     setInputPromptStartRow(row);
     const promptStr = C.accent(prompt);
     const promptW = visibleWidth(prompt);
-    const textW = Math.max(0, getWidth() - promptW - 1);
+    // Continuation rows carry a 4-cell `  · ` prefix instead of the prompt,
+    // so each row gets its own text width — sharing the first row's width
+    // let continuation rows overrun the terminal by `contPfxW - promptW` cells.
+    const contPfxW = visibleWidth(TEXT_INPUT_CONTINUATION_PREFIX);
+    const textWFor = (idx: number): number =>
+      Math.max(0, getWidth() - (idx === 0 ? promptW : contPfxW) - 1);
     const numLines = lines.length;
     // Visible window: at most `maxLines` rows on screen, but the buffer
     // (`lines`) may exceed that. `firstVisibleIdx` keeps the cursor's
@@ -1170,6 +1208,8 @@ export async function textInput(opts: {
     // from there as lines accumulate. `startOffset` is how many rows
     // up from `row` we start touching — zero when both current and
     // previous drew only one line.
+    const promptRowOwner = opts.promptRowOwner;
+    const ownedRows: string[] = [];
     for (let i = 0; i < rowsToTouch; i++) {
       const r = row - i; // i=0 → bottom row; i=1 → one row up; etc.
       if (r < 1) continue;
@@ -1177,18 +1217,20 @@ export async function textInput(opts: {
       if (i < visibleLines) {
         const lineIdxInArray = firstVisibleIdx + (visibleLines - 1 - i);
         const lineContent = lines[lineIdxInArray]!;
-        const pfx = lineIdxInArray === 0 ? promptStr : C.muted('  ' + '\u00B7' + ' ');
+        const pfx = lineIdxInArray === 0 ? promptStr : C.muted(TEXT_INPUT_CONTINUATION_PREFIX);
+        const rowTextW = textWFor(lineIdxInArray);
         const display = lineIdxInArray === 0 && numLines === 1 && !lineContent
-          ? truncate(C.muted(placeholder), Math.max(0, textW))
+          ? truncate(C.muted(placeholder), Math.max(0, rowTextW))
           : inputLineWindow(
             lineContent,
             lineIdxInArray === lineIdx ? colIdx : lineContent.length,
-            textW,
+            rowTextW,
           ).display;
 
-        const padded = display + ' '.repeat(Math.max(0, textW - visibleWidth(display)));
-        writeTerminal(ansi.moveTo(r, col) + '\x1b[2K' + pfx + padded);
-      } else {
+        const padded = display + ' '.repeat(Math.max(0, rowTextW - visibleWidth(display)));
+        if (promptRowOwner) ownedRows.unshift(pfx + padded);
+        else writeTerminal(ansi.moveTo(r, col) + '\x1b[2K' + pfx + padded);
+      } else if (!promptRowOwner) {
         // This row had content on the previous paint but doesn't anymore
         // (user deleted a line / shrank the input). Clear it so stale
         // text doesn't linger on what is now part of the log / divider
@@ -1198,7 +1240,9 @@ export async function textInput(opts: {
     }
     prevDrawnLines = visibleLines;
 
-    if (ctrlCHint) {
+    if (promptRowOwner) {
+      // The frame renders the hint row from the published paint.
+    } else if (ctrlCHint) {
       writeTerminal(ansi.moveTo(row + 2, col) + '\x1b[2K' + C.muted(truncate(ctrlCHint, getWidth())));
       ctrlCHintPainted = true;
     } else if (ctrlCHintPainted) {
@@ -1216,9 +1260,15 @@ export async function textInput(opts: {
       Math.min(lineIdx - firstVisibleIdx, visibleLines - 1),
     );
     const curR = row - (visibleLines - 1 - cursorScreenLine);
-    const pfxW = lineIdx === 0 ? visibleWidth(prompt) : 4;
-    const { cursorCol } = inputLineWindow(lines[lineIdx]!, colIdx, textW);
+    const pfxW = lineIdx === 0 ? visibleWidth(prompt) : contPfxW;
+    const { cursorCol } = inputLineWindow(lines[lineIdx]!, colIdx, textWFor(lineIdx));
     const curX = col + pfxW + cursorCol;
+    promptRowOwner?.publish({
+      rows: ownedRows,
+      hint: ctrlCHint ? C.muted(truncate(ctrlCHint, getWidth())) : null,
+      caret: curR >= 1 ? { row: curR, col: curX, visible: true } : null,
+      source: 'text-input',
+    });
     // P2.2.c — coordinator owns the cursor emit when wired; falls
     // back to direct stdout for non-coordinator callers (tests, non-dashboard
     // entry points) so the change is non-breaking.
@@ -1317,19 +1367,28 @@ export async function textInput(opts: {
     const display = prefix + result;
     const padded = display + ' '.repeat(Math.max(0, textW - visibleWidth(display)));
 
-    for (let i = 0; i < rowsToTouch; i++) {
-      const r = row - i;
-      if (r < 1) continue;
-      if (i === 0) {
-        writeTerminal(ansi.moveTo(searchRow, col) + '\x1b[2K' + promptStr + padded);
-      } else {
-        writeTerminal(ansi.moveTo(r, col) + '\x1b[2K');
+    const curR = searchRow;
+    const curX = col + promptW + visibleWidth(prefix);
+    if (opts.promptRowOwner) {
+      opts.promptRowOwner.publish({
+        rows: [promptStr + padded],
+        hint: null,
+        caret: { row: curR, col: curX, visible: true },
+        source: 'reverse-search',
+      });
+    } else {
+      for (let i = 0; i < rowsToTouch; i++) {
+        const r = row - i;
+        if (r < 1) continue;
+        if (i === 0) {
+          writeTerminal(ansi.moveTo(searchRow, col) + '\x1b[2K' + promptStr + padded);
+        } else {
+          writeTerminal(ansi.moveTo(r, col) + '\x1b[2K');
+        }
       }
     }
     prevDrawnLines = visibleLines;
 
-    const curR = searchRow;
-    const curX = col + promptW + visibleWidth(prefix);
     if (opts.cursorSink && (opts.canClaimCursor?.() ?? true)) {
       opts.cursorSink.setCursor({ row: curR, col: curX, visible: true });
     } else if (!opts.cursorSink) {
@@ -1364,11 +1423,16 @@ export async function textInput(opts: {
     syncActivePickerModal();
     drawInput();
   };
+  // A frame-owned prompt band has no direct paint to hide the cursor
+  // for, wrap in synchronized output, or re-assert divider chrome around:
+  // the frame render does all three in its own single write.
+  const frameOwnsPromptBand = opts.promptRowOwner !== undefined;
   const renderActions = createTextInputRenderActions({
     shouldPaint: opts.shouldPaint,
-    paintChrome: opts.onPaintChrome,
+    paintChrome: frameOwnsPromptBand ? undefined : opts.onPaintChrome,
     paint: repaintPure,
-    beforePaint: () => {
+    frameOwned: frameOwnsPromptBand,
+    beforePaint: frameOwnsPromptBand ? () => {} : () => {
       const chunk = hideTextInputCursor(opts.cursorSink);
       if (chunk) writeTerminal(chunk);
       else if (opts.cursorSink) writeTerminal(paintCursorVisibility(false));
@@ -1382,6 +1446,8 @@ export async function textInput(opts: {
   const finalizeInput = (result: InputResult): InputResult => {
     // 외부 주입 라우터가 «composer 가 안 떠 있다»를 알 수 있게 내린다.
     if (hostControl) hostControl.getBufferText = undefined;
+    opts.promptRowOwner?.clear();
+    detachInternalTurnYield(result.yieldedToInternalTurn === true);
     clearPicker();
     writeTerminal(endTextInputCursor(opts.cursorSink));
     return result;
@@ -1454,9 +1520,34 @@ export async function textInput(opts: {
     };
   }
 
+  // ⭐ H2 내부 턴 문 — 버퍼가 비었을 때만 물러남을 예약하고 걸린 readKey 를 «빈 키»로 깨운다.
+  //   ⛔ 버퍼·커서·키 큐는 건드리지 않는다(대표 비침투). 마운트가 끝나면(어느 반환 길이든) 무효다.
+  let internalYieldRequested = false;
+  let internalYieldMounted = true;
+  function detachInternalTurnYield(yielded = false): void {
+    if (!internalYieldMounted) return;
+    internalYieldMounted = false;
+    internalYieldRequested = false;
+    opts.internalTurnYield?.detach({ yielded });
+  }
+  opts.internalTurnYield?.attach(() => {
+    if (!internalYieldMounted || lines.join('\n').length > 0) return false;
+    internalYieldRequested = true;
+    cancelPendingReadKey();
+    return true;
+  });
+
   drawAll();
 
   while (true) {
+    if (internalYieldRequested) {
+      internalYieldRequested = false;
+      if (lines.join('\n').length === 0) {
+        return finalizeInput({ text: '', submitted: false, yieldedToInternalTurn: true });
+      }
+      // 판정과 물러남 사이에 사람이 글자를 넣었다 — 사람이 먼저다.
+      opts.internalTurnYield?.declined?.('buffer');
+    }
     // IDX-F2.5 — picker.onKey may have set pendingSubmit on the
     // previous iteration (the closure can't return from textInput
     // itself). Consume the signal at the top of the loop, tear
@@ -1471,6 +1562,7 @@ export async function textInput(opts: {
     }
 
     const key = await (opts.readKey ?? (() => readKey('input')))();
+    if (internalYieldRequested && !key.name) continue; // H2 — 내부 턴 문이 깨운 빈 키
     traceAfterSubmitKey(key);
 
     // Raw-key trace — diagnoses "modifier bit dropped before global-action
@@ -1671,6 +1763,8 @@ export async function textInput(opts: {
         // input loop exits cleanly and the dashboard's pane dispatcher
         // picks up the keys.
         if (hostControl) hostControl.getBufferText = undefined;
+        opts.promptRowOwner?.clear();
+        detachInternalTurnYield();
         return { text: '', submitted: false, gotoPane: true };
       }
       drawAll();
@@ -2001,9 +2095,24 @@ export function attachStreamingKeys(
   //    ⭐ 창 길이는 `readKey` 와 같은 25ms — 두 진입점이 같은 규칙을 쓴다.
   let escapeTimer: ReturnType<typeof setTimeout> | undefined;
   const clearEscapeTimer = () => { if (escapeTimer) { clearTimeout(escapeTimer); escapeTimer = undefined; } };
+  // ⭐ TUI-ESC-ABORT-TOOLS (2026-10-15) — 바깥 키(`pty key` · 제어 IPC input-key)는 stdin 이
+  //    아니라 `injectKey` 큐로 들어오고 빈 청크로 깨울 뿐이다. 이 리스너가 큐를 안 보면 턴 중
+  //    Esc 가 escGate 에 닿지 않고 다음 readKey(턴 끝)까지 잠든다. 주입이 먼저 왔으므로 먼저 배달한다.
+  const deliverInjected = () => {
+    const injected = takeInjectedKeys();
+    if (injected.length === 0) return;
+    for (const key of injected) debug.log('tui.input', 'injected-key-stream-delivered', { key: key.name });
+    deliver(injected);
+  };
   const listener = (data: string | Buffer) => {
     clearEscapeTimer();
+    deliverInjected();
+    // ⏹ TUI-STOP-RAW-PTY — 원시 pty 길로 한 청크에 온 `/stop⏎`·`/esc⏎` 는 typeahead 대기열 대신 지금 턴의 escGate 로.
+    //    파서가 이스케이프·붙여넣기·UTF-8 조각을 쥐고 있으면 그 청크는 앞 입력의 이어짐이라 건드리지 않는다.
+    if (!parser.hasPendingEscape() && !parser.hasPendingPaste() && !parser.hasPendingDecoderBytes()
+      && routeRawPtyStop(typeof data === 'string' ? data : data.toString('utf8'))) return;
     const keys = parser.push(data);
+    if (keys.length > 0) noteInputLagKey(keys.length);
     deliver(keys);
     // ⚠️ `unref()` — 이 타이머가 프로세스를 붙잡아 두면 안 된다(입력 대기는 stdin 의 몫).
     if (parser.hasPendingEscape()) {
@@ -2033,6 +2142,9 @@ export function attachStreamingKeys(
   // leaves streaming typeahead and lone Escape with no events at all.
   process.stdin.resume();
   traceKeyListener('attach', 'stream');
+  // 턴 시작 «전»에 주입돼 큐에 남은 키도 배달한다 — 마이크로태스크로 미뤄 호출자가 cleanup 을
+  // 손에 쥔 뒤에 handler 가 불리게 한다.
+  queueMicrotask(() => { if (!cleanedUp) deliverInjected(); });
   return () => {
     if (cleanedUp) return;
     cleanedUp = true;

package/src/chat/input-control-key.ts

@@ -16,22 +16,24 @@ export interface TextInputControlState {
 }
 
 export function resolveTextInputControlAction(
-  key: Pick<Key, 'name' | 'ctrl' | 'shift'>,
+  key: Pick<Key, 'name' | 'ctrl' | 'shift'> & { alt?: boolean },
   state: TextInputControlState,
 ): TextInputControlAction {
   const stripTrailingBackslash =
     key.name === 'enter'
     && state.cursor > 0
     && state.currentLine[state.cursor - 1] === '\\';
+  // ⭐ Alt+Enter 도 줄바꿈이다 — kitty 프로토콜을 켠 멀티플렉서(herdr)는 바깥의 `ESC CR` 을
+  //    `CSI 13;3u`(alt) 로 바꿔 넘긴다. 종전엔 그 꼴이 «제출»로 떨어져 대체 키가 죽어 있었다.
   const isNewline =
-    (key.name === 'enter' && key.shift)
+    (key.name === 'enter' && (key.shift || key.alt === true))
     || (key.name === 'j' && key.ctrl)
     || stripTrailingBackslash;
 
   if (isNewline) {
     return { kind: 'newline', stripTrailingBackslash };
   }
-  if (key.name === 'enter' && !key.shift) {
+  if (key.name === 'enter' && !key.shift && !key.alt) {
     return { kind: 'submit' };
   }
   if (key.name === 'escape') {

package/src/chat/pickers/modal-runtime.ts

@@ -146,6 +146,12 @@ export function createChatPickerModalRuntime(deps: ChatPickerModalRuntimeDeps):
     getInputZoneHeight: deps.getInputZoneHeight,
     width: deps.getBounds().width,
     getWidth: () => deps.getBounds().width,
+    // TUI-PICKER-RESIZE-SHRINK — follow the live prompt row, not the
+    // row captured when the family was created (stale after resize).
+    getAnchor: () => {
+      const b = deps.getBounds();
+      return { row: b.row, col: b.col };
+    },
     onKey: makePickerOnKey(kind),
     onRowClick: makePickerOnRowClick(kind),
   });