elanous 0.2.35 → 0.2.37

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

@@ -44,9 +44,30 @@ import {
 } from '../pty-shell/pty-manifest.js';
 import { writeHarnessScreen } from '../harness/harness-screen.js';
 import { runningBuild, startTuiRunStateRecorder } from '../pty-shell/tui-run-state.js';
+import type { TuiSelfRestartDeps } from '../pty-shell/tui-run-state.js';
+import { lastHumanKeyAt } from '../tui.js';
 import { debug } from '../debug/log.js';
+import { setTuiLogName, setTuiLogSession } from '../debug/tui-log-tag.js';
+import { getActiveSessionId } from '../session/index.js';
 import { routeExternalInput, type ExternalInputRoute } from '../input/external-input-queue.js';
 
+/**
+ * 사람 손이 «아직 떠난 것으로 안 본» 조용창 — 마지막 사람 키가 이 창 안이면 입력 중으로 친다.
+ * 유휴 임계(H9 기본 90초)보다 길게 잡아 «방금 만지던 사람» 을 절대 끊지 않는다.
+ */
+const SELF_RESTART_HUMAN_QUIET_MS = 10 * 60_000;
+
+/** 실제 TUI 가 쓰는 H9 신호: 낡음=기동 판⊕설치본⊕HEAD · 사람 입력=마지막 사람 키 · 세션=지금 대화. */
+export function productionTuiSelfRestart(readSessionId: () => string | null): TuiSelfRestartDeps {
+  return {
+    humanInputPending: () => {
+      const last = lastHumanKeyAt();
+      return last > 0 && Date.now() - last < SELF_RESTART_HUMAN_QUIET_MS;
+    },
+    readSessionId,
+  };
+}
+
 export interface TuiFrameObserverCfg {
   surfaceId: string;
   instance: string;
@@ -151,6 +172,97 @@ export function createTuiControlTarget(surfaceId: string, deps: TuiControlTarget
   };
 }
 
