minimal-agent 0.10.0 → 0.12.0

package/src/ui/App.tsx

@@ -0,0 +1,879 @@
+/**
+ * ============================================================
+ *  src/ui/App.tsx —— TUI 顶层组件
+ * ------------------------------------------------------------
+ *  组合所有 UI 子组件，把 useChat 暴露的状态映射到各组件 props。
+ *  不直接处理键盘输入，那是 InputBox 的事。
+ * ============================================================
+ */
+
+import React, { useDeferredValue } from 'react';
+import { Box, Text, useApp } from 'ink';
+
+import { getWorkingDir } from '../bootstrap/workingDir.js';
+import { ConfigMenu } from '../cli/configMenu.js';
+import { configService } from '../config/configService.js';
+import { listArchives, restoreArchive } from '../context/archive.js';
+import { saveContext } from '../context/persistContext.js';
+import { sessionFileFor } from '../context/sessionPath.js';
+import { workspaceIndexService, type WorkspaceRecord } from '../context/workspaceIndex.js';
+import { memoryService } from '../memory/memoryService.js';
+import {
+  createSession,
+  listSessionSummaries,
+  updateSessionMetadata,
+  type SessionSummary,
+} from '../context/sessionRegistry.js';
+import type { Message, Provider } from '../types.js';
+import type { ModelConfig } from '../config/configFile.js';
+import { activatePlugins } from '../plugins/pluginLifecycle.js';
+import { runAgentTurn } from '../session/runAgentTurn.js';
+import { writeClipboardText } from '../utils/clipboardImage.js';
+import {
+  createCliComputerRun,
+  readRecentComputerUseAudit,
+} from '../cli/computerUse.js';
+import { computerUseService } from '../tools/computeruse/computerUseService.js';
+import { advisorHelpText, parseAdvisorCommand } from './advisorCommand.js';
+import { AskQuestion } from './AskQuestion.js';
+import { InputBox } from './InputBox.js';
+import { LiveArea } from './LiveArea.js';
+import { QueuedMessagesBanner } from './QueuedMessagesBanner.js';
+import { MessageList } from './MessageList.js';
+import { ModelPicker } from './ModelPicker.js';
+import { SessionPicker } from './SessionPicker.js';
+import { WorkspacePicker } from './WorkspacePicker.js';
+import { StatusLine } from './StatusLine.js';
+import { theme } from './theme.js';
+import { parseComputerCommand } from './computerCommand.js';
+import { useChat } from './hooks/useChat.js';
+import { useTerminalSize } from './hooks/useTerminalSize.js';
+
+/**
+ * ANSI escape: 清屏 + 光标归位。
+ *
+ * 注意：项目里仅这两处保留 process.stdout.write 旁路 Ink：
+ *   1) onCompactDone（压缩完）
+ *   2) /new 清空历史后
+ * CLEAR_SCREEN 是**一次性**写入 + 整屏清空的语义，不存在"反复写新内容到 live 区"
+ * 的问题；ESC[2J 清屏后 ink 下次 onRender 会重发完整 lastOutput，lineCount 残留
+ * 也不会留下脏行（写在空白处）。其它"用户看到的非消息内容"必须走 chat.ephemeralLine
+ * 走 Ink 渲染管线，否则会破坏 log-update 计数。
+ */
+const CLEAR_SCREEN = '\x1b[2J\x1b[H';
+
+function formatProviderName(apiFormat: string): string {
+  if (apiFormat === 'anthropic') return 'Anthropic';
+  if (apiFormat === 'openai') return 'OpenAI兼容';
+  return apiFormat;
+}
+
+interface Props {
+  provider: Provider;
+  /** 启动时的历史（含 system prompt）；可能是从 last-context.json 加载来的旧对话。 */
+  initialHistory: Message[];
+}
+
+export function App({ provider, initialHistory }: Props): JSX.Element {
+  // v2 multi-session：持久化路径完全由 useChat 内部管控（按 activeSessionId 选文件）。
+  // App 不再传 onPersist —— 之前 App 端调 saveContext(messages) 会污染 default session。
+  const chat = useChat({
+    provider,
+    initialHistory,
+    onCompactDone: () => process.stdout.write(CLEAR_SCREEN),
+  });
+
+  // 终端尺寸感知：rows → MessageList 决定窄终端是否折叠 reasoning + LiveArea 收敛预览高；
+  //                cols → LiveArea 逐行截断防换行
+  const { rows: terminalRows, cols: terminalCols } = useTerminalSize();
+
+  React.useEffect(() => {
+    const controller = new AbortController();
+    let cleanup: (() => void) | undefined;
+    void activatePlugins({
+      provider,
+      signal: controller.signal,
+      runAgentTurn,
+    }).then((fn) => {
+      if (controller.signal.aborted) {
+        fn();
+        return;
+      }
+      cleanup = fn;
+    }).catch((err) => {
+      console.warn(
+        `[minimal-agent] plugin activation failed: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    });
+    return () => {
+      controller.abort();
+      cleanup?.();
+    };
+  }, [provider]);
+
+  /**
+   * 用 useDeferredValue 把 history 推后到低优先级渲染队列。
+   *
+   * 流式期间 transient state 高频 setState 是高优先级，
+   * 而 MessageList 重算 turn meta + Static reconcile 比较重，可以"等空闲再做"。
+   * React 在繁忙时会让 deferredHistory 保持旧值跳过 MessageList rerender，
+   * 直到 streamingText 稳定下来再 commit 新 history。
+   *
+   * 注意：assistant_message 落定时 history 增长 + streamingText 清空是同一次
+   * runQuery yield —— useDeferredValue 不会无限延迟，最终一定会 catch up，
+   * Static commit 新 message 进 scrollback 不会丢。
+   */
+  const deferredHistory = useDeferredValue(chat.history);
+
+  // /new：内存 reset + 磁盘 clearContext 全部由 chat.clearHistory() 内部完成，await 之后再清屏。
+  // ★ deps 用精细字段 chat.clearHistory，不是整个 chat。
+  //   理由：useChat 返回的 chat 对象每次 useChat 重渲都是新对象字面量引用。
+  //   如果 deps=[chat]，流式期 reasoningPreview/streamingText 每 100ms flush 触发
+  //   useChat rerender → chat 新引用 → handleClear 新引用 → InputBox 收到新 onClear
+  //   prop → 强制重渲 → 整个 live 区被 Ink 重写一次（看起来就是 spinner 每帧打新行）。
+  const handleClear = React.useCallback(async () => {
+    await chat.clearHistory();
+    process.stdout.write(CLEAR_SCREEN);
+  }, [chat.clearHistory]);
+
+  // history ref：在 handleSubmit 闭包里读最新 chat.history，避免每次流式 flush
+  // 重建 callback；同时避免把 chat.history 放进 deps 导致 InputBox 频繁 rerender。
+  const historyRef = React.useRef<Message[]>(chat.history);
+  React.useEffect(() => {
+    historyRef.current = chat.history;
+  }, [chat.history]);
+
+  // /session /sessions /resume（裸命令）打开的选择器数据；非 null 时顶替 InputBox。
+  // 纯本地 UI 态，不需要塞进 useChat——不像 pendingAsk 那样由 askBridge 从外部注入，
+  // 这里完全由 handleSubmit 自己的分支触发/清空。
+  const [sessionPicker, setSessionPicker] = React.useState<SessionSummary[] | null>(null);
+  const [workspacePicker, setWorkspacePicker] = React.useState<WorkspaceRecord[] | null>(null);
+
+  // /config —— 硬编码菜单覆盖层，纯本地 UI 态（与 sessionPicker 同构）。
+  const [configMenuOpen, setConfigMenuOpen] = React.useState(false);
+
+  // /model —— 基座模型选择器；/advisor select —— 顾问模型选择器
+  const [baseModelPicker, setBaseModelPicker] = React.useState<{ models: ModelConfig[]; currentId: string | null } | null>(null);
+  const [advisorModelPicker, setAdvisorModelPicker] = React.useState<{ models: ModelConfig[]; currentId: string | null } | null>(null);
+
+  // 强制刷新计数，用于切换模型后触发 StatusLine 重渲染
+  const [, forceRerender] = React.useState(0);
+
+  const handleSessionSelect = React.useCallback(
+    async (id: string) => {
+      setSessionPicker(null);
+      await chat.switchSession(id);
+      chat.ephemeralLine(`[/session] 已切换到 session "${id}"`);
+    },
+    [chat.switchSession, chat.ephemeralLine],
+  );
+
+  const handleSessionCreate = React.useCallback(
+    async (title: string) => {
+      setSessionPicker(null);
+      const summary = await createSession(getWorkingDir(), title ? { title } : {});
+      await chat.switchSession(summary.id);
+      chat.ephemeralLine(`[/session] 已新建并切换到 session "${summary.id}"（${summary.title}）`);
+    },
+    [chat.switchSession, chat.ephemeralLine],
+  );
+
+  const openWorkspacePicker = React.useCallback(async () => {
+    if (chat.isLoading) return;
+    setSessionPicker(null);
+    setConfigMenuOpen(false);
+    setWorkspacePicker(await workspaceIndexService.list());
+  }, [chat.isLoading]);
+
+  const handleWorkspaceSelect = React.useCallback(async (cwd: string, sessionId: string) => {
+    const switched = await chat.switchWorkspace(cwd, sessionId);
+    setWorkspacePicker(null);
+    if (switched) {
+      chat.ephemeralLine(`[/workspaces] 已切换到 ${cwd} · ${sessionId}`);
+    }
+  }, [chat.switchWorkspace, chat.ephemeralLine]);
+
+  const handleBaseModelSelect = React.useCallback(
+    async (modelId: string | null) => {
+      setBaseModelPicker(null);
+      if (!modelId) return;
+      const snap = await configService.getSnapshot();
+      const model = snap.config?.models.find((m) => m.id === modelId);
+      if (!model) {
+        chat.ephemeralLine(`[/model] 未找到模型 "${modelId}"`);
+        return;
+      }
+      const newProvider = await configService.providerForModel(modelId);
+      if (newProvider) {
+        await updateSessionMetadata(getWorkingDir(), chat.activeSessionId, { modelId });
+        chat.setProvider(newProvider);
+        forceRerender((v) => v + 1);
+        chat.ephemeralLine(`[/model] 当前 Session 已切换为 ${model.displayName || model.model}（${formatProviderName(model.apiFormat)}），下一轮对话生效。`);
+      }
+    },
+    [chat.activeSessionId, chat.setProvider, chat.ephemeralLine],
+  );
+
+  React.useEffect(() => {
+    let cancelled = false;
+    void listSessionSummaries(getWorkingDir()).then(async (sessions) => {
+      const modelId = sessions.find((session) => session.id === chat.activeSessionId)?.modelId;
+      const provider = await configService.providerForModel(modelId ?? null)
+        ?? await configService.providerForModel(null);
+      if (!cancelled && provider) chat.setProvider(provider);
+    }).catch(() => {});
+    return () => { cancelled = true; };
+  }, [chat.activeSessionId, chat.setProvider]);
+
+  const handleAdvisorModelSelect = React.useCallback(
+    async (modelId: string | null) => {
+      setAdvisorModelPicker(null);
+      if (modelId === null) {
+        await configService.savePatch({ advisor: { modelId: null, enabled: false } });
+        chat.ephemeralLine('[/advisor] 已关闭顾问模型。');
+        return;
+      }
+      const snap = await configService.getSnapshot();
+      const model = snap.config?.models.find((m) => m.id === modelId);
+      if (!model) {
+        chat.ephemeralLine(`[/advisor] 未找到模型 "${modelId}"`);
+        return;
+      }
+      await configService.savePatch({ advisor: { modelId, enabled: true } });
+      chat.ephemeralLine(`[/advisor] 已设置顾问模型为 ${model.displayName || model.model}（${formatProviderName(model.apiFormat)}）。`);
+    },
+    [chat.ephemeralLine],
+  );
+
+  /**
+   * v2 slash 命令拦截层。
+   *
+   * InputBox 已经拦截了 /exit /quit /new /compact 不走 onSubmit；
+   * 其他 / 开头命令落到这里。命中命令走 chat.ephemeralLine() 把提示作为
+   * _ephemeral 的 system 消息推进 history → MessageList <Static> 把它 commit
+   * 进 scrollback；不调 chat.submit 避免被 LLM 当成用户输入。
+   *
+   * 旧方案是 process.stdout.write 旁路 Ink，但那样会破坏 ink log-update 的
+   * previousLineCount 计数，下一帧 eraseLines 用过期 N 去清会留下脏行。
+   *
+   * 支持：
+   *   /session /sessions /resume（裸命令）  — 列出当前 cwd 下所有 session，弹选择器
+   *   /session <id> /resume <id>            — 直接切换到指定 session
+   *   /session new [title]                  — 新建 session 并切过去
+   *   /list-archive     — 列归档
+   *   /restore <id>     — 恢复归档为当前 session 历史（覆盖+重读）
+   *   /show <id-suffix> — 打印 tool_call_id 末尾匹配的完整 tool result
+   */
+  const handleSubmit = React.useCallback(
+    async (text: string) => {
+      const trimmed = text.trim();
+      const isBareSessionCmd =
+        trimmed === '/session' || trimmed === '/sessions' || trimmed === '/resume';
+      const sessionArgMatch = /^\/(?:session|resume)\s+(.+)$/.exec(trimmed);
+
+      if (trimmed === '/workspaces') {
+        await openWorkspacePicker();
+        return;
+      }
+
+      if (trimmed === '/copy') {
+        const latest = [...historyRef.current].reverse().find(
+          (message) => message.role === 'assistant' && typeof message.content === 'string' && message.content.length > 0,
+        );
+        if (!latest || latest.role !== 'assistant' || typeof latest.content !== 'string') {
+          chat.ephemeralLine('[/copy] 当前会话还没有可复制的 AI 最终回复。');
+          return;
+        }
+        try {
+          await writeClipboardText(latest.content);
+          chat.ephemeralLine('[/copy] 已复制最近一条 AI 最终回复。');
+        } catch (error) {
+          chat.ephemeralLine(`[/copy] ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+
+      const computerCommand = parseComputerCommand(trimmed);
+      if (computerCommand.matched && !computerCommand.invalid) {
+        const sub = computerCommand.command ?? 'help';
+
+        if (sub === 'help') {
+          const helperAvailable = computerUseService.available();
+          let helperBackend = '未知';
+          let modeLabel = chat.computerUseMode;
+          try {
+            const workspace = await workspaceIndexService
+              .findByPath(getWorkingDir())
+              .catch(() => null);
+            const context = createCliComputerRun({
+              mode: 'observe',
+              surface: 'tui',
+              conversationKey: `workspace:${workspace?.id ?? getWorkingDir()}:session:${chat.activeSessionId}`,
+              userInput: '',
+              allowedFileRoots: [getWorkingDir()],
+              supervised: true,
+            });
+            const resp = await computerUseService.request(context, { action: 'status' });
+            if (resp.ok && resp.state?.backend) {
+              helperBackend = resp.state.backend;
+            }
+          } catch {
+            // 探测失败就保持 "未知"
+          }
+          const modeDesc: Record<string, string> = {
+            disabled: '已关闭（默认）',
+            observe: '观察模式（只看不操作）',
+            interactive: '交互模式（可点击/输入）',
+          };
+          chat.ephemeralLine(
+            [
+              '[/computer] 电脑操控命令帮助',
+              '',
+              `  当前模式：${modeLabel}  —  ${modeDesc[modeLabel] ?? modeLabel}`,
+              `  Helper 状态：${helperAvailable ? '✅ 可用' : '❌ 不可用'}   backend：${helperBackend}`,
+              '',
+              '  可用子命令：',
+              '    /computer help          显示本帮助信息',
+              '    /computer status        显示当前模式与 helper 状态',
+              '    /computer permissions   检查辅助功能与屏幕录制权限',
+              '    /computer observe       进入观察模式（AI 只能看屏幕，不能操作）',
+              '    /computer interactive   进入交互模式（AI 可点击、输入、滚动等）',
+              '    /computer stop          关闭电脑操控，回到普通对话',
+              '    /computer takeover      同 interactive（受监督交互）',
+              '    /computer resume        恢复上一次电脑操控会话',
+              '    /computer cancel        取消当前电脑操控任务',
+              '    /computer apps          列出当前可见应用',
+              '    /computer audit         查看最近 10 条电脑操控审计记录',
+              '',
+              '  使用说明：',
+              '    1. 首次使用请先运行 /computer permissions 检查权限',
+              '    2. 输入 /computer observe 或 /computer interactive 开启',
+              '    3. 开启后，直接描述你想让 AI 做的事即可',
+              '    4. 随时可输入 /computer stop 关闭',
+            ].join('\n'),
+          );
+          return;
+        }
+
+        if (sub === 'interactive' || sub === 'takeover') {
+          chat.setComputerUseMode('interactive');
+          chat.ephemeralLine(
+            '[/computer] ✅ 已切换到交互模式（interactive）。\n' +
+              '  AI 可以观察屏幕并执行鼠标点击、键盘输入、滚动等操作。\n' +
+              '  直接描述你想做的事情即可开始。',
+          );
+          return;
+        }
+
+        if (sub === 'observe') {
+          chat.setComputerUseMode('observe');
+          chat.ephemeralLine(
+            '[/computer] ✅ 已切换到观察模式（observe）。\n' +
+              '  AI 只能观察屏幕画面，不会执行任何操作。\n' +
+              '  直接描述你想让 AI 看什么即可。',
+          );
+          return;
+        }
+
+        if (sub === 'stop') {
+          chat.ephemeralLine(`[/computer] ${await chat.stopComputerUse()}`);
+          return;
+        }
+
+        if (sub === 'audit') {
+          const records = await readRecentComputerUseAudit(10);
+          chat.ephemeralLine(
+            records.length
+              ? `[/computer] 最近审计：\n${records.map((line) => `  ${line}`).join('\n')}`
+              : '[/computer] 暂无本机 Computer Use 审计记录。',
+          );
+          return;
+        }
+
+        if (sub === 'resume') {
+          chat.ephemeralLine(`[/computer] ${await chat.resumeComputerUse()}`);
+          return;
+        }
+
+        if (sub === 'cancel') {
+          chat.ephemeralLine(`[/computer] ${await chat.cancelComputerUse()}`);
+          return;
+        }
+
+        const workspace = await workspaceIndexService
+          .findByPath(getWorkingDir())
+          .catch(() => null);
+        const context = createCliComputerRun({
+          mode: 'observe',
+          surface: 'tui',
+          conversationKey: `workspace:${workspace?.id ?? getWorkingDir()}:session:${chat.activeSessionId}`,
+          userInput: '',
+          allowedFileRoots: [getWorkingDir()],
+          supervised: true,
+        });
+
+        const action =
+          sub === 'apps'
+            ? 'list_apps'
+            : sub === 'permissions'
+              ? 'permissions'
+              : 'status';
+        const response = await computerUseService.request(context, { action });
+        if (!response.ok) {
+          chat.ephemeralLine(
+            `[/computer] ${response.error?.message ?? 'Computer Use 不可用'}${response.error?.hint ? `\n  ${response.error.hint}` : ''}`,
+          );
+          return;
+        }
+        if (sub === 'apps') {
+          const apps = response.state?.windows
+            .map((window) => window.appId)
+            .filter((id, index, all) => all.indexOf(id) === index);
+          chat.ephemeralLine(
+            `[/computer] 可见应用：${apps?.length ? apps.join('、') : response.content ?? '当前没有可见应用'}`,
+          );
+          return;
+        }
+        if (sub === 'permissions') {
+          chat.ephemeralLine(
+            `[/computer] 权限：${response.content ?? '原生服务已连接；详细权限状态未报告。'}`,
+          );
+          return;
+        }
+        // status
+        chat.ephemeralLine(
+          `[/computer] 状态：\n` +
+            `  模式：${chat.computerUseMode}\n` +
+            `  Helper：${computerUseService.available() ? '✅ 可用' : '❌ 不可用'}\n` +
+            `  Backend：${response.state?.backend ?? '未知'}\n` +
+            `  提示：输入 /computer help 查看所有可用命令`,
+        );
+        return;
+      }
+
+      if (computerCommand.matched) {
+        chat.ephemeralLine(
+          '[/computer] 用法：/computer status|apps|permissions|takeover|resume|cancel|stop|audit',
+        );
+        return;
+      }
+
+      if (trimmed === '/memories') {
+        const workspace = await workspaceIndexService.findByPath(getWorkingDir()).catch(() => null);
+        const records = await memoryService.recall('', workspace?.id, 100);
+        if (!records.length) {
+          chat.ephemeralLine('[/memories] 当前没有本机长期记忆。');
+          return;
+        }
+        chat.ephemeralLine(`[/memories] 本机长期记忆：\n${records.map((record) =>
+          `  ${record.id} · ${record.scope === 'personal' ? '个人' : '工作区'} · ${record.subject}: ${record.statement}`).join('\n')}\n使用 /forget-memory <id> 删除一条记忆。`);
+        return;
+      }
+
+      if (trimmed.startsWith('/forget-memory ')) {
+        const id = trimmed.slice('/forget-memory '.length).trim();
+        const workspace = await workspaceIndexService.findByPath(getWorkingDir()).catch(() => null);
+        const records = await memoryService.recall('', workspace?.id, 100);
+        const record = records.find((item) => item.id === id);
+        if (!record) {
+          chat.ephemeralLine(`[/forget-memory] 未找到记忆 ${id}，未做修改。`);
+          return;
+        }
+        await memoryService.forget(record.id, record.scope, record.workspaceId);
+        chat.ephemeralLine(`[/forget-memory] 已删除“${record.subject}”。`);
+        return;
+      }
+
+      if (isBareSessionCmd) {
+        const sessions = await listSessionSummaries(getWorkingDir());
+        setSessionPicker(sessions);
+        return;
+      }
+
+      if (sessionArgMatch) {
+        const arg = sessionArgMatch[1]!.trim();
+        // "new" 必须是独立词（后面跟空格或到此为止），避免 "/session newton" 被误
+        // 拆成 "new" + 标题 "ton"——真实 session id 恰好以 "new" 开头时会撞上。
+        if (arg === 'new' || arg.startsWith('new ')) {
+          const title = arg.slice('new'.length).trim();
+          await handleSessionCreate(title);
+          return;
+        }
+        await handleSessionSelect(arg);
+        return;
+      }
+
+      // /list-archive
+      if (text.trim() === '/list-archive') {
+        const entries = await listArchives();
+        if (entries.length === 0) {
+          chat.ephemeralLine('[/list-archive] 当前 cwd 下无归档。');
+          return;
+        }
+        const lines = entries
+          .slice(0, 30)
+          .map(
+            (e) =>
+              `  ${e.id}  ·  ${e.msgCount} msgs  ·  ${e.firstUserPreview || '(empty)'}`,
+          )
+          .join('\n');
+        const tail =
+          entries.length > 30 ? `\n  ...（共 ${entries.length} 条，仅显示前 30）` : '';
+        chat.ephemeralLine(
+          `[/list-archive] 归档列表（最新优先）：\n${lines}${tail}`,
+        );
+        return;
+      }
+
+      // /restore <id>
+      if (text.startsWith('/restore ')) {
+        const id = text.slice('/restore '.length).trim();
+        if (id.length === 0) {
+          chat.ephemeralLine('[/restore] 用法：/restore <archive-id>');
+          return;
+        }
+        const messages = await restoreArchive(id);
+        if (!messages) {
+          chat.ephemeralLine(`[/restore] 未找到 archive id "${id}"`);
+          return;
+        }
+        // 覆盖当前 active session 文件；强制 reload 让 history 替换
+        const targetFile = sessionFileFor(getWorkingDir(), chat.activeSessionId);
+        await saveContext(messages, targetFile);
+        await chat.switchSession(chat.activeSessionId, { force: true });
+        chat.ephemeralLine(
+          `[/restore] 已恢复 archive ${id} 到 session "${chat.activeSessionId}"（${messages.length} 条消息）`,
+        );
+        return;
+      }
+
+      // /show <id-suffix>
+      if (text.startsWith('/show ')) {
+        const suffix = text.slice('/show '.length).trim();
+        if (suffix.length === 0) {
+          chat.ephemeralLine('[/show] 用法：/show <tool_call_id 末尾 8 字符>');
+          return;
+        }
+        const hit = historyRef.current.find(
+          (m) => m.role === 'tool' && m.tool_call_id.endsWith(suffix),
+        );
+        if (!hit || hit.role !== 'tool') {
+          chat.ephemeralLine(
+            `[/show] 未找到 tool_call_id 末尾匹配 "${suffix}" 的 tool result`,
+          );
+          return;
+        }
+        chat.ephemeralLine(
+          `[tool result · #${hit.tool_call_id.slice(-8)} · 完整 ${hit.content.split('\n').length} 行]\n${hit.content}`,
+        );
+        return;
+      }
+
+      // /plan <目标> —— 便捷别名，等价 /workflow plan（跑 plan 工作流：
+      // 调研 → AskUserQuestion 选择 → 产出 ./PLAN.md）。改写后透传给 pluginRunner。
+      // 目标里的引号剥掉，避免破坏 workflow 参数 tokenizer（"..." 整体当一个位置参数）。
+      if (text.startsWith('/plan ') || text.trim() === '/plan') {
+        const goal = text.slice('/plan'.length).trim().replace(/"/g, '');
+        if (goal.length === 0) {
+          chat.ephemeralLine(
+            '[/plan] 用法：/plan <目标>（= /workflow plan：调研→提问选择→产出 ./PLAN.md）',
+          );
+          return;
+        }
+        void chat.submit(`/workflow plan "${goal}"`);
+        return;
+      }
+
+      // /model —— 列出已配置的基座模型并切换选择器；/model <id> 直接切换
+      const modelArgMatch = /^\/model(?:\s+(.+))?$/.exec(trimmed);
+      if (modelArgMatch) {
+        const arg = modelArgMatch[1]?.trim();
+        const models = await configService.models();
+        const enabledModels = models.filter((m) => m.enabled && m.apiKey);
+        if (enabledModels.length === 0) {
+          chat.ephemeralLine('[/model] 尚未配置任何模型，请先通过 Desktop 设置或 /config 添加模型。');
+          return;
+        }
+        if (arg) {
+          // 直接切换到指定模型（支持精确匹配 id 或模糊匹配 displayName/model）
+          const target = enabledModels.find((m) => m.id === arg || m.model === arg || m.displayName === arg);
+          if (!target) {
+            chat.ephemeralLine(`[/model] 未找到模型 "${arg}"，可用模型：\n${enabledModels.map((m) => `  ${m.id}  ·  ${m.displayName || m.model}`).join('\n')}`);
+            return;
+          }
+          await handleBaseModelSelect(target.id);
+          return;
+        }
+        // 无参数：打开交互选择器
+        const currentSession = (await listSessionSummaries(getWorkingDir())).find((session) => session.id === chat.activeSessionId);
+        const snap = await configService.getSnapshot();
+        setBaseModelPicker({ models: enabledModels, currentId: currentSession?.modelId ?? snap.config?.baseModelId ?? null });
+        return;
+      }
+
+      // /advisor [help|status|on|off|ask|select] —— 与 Desktop 共用统一配置。
+      // 解析在 ui/advisorCommand.ts（纯函数可测）：认不得的子命令一律当咨询内容，
+      // 不再静默掉进 chat.submit() 被当成聊天发给 LLM。
+      const advisorCommand = parseAdvisorCommand(trimmed);
+      if (advisorCommand.matched) {
+        const sub = advisorCommand.command;
+        const note = advisorCommand.note;
+
+        // help 先于配置读取返回：configService.advisor() 每次都做 fresh reload
+        // （跨进程一致性的有意设计），纯文案命令没必要为此读一次盘。
+        if (sub === 'help') {
+          chat.ephemeralLine(advisorHelpText());
+          return;
+        }
+
+        const advisor = await configService.advisor();
+
+        if (sub === 'status') {
+          if (!advisor) {
+            chat.ephemeralLine(
+              '[/advisor] 未配置顾问模型，请在 Desktop 设置 → 模型中配置。',
+            );
+          } else {
+            chat.ephemeralLine(
+              `[/advisor] ${advisor.provider.name}/${advisor.provider.model} · ${advisor.enabled ? '开启' : '关闭'} · ${advisor.mode === 'auto' ? '智能自动' : '仅手动'}。`,
+            );
+          }
+          return;
+        }
+
+        if (sub === 'on') {
+          if (!advisor) {
+            chat.ephemeralLine(
+              '[/advisor] 未配置顾问模型，无法开启。',
+            );
+          } else {
+            await configService.savePatch({ advisor: { enabled: true } });
+            chat.ephemeralLine(`[/advisor] 顾问模型已开启（${advisor.provider.name}/${advisor.provider.model}）。`);
+          }
+          return;
+        }
+
+        if (sub === 'off') {
+          if (advisor) await configService.savePatch({ advisor: { enabled: false } });
+          chat.ephemeralLine('[/advisor] 顾问模型已关闭。');
+          return;
+        }
+
+        if (sub === 'select') {
+          const models = await configService.models();
+          const enabledModels = models.filter((m) => m.enabled && m.apiKey);
+          if (enabledModels.length === 0) {
+            chat.ephemeralLine('[/advisor] 尚未配置任何模型，请先添加模型。');
+            return;
+          }
+          if (note) {
+            // /advisor select <id> 直接指定模型
+            const target = enabledModels.find((m) => m.id === note || m.model === note || m.displayName === note);
+            if (!target) {
+              chat.ephemeralLine(`[/advisor] 未找到模型 "${note}"，可用模型：\n${enabledModels.map((m) => `  ${m.id}  ·  ${m.displayName || m.model}`).join('\n')}`);
+              return;
+            }
+            await configService.savePatch({ advisor: { modelId: target.id, enabled: true } });
+            chat.ephemeralLine(`[/advisor] 已设置顾问模型为 ${target.displayName || target.model}（${formatProviderName(target.apiFormat)}）。`);
+          } else {
+            // 无参数：打开交互选择器（含"关闭"选项）
+            const snap = await configService.getSnapshot();
+            setAdvisorModelPicker({ models: enabledModels, currentId: snap.config?.advisor?.modelId ?? null });
+          }
+          return;
+        }
+
+        // sub === 'ask'：立即请求顾问意见。走 chat.runManualAdvisor 而不是裸 runAdvisor——
+        // 它负责过程显示（LiveArea 进度行）与 ESC 中断，否则最长 180 秒 TUI 全静默。
+        if (!advisor) {
+          chat.ephemeralLine('[/advisor] 未配置顾问模型：先用 /advisor select 选一个，或在 Desktop 设置 → 模型中配置。');
+          return;
+        }
+        if (!advisor.enabled) {
+          chat.ephemeralLine('[/advisor] 顾问模型当前已关闭；/advisor on 开启后再咨询。');
+          return;
+        }
+        const result = await chat.runManualAdvisor(note);
+        chat.ephemeralLine(
+          result.ok
+            ? `[/advisor] ${advisor.provider.model} 的意见：\n${result.content}`
+            : `[/advisor] ${result.error}`,
+        );
+        return;
+      }
+
+      // /config —— 硬编码配置菜单（取代旧版 LLM 驱动的 skills/config/SKILL.md）。
+      // 精确匹配，不接受多余文字（与 /advisor 等硬拦截命令同规则）。仅交互式 TUI
+      // 支持；-p 非交互模式没有 Ink 树可渲染菜单，此命令在那里就是普通聊天文本。
+      if (trimmed === '/config') {
+        setConfigMenuOpen(true);
+        return;
+      }
+
+      // 非命令 → 走正常 LLM 流程
+      void chat.submit(text);
+    },
+    // ★ 精细 deps：用 chat 的具体方法/字段，**不是**整个 chat 对象。
+    //   useChat 每次重渲都返回新的 chat 对象字面量；用 [chat] 会让 handleSubmit
+    //   随每次流式 flush（100ms）重建一次 → InputBox 收到新 onSubmit → 强制重渲
+    //   → Ink 重写 live 区 → spinner 看起来每帧打新行。
+    [
+      chat.ephemeralLine,
+      chat.switchSession,
+      chat.activeSessionId,
+      chat.submit,
+      chat.runManualAdvisor,
+      chat.setProvider,
+      chat.computerUseMode,
+      chat.setComputerUseMode,
+      chat.stopComputerUse,
+      chat.resumeComputerUse,
+      chat.cancelComputerUse,
+      handleSessionSelect,
+      handleSessionCreate,
+      openWorkspacePicker,
+      handleBaseModelSelect,
+      handleAdvisorModelSelect,
+    ],
+  );
+
+  // banner 改作为 Static items[0] 走 MessageList。原因：Ink 5 的 Static 约定
+  // 它必须是兄弟节点中第一个，否则 above-sibling 会跟 Static commit 一起被重打
+  // 到 stdout（实测看到 banner 反复打印 N 次）。
+  // 使用 getCurrentProvider() 获取最新 provider（/model 切换后实时显示）
+  const currentProvider = chat.getCurrentProvider();
+  const bannerText = `minimal-agent  · ${currentProvider.name}/${currentProvider.model} · /model 切模型 · /computer 控制桌面 · /copy 复制回复 · /paste-image 添加图片 · /new 清空 · /compact 压缩 · Ctrl+C 中断`;
+
+  return (
+    <Box flexDirection="column">
+      {/* 消息历史 + banner（banner 作为 Static items[0] 进 scrollback，避免重打） */}
+      {/* deferredHistory：流式期间让 MessageList 重算"等空闲再做"，避免高频抢渲染 */}
+      <MessageList
+        history={deferredHistory}
+        compactGeneration={chat.compactGeneration}
+        bannerText={bannerText}
+        terminalRows={terminalRows}
+      />
+
+      {/* ★ live 区整体钳到 cols-1：保证下面任何一行都不触及终端最后一列。
+          根因（已用 node_modules/ink/build/log-update.js 源码确认）：stock ink 用
+          `previousLineCount = output.split('\n').length` 决定下一帧 eraseLines(N)，
+          完全不补偿"满宽行被终端自动折行"。满宽行（如 InputBox 的 ╭──╮ 边框）在
+          Windows 下光标到末列、遇 \n 会双重换行 → 实际物理行 > \n 数 → eraseLines
+          擦少 → 它上方的 live 行（reasoning）每帧 strand 进 scrollback 刷屏。
+          留出最后一列即可从源头规避。MessageList(<Static>) 是 write-once、不参与每帧
+          log-update，无需约束（满宽 committed 行至多留一次性空行，不会持续刷屏）。 */}
+      <Box flexDirection="column" width={Math.max(1, terminalCols - 1)}>
+        {/* LiveArea：Static 下方唯一 live 区。有界多行（状态行 + 内容区）。
+            streamingText 让答案在 live 区流式逐行出现（落定后由 <Static> 接管完整呈现）；
+            terminalRows 用于 contentMaxLines 自适应（满足 INV-2：live 区总高 < 终端行数）。 */}
+        <LiveArea
+          progressStage={chat.progressStage}
+          reasoningPreview={chat.reasoningPreview}
+          streamingText={chat.streamingText}
+          runningTools={chat.runningTools}
+          pluginProgress={chat.pluginProgress}
+          transientError={chat.transientError}
+          terminalCols={terminalCols}
+          terminalRows={terminalRows}
+        />
+
+        {/* 排队消息列表（AI工作中用户插话时显示） */}
+        <QueuedMessagesBanner items={chat.queuedItems} />
+
+        {chat.pendingComputerIntervention && (
+          <Box flexDirection="column" borderStyle="round" borderColor={theme.warning} paddingX={1} marginBottom={1}>
+            <Text color={theme.warning}>需要人工操作：{chat.pendingComputerIntervention.sanitizedSummary}</Text>
+            <Text dimColor>
+              请直接在目标应用中处理；敏感内容不会进入终端或模型。完成后输入 /computer resume，取消输入 /computer cancel。
+            </Text>
+          </Box>
+        )}
+
+        {/* 错误提示 */}
+        {chat.error && (
+          <Box marginBottom={1}>
+            <Text color={theme.error}>⚠ {chat.error}</Text>
+          </Box>
+        )}
+
+        {/* 中断提示 */}
+        {chat.interrupted && (
+          <Box marginBottom={1}>
+            <Text color={theme.warning}>⚡ 操作被用户中断，等待新的任务输入...</Text>
+            <Text dimColor>  调整上一次计划：直接说调整内容 / 重新跑 /plan 目标 / 新任务直接说</Text>
+          </Box>
+        )}
+
+        {/* 输入区：/config 菜单覆盖层、/session /sessions /resume 打开的选择器、
+            /model /advisor select 打开的模型选择器、AskUserQuestion 待答、
+            或普通 InputBox——都用 useInput，同时挂会抢键 → 必须互斥渲染。
+            选完/取消/关闭后各自状态归位，InputBox 自动回归。 */}
+        {configMenuOpen ? (
+          <ConfigMenu mode="reconfigure" onDone={() => setConfigMenuOpen(false)} />
+        ) : baseModelPicker ? (
+          <ModelPicker
+            models={baseModelPicker.models}
+            currentModelId={baseModelPicker.currentId}
+            title="选择基座模型"
+            onSelect={handleBaseModelSelect}
+            onCancel={() => setBaseModelPicker(null)}
+          />
+        ) : advisorModelPicker ? (
+          <ModelPicker
+            models={advisorModelPicker.models}
+            currentModelId={advisorModelPicker.currentId}
+            title="选择顾问模型"
+            nullOptionLabel="○ 不使用顾问模型"
+            onSelect={handleAdvisorModelSelect}
+            onCancel={() => setAdvisorModelPicker(null)}
+          />
+        ) : workspacePicker ? (
+          <WorkspacePicker
+            workspaces={workspacePicker}
+            currentPath={getWorkingDir()}
+            currentSessionId={chat.activeSessionId}
+            onSelect={handleWorkspaceSelect}
+            onCancel={() => setWorkspacePicker(null)}
+          />
+        ) : sessionPicker ? (
+          <SessionPicker
+            sessions={sessionPicker}
+            activeSessionId={chat.activeSessionId}
+            onSelect={handleSessionSelect}
+            onCreate={handleSessionCreate}
+            onCancel={() => setSessionPicker(null)}
+          />
+        ) : chat.pendingAsk ? (
+          <AskQuestion
+            questions={chat.pendingAsk}
+            source={chat.pendingAskSource}
+            queuedCount={chat.pendingAskQueueCount}
+            onAnswer={chat.answerAsk}
+            onCancel={chat.cancelAsk}
+          />
+        ) : (
+          /* handleSubmit 包装做 slash 命令拦截，非命令透传 chat.submit */
+          <InputBox
+            onSubmit={handleSubmit}
+            disabled={chat.isLoading && !chat.pendingComputerIntervention}
+            onAbort={chat.abort}
+            onClear={handleClear}
+            onCompact={chat.compactNow}
+            onWorkspaces={openWorkspacePicker}
+          />
+        )}
+
+        {/* 底部状态栏 */}
+        <StatusLine
+          provider={currentProvider}
+          history={chat.history}
+          pluginProgress={chat.pluginProgress}
+          contextUsage={chat.contextUsage}
+        />
+      </Box>
+    </Box>
+  );
+}