elanous 0.2.35 → 0.2.37

package/src/tui/input/at-picker.ts

@@ -0,0 +1,55 @@
+import { readdir } from 'node:fs/promises';
+import { basename, isAbsolute, relative, resolve, sep } from 'node:path';
+
+/** Candidate contract matches the classic chat `onAtCandidates` shape. */
+export interface AtFileCandidate {
+  readonly label: string;
+  readonly absPath: string;
+  readonly isDir: false;
+}
+
+export interface AtQuery {
+  readonly prefix: string;
+  readonly start: number;
+  readonly end: number;
+}
+
+export function parseAtQuery(text: string, cursor: number): AtQuery | null {
+  const head = text.slice(0, cursor);
+  const match = head.match(/(?:^|\s)@([\p{L}\p{N}_./~\\-]*)$/u);
+  if (!match) return null;
+  const prefix = match[1] ?? '';
+  return { prefix, start: head.length - prefix.length - 1, end: cursor };
+}
+
+/** List local files under root only; directories are traversal prefixes, never candidates. */
+export async function listAtFiles(prefix: string, root: string): Promise<AtFileCandidate[]> {
+  const slash = Math.max(prefix.lastIndexOf('/'), prefix.lastIndexOf('\\'));
+  const typedDir = slash < 0 ? '' : prefix.slice(0, slash + 1);
+  const partial = slash < 0 ? prefix : prefix.slice(slash + 1);
+  const dirPart = typedDir.replaceAll('\\', sep).replace(/^~(?=\/)/, '');
+  const base = resolve(root, dirPart || '.');
+  const inside = relative(resolve(root), base);
+  if (inside === '..' || inside.startsWith(`..${sep}`) || isAbsolute(inside)) return [];
+  try {
+    const entries = await readdir(base, { withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile() && entry.name.toLocaleLowerCase().startsWith(partial.toLocaleLowerCase()))
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .slice(0, 15)
+      .map((entry) => ({ label: `${typedDir}${entry.name}`, absPath: resolve(base, entry.name), isDir: false as const }));
+  } catch {
+    return [];
+  }
+}
+
+export function acceptAtFile(text: string, query: AtQuery, candidate: AtFileCandidate, ordinal: number): { text: string; cursor: number; token: string } {
+  const token = `[attached ${ordinal}: ${basename(candidate.absPath)}]`;
+  const insertion = `${token} `;
+  const next = text.slice(0, query.start) + insertion + text.slice(query.end);
+  return { text: next, cursor: query.start + insertion.length, token };
+}
+
+export function attachmentsForMessage(text: string, selected: ReadonlyMap<string, string>): string[] {
+  return [...selected].filter(([token]) => text.includes(token)).map(([, path]) => path);
+}

package/src/tui/input/composer.ts

@@ -1,6 +1,6 @@
 import type { Key } from '../../tui.js';
 import { applyInlineEditorKey } from '../../input-core/inline-editor-key.js';
-import { createInlineEditorState, type InlineEditorState } from '../../input-core/inline-editor.js';
+import { createInlineEditorState, inlineEditorInsert, type InlineEditorState } from '../../input-core/inline-editor.js';
 import { safeLogText } from '../chat/log-view.js';
 
 const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
@@ -139,6 +139,13 @@ export function applyComposerKey(state: InlineEditorState, key: Key): ComposerRe
       ? { state: emptyComposer(), action: 'submit', submitted }
       : { state, action: 'none' };
   }
+  // One bracketed-paste envelope (terminal paste · herdr `pane run`) is one key whose body rides on `paste`.
+  // Without this the shared text rule inserted the key NAME («paste») instead of the pasted text.
+  if (name === 'paste') {
+    return typeof key.paste === 'string' && key.paste.length > 0
+      ? { state: inlineEditorInsert(state, key.paste), action: 'edit' }
+      : { state, action: 'none' };
+  }
   const edited = applyInlineEditorKey(state, key, { shiftEnter: 'newline', tab: null });
   return edited ? { state: edited, action: 'edit' } : { state, action: 'none' };
 }

