xshat-lite 1.0.0

package/src/index.mjs

@@ -0,0 +1,2865 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'process';
+import { resolve } from 'node:path';
+import { confirm, input as promptInput, select } from '@inquirer/prompts';
+import AgentExecutor from './modules/agent-executor.mjs';
+import browserManager from './modules/browser.mjs';
+import ConversationAgent from './modules/agent.mjs';
+import { buildQuickStartDoc } from './modules/docs.mjs';
+import sessionManager from './modules/session.mjs';
+import taskStore from './modules/task-store.mjs';
+import TaskRunner from './modules/task-runner.mjs';
+import logger from './modules/logger.mjs';
+import ui from './modules/ui.mjs';
+import { showSettingsMenu } from './modules/settings-menu.mjs';
+import {
+  browseSessions,
+  resumeLatestSession
+} from './modules/session-browser.mjs';
+import {
+  buildNavigationRecoveryRows,
+  isRecoverableNavigationError
+} from './modules/navigation-recovery.mjs';
+import {
+  buildAgentPrimer,
+  buildHistoryPrimer,
+  wrapAgentTurnMessage
+} from './modules/chat-helpers.mjs';
+import { runAgentLoop } from './modules/agent-loop.mjs';
+import {
+  getEnabledAgentRoster,
+  getAgentRoleLabel,
+  inferAgentRoleFromCommand
+} from './modules/multi-agent.mjs';
+import {
+  detectLocalIntent,
+  formatLocalIntentResult
+} from './modules/local-intent-router.mjs';
+import {
+  createProviderChatManager,
+  getProviderSessionUrl,
+  isApiProvider,
+  requiresBrowserForProvider
+} from './modules/provider-runtime.mjs';
+import { getFallbackProvider } from './modules/provider-pool.mjs';
+import { getAgentSystemPrompt } from './modules/response-parser.mjs';
+import {
+  isInterruptedTurnResponse,
+  normalizeResponseEnvelope
+} from './modules/response-pipeline.mjs';
+import { runRuntimeMaintenance } from './modules/runtime-maintenance.mjs';
+import { waitForKeypress } from './utils/key-input.mjs';
+import config, {
+  getProvider,
+  listProviders
+} from './utils/config.mjs';
+
+let chatManager = null;
+let conversationAgent = null;
+let agentExecutor = null;
+let isShuttingDown = false;
+let hasActiveSession = false;
+let agentMode = Boolean(config.agent?.enabled);
+let agentPrimedSessionId = null;
+let taskRunner = null;
+let chatChromeDirty = true;
+let lastSubmittedQuestion = '';
+let lastAgentOrReplySummary = '';
+const inputHistory = [];
+
+function getSessionCompressionOptions() {
+  return {
+    compressThreshold: Number(config.session?.compressThreshold) || 12,
+    keepRecentMessages: Number(config.session?.keepRecentMessages) || 6,
+    maxSummaryChars: Number(config.session?.maxSummaryChars) || 1200,
+    maxMessageChars: Number(config.session?.maxMessageChars) || 160
+  };
+}
+
+function isMultiAgentEnabled() {
+  return Boolean(config.agent?.enabled) && Boolean(config.agent?.multiAgent);
+}
+
+function getMultiAgentRoster() {
+  return getEnabledAgentRoster({
+    multiAgentEnabled: isMultiAgentEnabled(),
+    allowShell: Boolean(config.agent?.allowShell),
+    allowFileWrite: Boolean(config.agent?.allowFileWrite)
+  });
+}
+
+function resolveAgentRole(command = null, explicitRole = null) {
+  return explicitRole || inferAgentRoleFromCommand(command) || 'orchestrator';
+}
+
+function resolveAgentLabel(command = null, explicitRole = null) {
+  return getAgentRoleLabel(resolveAgentRole(command, explicitRole));
+}
+
+function buildAgentRuntimeState({
+  forceEnabled = null,
+  forceAutoExecute = null
+} = {}) {
+  const enabled = forceEnabled ?? agentMode;
+  const autoExecuteCommands =
+    forceAutoExecute ?? Boolean(config.agent?.autoExecuteCommands);
+
+  return {
+    enabled,
+    autoExecuteCommands,
+    allowShell: Boolean(config.agent?.allowShell),
+    allowFileWrite: Boolean(config.agent?.allowFileWrite),
+    longRunning: Boolean(config.agent?.longRunning),
+    multiAgent: isMultiAgentEnabled(),
+    roster: getMultiAgentRoster().map((item) => ({
+      id: item.id,
+      label: item.label,
+      description: item.description
+    }))
+  };
+}
+
+async function setupGracefulShutdown() {
+  const shutdown = async (signal, silent = false) => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
+    if (!silent) {
+      ui.clear();
+      ui.printSuccess('再见！');
+    }
+
+    if (chatManager) {
+      chatManager.cleanup();
+    }
+
+    await browserManager.close();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT', true));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+  process.on('uncaughtException', async (error) => {
+    if (error.name === 'AbortError') {
+      await shutdown('SIGINT', true);
+      return;
+    }
+    ui.printError(`未捕获的异常: ${error.message}`);
+    console.error(error.stack);
+    await shutdown('uncaughtException');
+  });
+
+  process.on('unhandledRejection', async (reason, promise) => {
+    ui.printError(`未处理的 Promise 拒绝: ${reason}`);
+    console.error('Promise:', promise);
+    await shutdown('unhandledRejection');
+  });
+
+  return shutdown;
+}
+
+async function askInput(prompt, allowEmpty = false) {
+  const rl = readline.createInterface({ input, output });
+  let answer = '';
+
+  while (!allowEmpty && !answer.trim()) {
+    answer = await rl.question(prompt);
+  }
+
+  if (allowEmpty && !answer) {
+    answer = await rl.question(prompt);
+  }
+
+  rl.close();
+  return answer.trim();
+}
+
+async function showStartupMenu() {
+  let selectedIndex = 0;
+
+  while (true) {
+    const choices = [];
+    if (hasActiveSession) {
+      choices.push({
+        label: '继续聊天  回到当前会话',
+        value: 'c'
+      });
+    }
+    choices.push(
+      { label: '新建聊天  开始全新对话', value: '1' },
+      { label: '历史会话  查找并恢复之前的对话', value: '2' },
+      { label: `系统设置  默认提供方: ${getProvider().name}`, value: 's' },
+      { label: '文档  查看简要使用说明', value: 'd' },
+      { label: '退出', value: 'q' }
+    );
+
+    selectedIndex = Math.min(Math.max(selectedIndex, 0), choices.length - 1);
+
+    ui.clear();
+    ui.printTitle('XShat - AI 聊天工具');
+    ui.printNewline();
+    ui.printMuted(`默认提供方: ${getProvider().name} · 默认模式: ${config.agent?.enabled ? 'Agent' : 'Chat'} · 浏览器: ${config.browser?.headless ? 'Headless' : 'Visible'}`);
+    if (hasActiveSession && sessionManager.current?.title) {
+      ui.printMuted(`当前会话: ${sessionManager.current.title}`);
+    }
+    ui.printInputHints([
+      'W/S 或 ↑↓ 选择',
+      'Enter 确认',
+      'D 文档',
+      'S 设置',
+      'Q/Esc 退出'
+    ]);
+    ui.printNewline();
+    ui.printSelectableList('主菜单', choices.map((item) => item.label), selectedIndex);
+    ui.printNewline();
+
+    const key = await waitForKeypress();
+
+    if (key === 'up' || key === 'w') {
+      selectedIndex = Math.max(0, selectedIndex - 1);
+      continue;
+    }
+
+    if (key === 'down' || key === 's') {
+      selectedIndex = Math.min(choices.length - 1, selectedIndex + 1);
+      continue;
+    }
+
+    if (key === 'enter') {
+      return choices[selectedIndex].value;
+    }
+
+    if (key === 'd') {
+      return 'd';
+    }
+
+    if (key === 'q' || key === 'escape') {
+      return 'q';
+    }
+  }
+}
+
+function showQuickDoc() {
+  ui.clearPinnedHeader();
+  ui.exitWorkspace();
+  ui.clear();
+  ui.printTitle('XShat 文档');
+  ui.printNewline();
+  ui.printMarkdown(buildQuickStartDoc());
+  ui.printNewline();
+}
+
+async function resumeSession(sessionMeta) {
+  ui.clearPinnedHeader();
+  ui.exitWorkspace();
+  const session = await sessionManager.resume(sessionMeta.id);
+  if (!session || !session.url) {
+    ui.printError('无法恢复该会话（缺少 URL）');
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    return false;
+  }
+
+  const provider = getProvider(session.provider);
+
+  ui.clear();
+  ui.printTitle(`恢复会话: ${session.title}`);
+  ui.printNewline();
+  ui.printInfo(`AI 提供方: ${provider.name}`);
+  ui.printInfo(`消息数量: ${session.messages.length} 条`);
+  ui.printNewline();
+  if (requiresBrowserForProvider(provider)) {
+    ui.printWarning('正在加载会话...');
+
+    const opened = await navigateWithRecovery(session.url, {
+      title: '恢复会话失败'
+    });
+    if (!opened) {
+      ui.printMuted('已取消恢复会话');
+      await new Promise((resolve) => setTimeout(resolve, 800));
+      return false;
+    }
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+
+  rebuildChatManager(provider);
+
+  if (session.messages.length > 0) {
+    ui.printWarning('正在恢复上下文...');
+    const primer = buildHistoryPrimer(
+      session.messages,
+      getSessionCompressionOptions()
+    );
+
+    const success = await chatManager.sendMessage(primer);
+    if (success) {
+      await new Promise(resolve => setTimeout(resolve, 800));
+      try {
+        await chatManager.waitForResponse(() => {});
+      } catch {
+        // 静默消费回复失败也继续
+      }
+    }
+  }
+
+  ui.clear();
+  ui.printTitle(`${session.title}`);
+  ui.printRenderedHistory(session.messages, {
+    renderMessage: (message) => {
+      if (message.role !== 'assistant') {
+        return null;
+      }
+
+      const envelope = normalizeResponseEnvelope(message.content, {
+        agentMode: false
+      });
+      const presentation = getHistoryEnvelopePresentation(envelope);
+
+      return {
+        title: presentation.title,
+        badges: presentation.badges,
+        text:
+          envelope.displayText ||
+          envelope.consoleText ||
+          envelope.text ||
+          (envelope.command?.name ? `动作: ${envelope.command.name}` : ''),
+        renderAs: envelope.renderAs
+      };
+    }
+  });
+  ui.printNewline();
+  ui.printSuccess('会话已恢复，可以继续对话');
+  printChatOnboarding();
+  ui.printNewline();
+  chatChromeDirty = true;
+
+  return true;
+}
+
+async function startNewChat(provider) {
+  ui.clearPinnedHeader();
+  ui.exitWorkspace();
+  sessionManager.create(provider);
+
+  ui.clear();
+  ui.printTitle(`新建会话 - ${provider.name}`);
+  ui.printNewline();
+  if (requiresBrowserForProvider(provider)) {
+    ui.printWarning('正在初始化浏览器...');
+
+    const opened = await navigateWithRecovery(provider.url, {
+      title: `连接 ${provider.name} 失败`
+    });
+    if (!opened) {
+      ui.printMuted('已取消新建会话');
+      await new Promise((resolve) => setTimeout(resolve, 800));
+      return false;
+    }
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  } else {
+    sessionManager.setUrl(`api://${provider.id}`);
+  }
+
+  rebuildChatManager(provider);
+
+  ui.clear();
+  ui.printSuccess(`${provider.name} 已准备好！`);
+  printChatOnboarding();
+  ui.printNewline();
+  chatChromeDirty = true;
+  return true;
+}
+
+async function askQuestion() {
+  if (chatChromeDirty) {
+    const hints = [
+      '/cmd 面板',
+      '/paste 多行',
+      '/menu 主菜单'
+    ];
+    const renderedPinned = await printRuntimeStatus({ pinned: true, hints });
+    if (!renderedPinned) {
+      ui.clearPinnedHeader();
+      await printRuntimeStatus();
+      ui.printInputHints(hints);
+    }
+    chatChromeDirty = false;
+  }
+
+  const rl = readline.createInterface({ input, output });
+  let question = '';
+
+  while (!question.trim()) {
+    question = await rl.question(ui.printPrompt());
+  }
+
+  rl.close();
+  return question.trim();
+}
+
+async function askMultiline(promptText = '请输入多行内容，输入 /end 结束:') {
+  const rl = readline.createInterface({ input, output });
+  const lines = [];
+
+  ui.printNewline();
+  ui.printInfo(promptText);
+  ui.printInfo('粘贴内容后请单独输入 /end 结束，输入 /cancel 取消。');
+  ui.printPromptLine();
+
+  while (true) {
+    const line = await rl.question('');
+    if (line.trim() === '/end') {
+      break;
+    }
+    if (line.trim() === '/cancel') {
+      rl.close();
+      return '';
+    }
+    lines.push(line);
+  }
+
+  rl.close();
+  return lines.join('\n').trim();
+}
+
+function getTaskModeLabel(mode = 'once') {
+  return {
+    once: '单次执行',
+    loop: '持续循环',
+    watch: '轮询监控',
+    interval: '定时间隔'
+  }[mode] || mode;
+}
+
+function buildTaskTitleFromGoal(goal = '') {
+  const firstLine = String(goal ?? '')
+    .split('\n')
+    .map((line) => line.trim())
+    .find(Boolean);
+  return (firstLine || '未命名任务').slice(0, 60);
+}
+
+async function collectTaskGoal() {
+  const initial = (await promptInput({
+    message: '任务目标（直接回车可切换到多行模式）'
+  })).trim();
+
+  if (initial) {
+    const useMultiline = await confirm({
+      message: '要继续补充为多行任务描述吗？',
+      default: false
+    });
+    if (!useMultiline) {
+      return initial;
+    }
+  }
+
+  return askMultiline('输入任务目标，单独输入 /end 结束');
+}
+
+async function runTaskCreationWizard(runner) {
+  ui.clear();
+  ui.printTitle('新建任务');
+  ui.printNewline();
+  ui.printInfo('先输入任务目标；短任务可直接一行创建，复杂任务可切到多行。');
+  ui.printNewline();
+
+  const goal = await collectTaskGoal();
+  if (!goal) {
+    ui.printMuted('已取消');
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    return null;
+  }
+
+  const mode = await select({
+    message: '选择任务模式',
+    choices: [
+      { name: '单次执行  创建后按需手动启动', value: 'once' },
+      { name: '持续循环  适合长期反复执行', value: 'loop' },
+      { name: '轮询监控  固定频率检查变化', value: 'watch' },
+      { name: '定时间隔  每隔一段时间运行', value: 'interval' }
+    ],
+    default: 'once'
+  });
+
+  let intervalMs = null;
+  if (mode === 'interval') {
+    const intervalAnswer = (await promptInput({
+      message: '输入间隔毫秒数',
+      default: '30000'
+    })).trim();
+    intervalMs = Math.max(1000, Number(intervalAnswer) || 30000);
+  } else if (mode === 'watch') {
+    const intervalAnswer = (await promptInput({
+      message: '输入监控间隔毫秒数',
+      default: '10000'
+    })).trim();
+    intervalMs = Math.max(1000, Number(intervalAnswer) || 10000);
+  }
+
+  const retryAnswer = (await promptInput({
+    message: '失败自动重试次数',
+    default: '1'
+  })).trim();
+  const retryLimit = retryAnswer ? Math.max(0, Number(retryAnswer) || 0) : 1;
+  const runNow = await confirm({
+    message: '创建后立即执行吗？',
+    default: mode === 'once'
+  });
+
+  const summaryRows = [
+    { label: '标题', value: buildTaskTitleFromGoal(goal) },
+    { label: '模式', value: getTaskModeLabel(mode) },
+    intervalMs ? { label: '间隔', value: `${intervalMs} ms` } : null,
+    { label: '重试', value: `${retryLimit} 次` },
+    { label: '提供方', value: getProvider().name },
+    { label: '立即执行', value: runNow ? '是' : '否' },
+    { label: '目标', value: goal }
+  ].filter(Boolean);
+
+  ui.clear();
+  ui.printTitle('确认新任务');
+  ui.printNewline();
+  ui.printKeyValueTable('任务配置', summaryRows);
+  ui.printNewline();
+
+  const approved = await confirm({
+    message: '确认创建这个任务吗？',
+    default: true
+  });
+  if (!approved) {
+    ui.printMuted('已取消');
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    return null;
+  }
+
+  const task = await runner.createTask({
+    title: buildTaskTitleFromGoal(goal),
+    goal,
+    provider: getProvider().id,
+    mode,
+    intervalMs,
+    retryLimit,
+    retryDelayMs: intervalMs
+  });
+
+  if (runNow) {
+    await runner.queueTask(task.id);
+    runner.runTask(task.id).catch(() => {});
+  }
+
+  ui.printSuccess(`任务已创建: ${task.title}`);
+  ui.printMuted(
+    `${getProvider().name} · ${getTaskModeLabel(mode)}${runNow ? ' · 已开始执行' : ''}`
+  );
+  await new Promise((resolve) => setTimeout(resolve, 700));
+  return {
+    task,
+    runNow
+  };
+}
+
+function rebuildChatManager(provider) {
+  chatManager = createProviderChatManager(provider, browserManager);
+  if (typeof browserManager.setChatManager === 'function') {
+    browserManager.setChatManager(chatManager);
+  }
+  if (!conversationAgent) {
+    conversationAgent = new ConversationAgent({
+      browserManager,
+      ui,
+      prompt: (prompt) => askInput(prompt, false)
+    });
+  }
+  if (!agentExecutor) {
+    agentExecutor = new AgentExecutor({
+      browserManager,
+      ui,
+      prompt: (prompt) => askInput(prompt, false),
+      sendMessage: (content) => sendAgentCommandMessage(content),
+      getAppState: () => ({
+        provider: chatManager?.provider?.id || null,
+        sessionId: sessionManager.current?.id || null,
+        sessionTitle: sessionManager.current?.title || null,
+        messageCount: sessionManager.current?.messages?.length || 0,
+        chatUrl: browserManager.getCurrentUrl(),
+        agentUrl: browserManager.getCurrentUrlFor?.('agent') || null,
+        browser: {
+          chatReady: browserManager.isChannelReady?.('chat') || false,
+          chatState: browserManager.getChannelState?.('chat') || null,
+          agentReady: browserManager.isChannelReady?.('agent') || false,
+          agentState: browserManager.getChannelState?.('agent') || null,
+          shareAuthState: Boolean(config.browser?.shareAuthState)
+        },
+        agent: {
+          ...buildAgentRuntimeState()
+        },
+        workspaceRoot: resolve(process.cwd())
+      }),
+      workspaceRoot: resolve(process.cwd()),
+      allowShell: Boolean(config.agent?.allowShell),
+      allowFileWrite: Boolean(config.agent?.allowFileWrite),
+      autoExecuteCommands: Boolean(config.agent?.autoExecuteCommands)
+    });
+  }
+}
+
+function ensureTaskRunner() {
+  if (taskRunner) {
+    return taskRunner;
+  }
+
+  taskRunner = new TaskRunner({
+    taskStore,
+    browserManager,
+    logger,
+    getProvider,
+    createChatManager: (provider) => createProviderChatManager(provider, browserManager),
+    createAgentExecutor: () =>
+      new AgentExecutor({
+        browserManager,
+        ui,
+        prompt: (prompt) => askInput(prompt, false),
+        sendMessage: (content) => sendAgentCommandMessage(content),
+        getAppState: () => ({
+          provider: chatManager?.provider?.id || null,
+          sessionId: sessionManager.current?.id || null,
+          sessionTitle: sessionManager.current?.title || null,
+          messageCount: sessionManager.current?.messages?.length || 0,
+          chatUrl: browserManager.getCurrentUrl(),
+          agentUrl: browserManager.getCurrentUrlFor?.('agent') || null,
+          browser: {
+            chatReady: browserManager.isChannelReady?.('chat') || false,
+            chatState: browserManager.getChannelState?.('chat') || null,
+            agentReady: browserManager.isChannelReady?.('agent') || false,
+            agentState: browserManager.getChannelState?.('agent') || null,
+            shareAuthState: Boolean(config.browser?.shareAuthState)
+          },
+          agent: {
+            ...buildAgentRuntimeState({
+              forceEnabled: true,
+              forceAutoExecute: true
+            })
+          },
+          workspaceRoot: resolve(process.cwd())
+        }),
+        workspaceRoot: resolve(process.cwd()),
+        allowShell: Boolean(config.agent?.allowShell),
+        allowFileWrite: Boolean(config.agent?.allowFileWrite),
+        autoExecuteCommands: true
+      }),
+    sessionCompressionOptions: getSessionCompressionOptions
+  });
+
+  return taskRunner;
+}
+
+function resetAgentPrimer() {
+  agentPrimedSessionId = null;
+}
+
+function printAgentHelp() {
+  ui.printNewline();
+  ui.printInfo('Agent 模式已开启:');
+  ui.printInfo('- 会要求网页模型尽量只返回 JSON');
+  ui.printInfo('- 能解析 reply/action/handoff/error 四种结构化结果');
+  if (isMultiAgentEnabled()) {
+    ui.printInfo('- 已启用多 Agent 协作，主控会按网页 / Shell / 文件 / 人工接管分工');
+  }
+  ui.printInfo('- 解析失败时会自动退回普通文本');
+  ui.printInfo('- 输入 /paste 可粘贴多行内容');
+  ui.printInfo('- 输入 /help 可查看聊天内命令');
+  ui.printNewline();
+}
+
+function printChatOnboarding() {
+  const provider = chatManager?.provider?.name || getProvider().name;
+  const mode = agentMode ? 'Agent' : 'Chat';
+  ui.printMuted(`当前: ${provider} · ${mode}`);
+  ui.printMuted('快捷命令: /cmd  /paste  /memory  /menu  /config');
+  chatChromeDirty = true;
+}
+
+function getWorkspaceSidebarSections() {
+  const memory = sessionManager.current?.memory || {};
+  const pinned = Array.isArray(memory.pinned) ? memory.pinned.slice(0, 5) : [];
+  const plan = Array.isArray(memory.plan) ? memory.plan.slice(0, 5) : [];
+
+  return {
+    leftSections: [
+      {
+        title: 'Session',
+        rows: [
+          { label: 'Provider', value: chatManager?.provider?.name || getProvider().name },
+          { label: 'Mode', value: agentMode ? 'Agent' : 'Chat' },
+          { label: 'Title', value: sessionManager.current?.title || '(无标题)' },
+          { label: 'Msgs', value: String(sessionManager.current?.messages?.length || 0) }
+        ]
+      },
+      {
+        title: 'Quick',
+        lines: [
+          '/cmd  命令面板',
+          '/memory  会话记忆',
+          '/retry-last  重试上一条',
+          '/switch-provider  切换提供方',
+          '/menu  返回主菜单'
+        ]
+      }
+    ],
+    rightSections: [
+      {
+        title: 'Memory',
+        rows: [
+          { label: 'Summary', value: memory.summary || '(空)' },
+          { label: 'Last User', value: memory.lastUserMessage || '(空)' },
+          { label: 'Last AI', value: memory.lastAssistantMessage || '(空)' }
+        ]
+      },
+      ...(pinned.length
+        ? [{
+          title: 'Pinned',
+          lines: pinned.map((item, index) => `${index + 1}. ${item?.text || ''}`)
+        }]
+        : []),
+      ...(plan.length
+        ? [{
+          title: 'Plan',
+          lines: plan.map((item, index) => `${index + 1}. ${item}`)
+        }]
+        : []),
+      ...(lastAgentOrReplySummary
+        ? [{
+          title: 'Last Action',
+          lines: [lastAgentOrReplySummary]
+        }]
+        : [])
+    ]
+  };
+}
+
+async function showRuntimeOverview() {
+  ui.clearPinnedHeader();
+  ui.exitWorkspace();
+  const taskSnapshot = await ensureTaskRunner().getRuntimeSnapshot();
+  const appState = {
+    provider: chatManager?.provider?.name || getProvider().name,
+    providerId: chatManager?.provider?.id || getProvider().id,
+    sessionTitle: sessionManager.current?.title || '(无会话)',
+    sessionMessages: sessionManager.current?.messages?.length || 0,
+    browserMode: config.browser?.headless ? 'Headless' : 'Visible',
+    visibleAllowed: config.browser?.allowVisibleBrowser !== false,
+    chatUrl: browserManager.getCurrentUrl() || '(无)',
+    agentUrl: browserManager.getCurrentUrlFor?.('agent') || '(无)',
+    channel:
+      browserManager.isChannelReady?.('agent')
+        ? 'agent'
+        : browserManager.isChannelReady?.('chat')
+          ? 'chat'
+          : '-',
+    agentMode: agentMode ? '开启' : '关闭',
+    autoExecute: config.agent?.autoExecuteCommands ? '开启' : '关闭',
+    multiAgent: config.agent?.multiAgent ? '开启' : '关闭'
+  };
+
+  const inspect = chatManager?.inspectSite
+    ? await chatManager.inspectSite().catch(() => null)
+    : null;
+
+  ui.clear();
+  ui.printTitle('运行状态');
+  ui.printNewline();
+  ui.printKeyValueTable('当前上下文', [
+    { label: '提供方', value: `${appState.provider} (${appState.providerId})` },
+    { label: '会话', value: appState.sessionTitle },
+    { label: '消息数', value: String(appState.sessionMessages) },
+    { label: '浏览器', value: `${appState.browserMode} / Channel ${appState.channel}` },
+    { label: '允许可见', value: appState.visibleAllowed ? '开启' : '关闭' },
+    { label: 'Agent 模式', value: appState.agentMode },
+    { label: '自动执行', value: appState.autoExecute },
+    { label: '多 Agent', value: appState.multiAgent },
+    { label: '聊天页', value: appState.chatUrl },
+    { label: 'Agent 页', value: appState.agentUrl }
+  ]);
+  ui.printNewline();
+  ui.printTaskRuntime(taskSnapshot);
+  if (sessionManager.current?.memory) {
+    const pinnedCount = Array.isArray(sessionManager.current.memory.pinned)
+      ? sessionManager.current.memory.pinned.length
+      : 0;
+    ui.printNewline();
+    ui.printKeyValueTable('会话记忆', [
+      { label: 'Pinned', value: String(pinnedCount) },
+      { label: 'Last User', value: sessionManager.current.memory.lastUserMessage || '(空)' },
+      { label: 'Last AI', value: sessionManager.current.memory.lastAssistantMessage || '(空)' }
+    ]);
+  }
+
+  if (inspect?.intervention?.blocked) {
+    ui.printNewline();
+    ui.printActionPanel('当前阻塞', [
+      { label: '类型', value: inspect.intervention.label || inspect.intervention.kind || '人工介入' },
+      { label: '原因', value: inspect.intervention.reason || '(未知)' },
+      { label: '页面', value: inspect.intervention.url || '(未知)' },
+      {
+        label: '建议',
+        value: config.browser?.allowVisibleBrowser === false
+          ? '当前禁止可见浏览器；可在 /config 切到 API provider，或开启允许可见浏览器。'
+          : '可输入 /agent 进入人工接管，完成登录/验证后继续。'
+      }
+    ]);
+  }
+
+  const suggestions = [];
+
+  if (inspect?.intervention?.blocked && config.browser?.allowVisibleBrowser === false) {
+    suggestions.push({ label: '/config', hint: '开启允许可见浏览器或调整策略' });
+    suggestions.push({ label: '/config', hint: '切换默认提供方或启用 API 兜底' });
+  }
+
+  if (taskSnapshot.handoff > 0) {
+    suggestions.push({ label: '/task', hint: '查看卡在 handoff 的任务' });
+  }
+
+  if (!agentMode) {
+    suggestions.push({ label: '/mode', hint: '切换到 Agent 模式' });
+  }
+
+  if (!suggestions.length) {
+    suggestions.push({ label: '/inspect', hint: '检查当前页面适配状态' });
+    suggestions.push({ label: '/sessions', hint: '查看历史会话' });
+  }
+
+  ui.printNewline();
+  ui.printSuggestedActions(suggestions);
+  ui.printNewline();
+  ui.printInfo('按回车返回聊天...');
+  await askInput('', true);
+}
+
+function createTimelineEvent(label, detail = '', options = {}) {
+  const roleLabel = options.agentRole ? getAgentRoleLabel(options.agentRole) : '';
+  return {
+    time: new Date().toLocaleTimeString('zh-CN', { hour12: false }),
+    label,
+    detail,
+    agentRole: options.agentRole || null,
+    agentLabel: roleLabel
+  };
+}
+
+async function showCommandPalette() {
+  ui.clearPinnedHeader();
+  ui.exitWorkspace();
+  const choice = await select({
+    message: '命令面板',
+    choices: [
+      { name: '/help  查看聊天命令', value: '/help' },
+      { name: '/status  查看当前运行状态', value: '/status' },
+      { name: '/task  打开任务面板', value: '/task' },
+      { name: '/sessions  打开历史会话', value: '/sessions' },
+      { name: '/resume  恢复最近会话', value: '/resume' },
+      { name: '/memory  查看会话记忆', value: '/memory' },
+      { name: '/pin  固定一条会话记忆', value: '/pin' },
+      { name: '/retry-last  重试上一条消息', value: '/retry-last' },
+      { name: '/plan  查看当前轻量计划', value: '/plan' },
+      { name: '/switch-provider  切换当前会话提供方', value: '/switch-provider' },
+      { name: '/mode  切换 Agent 模式', value: '/mode' },
+      { name: '/inspect  检查页面适配', value: '/inspect' },
+      { name: '/config  系统设置 / 默认提供方', value: '/config' },
+      { name: '/rename-session  修改当前会话标题', value: '/rename-session' },
+      { name: '/delete-session  删除当前会话', value: '/delete-session' },
+      { name: '/doc  查看文档', value: '/doc' },
+      { name: '/menu  返回主菜单', value: '/menu' },
+      { name: '取消', value: '__cancel__' }
+    ]
+  });
+
+  return choice;
+}
+
+async function switchCurrentSessionProvider() {
+  const providers = listProviders();
+  const currentProviderId = chatManager?.provider?.id || getProvider().id;
+  const choice = await select({
+    message: '切换当前会话提供方',
+    choices: [
+      ...providers.map((provider) => ({
+        name: `${provider.name}${provider.id === currentProviderId ? '（当前）' : ''}`,
+        value: provider.id
+      })),
+      { name: '取消', value: '__cancel__' }
+    ],
+    default: currentProviderId
+  });
+
+  if (choice === '__cancel__' || choice === currentProviderId) {
+    if (choice === currentProviderId) {
+      ui.printInfo('当前会话已在使用该提供方。');
+      await new Promise((resolve) => setTimeout(resolve, 700));
+    }
+    return false;
+  }
+
+  const targetProvider = getProvider(choice);
+  return switchProviderWithContext(targetProvider, {
+    reason: '正在切换当前会话 provider'
+  });
+}
+
+async function openModelSwitcher() {
+  const choice = await select({
+    message: '模型 / 提供方',
+    choices: [
+      { name: '切换当前会话提供方', value: 'session' },
+      { name: '打开设置，修改默认提供方', value: 'settings' },
+      { name: '取消', value: '__cancel__' }
+    ],
+    default: 'session'
+  });
+
+  if (choice === '__cancel__') {
+    return;
+  }
+
+  if (choice === 'session') {
+    await switchCurrentSessionProvider();
+    return;
+  }
+
+  await showSettingsMenu({ ui, config });
+}
+
+function getCurrentMemoryRows() {
+  const memory = sessionManager.current?.memory || {};
+  const rows = [];
+
+  if (memory.summary) {
+    rows.push({ label: 'Summary', value: memory.summary });
+  }
+
+  if (Array.isArray(memory.pinned) && memory.pinned.length > 0) {
+    memory.pinned.slice(0, 6).forEach((item, index) => {
+      rows.push({
+        label: `Pin ${index + 1}`,
+        value: item?.text || ''
+      });
+    });
+  }
+
+  if (Array.isArray(memory.plan) && memory.plan.length > 0) {
+    rows.push({
+      label: 'Plan',
+      value: memory.plan.join('  ->  ')
+    });
+  }
+
+  rows.push({
+    label: 'Last User',
+    value: memory.lastUserMessage || '(空)'
+  });
+  rows.push({
+    label: 'Last AI',
+    value: memory.lastAssistantMessage || '(空)'
+  });
+
+  return rows;
+}
+
+async function showMemoryPanel() {
+  ui.clearPinnedHeader();
+  ui.exitWorkspace();
+  while (true) {
+    const memory = sessionManager.current?.memory || {};
+    const pinned = Array.isArray(memory.pinned) ? memory.pinned : [];
+    const plan = Array.isArray(memory.plan) ? memory.plan : [];
+
+    ui.clear();
+    ui.printTitle('会话记忆');
+    ui.printNewline();
+    ui.printKeyValueTable('概览', [
+      { label: 'Summary', value: memory.summary || '(空)' },
+      { label: 'Pins', value: String(pinned.length) },
+      { label: 'Plan', value: plan.length > 0 ? `${plan.length} 条` : '(空)' },
+      { label: 'Last User', value: memory.lastUserMessage || '(空)' },
+      { label: 'Last AI', value: memory.lastAssistantMessage || '(空)' }
+    ]);
+    ui.printNewline();
+    ui.printInputHints([
+      'P 查看固定记忆',
+      'D 查看完整详情',
+      'Q/Esc 返回'
+    ]);
+
+    const key = await waitForKeypress();
+
+    if (key === 'p') {
+      ui.clear();
+      ui.printTitle('固定记忆');
+      ui.printNewline();
+      if (!pinned.length) {
+        ui.printInfo('(暂无固定记忆)');
+      } else {
+        ui.printKeyValueTable('Pins', pinned.slice(0, 12).map((item, index) => ({
+          label: `Pin ${index + 1}`,
+          value: item?.text || '(空)'
+        })));
+      }
+      ui.printNewline();
+      ui.printInfo('按任意键返回...');
+      await waitForKeypress();
+      continue;
+    }
+
+    if (key === 'd') {
+      ui.clear();
+      ui.printTitle('会话记忆详情');
+      ui.printNewline();
+      ui.printKeyValueTable('Memory', getCurrentMemoryRows());
+      ui.printNewline();
+      ui.printInfo('按任意键返回...');
+      await waitForKeypress();
+      continue;
+    }
+
+    if (key === 'q' || key === 'escape' || key === 'enter') {
+      return;
+    }
+  }
+}
+
+async function pinCurrentMemory() {
+  const note = await askInput('输入要固定的记忆: ', false);
+  if (!note.trim()) {
+    ui.printMuted('已取消');
+    return;
+  }
+
+  await sessionManager.pinMemory(note);
+  ui.printSuccess('已固定到会话记忆');
+}
+
+function printRuntimeStatus({ pinned = false, hints = [] } = {}) {
+  const taskCountPromise = taskStore.list();
+  return taskCountPromise.then((tasks) => {
+    const channel =
+      browserManager.isChannelReady?.('agent')
+        ? 'agent'
+        : browserManager.isChannelReady?.('chat')
+          ? 'chat'
+          : '-';
+    const state = {
+      provider: chatManager?.provider?.name || getProvider().name,
+      mode: agentMode ? 'Agent' : 'Chat',
+      browser: config.browser?.headless ? 'Headless' : 'Visible',
+      channel,
+      tasks: tasks.filter((task) => ['queued', 'running', 'stopping'].includes(task.status)).length,
+      session: sessionManager.current?.title
+        ? sessionManager.current.title.slice(0, 18)
+        : '-'
+    };
+
+    if (pinned) {
+      return ui.renderChatChrome(state, hints);
+    }
+
+    ui.printStatusBar(state);
+    return false;
+  });
+}
+
+function getProviderRetryConfig() {
+  return {
+    sendRetryCount: Math.max(0, Number(config.providersRuntime?.sendRetryCount) || 0),
+    responseRetryCount: Math.max(0, Number(config.providersRuntime?.responseRetryCount) || 0),
+    retryBackoffMs: Math.max(0, Number(config.providersRuntime?.retryBackoffMs) || 0)
+  };
+}
+
+async function waitBeforeProviderRetry(attempt, label = 'provider') {
+  const { retryBackoffMs } = getProviderRetryConfig();
+  const delayMs = retryBackoffMs * Math.max(1, attempt);
+  if (delayMs > 0) {
+    ui.printMuted(`${label} 重试前等待 ${Math.round(delayMs / 100) / 10}s...`);
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+}
+
+async function handleTaskHandoff(taskId, runner = ensureTaskRunner()) {
+  const task = await taskStore.load(taskId);
+  if (!task) {
+    ui.printError('未找到待接管任务');
+    await new Promise((resolve) => setTimeout(resolve, 700));
+    return false;
+  }
+
+  const provider = getProvider(task.provider);
+  if (!provider) {
+    ui.printError(`未找到任务提供方: ${task.provider || '(空)'}`);
+    await new Promise((resolve) => setTimeout(resolve, 900));
+    return false;
+  }
+
+  if (!requiresBrowserForProvider(provider)) {
+    ui.printInfo('该任务不依赖网页浏览器，可直接重试运行。');
+    await runner.retryTask(taskId, { run: true });
+    await new Promise((resolve) => setTimeout(resolve, 700));
+    return true;
+  }
+
+  if (config.browser?.allowVisibleBrowser === false) {
+    ui.printError('当前配置禁止可见浏览器，无法进入人工接管。请先到 /config 开启“允许可见浏览器”。');
+    await new Promise((resolve) => setTimeout(resolve, 1200));
+    return false;
+  }
+
+  const targetUrl = task.handoffUrl || provider.url;
+  const shouldRestoreHeadless = config.browser?.headless !== false;
+
+  try {
+    if (browserManager.isReady()) {
+      await browserManager.relaunch({
+        headless: false,
+        url: targetUrl
+      });
+    } else {
+      await browserManager.init({
+        headless: false
+      });
+      if (targetUrl) {
+        await browserManager.goto(targetUrl);
+      }
+    }
+  } catch (error) {
+    ui.printError(`打开接管页面失败: ${error.message}`);
+    await new Promise((resolve) => setTimeout(resolve, 1200));
+    return false;
+  }
+
+  await taskStore.appendHistory(taskId, {
+    type: 'status',
+    label: '人工接管中',
+    detail: targetUrl || provider.url || '已打开接管页面'
+  });
+
+  ui.clear();
+  ui.printTitle(`任务接管 · ${task.title}`);
+  ui.printNewline();
+  ui.printKeyValueTable('接管信息', [
+    { label: '任务状态', value: task.status || 'handoff' },
+    { label: '提供方', value: provider.name },
+    { label: '接管页面', value: targetUrl || '(未知)' },
+    { label: '当前说明', value: task.lastResult || task.lastError || '需要人工接管' }
+  ]);
+  ui.printNewline();
+  ui.printInfo('已切到可见浏览器，请在页面中完成登录、验证码、授权或人工确认。');
+  ui.printInfo('完成后输入 done 继续，输入 cancel 返回任务面板。');
+
+  while (true) {
+    const answer = await askInput('接管完成后输入 done/cancel: ', false);
+    const normalized = String(answer || '').trim().toLowerCase();
+
+    if (normalized === 'cancel' || normalized === 'c' || normalized === 'q') {
+      ui.printMuted('已取消本次人工接管');
+      await taskStore.appendHistory(taskId, {
+        type: 'status',
+        label: '取消接管',
+        detail: '用户取消人工接管'
+      });
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      return false;
+    }
+
+    if (!['done', 'ok', 'yes', 'y', '好了', '完成'].includes(normalized)) {
+      ui.printMuted('请输入 done 或 cancel。');
+      continue;
+    }
+
+    const resumeUrl = browserManager.getCurrentUrl() || targetUrl;
+
+    if (shouldRestoreHeadless) {
+      try {
+        await browserManager.relaunch({
+          headless: true,
+          url: resumeUrl
+        });
+        ui.printSuccess('已恢复默认浏览器模式');
+      } catch (error) {
+        ui.printWarning(`恢复默认浏览器模式失败，将继续保留可见浏览器: ${error.message}`);
+      }
+    }
+
+    await taskStore.appendHistory(taskId, {
+      type: 'status',
+      label: '接管完成',
+      detail: '人工接管结束，准备恢复任务执行'
+    });
+    await runner.retryTask(taskId, { run: true });
+    ui.printSuccess('任务已恢复执行');
+    await new Promise((resolve) => setTimeout(resolve, 800));
+    return true;
+  }
+}
+
+function printAgentActionPanel(parsed, step, maxSteps) {
+  ui.printActionPanel('Agent 行动面板', [
+    { label: '目标', value: sessionManager.current?.title || '当前任务' },
+    { label: '步骤', value: `${step}/${maxSteps}` },
+    {
+      label: '协作',
+      value: isMultiAgentEnabled() ? '多 Agent' : '单 Agent'
+    },
+    {
+      label: '角色',
+      value: parsed.agentLabel || resolveAgentLabel(parsed.command, parsed.agent)
+    },
+    { label: '动作', value: parsed.command?.name || '(无)' },
+    { label: '说明', value: parsed.displayText || parsed.text || '(无)' },
+    {
+      label: '权限',
+      value: `Shell ${config.agent?.allowShell ? '开' : '关'} / 文件 ${config.agent?.allowFileWrite ? '开' : '关'} / 自动执行 ${config.agent?.autoExecuteCommands ? '开' : '关'}`
+    }
+  ]);
+}
+
+function printAgentActionSummary(envelope, result = null) {
+  if (!envelope?.command && !result) {
+    return;
+  }
+
+  const rows = [];
+  if (envelope?.command?.name) {
+    rows.push({ label: '动作', value: envelope.command.name });
+  }
+  if (envelope?.agentLabel) {
+    rows.push({ label: '角色', value: envelope.agentLabel });
+  }
+  if (envelope?.displayText || envelope?.text) {
+    rows.push({ label: '说明', value: envelope.displayText || envelope.text });
+  }
+  if (result?.message) {
+    rows.push({ label: '结果', value: result.message });
+  }
+  if (result?.handoff) {
+    rows.push({ label: '状态', value: '需要人工接管' });
+  }
+  if (rows.length > 0) {
+    ui.printKeyValueTable('Agent 回执', rows);
+  }
+}
+
+function getHistoryEnvelopePresentation(envelope) {
+  const title = envelope.agentLabel
+    ? `AI / ${envelope.agentLabel}`
+    : 'AI';
+  const badges = [];
+
+  if (envelope.kind === 'command') {
+    badges.push('动作');
+    if (envelope.command?.name) {
+      badges.push(envelope.command.name);
+    }
+  } else if (envelope.kind === 'handoff') {
+    badges.push('接管');
+  } else if (envelope.type === 'error') {
+    badges.push('错误');
+  } else {
+    badges.push('回复');
+  }
+
+  return {
+    title,
+    badges
+  };
+}
+
+async function ensureBrowserReady() {
+  if (browserManager.isReady()) {
+    return true;
+  }
+
+  try {
+    ui.clear();
+    ui.printWarning('正在启动浏览器...');
+    await browserManager.init();
+    return true;
+  } catch (error) {
+    ui.printError(`浏览器启动失败: ${error.message}`);
+    return false;
+  }
+}
+
+async function navigateWithRecovery(url, {
+  title = '页面连接失败',
+  maxAttempts = 2
+} = {}) {
+  let attempt = 0;
+
+  while (attempt < maxAttempts) {
+    attempt++;
+
+    try {
+      await browserManager.goto(url);
+      return true;
+    } catch (error) {
+      const recoverable = isRecoverableNavigationError(error);
+
+      if (recoverable && attempt < maxAttempts) {
+        ui.printWarning(`连接失败，正在自动重试 (${attempt}/${maxAttempts})...`);
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        continue;
+      }
+
+      ui.clear();
+      ui.printTitle(title);
+      ui.printNewline();
+      const panel = buildNavigationRecoveryRows({
+        title,
+        url,
+        attempt,
+        maxAttempts,
+        error
+      });
+      ui.printActionPanel(panel.title, panel.rows);
+      ui.printNewline();
+
+      const action = await select({
+        message: '选择恢复操作',
+        choices: [
+          { name: '重试连接', value: 'retry' },
+          { name: '切换可见浏览器后重试', value: 'visible' },
+          { name: '返回上一步', value: 'back' }
+        ]
+      });
+
+      if (action === 'back') {
+        return false;
+      }
+
+      if (action === 'visible') {
+        if (config.browser?.allowVisibleBrowser === false) {
+          ui.printInfo('当前配置禁止切换到可见浏览器。可在 /config 中开启“允许可见浏览器”。');
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+          continue;
+        }
+        try {
+          await browserManager.relaunch({
+            headless: false,
+            url
+          });
+          ui.printSuccess('已切换到可见浏览器并重新打开页面');
+          await new Promise((resolve) => setTimeout(resolve, 800));
+          return true;
+        } catch (visibleError) {
+          ui.printError(`可见浏览器重试失败: ${visibleError.message}`);
+          await new Promise((resolve) => setTimeout(resolve, 1000));
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+async function deleteCurrentSession() {
+  const current = sessionManager.current;
+  if (!current) {
+    ui.printInfo('当前没有活跃会话。');
+    return false;
+  }
+
+  const approved = await confirm({
+    message: `确认删除当前会话“${current.title || '(无标题)'}”？`,
+    default: false
+  });
+
+  if (!approved) {
+    ui.printMuted('已取消删除');
+    return false;
+  }
+
+  const deleted = await sessionManager.delete(current.id);
+  if (!deleted) {
+    ui.printError('删除当前会话失败');
+    return false;
+  }
+
+  hasActiveSession = false;
+  resetAgentPrimer();
+  ui.printSuccess('当前会话已删除');
+  return true;
+}
+
+async function renameCurrentSession() {
+  if (!sessionManager.current) {
+    ui.printInfo('当前没有活跃会话。');
+    return false;
+  }
+
+  const nextTitle = await askInput('新的会话标题: ', false);
+  if (!nextTitle.trim()) {
+    ui.printMuted('已取消');
+    return false;
+  }
+
+  const renamed = await sessionManager.rename(sessionManager.current.id, nextTitle);
+  if (!renamed) {
+    ui.printError('重命名会话失败');
+    return false;
+  }
+
+  ui.printSuccess(`会话标题已更新为 ${nextTitle}`);
+  return true;
+}
+
+async function showTaskPanel() {
+  ui.clearPinnedHeader();
+  ui.exitWorkspace();
+  const runner = ensureTaskRunner();
+  let selectedIndex = 0;
+  const pageSize = 10;
+
+  while (true) {
+    const tasks = await taskStore.list();
+    const runtime = await runner.getRuntimeSnapshot();
+    selectedIndex = Math.min(Math.max(selectedIndex, 0), Math.max(0, tasks.length - 1));
+    const currentPage = Math.floor(selectedIndex / pageSize) + 1;
+    const totalPages = Math.max(1, Math.ceil(Math.max(tasks.length, 1) / pageSize));
+    const start = (currentPage - 1) * pageSize;
+    const pageTasks = tasks.slice(start, start + pageSize);
+    const localIndex = Math.max(0, selectedIndex - start);
+
+    ui.clear();
+    ui.printTitle('任务面板');
+    ui.printNewline();
+    ui.printTaskRuntime(runtime);
+    ui.printNewline();
+    ui.printInputHints([
+      'W/S 或 ↑↓ 选择',
+      'A/D 或 ←→ 翻页',
+      'N 新建',
+      'Enter/R 启动',
+      'H 接管/恢复',
+      'P 预览',
+      'T 停止',
+      'X 删除',
+      'Q/Esc 返回'
+    ]);
+    ui.printNewline();
+
+    if (!tasks.length) {
+      ui.printInfo('暂无任务。按 N 新建任务，按 Q 返回。');
+      const emptyKey = await waitForKeypress();
+
+      if (emptyKey === 'q' || emptyKey === 'escape') {
+        return;
+      }
+
+      if (emptyKey !== 'n') {
+        continue;
+      }
+    } else {
+      ui.printSelectableList(
+        `任务列表 · 第 ${currentPage}/${totalPages} 页，共 ${tasks.length} 条`,
+        pageTasks.map((task) => `${task.title} | ${task.status} | ${task.provider || '-'} | ${task.mode || 'once'}`),
+        localIndex
+      );
+      ui.printNewline();
+      ui.printInfo('按 P 预览任务详情，按 N 进入创建向导');
+      ui.printNewline();
+    }
+
+    if (!tasks.length) {
+      const created = await runTaskCreationWizard(runner);
+      if (created?.task?.id) {
+        const refreshed = await taskStore.list();
+        const nextIndex = refreshed.findIndex((item) => item.id === created.task.id);
+        selectedIndex = nextIndex >= 0 ? nextIndex : Math.max(0, refreshed.length - 1);
+      }
+      continue;
+    }
+
+    const key = await waitForKeypress();
+
+    if (key === 'up' || key === 'w') {
+      selectedIndex = Math.max(0, selectedIndex - 1);
+      continue;
+    }
+
+    if (key === 'down' || key === 's') {
+      selectedIndex = Math.min(tasks.length - 1, selectedIndex + 1);
+      continue;
+    }
+
+    if (key === 'left' || key === 'a') {
+      selectedIndex = Math.max(0, selectedIndex - pageSize);
+      continue;
+    }
+
+    if (key === 'right' || key === 'd') {
+      selectedIndex = Math.min(tasks.length - 1, selectedIndex + pageSize);
+      continue;
+    }
+
+    if (key === 'n') {
+      const created = await runTaskCreationWizard(runner);
+      if (created?.task?.id) {
+        const refreshed = await taskStore.list();
+        const nextIndex = refreshed.findIndex((item) => item.id === created.task.id);
+        selectedIndex = nextIndex >= 0 ? nextIndex : selectedIndex;
+      }
+      continue;
+    }
+
+    const taskId = tasks[selectedIndex].id;
+
+    if (key === 'p') {
+      const currentTask = await taskStore.load(taskId);
+      ui.clear();
+      ui.printTitle('任务预览');
+      ui.printNewline();
+      ui.printTaskDetails(currentTask);
+      ui.printNewline();
+      ui.printInfo('按任意键返回列表...');
+      await waitForKeypress();
+      continue;
+    }
+
+    if (key === 'enter' || key === 'r') {
+      if (tasks[selectedIndex].status === 'handoff') {
+        await handleTaskHandoff(taskId, runner);
+        continue;
+      }
+      await runner.queueTask(taskId);
+      runner.runTask(taskId).catch(() => {});
+      ui.printSuccess('任务已加入执行队列');
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      continue;
+    }
+
+    if (key === 'h') {
+      if (tasks[selectedIndex].status !== 'handoff') {
+        ui.printInfo('当前任务不是待接管状态。');
+        await new Promise((resolve) => setTimeout(resolve, 700));
+        continue;
+      }
+      await handleTaskHandoff(taskId, runner);
+      continue;
+    }
+
+    if (key === 't') {
+      await runner.stopTask(taskId);
+      ui.printSuccess('已请求停止任务');
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      continue;
+    }
+
+    if (key === 'x') {
+      const approved = await confirm({
+        message: `确认删除任务“${tasks[selectedIndex].title}”？`,
+        default: false
+      });
+      if (approved) {
+        await taskStore.delete(taskId);
+        ui.printSuccess('任务已删除');
+        await new Promise((resolve) => setTimeout(resolve, 700));
+        selectedIndex = Math.max(0, Math.min(selectedIndex, tasks.length - 2));
+      }
+      continue;
+    }
+
+    if (key === 'q' || key === 'escape') {
+      return;
+    }
+  }
+}
+
+async function waitForChatResponse() {
+  let response;
+  let streamed = false;
+  let streamBuffer = '';
+  let streamMode = 'pending';
+  let prefixPrinted = false;
+  let suppressStructuredStream = false;
+  let renderedDuringStream = false;
+
+  const flushStreamBuffer = (forceMarkdown = false) => {
+    if (!streamBuffer) {
+      return;
+    }
+
+    if (forceMarkdown || streamMode === 'markdown') {
+      ui.stopSpinner();
+      ui.printNewline();
+      ui.printMarkdown(streamBuffer);
+    } else {
+      if (!prefixPrinted) {
+        ui.stopSpinner();
+        ui.printAIPrefix();
+        prefixPrinted = true;
+      }
+      ui.printInlineMarkdown(streamBuffer, { streaming: true });
+    }
+
+    streamed = true;
+    renderedDuringStream = true;
+    streamBuffer = '';
+  };
+
+  try {
+    response = await chatManager.waitForResponse((chunk, first) => {
+      if (agentMode) {
+        return;
+      }
+
+      streamBuffer += chunk;
+      const preview = normalizeResponseEnvelope(streamBuffer, { agentMode: false });
+
+      if (preview.mode === 'structured' || preview.incompleteStructured) {
+        suppressStructuredStream = true;
+        return;
+      }
+
+      if (streamMode === 'pending') {
+        if (
+          preview.streamMarkdownPreferred ||
+          preview.renderAs === 'markdown'
+        ) {
+          streamMode = 'markdown';
+          flushStreamBuffer(true);
+          return;
+        }
+
+        const compact = (preview.displayText || '').trim();
+        if (first && compact.length < 24 && !/[.!?。！？\n]$/.test(compact)) {
+          return;
+        }
+
+        streamMode = 'inline';
+      }
+
+      if (streamMode === 'markdown') {
+        flushStreamBuffer(true);
+        return;
+      }
+
+      flushStreamBuffer(false);
+    });
+  } catch (error) {
+    const handled = await maybeHandleIntervention('wait', error);
+    if (!handled) {
+      if (error?.message === '响应超时') {
+        ui.stopSpinner();
+        ui.printWarning('本轮等待模型回复超时，页面可能卡住、站点变慢，或当前 provider 没有正常出字。');
+        try {
+          const snapshot = await chatManager.inspectSite();
+          printInspectResult(snapshot);
+        } catch {
+          // ignore inspect errors on timeout fallback
+        }
+        const switched = await maybeFallbackProvider('timeout');
+        if (switched) {
+          error.silentReported = true;
+          throw new Error('PROVIDER_FALLBACK_RETRY');
+        }
+        error.silentReported = true;
+      }
+      throw error;
+    }
+
+    response = await chatManager.waitForResponse((chunk, first) => {
+      if (agentMode) {
+        return;
+      }
+
+      streamBuffer += chunk;
+      const preview = normalizeResponseEnvelope(streamBuffer, { agentMode: false });
+
+      if (preview.mode === 'structured' || preview.incompleteStructured) {
+        suppressStructuredStream = true;
+        return;
+      }
+
+      if (streamMode === 'pending') {
+        if (
+          preview.streamMarkdownPreferred ||
+          preview.renderAs === 'markdown'
+        ) {
+          streamMode = 'markdown';
+          flushStreamBuffer(true);
+          return;
+        }
+
+        const compact = (preview.displayText || '').trim();
+        if (first && compact.length < 24 && !/[.!?。！？\n]$/.test(compact)) {
+          return;
+        }
+
+        streamMode = 'inline';
+      }
+
+      if (streamMode === 'markdown') {
+        flushStreamBuffer(true);
+        return;
+      }
+
+      flushStreamBuffer(false);
+    });
+  }
+
+  if (streamBuffer) {
+    if (!suppressStructuredStream) {
+      if (streamMode === 'markdown') {
+        flushStreamBuffer(true);
+      } else {
+        flushStreamBuffer(false);
+      }
+    }
+  }
+
+  return {
+    response,
+    streamed,
+    streamMode,
+    renderedDuringStream,
+    suppressStructuredStream
+  };
+}
+
+async function switchProviderWithContext(targetProvider, {
+  reason = '当前 provider 不稳定'
+} = {}) {
+  const previousSession = sessionManager.current;
+  if (!targetProvider) {
+    return false;
+  }
+
+  ui.printWarning(`${reason}，正在切换到 ${targetProvider.name}...`);
+
+  if (requiresBrowserForProvider(targetProvider)) {
+    const opened = await navigateWithRecovery(targetProvider.url, {
+      title: `切换到 ${targetProvider.name} 失败`
+    });
+    if (!opened) {
+      ui.printMuted('自动切换 provider 失败');
+      return false;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1200));
+  }
+
+  rebuildChatManager(targetProvider);
+  resetAgentPrimer();
+  await sessionManager.switchProvider(targetProvider, {
+    reason: `fallback:${reason}`
+  });
+  sessionManager.setUrl(getProviderSessionUrl(targetProvider, browserManager));
+
+  if (previousSession?.messages?.length) {
+    ui.printMuted('正在恢复上下文到新的 provider...');
+    const primer = buildHistoryPrimer(
+      previousSession.messages,
+      getSessionCompressionOptions()
+    );
+
+    const success = await chatManager.sendMessage(primer);
+    if (success) {
+      try {
+        await new Promise((resolve) => setTimeout(resolve, 800));
+        await chatManager.waitForResponse(() => {}, {
+          timeoutMs: 4000,
+          allowEmptyOnTimeout: true
+        });
+      } catch {
+        // ignore fallback primer ack timeout
+      }
+    }
+  }
+
+  ui.printSuccess(`已切换到 ${targetProvider.name}`);
+  printChatOnboarding();
+  ui.printNewline();
+  lastAgentOrReplySummary = `切换到 ${targetProvider.name}`;
+  return true;
+}
+
+async function maybeFallbackProvider(trigger = 'timeout') {
+  if (!config.providersRuntime?.autoFallback || !chatManager?.provider) {
+    return false;
+  }
+
+  const mode = config.providersRuntime?.includeApiFallback ? 'web-first' : 'web-only';
+  const fallback = getFallbackProvider({
+    currentProviderId: chatManager.provider.id,
+    mode
+  });
+
+  if (!fallback) {
+    return false;
+  }
+
+  const reason =
+    trigger === 'timeout'
+      ? '当前 provider 响应超时'
+      : trigger === 'send'
+        ? '当前 provider 发送失败'
+        : '当前 provider 状态异常';
+
+  return switchProviderWithContext(fallback, { reason });
+}
+
+async function submitConversationMessage(content, {
+  allowRetry = true,
+  skipLog = false,
+  sendAttempt = 0,
+  responseAttempt = 0
+} = {}) {
+  if (
+    !isApiProvider(chatManager.provider) &&
+    config.browser?.shareAuthState &&
+    browserManager.isChannelReady?.('agent') &&
+    browserManager.isChannelReady?.('chat') &&
+    typeof browserManager.syncStorageState === 'function'
+  ) {
+    await browserManager.syncStorageState('agent', 'chat').catch(() => {});
+  }
+
+  if (!skipLog) {
+    lastSubmittedQuestion = content;
+    inputHistory.push(content);
+    if (inputHistory.length > 50) {
+      inputHistory.shift();
+    }
+    await logger.log('YOU', content);
+    await sessionManager.addMessage('user', content);
+  }
+
+  const localIntent = detectLocalIntent(content);
+  if (localIntent.matched) {
+    return handleLocalIntent(localIntent);
+  }
+
+  await primeAgentMode();
+
+  ui.printAIPrefix();
+  ui.startSpinner();
+
+  const success = await chatManager.sendMessage(toProviderMessage(content));
+
+  if (!success) {
+    ui.stopSpinner();
+    const handled = await maybeHandleIntervention(
+      'send',
+      new Error('发送消息失败，可能需要登录、验证或人工确认')
+    );
+    if (handled && allowRetry) {
+      return retryQuestion(content);
+    }
+    const { sendRetryCount } = getProviderRetryConfig();
+    if (sendAttempt < sendRetryCount) {
+      ui.printWarning(`当前 provider 发送失败，正在第 ${sendAttempt + 1}/${sendRetryCount} 次重试...`);
+      await waitBeforeProviderRetry(sendAttempt + 1, '发送');
+      return submitConversationMessage(content, {
+        allowRetry,
+        skipLog: true,
+        sendAttempt: sendAttempt + 1,
+        responseAttempt
+      });
+    }
+    if (allowRetry) {
+      const switched = await maybeFallbackProvider('send');
+      if (switched) {
+        return retryQuestion(content, { skipLog: true });
+      }
+    }
+    ui.printError('发送消息失败，请重试');
+    return loopQuestion();
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 500));
+  sessionManager.setUrl(getProviderSessionUrl(chatManager.provider, browserManager));
+
+  let responseResult;
+
+  try {
+    responseResult = await waitForChatResponse();
+  } catch (error) {
+    ui.stopSpinner();
+    const { responseRetryCount } = getProviderRetryConfig();
+    if (error?.message === '响应超时' && responseAttempt < responseRetryCount) {
+      ui.printWarning(`当前 provider 回复超时，正在第 ${responseAttempt + 1}/${responseRetryCount} 次重试...`);
+      await waitBeforeProviderRetry(responseAttempt + 1, '回复');
+      return submitConversationMessage(content, {
+        allowRetry,
+        skipLog: true,
+        sendAttempt,
+        responseAttempt: responseAttempt + 1
+      });
+    }
+    throw error;
+  }
+
+  if (isInterruptedTurnResponse(responseResult?.response) && responseAttempt < 1) {
+    ui.printMuted('检测到网页回复疑似被中断，正在等待稳定后补抓一次...');
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+    try {
+      responseResult = await waitForChatResponse();
+    } catch (error) {
+      ui.stopSpinner();
+      if (!error?.silentReported) {
+        ui.printWarning('补抓回复失败，将先展示当前已拿到的内容。');
+      }
+    }
+  }
+
+  ui.stopSpinner();
+  const {
+    response,
+    streamed,
+    streamMode,
+    renderedDuringStream,
+    suppressStructuredStream
+  } = responseResult;
+  await handleModelResponse(response, {
+    streamed,
+    streamMode,
+    renderedDuringStream,
+    suppressStructuredStream
+  });
+  ui.ensureTrailingNewline();
+  return loopQuestion();
+}
+
+async function handleLocalIntent(intent) {
+  if (intent?.control) {
+    const action = intent.control.action;
+
+    if (action === 'switch_provider') {
+      const targetProvider = getProvider(intent.control.providerId);
+      const currentProviderId = chatManager?.provider?.id || getProvider().id;
+
+      if (targetProvider.id === currentProviderId) {
+        ui.printInfo(`当前已经是 ${targetProvider.name}。`);
+        return loopQuestion();
+      }
+
+      const switched = await switchProviderWithContext(targetProvider, {
+        reason: '根据自然语言指令切换当前会话 provider'
+      });
+      if (switched) {
+        chatChromeDirty = true;
+      }
+      return loopQuestion();
+    }
+
+    if (action === 'show_provider_status') {
+      ui.printNewline();
+      ui.printKeyValueTable('当前会话状态', [
+        { label: 'Provider', value: chatManager?.provider?.name || getProvider().name },
+        { label: 'Provider ID', value: chatManager?.provider?.id || getProvider().id },
+        { label: 'Mode', value: agentMode ? 'Agent' : 'Chat' },
+        { label: 'Browser', value: config.browser?.headless ? 'Headless' : 'Visible' },
+        { label: 'Session', value: sessionManager.current?.title || '(无会话)' },
+        { label: 'Messages', value: String(sessionManager.current?.messages?.length || 0) }
+      ]);
+      ui.printNewline();
+      return loopQuestion();
+    }
+
+    if (action === 'show_app_state') {
+      return handleLocalIntent({
+        matched: true,
+        reason: 'show-app-state',
+        command: {
+          name: 'get_app_state',
+          args: {}
+        }
+      });
+    }
+
+    if (action === 'show_config_summary') {
+      ui.printNewline();
+      ui.printKeyValueTable('配置摘要', [
+        { label: 'Default Provider', value: getProvider().name },
+        { label: 'Default Provider ID', value: getProvider().id },
+        { label: 'Browser', value: config.browser?.headless ? 'Headless' : 'Visible' },
+        { label: 'Allow Visible', value: String(config.browser?.allowVisibleBrowser !== false) },
+        { label: 'Share Auth', value: String(Boolean(config.browser?.shareAuthState)) },
+        { label: 'Agent Enabled', value: String(Boolean(config.agent?.enabled)) },
+        { label: 'Auto Execute', value: String(Boolean(config.agent?.autoExecuteCommands)) },
+        { label: 'Allow Shell', value: String(Boolean(config.agent?.allowShell)) },
+        { label: 'Allow File Write', value: String(Boolean(config.agent?.allowFileWrite)) },
+        { label: 'Multi Agent', value: String(Boolean(config.agent?.multiAgent)) }
+      ]);
+      ui.printNewline();
+      return loopQuestion();
+    }
+
+    if (action === 'open_task_panel') {
+      await showTaskPanel();
+      chatChromeDirty = true;
+      return loopQuestion();
+    }
+
+    if (action === 'open_memory_panel') {
+      await showMemoryPanel();
+      chatChromeDirty = true;
+      return loopQuestion();
+    }
+
+    if (action === 'open_sessions_panel') {
+      const sessionMeta = await browseSessions({
+        sessionManager,
+        ui
+      });
+      if (sessionMeta) {
+        const resumed = await resumeSession(sessionMeta);
+        if (resumed) {
+          hasActiveSession = true;
+        }
+      } else {
+        chatChromeDirty = true;
+      }
+      return loopQuestion();
+    }
+
+    if (action === 'open_settings') {
+      const beforeProviderId = getProvider().id;
+      await showSettingsMenu({ ui, config });
+      const afterProviderId = getProvider().id;
+      if (afterProviderId !== beforeProviderId) {
+        ui.printInfo(`默认提供方已改为 ${getProvider().name}。当前会话仍使用 ${chatManager?.provider?.name || getProvider().name}。`);
+        ui.printInfo('如需把当前会话一起切过去，请输入 /switch-provider。');
+      }
+      printChatOnboarding();
+      ui.printNewline();
+      return loopQuestion();
+    }
+
+    if (action === 'open_command_palette') {
+      const command = await showCommandPalette();
+      if (command === '__cancel__') {
+        return loopQuestion();
+      }
+      return loopQuestion(command);
+    }
+  }
+
+  ui.printAIPrefix();
+  ui.startSpinner();
+
+  try {
+    if (
+      !config.agent?.autoExecuteCommands &&
+      typeof agentExecutor?.requiresManualApproval === 'function' &&
+      agentExecutor.requiresManualApproval(intent.command)
+    ) {
+      ui.stopSpinner();
+      const approved = await agentExecutor.confirm(intent.command);
+      if (!approved) {
+        ui.printMuted('已取消执行该命令');
+        return loopQuestion();
+      }
+      ui.startSpinner();
+    }
+
+    const result = await agentExecutor.execute(intent.command);
+    ui.stopSpinner();
+
+    if (!result.ok) {
+      ui.printError(result.error);
+      await logger.log('AI ', result.error);
+      await sessionManager.addMessage('assistant', result.error);
+      return loopQuestion();
+    }
+
+    const responseText = formatLocalIntentResult(intent, result);
+    ui.printNewline();
+    ui.printMarkdown(responseText);
+    await logger.log('AI ', responseText);
+    await sessionManager.addMessage('assistant', responseText);
+    return loopQuestion();
+  } catch (error) {
+    ui.stopSpinner();
+    ui.printError(error.message);
+    await logger.log('AI ', error.message);
+    await sessionManager.addMessage('assistant', error.message);
+    return loopQuestion();
+  }
+}
+
+function printInspectResult(snapshot) {
+  ui.printNewline();
+  ui.printTitle(`站点检查 - ${snapshot.provider}`);
+  ui.printNewline();
+  ui.printInfo(`输入框: ${snapshot.inputSelector || '(未命中)'}`);
+  ui.printInfo(`发送按钮: ${snapshot.sendSelector || '(未命中，将回退 Enter)'}`);
+  ui.printInfo(`读取节点: ${snapshot.readSelector || '(未命中)'}`);
+  ui.printInfo(`完成模式: ${snapshot.completionMode}`);
+  ui.printInfo(`pending: ${String(snapshot.result.pending)}`);
+  ui.printInfo(`done: ${String(snapshot.result.done)}`);
+  ui.printInfo(`error: ${snapshot.result.error || '(无)'}`);
+  ui.printInfo(`preview: ${snapshot.result.preview || '(空)'}`);
+  if (snapshot.intervention?.blocked) {
+    ui.printInfo(`人工介入: ${snapshot.intervention.reason}`);
+    ui.printInfo(`页面: ${snapshot.intervention.url || '(未知)'}`);
+    if (config.browser?.allowVisibleBrowser === false) {
+      ui.printInfo('当前配置已禁止可见浏览器，程序不会自动弹出窗口。');
+      ui.printInfo('如需手动接管，请先在 /config 中开启“允许可见浏览器”。');
+    }
+  }
+  if (snapshot.observation?.observation?.counts) {
+    const counts = snapshot.observation.observation.counts;
+    ui.printInfo(
+      `观测: req ${counts.requests} / resp ${counts.responses} / console ${counts.console} / error ${counts.pageErrors}`
+    );
+  }
+  const latestResponse = snapshot.observation?.observation?.responses?.at?.(-1);
+  if (latestResponse?.url) {
+    ui.printInfo(
+      `最近响应: ${latestResponse.status || '-'} ${latestResponse.method || ''} ${latestResponse.url}`
+    );
+  }
+  const latestError = snapshot.observation?.observation?.pageErrors?.at?.(-1);
+  if (latestError?.message) {
+    ui.printInfo(`最近页面错误: ${latestError.message}`);
+  }
+  ui.printNewline();
+}
+
+async function maybeHandleIntervention(stage, error) {
+  if (!chatManager || !conversationAgent) {
+    return false;
+  }
+
+  const result = await conversationAgent.handleIntervention({
+    chatManager,
+    stage,
+    error
+  });
+
+  if (!result.handled) {
+    return false;
+  }
+
+  rebuildChatManager(chatManager.provider);
+  sessionManager.setUrl(browserManager.getCurrentUrl());
+  return true;
+}
+
+async function primeAgentMode() {
+  if (!agentMode || !sessionManager.current) {
+    return;
+  }
+
+  if (agentPrimedSessionId === sessionManager.current.id) {
+    return;
+  }
+
+  ui.printWarning('正在初始化 Agent 协议...');
+  const primer = buildAgentPrimer(
+    getAgentSystemPrompt({
+      providerId: chatManager?.provider?.id || '',
+      multiAgentEnabled: isMultiAgentEnabled(),
+      allowShell: Boolean(config.agent?.allowShell),
+      allowFileWrite: Boolean(config.agent?.allowFileWrite)
+    }),
+    sessionManager.current.messages || [],
+    getSessionCompressionOptions()
+  );
+  const success = await chatManager.sendMessage(primer);
+
+  if (!success) {
+    ui.printMuted('Agent 预热未完成，将直接按本轮协议继续。');
+    agentPrimedSessionId = sessionManager.current.id;
+    return;
+  }
+
+  agentPrimedSessionId = sessionManager.current.id;
+
+  try {
+    await new Promise(resolve => setTimeout(resolve, 800));
+    await chatManager.waitForResponse(() => {}, {
+      timeoutMs: 4000,
+      allowEmptyOnTimeout: true
+    });
+  } catch {
+    ui.printMuted('Agent 预热确认较慢，继续直接发送当前任务。');
+  }
+}
+
+function printAgentResult(parsed) {
+  const text = parsed.consoleText ?? parsed.displayText ?? parsed.text ?? '';
+
+  if (!text) {
+    return;
+  }
+
+  if ((parsed.consoleTextRenderAs || parsed.renderAs) === 'markdown') {
+    ui.printAIPrefix();
+    ui.printNewline();
+    ui.printMarkdown(text);
+    return;
+  }
+
+  ui.printAIPrefix();
+  ui.printInlineMarkdown(text);
+  ui.printNewline();
+}
+
+function printStandardResponse(envelope) {
+  const text = envelope.displayText ?? envelope.text ?? '';
+  if (!text) {
+    ui.printNewline();
+    return;
+  }
+  ui.printNewline();
+  if (envelope.renderAs === 'markdown') {
+    ui.printMarkdown(text);
+  } else if (envelope.inlinePreferred) {
+    ui.printAIPrefix();
+    ui.printInlineMarkdown(text);
+    ui.printNewline();
+  } else {
+    ui.printMarkdown(text);
+  }
+}
+
+async function handleModelResponse(response, context = {}) {
+  await logger.log('AI ', response);
+  await sessionManager.addMessage('assistant', response);
+
+  const envelope = normalizeResponseEnvelope(response, { agentMode });
+  const display = (envelope.displayText ?? envelope.text ?? '').trim();
+  if (display) {
+    const lines = display.split('\n').map((line) => line.trim()).filter(Boolean);
+    const summary = lines[0] || '';
+    const plan =
+      lines
+        .filter((line) => /^[-*]\s+/.test(line) || /^\d+\.\s+/.test(line))
+        .map((line) => line.replace(/^[-*]\s+/, '').replace(/^\d+\.\s+/, '').trim())
+        .slice(0, 6);
+    await sessionManager.updateMemory({
+      summary: summary.slice(0, 240),
+      plan
+    });
+    lastAgentOrReplySummary = summary.slice(0, 160);
+  }
+
+  if (agentMode) {
+    printAgentResult(envelope);
+    await maybeExecuteAgentCommand(envelope, context);
+  } else {
+    if (context.streamed && !context.suppressStructuredStream && context.renderedDuringStream) {
+      if (context.streamMode === 'inline' || envelope.inlinePreferred) {
+        ui.ensureTrailingNewline();
+      } else {
+        ui.printNewline();
+      }
+    } else if (context.streamed) {
+      printStandardResponse(envelope);
+    } else if (envelope.renderAs === 'markdown') {
+      ui.printNewline();
+      ui.printMarkdown(envelope.displayText ?? envelope.text);
+    } else if (envelope.inlinePreferred) {
+      ui.printAIPrefix();
+      ui.printInlineMarkdown(envelope.displayText ?? envelope.text);
+      ui.printNewline();
+    } else {
+      ui.printNewline();
+      ui.printMarkdown(envelope.displayText ?? envelope.text);
+    }
+  }
+
+  if (!agentMode) {
+    ui.ensureTrailingNewline();
+  }
+}
+
+function toProviderMessage(content) {
+  if (!agentMode) {
+    return content;
+  }
+
+  return wrapAgentTurnMessage(content, {
+    providerId: chatManager?.provider?.id || ''
+  });
+}
+
+async function requestAgentFollowupResponse(content, _context = {}) {
+  if (
+    !isApiProvider(chatManager.provider) &&
+    config.browser?.shareAuthState &&
+    browserManager.isChannelReady?.('agent') &&
+    browserManager.isChannelReady?.('chat') &&
+    typeof browserManager.syncStorageState === 'function'
+  ) {
+    await browserManager.syncStorageState('agent', 'chat').catch(() => {});
+  }
+
+  ui.printWarning('Agent 正在执行后续消息...');
+  ui.printAgentStatus({
+    stage: '继续规划',
+    summary: '正在向模型请求下一轮结构化动作',
+    detail: '主控会结合上一条命令回执继续判断是否观察、点击、输入或结束任务',
+    agentLabel: getAgentRoleLabel('orchestrator')
+  });
+  ui.printTimeline('Agent 时间线', [
+    createTimelineEvent('发送给模型', '继续当前任务并等待下一轮结构化回复', {
+      agentRole: 'orchestrator'
+    })
+  ]);
+  const sent = await chatManager.sendMessage(toProviderMessage(content));
+
+  if (!sent) {
+    throw new Error('Agent 后续消息发送失败');
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 500));
+  sessionManager.setUrl(getProviderSessionUrl(chatManager.provider, browserManager));
+
+  ui.printAgentStatus({
+    stage: '等待回复',
+    summary: '模型正在生成下一步',
+    detail: '如果网页模型返回结构化命令，将自动进入下一步执行',
+    agentLabel: getAgentRoleLabel('orchestrator')
+  });
+  ui.printTimeline('Agent 时间线', [
+    createTimelineEvent('等待回复', '模型正在返回新的观察或下一步命令', {
+      agentRole: 'orchestrator'
+    })
+  ]);
+  const response = await chatManager.waitForResponse(() => {});
+
+  const retryAttempt = Number(_context?.retryAttempt) || 0;
+  if (isInterruptedTurnResponse(response) && retryAttempt < 1) {
+    ui.printMuted('检测到网页模型把上一轮回答中断了，正在等待稳定后重试一次...');
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+    return requestAgentFollowupResponse(content, {
+      ..._context,
+      retryAttempt: retryAttempt + 1
+    });
+  }
+
+  return response;
+}
+
+async function sendAgentCommandMessage(content, context = {}) {
+  const response = await requestAgentFollowupResponse(content, context);
+  await handleModelResponse(response, context);
+  return response;
+}
+
+async function maybeExecuteAgentCommand(parsed, context = {}) {
+  if (parsed.kind === 'handoff') {
+    ui.printWarning('模型建议人工接管，可输入 /agent');
+    return;
+  }
+
+  if (parsed.kind !== 'command' || !parsed.command) {
+    return;
+  }
+
+  const maxSteps = Math.max(1, Number(config.agent?.maxAutoSteps) || 1);
+  const outcome = await runAgentLoop({
+    initialEnvelope: parsed,
+    initialStep: context.followupStep ?? 0,
+    maxSteps,
+    agentExecutor,
+    requestFollowupResponse: requestAgentFollowupResponse,
+    onBeforeCommand: async ({ envelope, step, maxSteps }) => {
+      ui.printAgentStep({
+        step,
+        maxSteps,
+        command: envelope.command,
+        phase: 'execute',
+        agentLabel: envelope.agentLabel || resolveAgentLabel(envelope.command, envelope.agent),
+        multiAgent: isMultiAgentEnabled()
+      });
+      printAgentActionPanel(envelope, step, maxSteps);
+        ui.printTimeline('Agent 时间线', [
+        createTimelineEvent(`第 ${step} 步`, envelope.displayText || envelope.text || envelope.command.name, {
+            agentRole: resolveAgentRole(envelope.command, envelope.agent)
+          }),
+        createTimelineEvent('执行命令', envelope.command.name, {
+          agentRole: resolveAgentRole(envelope.command, envelope.agent)
+        })
+      ]);
+
+      if (config.agent?.autoExecuteCommands) {
+        return { stop: false };
+      }
+
+      const approved = await agentExecutor.confirm(envelope.command);
+      if (!approved) {
+        ui.printMuted('已取消执行该命令');
+        return { stop: true, status: 'cancelled' };
+      }
+
+      return { stop: false };
+    },
+    onAfterCommand: async ({ envelope, result, step, maxSteps }) => {
+      if (!result.ok) {
+        if (result.recoverable) {
+          ui.printWarning(`动作未成功，正在尝试调整策略: ${result.error}`);
+          ui.printAgentStatus({
+            stage: '恢复中',
+            summary: '上一条命令失败，但判定为可恢复',
+            detail: result.error,
+            command: envelope.command,
+            agentLabel: envelope.agentLabel || resolveAgentLabel(envelope.command, envelope.agent)
+          });
+        } else {
+          ui.printError(result.error);
+        }
+        return;
+      }
+
+      if (result.message) {
+        ui.printSuccess(result.message);
+      }
+
+      printAgentActionSummary(envelope, result);
+
+      if (result.output && !result.silentOutput) {
+        ui.printNewline();
+        ui.printMarkdown(result.output);
+      }
+
+      if (result.handoff) {
+        ui.printWarning('需要你手动接手时，可输入 /agent');
+        return;
+      }
+
+      if (agentExecutor.shouldContinue(result) && step < maxSteps) {
+        ui.printAgentStep({
+          step,
+          maxSteps,
+          command: {
+            name: result.commandName,
+            args: {}
+          },
+          phase: 'observe',
+          agentLabel: getAgentRoleLabel(result.agent || inferAgentRoleFromCommand({
+            name: result.commandName
+          })),
+          multiAgent: isMultiAgentEnabled()
+        });
+        ui.printTimeline('Agent 时间线', [
+          createTimelineEvent(`第 ${step} 步`, `读取 ${result.commandName || '上一动作'} 的结果`, {
+            agentRole: resolveAgentRole({ name: result.commandName }, result.agent)
+          }),
+          createTimelineEvent(`第 ${step + 1} 步`, '基于结果继续向模型请求下一步', {
+            agentRole: 'orchestrator'
+          })
+        ]);
+      }
+    },
+    onFollowupResponse: async ({ rawResponse, envelope }) => {
+      await logger.log('AI ', rawResponse);
+      await sessionManager.addMessage('assistant', rawResponse);
+      printAgentResult(envelope);
+    }
+  });
+
+  if (outcome.status === 'handoff' && outcome.envelope?.kind === 'handoff') {
+    ui.printWarning('模型建议人工接管，可输入 /agent');
+  }
+
+  if (outcome.status === 'limit') {
+    ui.printMuted(`已达到 Agent 自动续跑上限 (${maxSteps} 步)`);
+  }
+}
+
+async function loopQuestion(overrideQuestion = null) {
+  if (isShuttingDown) return;
+
+  try {
+    ui.ensureTrailingNewline();
+    const rawQuestion = overrideQuestion ?? await askQuestion();
+    const question = rawQuestion.trim();
+    const isSlashCommand = question.startsWith('/');
+
+    // 检测快捷命令
+    if (question === '/menu' || question === '/back') {
+      ui.printNewline();
+      ui.printInfo('返回主菜单...');
+      await new Promise(resolve => setTimeout(resolve, 800));
+      return 'MENU';
+    }
+
+    if (question === '/quit' || question === '/exit') {
+      process.kill(process.pid, 'SIGINT');
+      return;
+    }
+
+    if (question === '/doc') {
+      showQuickDoc();
+      ui.printInfo('按回车返回聊天...');
+      await askInput('', true);
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/help') {
+      ui.printNewline();
+      ui.printChatHelp(agentMode);
+      ui.printNewline();
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/status') {
+      await showRuntimeOverview();
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/' || question === '/cmd') {
+      const command = await showCommandPalette();
+      if (command === '__cancel__') {
+        return await loopQuestion();
+      }
+      return await loopQuestion(command);
+    }
+
+    if (question === '/h') {
+      return await loopQuestion('/help');
+    }
+
+    if (question === '/m') {
+      return await loopQuestion('/menu');
+    }
+
+    if (question === '/s') {
+      return await loopQuestion('/status');
+    }
+
+    if (question === '/t') {
+      return await loopQuestion('/task');
+    }
+
+    if (question === '/paste') {
+      const pasted = await askMultiline('进入多行粘贴模式');
+      if (!pasted) {
+        ui.printMuted('已取消');
+        return await loopQuestion();
+      }
+
+      ui.printUserMessage(pasted);
+      return await submitConversationMessage(pasted);
+    }
+
+    if (question === '/memory') {
+      await showMemoryPanel();
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/pin') {
+      await pinCurrentMemory();
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/retry-last') {
+      if (!lastSubmittedQuestion) {
+        ui.printInfo('当前还没有可重试的上一条消息。');
+        return await loopQuestion();
+      }
+      ui.printWarning('正在重试上一条消息...');
+      return await submitConversationMessage(lastSubmittedQuestion, {
+        allowRetry: false,
+        skipLog: true
+      });
+    }
+
+    if (question === '/plan') {
+      const plan = sessionManager.current?.memory?.plan || [];
+      ui.printNewline();
+      if (!plan.length) {
+        ui.printInfo('当前还没有提炼出的轻量计划。');
+      } else {
+        ui.printKeyValueTable('当前计划', plan.map((item, index) => ({
+          label: `Step ${index + 1}`,
+          value: item
+        })));
+      }
+      ui.printNewline();
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/config') {
+      const beforeProviderId = getProvider().id;
+      await showSettingsMenu({ ui, config });
+      const afterProviderId = getProvider().id;
+      if (afterProviderId !== beforeProviderId) {
+        ui.printInfo(`默认提供方已改为 ${getProvider().name}。当前会话仍使用 ${chatManager?.provider?.name || getProvider().name}。`);
+        ui.printInfo('如需把当前会话一起切过去，请输入 /switch-provider。');
+      }
+      printChatOnboarding();
+      ui.printNewline();
+      return await loopQuestion();
+    }
+
+    if (question === '/task') {
+      await showTaskPanel();
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/sessions') {
+      const sessionMeta = await browseSessions({
+        sessionManager,
+        ui
+      });
+      if (sessionMeta) {
+        const resumed = await resumeSession(sessionMeta);
+        if (resumed) {
+          hasActiveSession = true;
+        }
+      } else {
+        chatChromeDirty = true;
+      }
+      return await loopQuestion();
+    }
+
+    if (question === '/resume') {
+      const latest = await resumeLatestSession(sessionManager);
+      if (!latest) {
+        ui.printInfo('没有可恢复的历史会话。');
+        return await loopQuestion();
+      }
+
+      const resumed = await resumeSession(latest);
+      if (resumed) {
+        hasActiveSession = true;
+      } else {
+        chatChromeDirty = true;
+      }
+      return await loopQuestion();
+    }
+
+    if (question === '/rename-session') {
+      await renameCurrentSession();
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/delete-session') {
+      const deleted = await deleteCurrentSession();
+      if (deleted) {
+        return 'MENU';
+      }
+      return await loopQuestion();
+    }
+
+    if (question === '/inspect') {
+      ui.printNewline();
+      ui.printWarning('正在检查当前页面适配状态...');
+      const snapshot = await chatManager.inspectSite();
+      printInspectResult(snapshot);
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/agent') {
+      ui.printNewline();
+      ui.printWarning('正在检查是否需要人工接管...');
+      const handled = await maybeHandleIntervention('manual', null);
+      if (!handled) {
+        ui.printInfo('当前没有明确的登录或验证阻塞。');
+        ui.printNewline();
+      }
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/mode') {
+      agentMode = !agentMode;
+      if (!agentMode) {
+        resetAgentPrimer();
+      }
+      ui.printNewline();
+      ui.printSuccess(`已切换到${agentMode ? ' Agent' : '普通'}模式`);
+      printChatOnboarding();
+      if (agentMode) {
+        printAgentHelp();
+      }
+      return await loopQuestion();
+    }
+
+    if (question === '/switch-provider') {
+      await switchCurrentSessionProvider();
+      chatChromeDirty = true;
+      return await loopQuestion();
+    }
+
+    if (question === '/model') {
+      await openModelSwitcher();
+      printChatOnboarding();
+      ui.printNewline();
+      return await loopQuestion();
+    }
+
+    if (isSlashCommand) {
+      ui.printWarning(`未识别的命令: ${question}`);
+      ui.printMuted('输入 /help 查看可用命令。');
+      return await loopQuestion();
+    }
+
+    ui.printUserMessage(question);
+    return await submitConversationMessage(question);
+
+  } catch (error) {
+    if (error?.message === 'PROVIDER_FALLBACK_RETRY') {
+      return await loopQuestion();
+    }
+
+    if (error.name === 'AbortError' || error.code === 'ERR_USE_AFTER_CLOSE') {
+      if (!isShuttingDown) {
+        process.kill(process.pid, 'SIGINT');
+      }
+      return;
+    }
+
+    ui.stopSpinner();
+    if (!error?.silentReported) {
+      ui.printError(`发生错误: ${error.message}`);
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    return await loopQuestion();
+  }
+}
+
+async function retryQuestion(question) {
+  ui.printWarning('人工接管已完成，正在重试当前消息...');
+  return submitConversationMessage(question, { allowRetry: false });
+}
+
+async function main() {
+  try {
+    await logger.init();
+    await sessionManager.init();
+    await taskStore.init();
+    const maintenance = await runRuntimeMaintenance();
+    ensureTaskRunner().startLoop();
+
+    setupGracefulShutdown();
+
+    if (maintenance.tempRemoved > 0) {
+      ui.printMuted(`启动清理: 已移除 ${maintenance.tempRemoved} 个临时文件`);
+    }
+    if (maintenance.sessionsArchived > 0 || maintenance.tasksArchived > 0) {
+      ui.printMuted(
+        `启动归档: 会话 ${maintenance.sessionsArchived} 个, 任务 ${maintenance.tasksArchived} 个`
+      );
+    }
+    if (maintenance.profileWarning) {
+      ui.printWarning(
+        `浏览器资料目录约 ${maintenance.profileWarning.sizeMb} MB，已超过提醒阈值 ${maintenance.profileWarning.thresholdMb} MB`
+      );
+    }
+
+    while (true) {
+      const choice = await showStartupMenu();
+
+      if (choice === 'q' || choice === 'Q') {
+        ui.clear();
+        ui.printSuccess('再见！');
+        process.exit(0);
+      }
+
+      if (choice === 'd' || choice === 'D') {
+        showQuickDoc();
+        ui.printInfo('按回车返回主菜单...');
+        await askInput('', true);
+        continue;
+      }
+
+      if (choice === 's' || choice === 'S') {
+        await showSettingsMenu({ ui, config });
+        continue;
+      }
+
+      if (choice === 'c' || choice === 'C') {
+        if (hasActiveSession) {
+          ui.clear();
+          ui.printSuccess('继续聊天...');
+          ui.printNewline();
+          const result = await loopQuestion();
+          if (result === 'MENU') {
+            continue;
+          }
+        } else {
+          ui.printError('没有活跃的会话');
+          await new Promise(resolve => setTimeout(resolve, 1500));
+          continue;
+        }
+      }
+
+      if (choice === '1') {
+        agentMode = Boolean(config.agent?.enabled);
+        resetAgentPrimer();
+        const browserReady = await ensureBrowserReady();
+        if (!browserReady) {
+          continue;
+        }
+
+        const provider = getProvider();
+        const started = await startNewChat(provider);
+        if (!started) {
+          continue;
+        }
+        hasActiveSession = true;
+        if (agentMode) {
+          printAgentHelp();
+        }
+
+        const result = await loopQuestion();
+        if (result === 'MENU') {
+          continue;
+        }
+        break;
+      }
+
+      if (choice === '2') {
+        agentMode = Boolean(config.agent?.enabled);
+        resetAgentPrimer();
+        const sessionMeta = await browseSessions({
+          sessionManager,
+          ui
+        });
+        if (sessionMeta) {
+          const browserReady = await ensureBrowserReady();
+          if (!browserReady) {
+            continue;
+          }
+
+          const resumed = await resumeSession(sessionMeta);
+          if (resumed) {
+            hasActiveSession = true;
+            const result = await loopQuestion();
+            if (result === 'MENU') {
+              continue;
+            }
+            break;
+          }
+        }
+        continue;
+      }
+
+      ui.printError('无效的选择，请从菜单中选择可用项。');
+      ui.printInfo(hasActiveSession ? '可选项: c, 1, 2, s, d, q' : '可选项: 1, 2, s, d, q');
+      await new Promise(resolve => setTimeout(resolve, 1500));
+    }
+
+  } catch (error) {
+    ui.printError(`初始化失败: ${error.message}`);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+main();