elanous 0.2.32 → 0.2.35

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/dashboard-session.ts

@@ -130,6 +130,9 @@ export interface DashboardSendRequest {
    *  more per turn, provider-dependent). Shape matches
    *  `StreamWithToolsHandlers.onUsage` modulo the correlation id. */
   onUsage?(usage: DashboardSessionUsage): void;
+  /** TUI-TURN-NARRATION — `agent_thought_chunk` ⊕ `_meta.reasoning: true`(추론 요약 문단).
+   *  전에는 usage 봉투가 아니면 버려서 화면에 0줄이었다(결함 #87). */
+  onThought?(text: string): void;
 }
 
 export interface DashboardSendResult {
@@ -550,6 +553,7 @@ function buildSendInterceptor(req: DashboardSendRequest): SessionUpdateIntercept
         rawInput?: unknown;
         rawOutput?: unknown;
         status?: string;
+        _meta?: { reasoning?: unknown };
       };
     };
     const inner = n.update;
@@ -582,8 +586,13 @@ function buildSendInterceptor(req: DashboardSendRequest): SessionUpdateIntercept
         return;
       }
       case 'agent_thought_chunk': {
-        if (!req.onUsage || inner.content?.type !== 'text') return;
+        if (inner.content?.type !== 'text') return;
         const text = inner.content.text ?? '';
+        if (inner._meta?.reasoning === true) {
+          req.onThought?.(text);
+          return;
+        }
+        if (!req.onUsage) return;
         const env = parseElanousUiEnvelope(text);
         if (!env || env.method !== 'usage') return;
         const { id: _id, ...rest } = env.payload as unknown as ElanousUiUsagePayload;

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);
+  }
+}

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

