elanous 0.2.34 → 0.2.35

package/src/tui/input/composer.ts

@@ -0,0 +1,144 @@
+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 { safeLogText } from '../chat/log-view.js';
+
+const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+
+export type ComposerAction = 'edit' | 'submit' | 'cancel' | 'quit' | 'none';
+
+export interface ComposerResult {
+  readonly state: InlineEditorState;
+  readonly action: ComposerAction;
+  readonly submitted?: string;
+}
+
+export function emptyComposer(): InlineEditorState {
+  return createInlineEditorState();
+}
+
+/** Keep the edit cursor and the newest text visible in one terminal row. */
+export function composerViewport(state: InlineEditorState, columns: number): { line: string; cursorCol: number } {
+  const text = safeLogText(state.text).replace(/\n/g, '↵');
+  const before = safeLogText(state.text.slice(0, state.cursor)).replace(/\n/g, '↵');
+  const graphemes = Array.from(segmenter.segment(text), ({ segment }) => segment);
+  const cursorAt = Math.min(graphemes.length, Array.from(segmenter.segment(before)).length);
+  // Reserve one cell for the visible cursor after the prompt and text.
+  const available = Math.max(1, columns - 3);
+  let start = cursorAt;
+  let beforeWidth = 0;
+  while (start > 0) {
+    const cells = Bun.stringWidth(graphemes[start - 1]!);
+    if (beforeWidth + cells > available) break;
+    beforeWidth += cells;
+    start--;
+  }
+  let used = 0;
+  let end = start;
+  while (end < graphemes.length) {
+    const cells = Bun.stringWidth(graphemes[end]!);
+    if (used + cells > available) break;
+    used += cells;
+    end++;
+  }
+  return {
+    line: `❯ ${graphemes.slice(start, end).join('')}`,
+    cursorCol: Math.min(columns, 3 + beforeWidth),
+  };
+}
+
+export type WheelDirection = 'up' | 'down';
+
+/** Wheel notch carried by a parsed SGR mouse key; null for every other key. */
+export function wheelDirection(key: Key): WheelDirection | null {
+  if (key.name !== 'mouse') return null;
+  if (key.mouse?.type === 'scroll-up') return 'up';
+  if (key.mouse?.type === 'scroll-down') return 'down';
+  return null;
+}
+
+/**
+ * Longest pause allowed *inside* a held SGR tail. The tail itself may come any
+ * time after the lone ESC (the guard stays armed until the next key decides),
+ * but once characters are held, a pause this long releases them as typing.
+ */
+export const MOUSE_RESIDUE_WINDOW_MS = 500;
+const SGR_MOUSE_TAIL = /^\[<(\d+);(\d+);(\d+)([Mm])$/;
+const SGR_MOUSE_TAIL_PREFIX = /^\[(?:<(?:\d+(?:;(?:\d*|\d+;\d*))?)?)?$/;
+
+export type MouseResidueStep =
+  | { readonly kind: 'pass' }
+  | { readonly kind: 'hold' }
+  | { readonly kind: 'release'; readonly keys: readonly Key[] }
+  | { readonly kind: 'mouse'; readonly wheel: WheelDirection | null };
+
+/**
+ * When the ESC of an SGR mouse report reaches us apart from its tail (slow link,
+ * split write), the key parser's quiet window turns the ESC into Escape and the
+ * tail `[<65;10;5M` into typed characters. The guard is armed by that lone ESC;
+ * it holds the following characters while they still spell an SGR mouse tail,
+ * swallows a complete one (reporting its wheel notch), and releases anything
+ * else unchanged and in order.
+ */
+export class MouseResidueGuard {
+  private armedAt: number | null = null;
+  private held: Key[] = [];
+  private text = '';
+
+  arm(now: number): void {
+    this.armedAt = now;
+    this.held = [];
+    this.text = '';
+  }
+
+  accept(key: Key, now: number): MouseResidueStep {
+    if (this.armedAt === null) return { kind: 'pass' };
+    const ch = key.ctrl || key.alt || key.meta ? null : (key.raw ?? key.name);
+    const inTime = this.held.length === 0 || now - this.armedAt <= MOUSE_RESIDUE_WINDOW_MS;
+    const candidate = ch !== null && ch.length === 1 && inTime ? this.text + ch : null;
+    if (candidate !== null) {
+      const full = candidate.match(SGR_MOUSE_TAIL);
+      if (full) {
+        this.reset();
+        const button = Number(full[1]) & ~(4 | 8 | 16);
+        const pressed = full[4] === 'M';
+        return { kind: 'mouse', wheel: pressed && button === 64 ? 'up' : pressed && button === 65 ? 'down' : null };
+      }
+      if (SGR_MOUSE_TAIL_PREFIX.test(candidate)) {
+        this.held.push(key);
+        this.text = candidate;
+        this.armedAt = now;   // the pause limit counts from the last held character
+        return { kind: 'hold' };
+      }
+    }
+    const held = this.held;
+    this.reset();
+    return held.length === 0 ? { kind: 'pass' } : { kind: 'release', keys: [...held, key] };
+  }
+
+  private reset(): void {
+    this.armedAt = null;
+    this.held = [];
+    this.text = '';
+  }
+}
+
+/** Reuse the shared editor contract; only TUI submit/cancel keys live here. */
+export function applyComposerKey(state: InlineEditorState, key: Key): ComposerResult {
+  const name = key.name.toLowerCase();
+  // Mouse reports (wheel, click, drag) never edit the prompt.
+  if (name === 'mouse') return { state, action: 'none' };
+  if (name === 'escape' && !state.text) return { state, action: 'none' };
+  if ((key.ctrl && (name === 'd' || name === 'c')) || name === 'escape') {
+    if (state.text && !(key.ctrl && name === 'd')) return { state: emptyComposer(), action: 'cancel' };
+    return { state, action: 'quit' };
+  }
+  if ((name === 'enter' || name === 'return') && !key.shift) {
+    const submitted = state.text.trim();
+    return submitted
+      ? { state: emptyComposer(), action: 'submit', submitted }
+      : { state, action: 'none' };
+  }
+  const edited = applyInlineEditorKey(state, key, { shiftEnter: 'newline', tab: null });
+  return edited ? { state: edited, action: 'edit' } : { state, action: 'none' };
+}

package/src/tui/seat-mail-boot.ts

@@ -0,0 +1,59 @@
+import { statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import type { MsgStore } from '../msg/msg-store.js';
+
+export interface SeatMailSnapshot {
+  seat: string;
+  unread: number | null;
+}
+
+const SEAT_IN_PATH = /(?:^|\/)seats\/([A-Za-z][A-Za-z0-9_-]{0,63})(?:\/|$)/;
+const SEAT_ID = /^[A-Z][A-Z0-9_-]{0,63}$/;
+
+/** A small, read-only snapshot for the next TUI's first frame. */
+export function readSeatMailSnapshot(
+  cwd: string,
+  deps: {
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    msgPath?: string;
+  } = {},
+): SeatMailSnapshot | null {
+  const env = deps.env ?? process.env;
+  const seat = (SEAT_IN_PATH.exec(cwd)?.[1] ?? env.COORD_ID ?? '').trim().toUpperCase();
+  if (!SEAT_ID.test(seat)) return null;
+  const seatDir = join(deps.home ?? homedir(), 'elanous-hq', 'seat-state', seat);
+  try {
+    if (!statSync(seatDir).isDirectory()) return null;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT' || code === 'ENOTDIR') return null;
+    return { seat, unread: null };
+  }
+  const msgPath = deps.msgPath ?? join(elanousStateRoot(), 'msg', 'messages.db');
+  try {
+    statSync(msgPath);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    return { seat, unread: code === 'ENOENT' ? 0 : null };
+  }
+  // Loading MsgStore is only needed when there is an existing ledger to read.
+  // A damaged or inaccessible ledger must not prevent the TUI from booting.
+  try {
+    const msg = require('../msg/msg-store.js') as typeof import('../msg/msg-store.js');
+    const store: MsgStore = new msg.MsgStore(msgPath, { readOnly: true });
+    try {
+      return { seat, unread: store.unreadCount(seat) };
+    } finally {
+      store.close();
+    }
+  } catch {
+    return { seat, unread: null };
+  }
+}
+
+export function seatMailLine(snapshot: SeatMailSnapshot | null): string | null {
+  return snapshot ? `${snapshot.seat} · 우편 ${snapshot.unread ?? '확인 불가'}` : null;
+}

package/src/tui/slash/compact.ts

@@ -0,0 +1,100 @@
+// TUI-NEXT-COMPACT — next TUI context compaction (auto before a turn · `/compact` now).
+// Wiring only: the threshold (shouldAutoCompact) and the pipeline (runCompactPipeline) run inside the
+// shared session bridge `compactSessionHistory` (src/session/compact-session.ts), the same seam the
+// continuation loop and `elanous session compact` use. Thresholds and anchor counts are the shared
+// `chat.autoCompact` defaults. The REPL child reloads the session file every turn (session/chat.ts
+// runTurn → loadSession), so rewriting the store between turns is what the next model call sees.
+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';
+}
+
+/** Test/embedding seams. Production passes none of these. */
+export interface NextTuiCompactDeps {
+  readonly provider?: CompactProvider;
+  readonly config?: ChatAutoCompactConfig;
+  readonly modelId?: string;
+}
+
+export interface NextTuiCompactOutcome {
+  readonly fired: boolean;
+  readonly reason: string;
+  readonly before: number;
+  readonly after: number;
+  readonly ms: number;
+  /** Status-line text, or null when an auto check stays silent (under threshold). */
+  readonly status: string | null;
+}
+
+function compactStatus(before: number, after: number): string {
+  return `압축 ${before}→${after} 메시지`;
+}
+
+async function defaultConfig(): Promise<ChatAutoCompactConfig> {
+  const { getUserConfig } = await import('../../user-config.js');
+  return getUserConfig().chat.autoCompact;
+}
+
+/** Same resolution order as the continuation runner (dispatch/continuation-turn-runner.ts). */
+async function defaultModelId(): Promise<string | undefined> {
+  try {
+    const { getUserConfig } = await import('../../user-config.js');
+    const cfg = getUserConfig();
+    if (cfg.llm?.model) return cfg.llm.model;
+    const { getProviderForConfig } = await import('../../llm.js');
+    return getProviderForConfig(cfg).defaultModel;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Compact the next-TUI session once. `force:false` = the pre-turn auto check (fires only over the
+ * shared threshold); `force:true` = `/compact` (bypasses the threshold). Never throws: a failure is
+ * observed and reported as not fired, so the caller sends its turn uncompacted.
+ */
+export async function compactNextTuiSession(
+  sessionId: string,
+  input: { readonly force: boolean; readonly modelId?: string | null },
+  deps: NextTuiCompactDeps = {},
+): Promise<NextTuiCompactOutcome> {
+  const auto = !input.force;
+  const started = Date.now();
+  try {
+    const config = deps.config ?? await defaultConfig();
+    if (auto && !config.enabled) return { fired: false, reason: 'disabled', before: 0, after: 0, ms: 0, status: null };
+    const modelId = input.modelId ?? deps.modelId ?? await defaultModelId();
+    const result = await compactSessionHistory(sessionId, {
+      config,
+      force: input.force,
+      ...(modelId ? { modelId } : {}),
+      ...(deps.provider ? { provider: deps.provider } : {}),
+    });
+    const ms = Date.now() - started;
+    if (result.fired) {
+      debug.log('tui.next', 'compact', { auto, before: result.before, after: result.after, ms });
+      return { fired: true, reason: result.reason, before: result.before, after: result.after, ms, status: compactStatus(result.before, result.after) };
+    }
+    if (!auto) debug.log('tui.next', 'compact-skipped', { auto, reason: result.reason, before: result.before, ms });
+    return {
+      fired: false,
+      reason: result.reason,
+      before: result.before,
+      after: result.after,
+      ms,
+      status: auto ? null : `압축할 내용 없음 · ${result.before} 메시지`,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const ms = Date.now() - started;
+    debug.log('tui.next', 'compact-failed', { auto, ms, error: message }, { level: 'warn' });
+    return { fired: false, reason: 'error', before: 0, after: 0, ms, status: auto ? null : `압축 실패: ${message}` };
+  }
+}

package/src/tui/slash/new-session.ts

@@ -0,0 +1,35 @@
+// `/new` (alias `/session new`) — leave a session that outgrew its context without quitting next TUI.
+// The old session is never deleted; only the active marker moves.
+import { debug } from '../../debug/log.js';
+import { createSession, setActiveSessionId } from '../../session/index.js';
+
+export const NEW_SESSION_BUSY_STATUS = '응답 중에는 /new 를 받지 않습니다 · 완료(또는 Esc 취소) 뒤 다시';
+
+/** Store placeholder for an untitled session (session/index.ts createSession). */
+const UNTITLED = '(new session)';
+
+export function isNewSessionCommand(text: string): boolean {
+  const normalized = text.trim().split(/\s+/).join(' ');
+  return normalized === '/new' || normalized === '/session new';
+}
+
+export function nextTuiTitle(meta: { readonly title?: string } | null | undefined): string {
+  const title = meta?.title?.split('\n')[0]?.trim() ?? '';
+  return !title || title === UNTITLED ? '새 대화' : title;
+}
+
+export type NewTuiSessionResult =
+  | { readonly kind: 'started'; readonly id: string; readonly status: string }
+  | { readonly kind: 'rejected'; readonly status: string };
+
+export function requestNewTuiSession(input: { readonly busy: boolean; readonly from: string | null }): NewTuiSessionResult {
+  const { busy, from } = input;
+  if (busy) {
+    debug.log('tui.next', 'session-new-rejected', { from, reason: 'busy' });
+    return { kind: 'rejected', status: NEW_SESSION_BUSY_STATUS };
+  }
+  const id = createSession({ source: 'tui' }).id;
+  setActiveSessionId(id);
+  debug.log('tui.next', 'session-new', { from, to: id });
+  return { kind: 'started', id, status: `새 대화 · 이전 = ${from ? from.slice(0, 8) : '없음'}` };
+}

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

@@ -0,0 +1,239 @@
+/** Keep one REPL child per session so background tasks and their completion queue survive turns. */
+import type { NextTuiCompactDeps, NextTuiCompactOutcome } from '../tui/slash/compact.js';
+
+const STATUS_PREFIX = 'ELANOUS_TUI_BG_STATUS\t';
+
+interface TurnResult {
+  event?: string | null;
+  turnId?: string | null;
+  text?: string;
+  error?: string;
+  provider?: string;
+  model?: string | null;
+}
+interface WaitingTurn {
+  turnId: string;
+  onDelta?: (text: string) => void;
+  resolve: (result: TurnResult) => void;
+  reject: (error: Error) => void;
+}
+
+class LocalChatSession {
+  readonly child: ReturnType<typeof Bun.spawn>;
+  readonly exited: Promise<number>;
+  private readonly writeInput: (payload: string) => Promise<void>;
+  private waiting: WaitingTurn | null = null;
+  private stderrTail = '';
+  private closed = false;
+  private closing: Promise<void> | null = null;
+  private invalidated = false;
+  private turnCount = 0;
+
+  constructor(private readonly sessionId: string, cli: string) {
+    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' },
+    });
+    const input = this.child.stdin;
+    const output = this.child.stdout;
+    const errors = this.child.stderr;
+    if (!input || typeof input === 'number' || !output || typeof output === 'number'
+      || !errors || typeof errors === 'number') throw new Error('REPL pipe unavailable');
+    this.writeInput = async (payload) => { input.write(payload); await input.flush(); };
+    this.exited = this.child.exited;
+    void this.readLines(output, (line) => {
+      if (!line.trim()) return;
+      let result: TurnResult;
+      try { result = JSON.parse(line) as TurnResult; }
+      catch { this.fail(new Error('invalid REPL JSONL response')); return; }
+      const waiting = this.waiting;
+      if (!waiting) return;
+      if ('turnId' in result && result.turnId !== waiting.turnId) return;
+      if (result.event === 'delta') {
+        if (result.turnId !== waiting.turnId) return;
+        if (typeof result.text === 'string') {
+          try { waiting.onDelta?.(result.text); } catch { /* renderer cannot break the turn */ }
+        }
+        return;
+      }
+      // Future side-channel events cannot complete a turn. Legacy final
+      // frames have no event; typed final frames use event=result.
+      if ('event' in result && result.event !== 'result') return;
+      this.waiting = null;
+      waiting.resolve(result);
+    }, () => {
+      this.invalidate();
+      this.fail(new Error('REPL stdout closed'));
+      void this.close();
+    });
+    void this.readLines(errors, (line) => {
+      if (line.startsWith(STATUS_PREFIX)) {
+        for (const listener of statusListeners.get(sessionId) ?? []) {
+          try { listener(line.slice(STATUS_PREFIX.length)); } catch { /* status observers cannot break the turn */ }
+        }
+      } else if (line.trim()) {
+        this.stderrTail = line.trim();
+      }
+    });
+    void this.exited.then((code) => {
+      this.closed = true;
+      this.invalidate();
+      if (sessions.get(sessionId) === this) sessions.delete(sessionId);
+      this.fail(new Error(this.stderrTail || `chat exit ${code}`));
+    });
+  }
+
+  private async readLines(stream: ReadableStream<Uint8Array>, receive: (line: string) => void, onEnd?: () => void): Promise<void> {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        let newline: number;
+        while ((newline = buffer.indexOf('\n')) >= 0) {
+          receive(buffer.slice(0, newline));
+          buffer = buffer.slice(newline + 1);
+        }
+      }
+      buffer += decoder.decode();
+      if (buffer) receive(buffer);
+    } catch (error) {
+      this.fail(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      reader.releaseLock();
+      onEnd?.();
+    }
+  }
+
+  private fail(error: Error): void {
+    const waiting = this.waiting;
+    this.waiting = null;
+    waiting?.reject(error);
+  }
+
+  private invalidate(): void {
+    if (this.invalidated) return;
+    this.invalidated = true;
+    for (const listener of statusListeners.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> {
+    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 response = new Promise<TurnResult>((resolve, reject) => { this.waiting = { turnId, onDelta, resolve, reject }; });
+    try {
+      if (writePrompt) await writePrompt(payload);
+      else await this.writeInput(payload);
+    } catch (error) {
+      this.fail(error instanceof Error ? error : new Error(String(error)));
+    }
+    return response;
+  }
+
+  async close(): Promise<void> {
+    if (!this.closing) {
+      this.closing = (async () => {
+        if (!this.closed) {
+          this.closed = true;
+          this.invalidate();
+          try { this.child.kill(); } catch { /* already exited */ }
+        }
+        await this.exited;
+      })();
+    }
+    await this.closing;
+  }
+}
+
+const sessions = new Map<string, LocalChatSession>();
+/** Model the child last answered with, per session — sizes the next pre-turn compaction check. */
+const lastModels = new Map<string, string>();
+
+export function localChatModel(sessionId: string): string | null {
+  return lastModels.get(sessionId) ?? null;
+}
+
+/** TUI-NEXT-COMPACT — pre-turn auto compaction hook (deps are test seams; production passes none). */
+export interface LocalChatTurnCompact {
+  readonly deps?: NextTuiCompactDeps;
+  readonly onCompact?: (outcome: NextTuiCompactOutcome) => void;
+}
+const statusListeners = new Map<string, Set<(json: string | null) => void>>();
+
+export function onLocalChatBackgroundStatus(sessionId: string, listener: (json: string | null) => void): () => void {
+  const listeners = statusListeners.get(sessionId) ?? new Set();
+  listeners.add(listener);
+  statusListeners.set(sessionId, listeners);
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0) statusListeners.delete(sessionId);
+  };
+}
+
+export async function closeLocalChatSession(sessionId: string): Promise<void> {
+  const session = sessions.get(sessionId);
+  sessions.delete(sessionId);
+  lastModels.delete(sessionId);
+  await session?.close();
+}
+
+/** Run one turn while retaining the child for the next turn. */
+export async function runLocalChatTurn(
+  sessionId: string,
+  text: string,
+  signal: AbortSignal,
+  cli = process.argv[1],
+  writePrompt?: (payload: string) => Promise<void>,
+  onDelta?: (text: string) => void,
+  compact: LocalChatTurnCompact = {},
+): Promise<void> {
+  if (signal.aborted) throw new Error('응답을 취소했습니다');
+  if (!cli) throw new Error('elanous CLI entry is unavailable');
+  // The REPL child reloads the session store each turn, so compacting the store here is what this
+  // turn's model call sees. Over the shared threshold only; a failure leaves the turn uncompacted.
+  // Lazy like this module itself: the compaction path pulls in the LLM router, so next TUI boot stays light.
+  const { compactNextTuiSession } = await import('../tui/slash/compact.js');
+  const compacted = await compactNextTuiSession(sessionId, { force: false, modelId: localChatModel(sessionId) }, compact.deps);
+  if (compacted.fired) {
+    try { compact.onCompact?.(compacted); } catch { /* status observers cannot break the turn */ }
+  }
+  if (signal.aborted) throw new Error('응답을 취소했습니다');
+  const session = sessions.get(sessionId) ?? new LocalChatSession(sessionId, cli);
+  sessions.set(sessionId, session);
+  const abort = (): void => { void closeLocalChatSession(sessionId); };
+  signal.addEventListener('abort', abort, { once: true });
+  if (signal.aborted) abort();
+  let result: TurnResult;
+  try {
+    result = await session.turn(text, writePrompt, (delta) => {
+      if (!signal.aborted) onDelta?.(delta);
+    });
+  } catch (error) {
+    if (signal.aborted) throw new Error('응답을 취소했습니다');
+    await closeLocalChatSession(sessionId);
+    throw error;
+  } finally {
+    signal.removeEventListener('abort', abort);
+  }
+  if (signal.aborted) throw new Error('응답을 취소했습니다');
+  // A completed JSONL error frame is a turn failure, not a transport failure:
+  // the child still owns live tasks and buffered notifications for retry.
+  if (result.error) throw new Error(result.error);
+  if (result.model) lastModels.set(sessionId, result.model);
+  if (result.provider) {
+    try {
+      const { debug } = await import('../debug/log.js');
+      debug.log('llm.route-decision', 'local-chat-executed', {
+        surface: 'tui-local', sessionId, provider: result.provider, model: result.model ?? null,
+      });
+    } catch { /* observation must not fail a completed turn */ }
+  }
+}

package/src/tui-client/local-harness-command.ts

@@ -0,0 +1,63 @@
+/** Run the existing harness CLI outside the TUI import graph and stream its result. */
+export async function runLocalHarnessCommand(
+  command: 'ask' | 'runs',
+  goal: string,
+  signal: AbortSignal,
+  onLine: (line: string) => void,
+  cli = process.argv[1],
+): Promise<void> {
+  if (signal.aborted) throw new Error('하니스 호출을 취소했습니다');
+  if (!cli) throw new Error('elanous CLI entry is unavailable');
+  const dryRun = command === 'ask' && goal.startsWith('--dry-run ');
+  const objective = dryRun ? goal.slice('--dry-run '.length).trim() : goal;
+  if (command === 'ask' && !objective) throw new Error('하니스 목표가 비었습니다');
+  const cmd = command === 'runs'
+    ? [process.execPath, cli, 'harness', 'progress']
+    : [process.execPath, cli, 'harness', 'say', '--no-auto-merge', ...(dryRun ? ['--dry-run'] : []), objective];
+  const child = Bun.spawn({ cmd, stdin: 'ignore', stdout: 'pipe', stderr: 'pipe', env: process.env });
+  let omittedRunRows = 0;
+  let shownRunRows = 0;
+  const emit = (line: string): void => {
+    if (command === 'runs' && shownRunRows >= 16) { omittedRunRows++; return; }
+    shownRunRows++;
+    onLine(line);
+  };
+  const abort = (): void => { child.kill(); };
+  signal.addEventListener('abort', abort, { once: true });
+  if (signal.aborted) abort();
+  const readLines = async (stream: ReadableStream<Uint8Array>): Promise<string> => {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let pending = '';
+    let last = '';
+    while (true) {
+      const { done, value } = await reader.read();
+      pending += decoder.decode(value, { stream: !done });
+      let newline = pending.indexOf('\n');
+      while (newline >= 0) {
+        const line = pending.slice(0, newline).replace(/\r$/, '');
+        if (line.trim()) { emit(line); last = line; }
+        pending = pending.slice(newline + 1);
+        newline = pending.indexOf('\n');
+      }
+      if (done) break;
+    }
+    if (pending.trim()) { emit(pending); last = pending; }
+    return last;
+  };
+  try {
+    const [outLast, errLast, code] = await Promise.all([
+      readLines(child.stdout), readLines(child.stderr), child.exited,
+    ]);
+    if (signal.aborted) throw new Error('하니스 호출을 취소했습니다');
+    if (code !== 0) throw new Error(errLast || outLast || `harness exit ${code}`);
+    if (omittedRunRows > 0) onLine(`추가 ${omittedRunRows}행 생략 · 전체: eln harness progress`);
+  } catch (error) {
+    try { child.kill(); } catch { /* already exited */ }
+    await child.exited;
+    if (signal.aborted) throw new Error('하니스 호출을 취소했습니다');
+    throw error;
+  } finally {
+    signal.removeEventListener('abort', abort);
+  }
+}