package/src/tui/slash/compact-command.ts

@@ -0,0 +1,7 @@
+/** Lightweight `/compact` command recognition for next TUI startup. */
+export const COMPACT_BUSY_STATUS = '응답 중에는 /compact 를 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+export const COMPACT_NO_SESSION_STATUS = '압축할 대화가 없습니다';
+
+export function isCompactCommand(text: string): boolean {
+  return text.trim() === '/compact';
+}

package/src/tui/slash/compact.ts

@@ -8,13 +8,7 @@ import { debug } from '../../debug/log.js';
 import { compactSessionHistory } from '../../session/compact-session.js';
 import type { CompactProvider } from '../../compact/provider.js';
 import type { ChatAutoCompactConfig } from '../../user-config.js';
-
-export const COMPACT_BUSY_STATUS = '응답 중에는 /compact 를 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
-export const COMPACT_NO_SESSION_STATUS = '압축할 대화가 없습니다';
-
-export function isCompactCommand(text: string): boolean {
-  return text.trim() === '/compact';
-}
+export { COMPACT_BUSY_STATUS, COMPACT_NO_SESSION_STATUS, isCompactCommand } from './compact-command.js';
 
 /** Test/embedding seams. Production passes none of these. */
 export interface NextTuiCompactDeps {

package/src/tui/slash/resume.ts

@@ -0,0 +1,98 @@
+// `/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';
+import { idPrefixCell, sessionIdPrefixes, sessionListTime } from '../../session/id-prefix.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 numbered line per session: number · marker · unique id prefix · updated · turns · title.
+ * The number is what `/resume <n>` takes (next TUI has no arrow picker — the list is the picker);
+ * the prefix grows past 8 characters when another stored session shares them.
+ */
+export function resumeListLines(rows: readonly SessionMeta[], activeId: string | null): string[] {
+  if (rows.length === 0) return ['저장된 대화 없음'];
+  const prefixes = sessionIdPrefixes(rows.map((m) => m.id));
+  const numberWidth = String(rows.length).length;
+  return [
+    `최근 대화 ${rows.length}개 · /resume <번호> 또는 /resume <id 앞자리> 로 이어 가기`,
+    ...rows.map((m, i) => {
+      const marker = m.id === activeId ? '▸' : ' ';
+      const when = sessionListTime(m.updatedAt);
+      const title = (m.title || '(제목 없음)').split('\n')[0]!.slice(0, 48);
+      return `${String(i + 1).padStart(numberWidth)}. ${marker} ${idPrefixCell(prefixes, m.id)}  ${when}  ${String(m.messageCount).padStart(3)}t  ${title}`;
+    }),
+  ];
+}
+
+/** `/resume 3` → the 3rd row of the list the user saw. Only 1–3 digits within the list count as a number. */
+export function resumeRowByNumber(arg: string, rows: readonly SessionMeta[]): SessionMeta | null {
+  if (!/^\d{1,3}$/.test(arg)) return null;
+  const n = Number(arg);
+  return n >= 1 && n <= rows.length ? rows[n - 1]! : null;
+}
+
+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;
+  /** The rows the last `/resume` list showed, so `/resume <n>` picks the row the user saw. */
+  readonly rows?: readonly SessionMeta[];
+}): 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 };
+  }
+  const byNumber = input.rows ? resumeRowByNumber(prefix, input.rows) : null;
+  let id: string | null = byNumber?.id ?? null;
+  try {
+    if (!byNumber) 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 으로 목록 보기` };
+  }
+  const shortId = sessionIdPrefixes([id]).get(id) ?? id;
+  if (id === from) return { kind: 'rejected', status: `이미 이 대화다 · ${shortId}` };
+  setActiveSessionId(id);
+  debug.log('tui.next', 'session-resume', { from, to: id, by: byNumber ? 'number' : 'prefix' });
+  const shortFrom = from ? (sessionIdPrefixes([from]).get(from) ?? from) : '없음';
+  return { kind: 'started', id, status: `대화 이어 가기 · ${shortId} · 이전 = ${shortFrom}` };
+}

package/src/tui/slash/signals.ts

@@ -0,0 +1,114 @@
+// TUI-SLASH-SIGNALS — Next TUI `/signals` 슬래시 묶음(관측 전용).
+//
+// classic 의 /signals 는 dashboard 전용 registry/runtime 에 살지만, 이 handler 는 Next TUI 가
+// 직접 소유한다. src/input/control-signal-observer.ts 의 실제 defaultControlSignalObserver()
+// 싱글턴에서 읽기 API(list·latest·countsByKind)만 소비한다 — observer mutation(clear·detach)과
+// signal emission(버스 발행)은 명시적으로 범위 밖이며, dashboard/index.ts 는 import 하지 않는다.
+
+import { defaultControlSignalObserver } from '../../input/control-signal-observer.js';
+import type { ControlSignal } from '../../input/control-signal.js';
+
+/** `/signals`가 ctx 에서 쓰는 것만(구조 타입 — NextTuiContext 가 이 계약을 만족한다). */
+export interface SignalsSlashContext {
+  chatLines: string[];
+  setChatScrollOffset(value: number): void;
+  muted(text: string): string;
+  accent(text: string): string;
+  text(text: string): string;
+  error(text: string): string;
+  warning(text: string): string;
+  info(text: string): string;
+}
+
+const SIGNALS_USAGE = 'usage: /signals [help|status|latest|list [kind]]';
+
+function signalClock(createdAt: string): string {
+  return createdAt.slice(11, 19);
+}
+
+/** 관측된 신호 한 줄 요약 — 관측 API가 보증하는 필드(kind·urgency·createdAt·scope.sessionId)만 읽는다. */
+function signalSummary(signal: ControlSignal): string {
+  const sessionId = signal.scope?.sessionId;
+  return `[${signal.urgency}] ${signal.kind} · ${signalClock(signal.createdAt)}${sessionId ? ` · session ${sessionId}` : ''}`;
+}
+
+function signalsHelp(ctx: SignalsSlashContext): void {
+  ctx.chatLines.push(ctx.accent('❯ /signals help'));
+  ctx.chatLines.push(ctx.warning(`  ${SIGNALS_USAGE}`));
+  ctx.chatLines.push(ctx.muted('  · status — 종류별 관측 신호 수 요약'));
+  ctx.chatLines.push(ctx.muted('  · latest — 최신 신호 1건'));
+  ctx.chatLines.push(ctx.muted('  · list [kind] — 신호 목록(선택 kind 필터)'));
+  ctx.chatLines.push(ctx.muted('  · clear·emit 은 관측 전용 경계상 이 명령 범위 밖입니다'));
+  ctx.setChatScrollOffset(-1);
+}
+
+function signalsStatus(ctx: SignalsSlashContext): void {
+  ctx.chatLines.push(ctx.accent('❯ /signals status'));
+  const counts = defaultControlSignalObserver().countsByKind();
+  const kinds = Object.keys(counts).sort();
+  const total = kinds.reduce((sum, kind) => sum + (counts[kind] ?? 0), 0);
+  if (total === 0) {
+    ctx.chatLines.push(ctx.muted('  관측된 신호 없음 (총 0건)'));
+    ctx.setChatScrollOffset(-1);
+    return;
+  }
+  ctx.chatLines.push(ctx.text(`  신호 총 ${total}건 · 종류 ${kinds.length}종`));
+  for (const kind of kinds) {
+    ctx.chatLines.push(ctx.muted(`  · ${kind} ×${counts[kind] ?? 0}`));
+  }
+  ctx.setChatScrollOffset(-1);
+}
+
+function signalsLatest(ctx: SignalsSlashContext): void {
+  ctx.chatLines.push(ctx.accent('❯ /signals latest'));
+  const latest = defaultControlSignalObserver().latest();
+  if (!latest) {
+    ctx.chatLines.push(ctx.muted('  최신 신호 없음 — 아직 관측된 control-signal 이 없습니다'));
+  } else {
+    ctx.chatLines.push(`  ${ctx.info(signalSummary(latest))}`);
+  }
+  ctx.setChatScrollOffset(-1);
+}
+
+function signalsList(args: string[], ctx: SignalsSlashContext): void {
+  const kind = (args[1] ?? '').trim();
+  const signals = defaultControlSignalObserver().list(kind ? { kind } : undefined);
+  ctx.chatLines.push(ctx.accent(`❯ /signals list${kind ? ` ${kind}` : ''} (${signals.length}건)`));
+  if (signals.length === 0) {
+    ctx.chatLines.push(ctx.muted('  관측된 신호 없음'));
+  }
+  for (const [index, signal] of signals.entries()) {
+    ctx.chatLines.push(`  ${ctx.muted(`${index + 1}. ${signalSummary(signal)}`)}`);
+  }
+  ctx.setChatScrollOffset(-1);
+}
+
+/** `/signals` 본체 — 관측 전용. help·status·latest·list 만 실행하고 clear·emit 은 거절한다. */
+export async function handleSignalsSlash(args: string[], ctx: SignalsSlashContext): Promise<void> {
+  const sub = (args[0] ?? 'status').toLowerCase();
+  ctx.chatLines.push('');
+  if (sub === 'help') {
+    signalsHelp(ctx);
+    return;
+  }
+  if (sub === 'status') {
+    signalsStatus(ctx);
+    return;
+  }
+  if (sub === 'latest') {
+    signalsLatest(ctx);
+    return;
+  }
+  if (sub === 'list') {
+    signalsList(args, ctx);
+    return;
+  }
+  ctx.chatLines.push(ctx.accent(`❯ /signals ${sub}`));
+  if (sub === 'clear' || sub === 'emit') {
+    ctx.chatLines.push(ctx.error(`  ✗ out of scope — /signals는 관측 전용입니다 (${sub} 미지원)`));
+  } else {
+    ctx.chatLines.push(ctx.warning(`  unknown subcommand: ${sub}`));
+  }
+  ctx.chatLines.push(ctx.warning(`  ${SIGNALS_USAGE}`));
+  ctx.setChatScrollOffset(-1);
+}

package/src/tui/slash/term-next.ts

@@ -0,0 +1,71 @@
+/** Read-only terminal view exposed to the Next TUI. Tests can inject an isolated fake. */
+export interface NextTuiTermSession {
+  readonly id: string;
+  readonly title: string;
+  readonly kind: string;
+  readonly status: 'running' | 'backgrounded' | 'completed' | 'killed' | 'exited';
+  readonly cwd?: string;
+  readonly exitCode?: number | null;
+}
+
+export interface NextTuiTermSlashContext {
+  readonly chatLines: string[];
+  readonly setChatScrollOffset: (value: number) => void;
+  readonly sessions: { list(): readonly NextTuiTermSession[] | Promise<readonly NextTuiTermSession[]> };
+}
+
+const isLive = (session: NextTuiTermSession): boolean =>
+  session.status === 'running' || session.status === 'backgrounded';
+
+const unknownOrValue = (value: string | number | null | undefined): string =>
+  value === null || value === undefined || value === '' ? 'unknown' : String(value);
+
+function sessionLines(sessions: readonly NextTuiTermSession[]): string[] {
+  if (sessions.length === 0) return ['  No terminal sessions.'];
+  return sessions.map((session) => {
+    const exit = isLive(session) ? 'not-exited' : unknownOrValue(session.exitCode);
+    return `  ${session.status.padEnd(12)} ${session.id.slice(-8)} ${session.title} · cwd=${unknownOrValue(session.cwd)} · exitCode=${exit}`;
+  });
+}
+
+function matrixLines(sessions: readonly NextTuiTermSession[]): string[] {
+  if (sessions.length === 0) return ['  No terminal sessions.'];
+  return [
+    '  term:ID    character    transport   placement         groups     title',
+    ...sessions.map((session) => {
+      const dead = isLive(session) ? '' : ' exited';
+      return `  ${session.id.padEnd(10)} ${session.kind.padEnd(12)} pty         pty               -          ${session.title}${dead}`;
+    }),
+  ];
+}
+
+/** Next TUI exposes only read-only terminal inventory and status. */
+export async function handleNextTuiTermSlash(args: string[], context: NextTuiTermSlashContext): Promise<void> {
+  const command = (args[0] ?? 'help').trim().toLowerCase();
+  if (command === '' || command === 'help') {
+    context.chatLines.push(
+      '  /term help    Show Next TUI terminal commands.',
+      '  /term list    List terminal sessions.',
+      '  /term status  Show live/exited session counts.',
+      '  /term matrix  Show terminal transport and liveness.',
+      '  Unknown cwd or exit codes are shown as unknown.',
+      '  Mutating terminal commands remain on the classic terminal surface.',
+    );
+  } else if (command === 'status') {
+    const sessions = await context.sessions.list();
+    const live = sessions.filter(isLive).length;
+    const exited = sessions.length - live;
+    context.chatLines.push(`  Terminal sessions: ${live} live · ${exited} exited.`);
+  } else if (command === 'list' || command === 'matrix') {
+    const sessions = await context.sessions.list();
+    context.chatLines.push(...(command === 'list' ? sessionLines(sessions) : matrixLines(sessions)));
+  } else {
+    context.chatLines.push(`  Unsupported /term command in Next TUI: ${command}. Try /term help.`);
+  }
+  context.setChatScrollOffset(-1);
+}
+
+/** The entry point reaches this only for `/term` or `/terminal` input. */
+export async function dispatchNextTermSlash(args: string[], context: NextTuiTermSlashContext): Promise<void> {
+  await handleNextTuiTermSlash(args, context);
+}

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,13 +150,16 @@ 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> {
+  async turn(prompt: string, writePrompt?: (payload: string) => Promise<void>, onDelta?: (text: string) => void, attachments: readonly string[] = []): Promise<TurnResult> {
     if (this.closed) throw new Error('REPL child exited');
     if (this.waiting) throw new Error('REPL turn already running');
     const turnId = `tui-${++this.turnCount}`;
-    const payload = `${JSON.stringify({ prompt, id: turnId })}\n`;
+    const payload = JSON.stringify({ prompt, id: turnId, ...(attachments.length ? { attachments } : {}) }) + '\n';
     const response = new Promise<TurnResult>((resolve, reject) => { this.waiting = { turnId, onDelta, resolve, reject }; });
     try {
       if (writePrompt) await writePrompt(payload);
@@ -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);
@@ -194,6 +237,7 @@ export async function runLocalChatTurn(
   writePrompt?: (payload: string) => Promise<void>,
   onDelta?: (text: string) => void,
   compact: LocalChatTurnCompact = {},
+  attachments: readonly string[] = [],
 ): Promise<void> {
   if (signal.aborted) throw new Error('응답을 취소했습니다');
   if (!cli) throw new Error('elanous CLI entry is unavailable');
@@ -215,7 +259,7 @@ export async function runLocalChatTurn(
   try {
     result = await session.turn(text, writePrompt, (delta) => {
       if (!signal.aborted) onDelta?.(delta);
-    });
+    }, attachments);
   } catch (error) {
     if (signal.aborted) throw new Error('응답을 취소했습니다');
     await closeLocalChatSession(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,
+  };
+}