elanous 0.2.35 → 0.2.36

package/src/tui/slash/resume.ts

@@ -0,0 +1,75 @@
+// `/resume` · `/session list` · `/session load <id>` for next TUI (TUI-RESUME-PICKER · backlog #16).
+// Before this, next TUI had no handler: the words went to the model as a chat turn, so after an
+// n8n restart «/resume» started an investigation instead of showing the sessions to pick from.
+import { debug } from '../../debug/log.js';
+import { listSessions, resolveSessionId, setActiveSessionId, type SessionMeta } from '../../session/index.js';
+
+export const RESUME_BUSY_STATUS = '응답 중에는 /resume 을 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+/** Rows shown by `/resume` · `/session list`. */
+export const RESUME_LIST_LIMIT = 12;
+
+export type ResumeCommand =
+  | { readonly kind: 'list' }
+  | { readonly kind: 'load'; readonly prefix: string };
+
+/** `/resume` · `/session` · `/session list|ls` → list; `/resume <id>` · `/session load|resume <id>` → load. */
+export function parseResumeCommand(text: string): ResumeCommand | null {
+  const [cmd, sub, arg, ...rest] = text.trim().split(/\s+/);
+  if (rest.length > 0) return null;
+  if (cmd === '/resume') {
+    if (arg !== undefined) return null;
+    return sub === undefined ? { kind: 'list' } : { kind: 'load', prefix: sub };
+  }
+  if (cmd === '/session' || cmd === '/sessions') {
+    if (sub === undefined || ((sub === 'list' || sub === 'ls') && arg === undefined)) return { kind: 'list' };
+    if ((sub === 'load' || sub === 'resume') && arg !== undefined) return { kind: 'load', prefix: arg };
+  }
+  return null;
+}
+
+/** Recent conversations, newest first — the rows `/resume` shows (empty scratch sessions hidden, the active one kept). */
+export function resumeCandidates(activeId: string | null, limit = RESUME_LIST_LIMIT): SessionMeta[] {
+  return listSessions({ limit, hideEmpty: true, ...(activeId ? { keepIds: [activeId] } : {}) });
+}
+
+/** One line per session: marker · 8-char id · updated · turns · title. */
+export function resumeListLines(rows: readonly SessionMeta[], activeId: string | null): string[] {
+  if (rows.length === 0) return ['저장된 대화 없음'];
+  return [
+    `최근 대화 ${rows.length}개 · /resume <id 앞자리> 로 이어 가기`,
+    ...rows.map((m) => {
+      const marker = m.id === activeId ? '▸' : ' ';
+      const when = m.updatedAt.slice(5, 16).replace('T', ' ');
+      const title = (m.title || '(제목 없음)').split('\n')[0]!.slice(0, 48);
+      return `${marker} ${m.id.slice(0, 8)}  ${when}  ${String(m.messageCount).padStart(3)}t  ${title}`;
+    }),
+  ];
+}
+
+export type ResumeTuiSessionResult =
+  | { readonly kind: 'started'; readonly id: string; readonly status: string }
+  | { readonly kind: 'rejected'; readonly status: string };
+
+/** Resolve the prefix and make that session active; rejects while a turn runs or when the prefix misses. */
+export function requestResumeTuiSession(input: { readonly busy: boolean; readonly from: string | null; readonly prefix: string }): ResumeTuiSessionResult {
+  const { busy, from, prefix } = input;
+  if (busy) {
+    debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'busy' });
+    return { kind: 'rejected', status: RESUME_BUSY_STATUS };
+  }
+  let id: string | null;
+  try {
+    id = resolveSessionId(prefix);
+  } catch (error) {
+    debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'ambiguous' });
+    return { kind: 'rejected', status: error instanceof Error ? error.message : String(error) };
+  }
+  if (!id) {
+    debug.log('tui.next', 'session-resume-rejected', { from, prefix, reason: 'not-found' });
+    return { kind: 'rejected', status: `"${prefix}" 로 시작하는 대화 없음 · /resume 으로 목록 보기` };
+  }
+  if (id === from) return { kind: 'rejected', status: `이미 이 대화다 · ${id.slice(0, 8)}` };
+  setActiveSessionId(id);
+  debug.log('tui.next', 'session-resume', { from, to: id });
+  return { kind: 'started', id, status: `대화 이어 가기 · ${id.slice(0, 8)} · 이전 = ${from ? from.slice(0, 8) : '없음'}` };
+}