@@ -0,0 +1,184 @@
+import { loadCatalog } from '../intelligence-map/model-catalog.js';
+import { getUserConfig, PROVIDER_DEFAULT_MODEL, reloadUserConfig } from '../user-config.js';
+
+type FetchModels = (url: string, init: RequestInit) => Promise<Response>;
+type ModelList = { ids: string[]; source: 'remote' | 'cache' | 'local'; note?: string };
+
+const MODEL_LOOKUP_TIMEOUT_MS = 2_000;
+const MODEL_DISPLAY_LIMIT = 12;
+
+/** The provider command is imported only when opened; this cache lives for one TUI process. */
+export class ProviderModelCache {
+  private local = new Map<string, string[]>();
+  private lastGoodRemote = new Map<string, { apiKey: string | undefined; ids: string[] }>();
+
+  localModels(provider: string): string[] {
+    const cached = this.local.get(provider);
+    if (cached) return cached;
+    const ids = [...new Set(loadCatalog().catalog.models
+      .filter((model) => model.provider === provider)
+      .map((model) => model.id))].sort();
+    this.local.set(provider, ids);
+    return ids;
+  }
+
+  async models(
+    provider: string,
+    remoteUrl: string | undefined,
+    apiKey: string | undefined,
+    signal: AbortSignal,
+    refresh = false,
+    fetchModels: FetchModels = fetch,
+    timeoutMs = MODEL_LOOKUP_TIMEOUT_MS,
+  ): Promise<ModelList> {
+    if (signal.aborted) throw new Error('provider lookup cancelled');
+    const local = this.localModels(provider);
+    if (!remoteUrl) return { ids: local, source: 'local' };
+    const cacheKey = `${provider}\0${remoteUrl}`;
+    const cached = this.lastGoodRemote.get(cacheKey);
+    const previous = cached && cached.apiKey === apiKey ? cached.ids : undefined;
+    if (previous && !refresh) return { ids: previous, source: 'cache' };
+    try {
+      const ids = await queryRemoteModels(remoteUrl, apiKey, signal, fetchModels, timeoutMs);
+      this.lastGoodRemote.set(cacheKey, { apiKey, ids });
+      return { ids, source: 'remote' };
+    } catch (error) {
+      if (signal.aborted) throw error;
+      const note = error instanceof Error ? error.message : String(error);
+      if (previous) return { ids: previous, source: 'cache', note };
+      return { ids: local, source: 'local', note };
+    }
+  }
+}
+
+const cache = new ProviderModelCache();
+const supportedProvider = (name: string): boolean => Object.prototype.hasOwnProperty.call(PROVIDER_DEFAULT_MODEL, name);
+
+async function queryRemoteModels(
+  url: string,
+  apiKey: string | undefined,
+  signal: AbortSignal,
+  fetchModels: FetchModels = fetch,
+  timeoutMs = MODEL_LOOKUP_TIMEOUT_MS,
+): Promise<string[]> {
+  if (signal.aborted) throw new Error('provider lookup cancelled');
+  const controller = new AbortController();
+  let rejectCancelled: ((reason: Error) => void) | undefined;
+  const cancelled = new Promise<never>((_, reject) => { rejectCancelled = reject; });
+  const cancel = (): void => {
+    controller.abort();
+    rejectCancelled?.(new Error('provider lookup cancelled'));
+  };
+  signal.addEventListener('abort', cancel, { once: true });
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    if (signal.aborted) throw new Error('provider lookup cancelled');
+    const deadline = new Promise<never>((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error('remote model lookup timed out'));
+        controller.abort();
+      }, timeoutMs);
+    });
+    const request = (async () => {
+      const response = await fetchModels(url, {
+        signal: controller.signal,
+        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      });
+      if (!response.ok) throw new Error(`remote model lookup HTTP ${response.status}`);
+      const payload = await response.json() as unknown;
+      if (!payload || typeof payload !== 'object' || !('data' in payload) || !Array.isArray(payload.data)
+        || payload.data.some((entry: unknown) => !entry || typeof entry !== 'object'
+          || !('id' in entry) || typeof entry.id !== 'string' || entry.id.trim().length === 0)) {
+        throw new Error('remote model list is malformed');
+      }
+      const ids = [...new Set(payload.data.map((entry: { id: string }) => entry.id))].sort();
+      if (ids.length === 0) throw new Error('remote model list is empty');
+      return ids;
+    })();
+    return await Promise.race([request, deadline, cancelled]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    signal.removeEventListener('abort', cancel);
+  }
+}
+
+function remoteModelsUrl(provider: string, baseUrl: string | undefined): string | undefined {
+  if (baseUrl) {
+    const base = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    const url = new URL('models', base);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') throw new Error('invalid base URL');
+    return url.toString();
+  }
+  return provider === 'openrouter' ? 'https://openrouter.ai/api/v1/models' : undefined;
+}
+
+async function setProviderViaCli(provider: string, model: string | undefined, signal: AbortSignal): Promise<void> {
+  const cli = process.argv[1];
+  if (!cli) throw new Error('elanous CLI entry is unavailable');
+  const child = Bun.spawn({
+    cmd: [process.execPath, cli, 'provider:set', provider, ...(model ? ['--model', model] : [])],
+    stdin: 'ignore', stdout: 'pipe', stderr: 'pipe', env: process.env,
+  });
+  const abort = (): void => { child.kill(); };
+  signal.addEventListener('abort', abort, { once: true });
+  if (signal.aborted) abort();
+  try {
+    const [stdout, stderr, code] = await Promise.all([
+      new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited,
+    ]);
+    if (signal.aborted) throw new Error('provider switch cancelled');
+    if (code !== 0) throw new Error(stderr.trim().split('\n').at(-1) || stdout.trim().split('\n').at(-1) || `provider:set exit ${code}`);
+    reloadUserConfig();
+  } finally {
+    signal.removeEventListener('abort', abort);
+  }
+}
+
+export async function runLocalProviderCommand(
+  raw: string,
+  signal: AbortSignal,
+  onLine: (line: string) => void,
+): Promise<void> {
+  if (signal.aborted) throw new Error('provider lookup cancelled');
+  const [action, providerArg, modelArg] = raw.trim() ? raw.trim().split(/\s+/) : ['list'];
+  const cfg = getUserConfig().llm;
+  const current = cfg.provider;
+  if (action === 'list') {
+    onLine(`현재: ${current}/${cfg.model || PROVIDER_DEFAULT_MODEL[current] || '기본 모델'}`);
+    for (const [name, model] of Object.entries(PROVIDER_DEFAULT_MODEL)) {
+      if (name === 'auto') continue;
+      onLine(`${name === current ? '●' : '○'} ${name} · ${model || '기본 모델'}`);
+    }
+    onLine('모델: /provider models [provider] · /provider refresh [provider]');
+    onLine('전환: /provider use <provider> [model]');
+    return;
+  }
+  if (action === 'models' || action === 'refresh') {
+    const provider = providerArg || current;
+    if (!supportedProvider(provider)) throw new Error(`알 수 없는 provider: ${provider}`);
+    let url: string | undefined;
+    let urlError: string | undefined;
+    try {
+      url = provider === current ? remoteModelsUrl(provider, cfg.baseUrl) : remoteModelsUrl(provider, undefined);
+    } catch {
+      urlError = 'invalid base URL';
+    }
+    const result = await cache.models(provider, url, provider === current ? cfg.apiKey : undefined, signal, action === 'refresh');
+    const note = urlError ?? result.note;
+    onLine(`${provider} 모델 · ${result.source}${note ? ` (조회 실패: ${note})` : ''}`);
+    for (const id of result.ids.slice(0, MODEL_DISPLAY_LIMIT)) onLine(`  ${id}`);
+    if (result.ids.length > MODEL_DISPLAY_LIMIT) onLine(`  외 ${result.ids.length - MODEL_DISPLAY_LIMIT}개`);
+    if (result.ids.length === 0) onLine('  목록 없음 · /provider use <provider> <model>로 직접 지정 가능');
+    return;
+  }
+  if (action === 'use') {
+    if (!providerArg || !supportedProvider(providerArg)) {
+      throw new Error('사용법: /provider use <provider> [model]');
+    }
+    await setProviderViaCli(providerArg, modelArg, signal);
+    const next = getUserConfig().llm;
+    onLine(`다음 턴 provider: ${next.provider}/${next.model || '기본 모델'}`);
+    return;
+  }
+  throw new Error('사용법: /provider · /provider models [provider] · /provider use <provider> [model]');
+}