+// ── 재기동 세션 소유(TUI-H9-ACTIVE-SESSION-ID · 0.2.36) ──
+//
+// 재기동은 «지금 이 TUI 가 보여 주던 대화» 로만 이어 간다. 기동 때의 `--resume` 값이나 전역 최신
+// 세션은 이 TUI 의 것이 아닐 수 있으므로, 이 TUI 가 화면을 그리며 «직접 본» 활성 id 만 여기 적는다.
+// 확인이 안 되면 재기동을 막는 쪽이 기본값이다(⛔ 비슷한 id 로 메우지 않는다).
+
+export interface TuiOwnedSession {
+  readonly sessionId: string;
+  /** 이 TUI 가 그 대화를 «화면으로 확인한» 시각(`at`). */
+  readonly at: number;
+}
+
+let ownedSession: TuiOwnedSession | null = null;
+
+function normalizeSessionId(value: string | null | undefined): string | null {
+  const id = typeof value === 'string' ? value.trim() : '';
+  return id || null;
+}
+
+/** 이 TUI 가 지금 보여 주는 대화 id 를 적는다. 빈 값이면 «소유 없음» 으로 되돌린다(추측 금지). */
+export function claimTuiOwnedSession(
+  sessionId: string | null | undefined,
+  at: number = Date.now(),
+): TuiOwnedSession | null {
+  const id = normalizeSessionId(sessionId);
+  ownedSession = id ? { sessionId: id, at } : null;
+  setTuiLogSession(id);
+  return ownedSession;
+}
+
+/** 이 TUI 가 화면으로 확인한 대화 — 모르면 null(전역 최신·기동 resume 으로 메우지 않는다). */
+export function getTuiOwnedSession(): TuiOwnedSession | null {
+  return ownedSession;
+}
+
+// 재기동 «요청» — 사용자가 q 로 끄는 것은 재기동이 아니다(기본 동작 보존). 재기동은 누군가(H9 유휴
+// 재기동 방아쇠 등)가 «다시 뜨려고» TUI 를 닫을 때만 일어난다 — 그 쪽이 닫기 전에 이것을 부른다.
+let restartRequest: { readonly reason: string; readonly at: number } | null = null;
+
+/** TUI 를 «다시 뜨려고» 닫는다고 적는다 — 종료 경계(`exitTuiRun`)가 한 번 읽고 지운다. */
+export function requestTuiSelfRestart(reason: string, at: number = Date.now()): void {
+  const why = reason.trim();
+  restartRequest = { reason: why || 'unspecified', at };
+}
+
+/** 재기동 요청을 꺼낸다(꺼내면 사라진다) — 없으면 null = 사용자 종료. */
+export function takeTuiSelfRestartRequest(): { readonly reason: string; readonly at: number } | null {
+  const request = restartRequest;
+  restartRequest = null;
+  return request;
+}
+
+/** 재기동을 막는 이유 — 전부 «확인 실패» 다(전역 최신·기동 resume 으로 폴백하지 않는다). */
+export type TuiRestartBlockReason =
+  /** 지금 이 TUI 가 보여 주는 활성 대화가 없다(집중 표식 비었음·읽기 실패). */
+  | 'no-active-session'
+  /** 이 TUI 가 화면으로 확인한 대화 기록이 없다(발행된 프레임 0). */
+  | 'no-owned-session'
+  /** 마지막 관측 뒤 활성 대화가 움직였다 — 어느 쪽이 맞는지 확인할 수 없다. */
+  | 'owned-session-mismatch'
+  /** 확인한 id 의 대화가 저장소에 없다. */
+  | 'active-session-missing';
+
+export type TuiRestartSessionDecision =
+  | { readonly ok: true; readonly sessionId: string; readonly claimedAt: number }
+  | { readonly ok: false; readonly reason: TuiRestartBlockReason };
+
+/**
+ * 재기동에 실을 세션 id 를 정한다. `owned`(이 TUI 가 본 것)와 `liveActiveSessionId`(지금 집중된 것)가
+ * «같고 그 대화가 실재할 때만» 통과한다 — 하나라도 어긋나면 막는다.
+ */
+export function decideTuiRestartSession(input: {
+  readonly owned: TuiOwnedSession | null;
+  readonly liveActiveSessionId: string | null | undefined;
+  readonly sessionExists: (sessionId: string) => boolean;
+}): TuiRestartSessionDecision {
+  const live = normalizeSessionId(input.liveActiveSessionId);
+  if (!live) return { ok: false, reason: 'no-active-session' };
+  const owned = input.owned;
+  if (!owned) return { ok: false, reason: 'no-owned-session' };
+  if (owned.sessionId !== live) return { ok: false, reason: 'owned-session-mismatch' };
+  let exists = false;
+  try {
+    exists = input.sessionExists(live);
+  } catch {
+    exists = false;
+  }
+  if (!exists) return { ok: false, reason: 'active-session-missing' };
+  return { ok: true, sessionId: live, claimedAt: owned.at };
+}
+
 export interface TuiSelfReportDeps {
   surfaceId?: string;
   /** `elanous --name <name>` — 자기 manifest 행 별명. `pty list`·`pty snapshot <name>` 이 이것으로 부른다. */
@@ -186,12 +298,18 @@ export interface TuiSelfReportDeps {
   reportControlCleanupFailure?: (stage: TuiControlCleanupStage, error: unknown) => void;
   /** 행 등록 직후 실행 판 ⊕ 턴(idle) 기록을 연다 — `elanous pty state` 가 읽는다. 반환 = 정리. */
   startRunState?: (surfaceId: string) => (() => void);
+  /** 자기 재기동 신호(TUI-H9)를 갈아 끼운다 — 기본 = 실 신호(`lastHumanKeyAt` ⊕ `getActiveSessionId`).
+   *  시험은 가짜 시계·가짜 restart 로 판정선을 증명한다. */
+  selfRestart?: TuiSelfRestartDeps | null;
   /** 미룬 우편 깨움 폴러(TUI-H4)를 연다 — 반환 = 정리. 기본은 실 행 등록과 짝일 때만 늦게 불러온 `startPendingWakePoller`. */
   startWakePoller?: (surfaceId: string) => (() => void);
   /** 박동마다 자기 행을 본다 — 없으면 null · ⛔ 조회 실패는 «던진다»(없다로 읽지 않는다). 기본 = `getPtyManifest(id, { strict })`. */
   lookupRow?: (surfaceId: string) => TuiOwnRowView | null;
   /** 재등록 뒤 실행 판(build) 칸을 다시 적는다 — 기본 = 기동 때 판(`runningBuild`). */
   restoreBuild?: (surfaceId: string) => void;
+  /** 이 TUI 가 지금 보여 주는 대화 id 를 읽는다 — 프레임을 발행할 때마다 소유 기록을 갱신한다
+   *  (TUI-H9). 기본 = `getActiveSessionId()`. ⛔ 읽기 실패는 «모른다»(소유 없음)로 접는다. */
+  readActiveSessionId?: () => string | null;
   /** 박동 스케줄러 — 기본 setInterval(unref). 시험이 박동을 손으로 돌린다. */
   driveHeartbeat?: (tick: () => void, ms: number) => (() => void);
   /** SIGCONT 수신 훅(행 상실 단서) — 반환 = 해제. 기본 = process.on('SIGCONT'). */
@@ -290,6 +408,7 @@ export function startTuiSelfReport(deps: TuiSelfReportDeps = {}): () => void {
     controlInitStage = 'publish-manifest';
     initDisposers.push({ stage: 'rollback-manifest', dispose: () => rollbackRow(surfaceId) });
     const nickname = deps.nickname?.trim() || undefined;
+    setTuiLogName(nickname);
     registerRow(surfaceId, now(), nickname);
     if (nickname) debug.log('pty.rename', 'tui-launch-name', { ptyId: surfaceId, nickname });
   } catch (error) {
@@ -302,9 +421,18 @@ export function startTuiSelfReport(deps: TuiSelfReportDeps = {}): () => void {
     return () => {};
   }
   const activeControlTarget = controlTarget;
+  const readActiveSessionId: () => string | null = deps.readActiveSessionId
+    ?? (() => { try { return getActiveSessionId(); } catch { return null; } });
   let stopRunState: () => void = () => {};
   // 행 등록을 갈아 끼운 호출자(시험)는 실 manifest 를 안 건드린다 — 기본 녹음기는 기본 행 등록과 짝일 때만.
-  const startRunState = deps.startRunState ?? (deps.registerRow ? () => () => {} : startTuiRunStateRecorder);
+  // TUI-H9: 그 기본 녹음기에 «사람 입력 없음»(마지막 사람 키 입력) ⊕ «지금 대화» 를 실 신호로 주입한다 —
+  //   judged-stale ∧ idle ∧ 사람 없음 이면 스스로 재기동(새 세션 ⊕ 자리 맥락)한다(자세한 판정선은 startTuiRunStateRecorder).
+  const startRunState = deps.startRunState
+    ?? (deps.registerRow
+      ? () => () => {}
+      : (id: string) => startTuiRunStateRecorder(id, {
+        selfRestart: deps.selfRestart === null ? undefined : (deps.selfRestart ?? productionTuiSelfRestart(readActiveSessionId)),
+      }));
   try { stopRunState = startRunState(surfaceId); } catch { /* fail-soft — recorder logs its own write failures */ }
   // 미룬 우편 깨움(TUI-H4) — 이 TUI 가 턴 중·5분 창이라 못 받은 깨움을 idle 로 «기록»된 뒤 한 번 다시 두드린다.
   // 실 행 등록과 짝일 때만(시험이 행 등록을 갈아 끼우면 0) · 무거운 모듈은 늦게 불러온다.
@@ -338,6 +466,9 @@ export function startTuiSelfReport(deps: TuiSelfReportDeps = {}): () => void {
   const emitText = (text: string, cols: number, rows: number): void => {
     const at = now();
     lastEmittedText = text;
+    // TUI-H9 — 이 프레임이 «지금 이 TUI 가 보여 주는 대화» 의 소유 기록이다. 재기동은 이 id 로만 잇는다
+    // (읽기 실패 → 소유 없음 → 재기동 막힘 · 다른 세션으로 대체하지 않는다).
+    try { claimTuiOwnedSession(readActiveSessionId(), at); } catch { claimTuiOwnedSession(null, at); }
     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

package/src/chat/goal-continue-verdict.ts

@@ -0,0 +1,41 @@
+const TAIL_CHARS = 160;
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+const NON_REPLY_LINE = /^\s*(?:✔ 완료|✘ 실패|응답 완료|응답 중|라우팅:|󰧑|⚙️|도구:|나:|↻ 자동 재개|⏰|⏸|⏹|❯)/u;
+const PLEDGE_ALTS = [
+  '[가-힣]+겠습니다', '[가-힣]+겠다', '[가-힣]*[갈낼될들랄릴볼할줄쓸올만]게요',
+  '(?:해야|진행해야|완료해야|만들어야|실행해야|마쳐야|끝내야) (?:합니다|한다|해요|됩니다)',
+  '(?:멈췄습니다|멈춰 있었습니다|중단했습니다)', "\\bI(?:'ll| will| need to| should)\\b[^?]*",
+  "\\blet me\\b[^?]*", "\\bnext,? I\\b[^?]*",
+].map((p) => `(?:${p})`).join('|');
+const PLEDGE_RE = new RegExp(`(?:${PLEDGE_ALTS})[.!。…\\s]*$`, 'iu');
+const ACK_END = /(?:알겠|좋겠|감사하겠|되겠|모르겠|있겠|없겠|같겠)(?:습니다|다)[.!。…\s]*$/u;
+const ASKS_HUMAN = /(?:\?|？|까요[.!]?\s*$|주세요[.!]?\s*$|주시면|원하시면|알려 주|말씀해|선택해|승인(?:해 주세요|이 필요)|괜찮을까|어떨까|확인 부탁|let me know|please (?:confirm|choose)|tell me (?:if|which|what))/iu;
+
+export type GoalContinueVerdict =
+  | { pledge: true; phrase: string }
+  | { pledge: false; reason: 'no-reply' | 'asks-human' | 'not-pledge' };
+
+export function replyTailFromLines(lines: readonly string[]): string | null {
+  const reply: string[] = [];
+  for (let i = lines.length - 1; i >= 0 && reply.length < 6; i--) {
+    const plain = lines[i]!.replace(ANSI, '').trimEnd();
+    if (!plain.trim()) { if (reply.length) break; continue; }
+    if (NON_REPLY_LINE.test(plain)) { if (reply.length) break; continue; }
+    reply.unshift(plain.trim());
+  }
+  if (!reply.length) return null;
+  const text = reply.join(' ').replace(/\s+/g, ' ').trim();
+  return text.length > TAIL_CHARS ? text.slice(-TAIL_CHARS) : text;
+}
+
+export function classifyReplyTail(tail: string | null): GoalContinueVerdict {
+  if (!tail) return { pledge: false, reason: 'no-reply' };
+  const sentences = tail.split(/(?<=[.!?。？])\s+/u).filter(Boolean);
+  const last = sentences.at(-1) ?? tail;
+  if (ASKS_HUMAN.test(last)) return { pledge: false, reason: 'asks-human' };
+  if (ACK_END.test(last)) return { pledge: false, reason: 'not-pledge' };
+  const m = PLEDGE_RE.exec(last);
+  if (!m) return { pledge: false, reason: 'not-pledge' };
+  return { pledge: true, phrase: m[0].trim() };
+}

package/src/chat/index.ts

@@ -19,6 +19,8 @@ import type { PromptRowOwner } from '../display/prompt-row-owner.js';
 // "history-as-source-of-truth" pattern claude-code-fork uses.
 import type { ContentBlock } from '../llm.js';
 import { debug } from '../debug/log.js';
+import { createPasteFold } from './paste-fold.js';
+import { hasClipboardImage, readClipboardText } from '../clipboard/index.js';
 import { matchTextInputGlobalAction } from './global-actions.js';
 import { CTRL_C_ARM_MS, resolveCtrlCInInput } from './ctrl-c-in-input.js';
 import { isTextInputQuitChord } from './input-quit-chord.js';
@@ -742,6 +744,9 @@ export async function textInput(opts: {
    * abort the input session.
    */
   onPasteImage?: () => Promise<string | null>;
+  /** TUI-PASTE-ECHO — Ctrl+V 클립보드 읽기(시험 주입용 · 기본 = clipboard 모듈). 이미지가 없으면 글을 붙여넣는다. */
+  clipboardHasImage?: () => Promise<boolean>;
+  clipboardText?: () => Promise<string | null>;
   /** Dynamic completer for arg-level suggestions (e.g. plugin names). */
   getArgSuggestions?: GetArgSuggestions;
   /** Dynamic completer for `$` skill invocations. */
@@ -927,7 +932,12 @@ export async function textInput(opts: {
   host?: TextInputHost;
   /** H2 내부 턴 문 — 버퍼가 비었을 때 입력 루프가 물러나 호스트가 내부 턴을 실행하게 한다. */
   internalTurnYield?: TextInputInternalTurnYieldPort;
+  /** TUI-PASTE-WHILE-STREAMING — `initialText` 속 붙여넣기 토큰의 원문(턴 중 typeahead 가 접은 것). */
+  initialPastes?: ReadonlyArray<readonly [token: string, raw: string]>;
 }): Promise<InputResult> {
+  // TUI-PASTE-ECHO — 긴 붙여넣기는 입력창에 «[붙여넣음 #k · N줄 · M자]» 로 보이고, 제출 때 원문 전체로 되돌린다.
+  const pasteFold = createPasteFold();
+  if (opts.initialPastes?.length) pasteFold.adopt(opts.initialPastes.filter(([token]) => opts.initialText?.includes(token)));
   const { row: initialRow, col, width, maxLines = 5, prompt = '\u276f ', placeholder = '' } = opts;
   const getWidth = (): number => opts.getWidth?.() ?? width;
   const getRow = (): number => opts.getRow?.() ?? initialRow;
@@ -1451,10 +1461,12 @@ export async function textInput(opts: {
     return result;
   };
   const submitBufferResult = (text: string): InputResult => {
-    debug.log('chat.input.submit', 'summary', summarizeSubmitText(text.trim()));
+    // 입력칸 글만 다듬고(앞뒤 공백) 그다음 원문을 펼친다 — 붙여넣은 원문의 앞뒤 공백·끝 줄바꿈·CRLF 는 그대로 간다(r2 must-fix).
+    const expanded = pasteFold.expand(text.trim());
+    debug.log('chat.input.submit', 'summary', summarizeSubmitText(expanded));
     lastSubmitAt = Date.now();
     return finalizeInput({
-      text: text.trim(),
+      text: expanded,
       submitted: true,
       ...(pendingExternalSubmitSource ? { externalSubmitSource: pendingExternalSubmitSource } : {}),
     });
@@ -1615,7 +1627,8 @@ export async function textInput(opts: {
     // host routing so embedded newlines cannot reach a submit handler.
     if (key.name === 'paste') {
       const pasted = key.paste ?? '';
-      const inserted = opts.onPaste ? await opts.onPaste(pasted) : pasted;
+      const hosted = opts.onPaste ? await opts.onPaste(pasted) : pasted;
+      const inserted = pasteFold.fold(hosted);
       const beforeNumLines = lines.length;
       applyBufferState(insertMultilineTextAtCursor(bufferState(), inserted));
       if (debug.enabled) {
@@ -1817,7 +1830,11 @@ export async function textInput(opts: {
     // to the app (it's their own paste shortcut). Ctrl+V survives in
     // raw mode, so bind there. Also accept `ㅍ` for 한글 IME.
     if (key.ctrl && (key.name === 'v' || key.name === 'V' || key.name === 'ㅍ')) {
-      if (opts.onPasteImage) {
+      // TUI-PASTE-ECHO — 이미지가 있으면 첨부(기존), 없으면 클립보드 «글»을 붙여넣기와 같은 규칙으로 넣는다
+      //   (짧으면 그대로 · 길면 «[붙여넣음 #k · N줄 · M자]»). 예전엔 글이면 «No image» 만 남고 아무것도 안 들어갔다.
+      let hasImage = false;
+      try { hasImage = opts.onPasteImage ? await (opts.clipboardHasImage ?? hasClipboardImage)() : false; } catch { hasImage = false; }
+      if (opts.onPasteImage && hasImage) {
         let token: string | null = null;
         try { token = await opts.onPasteImage(); }
         catch { /* swallow — leave buffer unchanged */ }
@@ -1828,6 +1845,15 @@ export async function textInput(opts: {
         drawAll();
         continue;
       }
+      let clip: string | null = null;
+      try { clip = await (opts.clipboardText ?? readClipboardText)(); } catch { clip = null; }
+      debug.log('tui.paste', 'clipboard-read', { surface: 'classic', chars: clip?.length ?? 0, image: hasImage });
+      if (clip) {
+        applyBufferState(insertMultilineTextAtCursor(bufferState(), pasteFold.fold(clip)));
+        onUserBufferEdit();
+      }
+      drawAll();
+      continue;
     }
 
     if (!key.ctrl && (key.name === 'pageup' || key.name === 'pagedown') && opts.onScrollKey) {

package/src/chat/internal-turn-origin.ts

@@ -0,0 +1 @@
+export type InternalTurnOrigin = 'autowake' | 'msg-wake' | 'scheduled' | 'child-complete' | 'goal-continue' | 'test';

package/src/chat/paste-fold.ts

@@ -0,0 +1,86 @@
+// ── 긴 붙여넣기 자리표시 `paste-fold` (TUI-PASTE-ECHO · 0.2.36 · 2026-10-22 · 대표 P0 «classic·next 둘 다») ──────
+//
+// 🚨 무엇을 푸는가: 여러 줄을 붙여넣으면 입력창이 그 줄 수만큼 펼쳐져 화면을 덮거나(classic) 끝 몇 줄만
+//   «↵» 로 이어 보인다(next) — 무엇이 몇 줄 들어갔는지 한눈에 안 보인다(10-22 설치본 재현).
+// ⭐ 긴 붙여넣기는 입력창에 «[붙여넣음 #k · N줄 · M자]» 토큰 한 덩어리로 넣고 원문은 여기 쥔다.
+//   제출할 때 토큰을 원문으로 되돌린다 — 모델이 받는 글은 붙여넣은 글 전부다. 짧은 글은 그대로 넣는다.
+// ⛔ 토큰을 지우면 그 붙여넣기도 빠진다(사람이 지운 것) · 토큰 글자를 손으로 고치면 원문 대신 그 글이 간다.
+//
+// 세 얼굴:
+//   관측 = debug.log('tui.paste', 'folded', { id, lines, chars }) · 'expanded' { count, chars }
+//   인지 = 줄 수 ≥ PASTE_FOLD_MIN_LINES 또는 글자 ≥ PASTE_FOLD_MIN_CHARS
+//   힐링 = 자리표시로 보이고 제출 때 원문 전체 · 실패 없음(접지 않으면 원문 그대로)
+
+import { debug } from '../debug/log.js';
+
+export const PASTE_FOLD_MIN_LINES = 4;
+export const PASTE_FOLD_MIN_CHARS = 800;
+
+export interface PasteFold {
+  /** 붙여넣은 글 — 길면 자리표시 토큰, 짧으면 그대로. */
+  fold(text: string): string;
+  /** 제출 글 — 남아 있는 토큰을 원문으로 되돌린다. */
+  expand(text: string): string;
+  /** 쥐고 있는 붙여넣기 수. */
+  size(): number;
+  /** 아직 살아 있는 글(입력칸·대기열)에 없는 토큰의 원문을 놓는다 — 지운 붙여넣기 회수. 놓은 수. */
+  retainOnly(liveTexts: readonly string[]): number;
+  /** 다른 입력칸(턴 중 typeahead)이 접은 토큰·원문 짝을 넘겨받는다 — 넘김 뒤에도 토큰으로 보이고 제출 때 펴진다. */
+  adopt(pairs: ReadonlyArray<readonly [token: string, raw: string]>): void;
+}
+
+export function pasteFoldToken(id: number, text: string): string {
+  const lines = text.split('\n').length;
+  return `[붙여넣음 #${id} · ${lines}줄 · ${text.length}자]`;
+}
+
+export function shouldFoldPaste(text: string): boolean {
+  return text.split('\n').length >= PASTE_FOLD_MIN_LINES || text.length >= PASTE_FOLD_MIN_CHARS;
+}
+
+export function createPasteFold(log: (category: string, event: string, data: Record<string, unknown>) => void = (c, e, d) => debug.log(c, e, d)): PasteFold {
+  const held = new Map<string, string>();
+  let seq = 0;
+  return {
+    fold(text) {
+      // 표시(줄 수·글자 수)만 정규화한다 — 끝 줄바꿈 하나는 터미널이 붙이는 것 · CRLF 는 한 줄바꿈.
+      //   쥐는 것·제출하는 것은 붙여넣은 원문 그대로다(r1 must-fix).
+      const shown = text.replace(/\r\n?/g, '\n').replace(/\n$/, '');
+      if (!shouldFoldPaste(shown)) return text;
+      const token = pasteFoldToken(++seq, shown);
+      held.set(token, text);
+      log('tui.paste', 'folded', { id: seq, lines: shown.split('\n').length, chars: shown.length });
+      return token;
+    },
+    expand(text) {
+      if (held.size === 0) return text;
+      // 한 번에 훑는다 — 펼친 원문 안에 다른 토큰 글이 있어도 다시 치환하지 않는다(지운 붙여넣기가 되살아나지 않게 · r3 must-fix).
+      const tokens = [...held.keys()].filter((t) => text.includes(t));
+      if (tokens.length === 0) return text;
+      const re = new RegExp(tokens.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'g');
+      const used = new Set<string>();
+      const out = text.replace(re, (m) => { used.add(m); return held.get(m) ?? m; });
+      for (const t of used) held.delete(t);
+      log('tui.paste', 'expanded', { count: used.size, chars: out.length });
+      return out;
+    },
+    retainOnly(liveTexts) {
+      // 입력칸·대기열 어디에도 없는 토큰(사람이 지운 것)의 원문을 놓는다 — 메모리 누적·나중에 같은 글을 쳤을 때 되살아남 방지(r3 must-fix).
+      let dropped = 0;
+      for (const token of [...held.keys()]) {
+        if (!liveTexts.some((t) => t.includes(token))) { held.delete(token); dropped++; }
+      }
+      if (dropped > 0) log('tui.paste', 'dropped', { count: dropped, held: held.size });
+      return dropped;
+    },
+    adopt(pairs) {
+      for (const [token, raw] of pairs) {
+        held.set(token, raw);
+        const id = Number(/^\[붙여넣음 #(\d+) /.exec(token)?.[1] ?? 0);
+        if (id > seq) seq = id;
+      }
+      if (pairs.length > 0) log('tui.paste', 'adopted', { count: pairs.length, held: held.size });
+    },
+    size: () => held.size,
+  };
+}

package/src/chat/tool-render/block.ts

@@ -5,6 +5,7 @@ import type { ToolRenderModel } from './types.js';
 
 const PERSISTED_REF_PREFIX = '... Full output saved to ';
 const LISTING_TOOL_MAX_LINES = 8;
+const WARNING_LINE_PREFIX = '⚠';
 
 interface ToolBlockLineBudget {
   maxLines: number;
@@ -67,11 +68,42 @@ export function toolBlockGrouping(model: ToolRenderModel, foldMode: FoldMode = '
   return { operationKind: model.operationKind };
 }
 
+/**
+ * ⚠ lines (RunShell long-sleep 등) are pinned: folding them away hides a warning
+ * from the human eye, so they always render above the fold marker.
+ */
+function splitWarningLines(lines: string[]): { warnings: string[]; foldable: string[] } {
+  const warnings: string[] = [];
+  const foldable: string[] = [];
+  for (const line of lines) {
+    if (line.startsWith(WARNING_LINE_PREFIX)) warnings.push(line);
+    else foldable.push(line);
+  }
+  return { warnings, foldable };
+}
+
 function truncateBlockBody(
   lines: string[],
   maxLines: number,
   foldMode: FoldMode = 'line',
   expandHint?: boolean,
+): string[] {
+  const { warnings, foldable } = splitWarningLines(lines);
+  if (warnings.length === 0) return foldBlockBody(lines, maxLines, foldMode, expandHint);
+  // 본문이 전부 경고면 접을 것이 없다 — 그대로 보여주고 폴드 마커를 내지 않는다.
+  if (foldable.length === 0) return warnings;
+  // 고정된 경고는 접힌 줄 수에 넣지 않는다 — 예산만 경고 줄 수만큼 줄인다.
+  return [
+    ...warnings,
+    ...foldBlockBody(foldable, maxLines - warnings.length, foldMode, expandHint),
+  ];
+}
+
+function foldBlockBody(
+  lines: string[],
+  maxLines: number,
+  foldMode: FoldMode = 'line',
+  expandHint?: boolean,
 ): string[] {
   const hint = (hidden: number): string => foldHint('line', hidden, { expandHint });
   if (

package/src/chat/tool-render/dispatch.ts

@@ -17,6 +17,8 @@ import type {
 } from './types.js';
 import { renderToolBlock } from './block.js';
 import { renderToolInline } from './inline.js';
+// Shared with the next TUI chat log (TUI-NEXT-TOOL-RESULT-RENDER) — one extractor for both surfaces.
+import { toolResultBodyText as extractBodyText, toolResultErrorText as extractErrorText } from './result-text.js';
 
 /** 접힌 결과 요약 첫 조각은 `MsgPost` 하나뿐이라 이름 확장을 `dispatch.ts` 안에 둔다.
  *  `types.ts:ToolRenderName` 은 나머지 도구의 공용 계약 그대로 두고, 이 파일의 내부
@@ -425,19 +427,6 @@ function extractSyntheticGuardSummary(result: unknown): string | null {
   return null;
 }
 
-function extractBodyText(result: unknown): string | null {
-  if (typeof result === 'string') return result;
-  if (result && typeof result === 'object' && typeof (result as Record<string, unknown>).output === 'string') {
-    return (result as Record<string, string>).output;
-  }
-  if (result === null || result === undefined) return null;
-  try {
-    return JSON.stringify(result, null, 2);
-  } catch {
-    return String(result);
-  }
-}
-
 function maybeHighlightCodePreview(
   kind: ToolRenderName,
   args: Record<string, unknown>,
@@ -515,13 +504,6 @@ function highlightPreviewLine(line: string, ext: string): string {
   return line;
 }
 
-function extractErrorText(result: unknown): string | null {
-  if (result && typeof result === 'object' && typeof (result as Record<string, unknown>).error === 'string') {
-    return String((result as Record<string, unknown>).error);
-  }
-  return null;
-}
-
 function asRecord(value: unknown): Record<string, unknown> | null {
   return value && typeof value === 'object' ? value as Record<string, unknown> : null;
 }

package/src/chat/tool-render/result-text.ts

@@ -0,0 +1,98 @@
+// Tool-result text extraction shared by the classic dashboard renderer (dispatch.ts)
+// and the next TUI chat log (src/tui/chat/log-view.ts).
+//
+// TUI-NEXT-TOOL-RESULT-RENDER (0.2.36): the next TUI only has the persisted tool
+// result — `JSON.stringify(result)` cut at 2000 chars (session/chat.ts
+// truncateForPersist) — so it showed the raw envelope on one line with escaped
+// `\n`. `parseToolResultEnvelope` turns that string back into the result value;
+// `toolResultBodyText` / `toolResultErrorText` are classic's own extractors, moved
+// here so both surfaces read the same «human text» out of a result.
+//
+// Pure, no imports: safe to load from either surface.
+
+/** The persisted suffix `truncateForPersist` appends when it cuts a value. */
+const PERSIST_TRUNCATION_SUFFIX = /… \(\+\d+ chars\)$/;
+
+/** Body text of a tool result: a string as-is, the `output` field, else pretty JSON. */
+export function toolResultBodyText(result: unknown): string | null {
+  if (typeof result === 'string') return result;
+  if (result && typeof result === 'object' && typeof (result as Record<string, unknown>).output === 'string') {
+    return (result as Record<string, string>).output;
+  }
+  if (result === null || result === undefined) return null;
+  try {
+    return JSON.stringify(result, null, 2);
+  } catch {
+    return String(result);
+  }
+}
+
+/** `error` field text of a tool result, or null. */
+export function toolResultErrorText(result: unknown): string | null {
+  if (result && typeof result === 'object' && typeof (result as Record<string, unknown>).error === 'string') {
+    return String((result as Record<string, unknown>).error);
+  }
+  return null;
+}
+
+export interface ParsedToolResultEnvelope {
+  /** The result value (an object for JSON envelopes; the raw string otherwise). */
+  value: unknown;
+  /** The persisted string was cut (by `truncateForPersist`) — the body is partial. */
+  truncated: boolean;
+}
+
+/**
+ * Turn a persisted tool result string back into the result value.
+ * - Plain text (not a JSON object) stays the same string.
+ * - A whole JSON object parses normally.
+ * - A cut JSON object (`{"output":"…` ⊕ «… (+N chars)») keeps what can be read: the
+ *   `output` string up to the cut, decoded (real newlines), marked `truncated`.
+ */
+export function parseToolResultEnvelope(raw: string): ParsedToolResultEnvelope {
+  const text = raw.trim();
+  if (!text.startsWith('{')) return { value: raw, truncated: false };
+  try {
+    const value: unknown = JSON.parse(text);
+    return { value, truncated: false };
+  } catch { /* fall through — maybe cut by truncateForPersist */ }
+  if (!PERSIST_TRUNCATION_SUFFIX.test(text)) return { value: raw, truncated: false };
+  const body = text.replace(PERSIST_TRUNCATION_SUFFIX, '');
+  const output = readPartialJsonStringField(body, 'output');
+  if (output === null) return { value: raw, truncated: false };
+  return { value: { output }, truncated: true };
+}
+
+/** Decode the string value of `"<field>":"…` from a possibly cut JSON text (to its end or the cut). */
+function readPartialJsonStringField(json: string, field: string): string | null {
+  const key = `"${field}":"`;
+  const at = json.indexOf(key);
+  if (at < 0) return null;
+  let i = at + key.length;
+  let literal = '';
+  while (i < json.length) {
+    const ch = json[i]!;
+    if (ch === '"') break;
+    if (ch === '\\') {
+      const next = json[i + 1];
+      if (next === undefined) break; // escape cut in half
+      if (next === 'u') {
+        const hex = json.slice(i + 2, i + 6);
+        if (!/^[0-9a-fA-F]{4}$/.test(hex)) break;
+        literal += json.slice(i, i + 6);
+        i += 6;
+        continue;
+      }
+      literal += json.slice(i, i + 2);
+      i += 2;
+      continue;
+    }
+    literal += ch;
+    i += 1;
+  }
+  try {
+    return JSON.parse(`"${literal}"`) as string;
+  } catch {
+    return null;
+  }
+}