package/src/tui-client/local-chat-turn.ts

@@ -1,15 +1,19 @@
 /** Keep one REPL child per session so background tasks and their completion queue survive turns. */
 import type { NextTuiCompactDeps, NextTuiCompactOutcome } from '../tui/slash/compact.js';
+import { NEXT_TUI_WAKEUP_IPC_ENV, answerWakeupCall, isWakeupCallMessage, nextTuiWakeupTool } from './next-wakeup.js';
+import { isNextTuiSelfHealthSnapshot, type NextTuiSelfHealthSnapshot } from '../tui/chat/self-health-status.js';
 
 const STATUS_PREFIX = 'ELANOUS_TUI_BG_STATUS\t';
 
 interface TurnResult {
   event?: string | null;
   turnId?: string | null;
+  sessionId?: string;
   text?: string;
   error?: string;
   provider?: string;
   model?: string | null;
+  selfHealth?: NextTuiSelfHealthSnapshot | null;
 }
 interface WaitingTurn {
   turnId: string;
@@ -30,10 +34,25 @@ class LocalChatSession {
   private turnCount = 0;
 
   constructor(private readonly sessionId: string, cli: string) {
+    // TUI-NEXT-QUEUE-AND-WAKE: the child's ScheduleWakeup asks this process over Bun IPC — the scheduler
+    // lives here because the child dies on Esc and /new. No tool registered → no IPC, env unchanged.
+    const wakeupTool = nextTuiWakeupTool();
     this.child = Bun.spawn({
       cmd: [process.execPath, cli, 'repl', '--session', sessionId, '--json', '--stdin-jsonl'],
       stdin: 'pipe', stdout: 'pipe', stderr: 'pipe',
-      env: { ...process.env, ELANOUS_NEXT_TUI_BG_STATUS: '1', ELANOUS_NEXT_TUI_STREAM: '1' },
+      env: {
+        ...process.env, ELANOUS_NEXT_TUI_BG_STATUS: '1', ELANOUS_NEXT_TUI_STREAM: '1',
+        ELANOUS_NEXT_TUI_SELF_HEALTH: '1',
+        ...(wakeupTool ? { [NEXT_TUI_WAKEUP_IPC_ENV]: '1' } : {}),
+      },
+      ...(wakeupTool ? {
+        ipc: (message: unknown, child: { send(message: unknown): unknown }) => {
+          if (!isWakeupCallMessage(message)) return;
+          void answerWakeupCall(wakeupTool, message).then((reply) => {
+            try { child.send(reply); } catch { /* the child exited mid-call; its dispatch times out */ }
+          });
+        },
+      } : {}),
     });
     const input = this.child.stdin;
     const output = this.child.stdout;
@@ -46,7 +65,17 @@ class LocalChatSession {
       if (!line.trim()) return;
       let result: TurnResult;
       try { result = JSON.parse(line) as TurnResult; }
-      catch { this.fail(new Error('invalid REPL JSONL response')); return; }
+      catch { this.fail(new Error(`invalid REPL JSONL response: ${line.slice(0, 160)}`)); return; }
+      if (result.event === 'self-health') {
+        const waiting = this.waiting;
+        if (!waiting || result.turnId !== waiting.turnId || result.sessionId !== this.sessionId
+          || !isNextTuiSelfHealthSnapshot(result.selfHealth) || result.selfHealth.sessionId !== this.sessionId) return;
+        const snapshot = Object.freeze(result.selfHealth);
+        for (const listener of selfHealthListeners.get(this.sessionId) ?? []) {
+          try { listener(snapshot); } catch { /* status observers cannot break the turn */ }
+        }
+        return;
+      }
       const waiting = this.waiting;
       if (!waiting) return;
       if ('turnId' in result && result.turnId !== waiting.turnId) return;
@@ -121,6 +150,9 @@ class LocalChatSession {
     for (const listener of statusListeners.get(this.sessionId) ?? []) {
       try { listener(null); } catch { /* status observers cannot break teardown */ }
     }
+    for (const listener of selfHealthListeners.get(this.sessionId) ?? []) {
+      try { listener(null); } catch { /* status observers cannot break teardown */ }
+    }
   }
 
   async turn(prompt: string, writePrompt?: (payload: string) => Promise<void>, onDelta?: (text: string) => void): Promise<TurnResult> {
@@ -167,6 +199,7 @@ export interface LocalChatTurnCompact {
   readonly onCompact?: (outcome: NextTuiCompactOutcome) => void;
 }
 const statusListeners = new Map<string, Set<(json: string | null) => void>>();
+const selfHealthListeners = new Map<string, Set<(snapshot: NextTuiSelfHealthSnapshot | null) => void>>();
 
 export function onLocalChatBackgroundStatus(sessionId: string, listener: (json: string | null) => void): () => void {
   const listeners = statusListeners.get(sessionId) ?? new Set();
@@ -178,6 +211,16 @@ export function onLocalChatBackgroundStatus(sessionId: string, listener: (json:
   };
 }
 
+export function onLocalChatSelfHealthStatus(sessionId: string, listener: (snapshot: NextTuiSelfHealthSnapshot | null) => void): () => void {
+  const listeners = selfHealthListeners.get(sessionId) ?? new Set();
+  listeners.add(listener);
+  selfHealthListeners.set(sessionId, listeners);
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0) selfHealthListeners.delete(sessionId);
+  };
+}
+
 export async function closeLocalChatSession(sessionId: string): Promise<void> {
   const session = sessions.get(sessionId);
   sessions.delete(sessionId);

package/src/tui-client/next-dashboard-runtime.ts

@@ -0,0 +1,8 @@
+/** Dashboard integrations used by next TUI, loaded only after that surface is opened. */
+export async function loadNextTuiDashboardRuntime() {
+  const [segments, goalContinue] = await Promise.all([
+    import('../dashboard/turn-start-segments.js'),
+    import('../dashboard/input/goal-continue.js'),
+  ]);
+  return { ...segments, ...goalContinue };
+}

package/src/tui-client/next-loop-command.ts

@@ -0,0 +1,70 @@
+import { createLoopScheduler, type LoopScheduler } from '../dashboard/loop-scheduler.js';
+import type { InternalTurnGate } from '../dashboard/input/internal-turn.js';
+
+export interface NextLoopCommand {
+  run(raw: string): string[];
+  dispose(): void;
+}
+
+export interface NextLoopCommandOptions {
+  schedule?: (callback: () => void, intervalMs: number) => { unsubscribe(): void };
+}
+
+function parseInterval(raw: string): { intervalMs: number; label: string } | null {
+  const match = /^(\d+)(s|sec|초|m|min|분|h|시간)?$/i.exec(raw.trim());
+  if (!match) return null;
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) return null;
+  const unit = (match[2] ?? 'm').toLowerCase();
+  const intervalMs = unit === 's' || unit === 'sec' || unit === '초' ? amount * 1_000
+    : unit === 'h' || unit === '시간' ? amount * 3_600_000
+    : amount * 60_000;
+  // Node/Bun timers clamp delays above 2^31-1ms and can then fire almost immediately.
+  if (!Number.isSafeInteger(intervalMs) || intervalMs < 1_000 || intervalMs > 2_147_483_647) return null;
+  const label = unit === 's' || unit === 'sec' || unit === '초' ? `${amount}초`
+    : unit === 'h' || unit === '시간' ? `${amount}시간`
+    : `${amount}분`;
+  return { intervalMs, label };
+}
+
+/** Next TUI's `/loop` surface; H2 decides whether each scheduled turn may open. */
+export function createNextLoopCommand(
+  gate: InternalTurnGate,
+  log: (event: 'fired' | 'rejected', data: Record<string, unknown>) => void,
+  options: NextLoopCommandOptions = {},
+): NextLoopCommand {
+  let scheduler: LoopScheduler | null = null;
+  const stop = (): boolean => {
+    if (!scheduler?.isRunning()) return false;
+    scheduler.stop();
+    scheduler = null;
+    return true;
+  };
+  return {
+    run(raw) {
+      const [interval = '', ...promptParts] = raw.trim().split(/\s+/);
+      const sub = interval.toLowerCase();
+      if (!interval || sub === 'help') {
+        return ['usage: /loop <간격> <프롬프트> · /loop stop', '간격: 30s · 5m · 1h · 맨숫자=분 — TUI가 쉴 때 프롬프트를 발사합니다'];
+      }
+      if (sub === 'stop') return [stop() ? '⏹ /loop 정지 — 더 이상 발사하지 않습니다' : '/loop: 실행 중인 루프가 없습니다'];
+      const parsed = parseInterval(interval);
+      const prompt = promptParts.join(' ').trim();
+      if (!parsed || !prompt) return ['사용법: /loop <간격> <프롬프트> · /loop stop'];
+      stop();
+      scheduler = createLoopScheduler({
+        intervalMs: parsed.intervalMs,
+        isIdle: () => true,
+        ...(options.schedule ? { schedule: options.schedule } : {}),
+        fire: () => {
+          const result = gate.startTurnIfIdle(prompt, { origin: 'scheduled', reason: '/loop' });
+          if (result.opened) log('fired', { turnId: result.turnId });
+          else log('rejected', { reason: result.reason });
+        },
+      });
+      scheduler.start();
+      return [`↻ /loop 시작 — ${parsed.label}마다: ${prompt}`];
+    },
+    dispose: stop,
+  };
+}

package/src/tui-client/next-wakeup.ts

@@ -0,0 +1,191 @@
+// ── next TUI 의 자기 예약 깨움 (TUI-NEXT-QUEUE-AND-WAKE · 0.2.36 · 2026-10-22) ──────────────────────
+//
+// 🚨 무엇을 푸는가: 클래식 대시보드엔 `ScheduleWakeup`(H5) ⊕ 내부 턴 문(H2)이 있는데 next TUI 엔 없었다 —
+//   next 에서 모델이 «다음 점검 HH:MM» 이라고 적고 턴을 끝내면 그 시각에 아무것도 안 열린다.
+// ⭐ 재구현 0: 스케줄러 = 클래식 `createDashboardWakeupScheduler` · 문 = 클래식 `createInternalTurnGate` ·
+//   도구 문면·인자 = 클래식 `buildScheduleWakeupHostTool` 그대로. 바쁘면 미룸(#30291)도 스케줄러 몫 그대로다.
+// 새 것은 «한 홉»뿐이다: next 의 턴은 REPL 자식(`elanous repl --stdin-jsonl`)에서 돌아 도구도 자식에서 불린다.
+//   스케줄러는 TUI(부모)에 산다 — 자식은 Esc·/new 때 죽으므로 거기 타이머를 두면 예약이 같이 죽는다.
+//   ⇒ 자식의 `ScheduleWakeup` 은 Bun IPC(`process.send`)로 부모에 묻고, 부모가 클래식 도구 handler 로 답한다.
+//   stdin 은 턴 단위 JSONL 이라 도는 턴 «안»에 답을 실을 수 없다 — IPC 는 턴과 따로 흐른다.
+// ⛔ 하니스 자식(`ELANOUS_HARNESS_ROLE`)은 무인 런이라 도구를 안 싣는다(클래식 `registerScheduleWakeupHostTool` 과 같은 경계).
+//
+// 세 얼굴(클래식과 같다):
+//   관측 = debug.log('tui.wakeup', …) · debug.log('tui.autoturn', …) — 스케줄러·문이 이미 남긴다
+//   인지 = 예약 시각 도래 ∧ 문 판정(NotIdle · HumanTyping …)
+//   힐링 = 문이 열리면 next 가 내부 턴 한 번 · 바쁘면 1분마다 미룸(상한 30분) · 끝내 못 열면 «⏰ 예약 깨움 놓침» 한 줄
+
+import { createInternalTurnGate, formatInternalTurnBanner, isInternalTurnEnabledByEnv, type InternalTurnGate, type InternalTurnRequest } from '../dashboard/input/internal-turn.js';
+import type { LLMToolSpec } from '../llm.js';
+import type { LLMToolDef, PluginContext } from '../plugins/core/types.js';
+import {
+  SCHEDULE_WAKEUP_TOOL_NAME,
+  buildScheduleWakeupHostTool,
+  createDashboardWakeupScheduler,
+  createWakeupScheduler,
+  type WakeupScheduler,
+  type WakeupTimerHandle,
+} from '../skills/tools/schedule-wakeup.js';
+
+/** 부모(next TUI)가 REPL 자식에 «IPC 홉이 열렸다»고 알리는 표지. 없으면 자식은 도구를 안 싣는다. */
+export const NEXT_TUI_WAKEUP_IPC_ENV = 'ELANOUS_NEXT_TUI_WAKEUP_IPC';
+const CALL_TYPE = 'elanous.wakeup.call';
+const RESULT_TYPE = 'elanous.wakeup.result';
+const DEFAULT_CALL_TIMEOUT_MS = 15_000;
+
+export interface WakeupCallMessage { type: typeof CALL_TYPE; callId: string; args: Record<string, unknown> }
+export interface WakeupResultMessage { type: typeof RESULT_TYPE; callId: string; result: unknown }
+
+export function isWakeupCallMessage(message: unknown): message is WakeupCallMessage {
+  const m = message as Partial<WakeupCallMessage> | null;
+  return !!m && m.type === CALL_TYPE && typeof m.callId === 'string' && !!m.args && typeof m.args === 'object';
+}
+
+function isWakeupResultMessage(message: unknown): message is WakeupResultMessage {
+  const m = message as Partial<WakeupResultMessage> | null;
+  return !!m && m.type === RESULT_TYPE && typeof m.callId === 'string';
+}
+
+/** 부모 쪽: 자식의 호출 한 건을 클래식 도구 handler 로 풀어 답 메시지를 만든다(던지면 오류 결과). */
+export async function answerWakeupCall(tool: LLMToolDef, message: WakeupCallMessage): Promise<WakeupResultMessage> {
+  let result: unknown;
+  try {
+    // 클래식 handler 는 ctx 를 안 본다 — 대시보드도 같은 handler 를 플러그인 문맥 없이 부른다.
+    result = await tool.handler(message.args, {} as PluginContext);
+  } catch (error) {
+    result = { error: `ScheduleWakeup failed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  return { type: RESULT_TYPE, callId: message.callId, result };
+}
+
+/** 자식이 쓰는 IPC 구멍 — `process` 의 그 부분만(시험이 같은 함수에 가짜를 넘긴다). */
+export interface WakeupIpcProcess {
+  send?: (message: unknown) => boolean | void;
+  on(event: 'message', listener: (message: unknown) => void): unknown;
+  off(event: 'message', listener: (message: unknown) => void): unknown;
+}
+
+/** 도구 문면만 꺼내는 데 쓰는 스케줄러 — handler 는 자식에서 불리지 않는다(부모가 진짜를 부른다). */
+const SPEC_ONLY_SCHEDULER: WakeupScheduler = createWakeupScheduler({
+  startTurnIfIdle: () => ({ opened: false, reason: 'Disabled' }),
+  log: () => {},
+});
+
+/**
+ * 자식(REPL) 쪽: 부모가 홉을 열었을 때만(`NEXT_TUI_WAKEUP_IPC_ENV=1` ∧ `process.send`) 클래식 `ScheduleWakeup`
+ * 문면 그대로의 도구 하나를 낸다. dispatch 는 부모에 묻고 답을 그대로 돌려준다 — 부모가 안 답하면 오류 결과.
+ */
+export function createReplWakeupTool(
+  proc: WakeupIpcProcess,
+  env: NodeJS.ProcessEnv = process.env,
+  opts: { timeoutMs?: number } = {},
+): { spec: LLMToolSpec; dispatch: (args: Record<string, unknown>) => Promise<unknown> } | null {
+  if (env[NEXT_TUI_WAKEUP_IPC_ENV] !== '1' || typeof proc.send !== 'function') return null;
+  const send = proc.send.bind(proc);
+  const { name, description, parameters } = buildScheduleWakeupHostTool(SPEC_ONLY_SCHEDULER);
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+  const waiting = new Map<string, (result: unknown) => void>();
+  let seq = 0;
+  const listener = (message: unknown): void => {
+    if (!isWakeupResultMessage(message)) return;
+    const resolve = waiting.get(message.callId);
+    if (!resolve) return;
+    waiting.delete(message.callId);
+    resolve(message.result);
+  };
+  proc.on('message', listener);
+  return {
+    spec: { name, description, parameters },
+    dispatch: (args) => new Promise<unknown>((resolve) => {
+      const callId = `c${++seq}`;
+      const timer = setTimeout(() => {
+        if (!waiting.delete(callId)) return;
+        resolve({ error: `${SCHEDULE_WAKEUP_TOOL_NAME}: next TUI did not answer` });
+      }, timeoutMs);
+      waiting.set(callId, (result) => { clearTimeout(timer); resolve(result); });
+      try {
+        send({ type: CALL_TYPE, callId, args } satisfies WakeupCallMessage);
+      } catch (error) {
+        waiting.delete(callId);
+        clearTimeout(timer);
+        resolve({ error: `${SCHEDULE_WAKEUP_TOOL_NAME}: IPC send failed: ${error instanceof Error ? error.message : String(error)}` });
+      }
+    }),
+  };
+}
+
+export interface NextTuiWakeupDeps {
+  /** next 의 `busy`(채팅 턴·압축·provider·harness 명령 중). */
+  isTurnRunning: () => boolean;
+  /** 입력칸 글 — 비어 있지 않으면 문이 HumanTyping 으로 거부한다. */
+  getBufferText: () => string;
+  /** 턴 중 쌓인 대기 제출 수 — 있으면 사람 몫이 먼저다(HumanTyping). */
+  getQueuedCount: () => number;
+  /** 문이 열렸을 때 입력 루프를 깨운다(next 는 감시 키 하나를 넣는다). true = 깨웠다. */
+  requestYield: () => boolean;
+  /** 화면 한 줄(⏰ 예약 깨움 … · 놓침). */
+  notify: (line: string) => void;
+  env?: NodeJS.ProcessEnv;
+  now?: () => number;
+  setTimer?: (fn: () => void, ms: number) => WakeupTimerHandle;
+  clearTimer?: (handle: WakeupTimerHandle) => void;
+  lastHumanKeyAt?: () => number;
+  pendingKeyCount?: () => number;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export interface NextTuiWakeup {
+  readonly gate: InternalTurnGate;
+  readonly scheduler: WakeupScheduler;
+  /** REPL 자식이 부를 도구(부모 handler) — 하니스 자식이면 null. */
+  readonly tool: LLMToolDef | null;
+  banner(request: Pick<InternalTurnRequest, 'origin' | 'reason'>): string;
+  dispose(): void;
+}
+
+/** next TUI 에 클래식 문 ⊕ 클래식 스케줄러를 잇는다. */
+export function createNextTuiWakeup(deps: NextTuiWakeupDeps): NextTuiWakeup {
+  const env = deps.env ?? process.env;
+  const gate = createInternalTurnGate({
+    isTurnRunning: deps.isTurnRunning,
+    getBufferText: deps.getBufferText,
+    getTypeaheadCount: deps.getQueuedCount,
+    isEnabled: () => isInternalTurnEnabledByEnv(env),
+    ...(deps.now ? { now: deps.now } : {}),
+    ...(deps.lastHumanKeyAt ? { lastHumanKeyAt: deps.lastHumanKeyAt } : {}),
+    ...(deps.pendingKeyCount ? { pendingKeyCount: deps.pendingKeyCount } : {}),
+    ...(deps.log ? { log: deps.log } : {}),
+  });
+  gate.port.attach(deps.requestYield);
+  const scheduler = createDashboardWakeupScheduler(gate, {
+    notify: deps.notify,
+    ...(deps.now ? { now: deps.now } : {}),
+    ...(deps.setTimer ? { setTimer: deps.setTimer } : {}),
+    ...(deps.clearTimer ? { clearTimer: deps.clearTimer } : {}),
+    ...(deps.log ? { log: deps.log } : {}),
+  });
+  const tool = env.ELANOUS_HARNESS_ROLE?.trim() ? null : buildScheduleWakeupHostTool(scheduler);
+  return {
+    gate,
+    scheduler,
+    tool,
+    banner: formatInternalTurnBanner,
+    dispose() {
+      scheduler.dispose();
+      gate.port.detach({ yielded: true });
+    },
+  };
+}
+
+// ── 부모 쪽 홉 등록 — local-chat-turn 이 REPL 자식을 띄울 때 읽는다 ─────────────────────────────
+
+let activeWakeupTool: LLMToolDef | null = null;
+
+/** next TUI 가 부팅 때 자기 도구를 건다(끝날 때 null). 이후 띄우는 REPL 자식에만 홉이 열린다. */
+export function setNextTuiWakeupTool(tool: LLMToolDef | null): void {
+  activeWakeupTool = tool;
+}
+
+export function nextTuiWakeupTool(): LLMToolDef | null {
+  return activeWakeupTool;
+}

package/src/tui.ts

@@ -7,6 +7,7 @@ import { StringDecoder } from 'node:string_decoder';
 import { perf } from './perf-counters.js';
 import { noteInputLagKey, noteInputLagPaint } from './tui/input-lag-probe.js';
 import { debug } from './debug/log.js';
+import { startForegroundGuard } from './tty-foreground.js';
 
 // ── ANSI escape sequences ──
 const CSI = '\x1b[';
@@ -441,8 +442,12 @@ function trailingUtf8Carry(data: Buffer): Buffer {
 let _raw = false;
 let _alt = false;
 let _cancelReadKey: (() => void) | undefined;
+/** TUI-SIGTTIN-SUSPEND — stops the tty-foreground guard (src/tty-foreground.ts). */
+let _stopForegroundGuard: (() => void) | undefined;
 
 function cleanup(): void {
+  _stopForegroundGuard?.();
+  _stopForegroundGuard = undefined;
   resetRenderCache();
   _cancelReadKey?.();
   resetInputState();
@@ -473,11 +478,40 @@ function runExitNotice(): void {
   try { fn?.(); } catch { /* 알림 실패가 종료를 막지 않는다 */ }
 }
 
+/**
+ * TUI-SIGCONT-RESTORE-TERM (0.2.36 · 2026-10-22) — 멈췄다(SIGTSTP·SIGTTIN · 상태 T) `fg` 로 돌아오면 셸의 작업 제어가
+ * 터미널을 cooked 로 돌려놓았다. raw 모드·kitty/modifyOtherKeys·마우스·붙여넣기·alt 화면을 다시 세우지 않으면
+ * Enter 가 «^M», Ctrl+C 가 «^[[99;5u» 로 입력창에 박혀 먹통이 된다(10-22 OPT 실물).
+ * 지금 켜 둔 것만 다시 켜고, 렌더 캐시를 비운 뒤 `resize` 를 내 화면 전체를 다시 그리게 한다.
+ */
+export interface TerminalRestoreIo {
+  stdin: { isTTY?: boolean; setRawMode?: (mode: boolean) => unknown; resume?: () => unknown };
+  stdout: { write: (chunk: string) => unknown; emit?: (event: string) => unknown };
+}
+export function restoreTerminalAfterContinue(state: { raw: boolean; alt: boolean }, io: TerminalRestoreIo): boolean {
+  if (!state.raw && !state.alt) return false;
+  if (state.raw && io.stdin.isTTY) {
+    io.stdin.setRawMode?.(true);
+    io.stdin.resume?.();
+  }
+  io.stdout.write(ansi.mouseOn + ansi.pasteOn + ansi.kittyKbOn + ansi.modKeysOn);
+  io.stdout.write(state.alt ? ansi.altOn + ansi.hideCursor : ansi.hideCursor);
+  resetRenderCache();
+  debug.log('tui.lifecycle', 'sigcont-restored', { raw: state.raw, alt: state.alt });
+  // 화면 주인(대시보드·next)은 resize 에서 전체를 다시 그린다.
+  io.stdout.emit?.('resize');
+  return true;
+}
+
 let _exitHandlersRegistered = false;
 function registerExitHandlers(): void {
   if (_exitHandlersRegistered) return;
   _exitHandlersRegistered = true;
   process.on('exit', cleanup);
+  process.on('SIGCONT', () => {
+    try { restoreTerminalAfterContinue({ raw: _raw, alt: _alt }, { stdin: process.stdin, stdout: process.stdout }); }
+    catch { /* fail-soft: 복구 실패가 프로세스를 죽이지 않는다 */ }
+  });
   process.on('SIGINT',  () => { cleanup(); runExitNotice(); process.exit(130); });
   process.on('SIGTERM', () => { cleanup(); runExitNotice(); process.exit(143); });
 }
@@ -490,6 +524,9 @@ export function initTui(altScreen = true): void {
   process.stdin.setEncoding('utf8'); // decode UTF-8 for CJK/IME support
   process.stdin.resume();
   _raw = true;
+  // TUI-SIGTTIN-SUSPEND (10-23 n8n): a child that steals the terminal's foreground group would leave
+  // us to be stopped by SIGTTIN on the next keystroke. The guard takes it back from our own children.
+  _stopForegroundGuard ??= startForegroundGuard();
   // Enable mouse + paste globally. Kitty keyboard protocol + xterm
   // modifyOtherKeys are ALSO enabled dashboard-wide so Ctrl+M / Ctrl+J /
   // Ctrl+I / Ctrl+H can be distinguished from Enter / Tab / Backspace

package/src/ui/modal-adapter.ts

@@ -46,7 +46,7 @@ import type { ClickRegion, ClickRegistry } from './click-registry.js';
 import type { MouseEvent, MouseEventType } from './mouse-events.js';
 import { DragMachine } from './drag-machine.js';
 import type { ContextKeyService, ContextKeys } from '../input-core/context-keys.js';
-import { getDashboardContextKeyService } from '../dashboard/context/keys.js';
+import { getRuntimeContextKeyService } from '../input-core/context-key-runtime.js';
 import { ansiForPair, resolveWidgetTokens, type ThemeTokens } from '../theme/tokens.js';
 import type { BoxDecoration } from './attributes/box-decoration.js';
 import { resolveColorToken } from './chrome/resolve-color.js';
@@ -706,7 +706,7 @@ export function mountViewAsModalSurface(spec: ViewSurfaceSpec): ViewSurfaceHandl
   // least one modal of that tier exists. Proper stack-counting lands
   // in IDX-2c with the ModalTier enum + registry.
   const ctxSvc = spec.tier
-    ? (spec.contextKeyService ?? getDashboardContextKeyService())
+    ? (spec.contextKeyService ?? getRuntimeContextKeyService())
     : null;
   const ctxKey = spec.tier ? MODAL_TIER_CONTEXT_KEY[spec.tier] : null;
   if (ctxSvc && ctxKey) {