minimal-agent 0.12.0 → 0.14.0

package/src/ui/App.tsx

@@ -7,47 +7,67 @@
  * ============================================================
  */
 
-import React, { useDeferredValue } from 'react';
 import { Box, Text, useApp } from 'ink';
+import React, { useDeferredValue } from 'react';
 
 import { getWorkingDir } from '../bootstrap/workingDir.js';
+import {
+  createCliComputerRun,
+  readRecentComputerUseAudit,
+} from '../cli/computerUse.js';
 import { ConfigMenu } from '../cli/configMenu.js';
+import type { ModelConfig } from '../config/configFile.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 {
+  type SessionSummary,
   createSession,
   listSessionSummaries,
   updateSessionMetadata,
-  type SessionSummary,
 } from '../context/sessionRegistry.js';
-import type { Message, Provider } from '../types.js';
-import type { ModelConfig } from '../config/configFile.js';
+import {
+  type WorkspaceRecord,
+  workspaceIndexService,
+} from '../context/workspaceIndex.js';
+import { memoryService } from '../memory/memoryService.js';
+import { legacyModelId, modelRefFromLegacy } from '../modelRef.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';
+  type OnlineModelCatalogItem,
+  beginTeamLogin,
+  clearTeamCredentials,
+  fetchOnlineModels,
+  fetchTeamSubscription,
+  fetchTeamUsage,
+  loadTeamCredentials,
+  revokeTeamCredentials,
+} from '../team/auth.js';
 import { computerUseService } from '../tools/computeruse/computerUseService.js';
-import { advisorHelpText, parseAdvisorCommand } from './advisorCommand.js';
+import type { Message, Provider } from '../types.js';
+import { writeClipboardText } from '../utils/clipboardImage.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 type { PickerModel } from './ModelPicker.js';
+import { QueuedMessagesBanner } from './QueuedMessagesBanner.js';
 import { SessionPicker } from './SessionPicker.js';
-import { WorkspacePicker } from './WorkspacePicker.js';
 import { StatusLine } from './StatusLine.js';
-import { theme } from './theme.js';
+import { WorkspacePicker } from './WorkspacePicker.js';
+import { advisorHelpText, parseAdvisorCommand } from './advisorCommand.js';
 import { parseComputerCommand } from './computerCommand.js';
 import { useChat } from './hooks/useChat.js';
 import { useTerminalSize } from './hooks/useTerminalSize.js';
+import {
+  isLogoutCommand,
+  loginHelpText,
+  parseLoginCommand,
+} from './loginCommand.js';
+import { theme } from './theme.js';
 
 /**
  * ANSI escape: 清屏 + 光标归位。
@@ -68,6 +88,40 @@ function formatProviderName(apiFormat: string): string {
   return apiFormat;
 }
 
+function toPickerModel(model: OnlineModelCatalogItem): PickerModel {
+  return {
+    id: legacyModelId({
+      source: 'gateway',
+      serverId: 'gateway',
+      modelId: model.id,
+    }),
+    apiFormat: model.apiFormat,
+    displayName: model.displayName,
+    model: model.model,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens,
+    supportsVision: model.supportsVision,
+    enabled: true,
+    source: 'gateway',
+    isDefault: model.isDefault,
+    availability: model.availability,
+  };
+}
+
+async function openTeamBrowser(url: string): Promise<void> {
+  const command =
+    process.platform === 'darwin'
+      ? ['open', url]
+      : process.platform === 'win32'
+        ? ['cmd', '/c', 'start', '', url]
+        : ['xdg-open', url];
+  try {
+    Bun.spawn({ cmd: command, stdout: 'ignore', stderr: 'ignore' });
+  } catch {
+    /* TUI prints the URL below */
+  }
+}
+
 interface Props {
   provider: Provider;
   /** 启动时的历史（含 system prompt）；可能是从 last-context.json 加载来的旧对话。 */
@@ -94,19 +148,21 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
       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)
-        }`,
-      );
-    });
+    })
+      .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?.();
@@ -148,15 +204,25 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
   // /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);
+  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);
+  const [baseModelPicker, setBaseModelPicker] = React.useState<{
+    models: PickerModel[];
+    currentId: string | null;
+  } | null>(null);
+  const [advisorModelPicker, setAdvisorModelPicker] = React.useState<{
+    models: PickerModel[];
+    currentId: string | null;
+  } | null>(null);
 
   // 强制刷新计数，用于切换模型后触发 StatusLine 重渲染
   const [, forceRerender] = React.useState(0);
@@ -173,9 +239,14 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
   const handleSessionCreate = React.useCallback(
     async (title: string) => {
       setSessionPicker(null);
-      const summary = await createSession(getWorkingDir(), title ? { title } : {});
+      const summary = await createSession(
+        getWorkingDir(),
+        title ? { title } : {},
+      );
       await chat.switchSession(summary.id);
-      chat.ephemeralLine(`[/session] 已新建并切换到 session "${summary.id}"（${summary.title}）`);
+      chat.ephemeralLine(
+        `[/session] 已新建并切换到 session "${summary.id}"（${summary.title}）`,
+      );
     },
     [chat.switchSession, chat.ephemeralLine],
   );
@@ -187,13 +258,16 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
     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 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) => {
@@ -201,16 +275,54 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
       if (!modelId) return;
       const snap = await configService.getSnapshot();
       const model = snap.config?.models.find((m) => m.id === modelId);
+      const selectedRef = modelRefFromLegacy(modelId);
+      const isGateway = selectedRef.source === 'gateway';
+      if (isGateway) {
+        const provider = await configService.providerForRef(selectedRef);
+        if (provider) {
+          const gatewayProvider =
+            provider.source === 'gateway' ? provider : null;
+          if (!gatewayProvider) return;
+          await updateSessionMetadata(getWorkingDir(), chat.activeSessionId, {
+            modelId: null,
+            preferredModel: {
+              source: 'gateway',
+              serverId: gatewayProvider.gatewayUrl,
+              modelId: selectedRef.modelId,
+            },
+            effectiveModel: {
+              source: 'gateway',
+              serverId: gatewayProvider.gatewayUrl,
+              modelId: selectedRef.modelId,
+            },
+            restoreWhenAvailable: true,
+          });
+          chat.setProvider(provider);
+          forceRerender((v) => v + 1);
+          chat.ephemeralLine(
+            `[/model] 当前 Session 已切换为在线模型 ${provider.name}，下一轮对话生效。`,
+          );
+        }
+        return;
+      }
       if (!model) {
         chat.ephemeralLine(`[/model] 未找到模型 "${modelId}"`);
         return;
       }
       const newProvider = await configService.providerForModel(modelId);
       if (newProvider) {
-        await updateSessionMetadata(getWorkingDir(), chat.activeSessionId, { modelId });
+        await updateSessionMetadata(getWorkingDir(), chat.activeSessionId, {
+          modelId: null,
+          preferredModel: { source: 'local', modelId },
+          effectiveModel: { source: 'local', modelId },
+          fallbackReason: undefined,
+          restoreWhenAvailable: false,
+        });
         chat.setProvider(newProvider);
         forceRerender((v) => v + 1);
-        chat.ephemeralLine(`[/model] 当前 Session 已切换为 ${model.displayName || model.model}（${formatProviderName(model.apiFormat)}），下一轮对话生效。`);
+        chat.ephemeralLine(
+          `[/model] 当前 Session 已切换为 ${model.displayName || model.model}（${formatProviderName(model.apiFormat)}），下一轮对话生效。`,
+        );
       }
     },
     [chat.activeSessionId, chat.setProvider, chat.ephemeralLine],
@@ -218,23 +330,120 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
 
   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]);
+    void listSessionSummaries(getWorkingDir())
+      .then(async (sessions) => {
+        const currentSession = sessions.find(
+          (session) => session.id === chat.activeSessionId,
+        );
+        const preferredModel =
+          currentSession?.preferredModel ??
+          (currentSession?.modelId
+            ? modelRefFromLegacy(currentSession.modelId)
+            : null);
+        let provider: Provider | null = null;
+        let fallbackReason: import('../modelRef.js').ModelFallbackReason = null;
+        if (preferredModel) {
+          const resolved = await configService.resolveModelRef(preferredModel);
+          provider = resolved.provider;
+          fallbackReason = resolved.fallbackReason;
+          if (!provider && preferredModel.source === 'gateway')
+            provider = await configService.providerForModel(null);
+        } else {
+          provider = await configService.onlineDefaultProvider();
+          if (!provider) provider = await configService.providerForModel(null);
+        }
+        if (cancelled) return;
+        if (provider) {
+          const localModelId =
+            currentSession?.preferredModel?.source === 'local'
+              ? currentSession.preferredModel.modelId
+              : currentSession?.modelId &&
+                  !currentSession.modelId.startsWith('online:')
+                ? currentSession.modelId
+                : ((await configService.getSnapshot()).config?.baseModelId ??
+                  provider.model);
+          const effectiveModel =
+            provider.source === 'gateway'
+              ? {
+                  source: 'gateway' as const,
+                  serverId: provider.gatewayUrl ?? 'gateway',
+                  modelId: provider.remoteModelId ?? provider.model,
+                }
+              : { source: 'local' as const, modelId: localModelId };
+          const isGatewayPreference = preferredModel?.source === 'gateway';
+          const shouldPersist =
+            (provider.source === 'gateway' && !preferredModel) ||
+            (isGatewayPreference &&
+              (currentSession?.effectiveModel?.source !==
+                effectiveModel.source ||
+                currentSession?.effectiveModel?.modelId !==
+                  effectiveModel.modelId ||
+                currentSession.fallbackReason !== fallbackReason));
+          chat.setProvider(provider);
+          if (
+            shouldPersist ||
+            (isGatewayPreference && provider.source === 'local')
+          ) {
+            await updateSessionMetadata(getWorkingDir(), chat.activeSessionId, {
+              ...(provider.source === 'gateway' && !preferredModel
+                ? { preferredModel: effectiveModel }
+                : {}),
+              effectiveModel,
+              fallbackReason:
+                provider.source === 'local' ? fallbackReason : null,
+              restoreWhenAvailable:
+                isGatewayPreference || provider.source === 'gateway',
+            }).catch(() => {});
+            if (isGatewayPreference && provider.source === 'local')
+              chat.ephemeralLine(
+                `[/model] 在线模型暂不可用，已回退本地模型（${fallbackReason ?? 'offline'}）；服务恢复后将自动恢复。`,
+              );
+            else if (
+              isGatewayPreference &&
+              provider.source === 'gateway' &&
+              currentSession?.fallbackReason
+            )
+              chat.ephemeralLine(
+                `[/model] 在线模型已恢复，当前 Session 已恢复在线模型 ${provider.name}。`,
+              );
+          }
+        } else if (preferredModel?.source === 'gateway') {
+          chat.ephemeralLine(
+            '[/model] 在线模型不可用，且未配置本地模型；请连接团队服务器或配置本地模型。',
+          );
+        }
+      })
+      .catch(() => {});
+    return () => {
+      cancelled = true;
+    };
+  }, [chat.activeSessionId, chat.setProvider, chat.ephemeralLine]);
 
   const handleAdvisorModelSelect = React.useCallback(
     async (modelId: string | null) => {
       setAdvisorModelPicker(null);
       if (modelId === null) {
-        await configService.savePatch({ advisor: { modelId: null, enabled: false } });
+        await configService.savePatch({
+          advisor: { modelId: null, enabled: false },
+        });
         chat.ephemeralLine('[/advisor] 已关闭顾问模型。');
         return;
       }
+      const selectedRef = modelRefFromLegacy(modelId);
+      if (selectedRef.source === 'gateway') {
+        const provider = await configService.providerForRef(selectedRef);
+        if (!provider) {
+          chat.ephemeralLine(
+            '[/advisor] 在线模型不可用、未授权或设备凭据已过期。',
+          );
+          return;
+        }
+        await configService.savePatch({ advisor: { modelId, enabled: true } });
+        chat.ephemeralLine(
+          `[/advisor] 已设置顾问模型为 ${provider.name}（在线）。`,
+        );
+        return;
+      }
       const snap = await configService.getSnapshot();
       const model = snap.config?.models.find((m) => m.id === modelId);
       if (!model) {
@@ -242,7 +451,9 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
         return;
       }
       await configService.savePatch({ advisor: { modelId, enabled: true } });
-      chat.ephemeralLine(`[/advisor] 已设置顾问模型为 ${model.displayName || model.model}（${formatProviderName(model.apiFormat)}）。`);
+      chat.ephemeralLine(
+        `[/advisor] 已设置顾问模型为 ${model.displayName || model.model}（${formatProviderName(model.apiFormat)}）。`,
+      );
     },
     [chat.ephemeralLine],
   );
@@ -270,7 +481,9 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
     async (text: string) => {
       const trimmed = text.trim();
       const isBareSessionCmd =
-        trimmed === '/session' || trimmed === '/sessions' || trimmed === '/resume';
+        trimmed === '/session' ||
+        trimmed === '/sessions' ||
+        trimmed === '/resume';
       const sessionArgMatch = /^\/(?:session|resume)\s+(.+)$/.exec(trimmed);
 
       if (trimmed === '/workspaces') {
@@ -279,10 +492,19 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
       }
 
       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') {
+        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;
         }
@@ -290,7 +512,9 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
           await writeClipboardText(latest.content);
           chat.ephemeralLine('[/copy] 已复制最近一条 AI 最终回复。');
         } catch (error) {
-          chat.ephemeralLine(`[/copy] ${error instanceof Error ? error.message : String(error)}`);
+          chat.ephemeralLine(
+            `[/copy] ${error instanceof Error ? error.message : String(error)}`,
+          );
         }
         return;
       }
@@ -302,7 +526,7 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
         if (sub === 'help') {
           const helperAvailable = computerUseService.available();
           let helperBackend = '未知';
-          let modeLabel = chat.computerUseMode;
+          const modeLabel = chat.computerUseMode;
           try {
             const workspace = await workspaceIndexService
               .findByPath(getWorkingDir())
@@ -315,7 +539,9 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
               allowedFileRoots: [getWorkingDir()],
               supervised: true,
             });
-            const resp = await computerUseService.request(context, { action: 'status' });
+            const resp = await computerUseService.request(context, {
+              action: 'status',
+            });
             if (resp.ok && resp.state?.backend) {
               helperBackend = resp.state.backend;
             }
@@ -432,7 +658,7 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
             .map((window) => window.appId)
             .filter((id, index, all) => all.indexOf(id) === index);
           chat.ephemeralLine(
-            `[/computer] 可见应用：${apps?.length ? apps.join('、') : response.content ?? '当前没有可见应用'}`,
+            `[/computer] 可见应用：${apps?.length ? apps.join('、') : (response.content ?? '当前没有可见应用')}`,
           );
           return;
         }
@@ -444,11 +670,7 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
         }
         // status
         chat.ephemeralLine(
-          `[/computer] 状态：\n` +
-            `  模式：${chat.computerUseMode}\n` +
-            `  Helper：${computerUseService.available() ? '✅ 可用' : '❌ 不可用'}\n` +
-            `  Backend：${response.state?.backend ?? '未知'}\n` +
-            `  提示：输入 /computer help 查看所有可用命令`,
+          `[/computer] 状态：\n  模式：${chat.computerUseMode}\n  Helper：${computerUseService.available() ? '✅ 可用' : '❌ 不可用'}\n  Backend：${response.state?.backend ?? '未知'}\n  提示：输入 /computer help 查看所有可用命令`,
         );
         return;
       }
@@ -461,20 +683,30 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
       }
 
       if (trimmed === '/memories') {
-        const workspace = await workspaceIndexService.findByPath(getWorkingDir()).catch(() => null);
+        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> 删除一条记忆。`);
+        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 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) {
@@ -520,7 +752,9 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
           )
           .join('\n');
         const tail =
-          entries.length > 30 ? `\n  ...（共 ${entries.length} 条，仅显示前 30）` : '';
+          entries.length > 30
+            ? `\n  ...（共 ${entries.length} 条，仅显示前 30）`
+            : '';
         chat.ephemeralLine(
           `[/list-archive] 归档列表（最新优先）：\n${lines}${tail}`,
         );
@@ -540,7 +774,10 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
           return;
         }
         // 覆盖当前 active session 文件；强制 reload 让 history 替换
-        const targetFile = sessionFileFor(getWorkingDir(), chat.activeSessionId);
+        const targetFile = sessionFileFor(
+          getWorkingDir(),
+          chat.activeSessionId,
+        );
         await saveContext(messages, targetFile);
         await chat.switchSession(chat.activeSessionId, { force: true });
         chat.ephemeralLine(
@@ -571,45 +808,226 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
         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) {
+      // ⚠️ 这里曾有一个 `/plan` 的硬编码特例（改写成 `/workflow plan`）。
+      // 已删 —— `src/plugins/slashFallback.ts` 把它通用化了：`/xxx` 没命中插件
+      // 命令时会按「工具 → skill → 工作流目录」继续找，所以 `/plan`、`/research`、
+      // `/pptx` 全都自动可用，加一条工作流不用再回来改 TUI。
+
+      // /model —— 列出已配置的基座模型并切换选择器；/model <id> 直接切换
+      // /login /logout —— 团队在线模型登录；不登录不影响本机模型（原 /team，改名理由见 loginCommand.ts）。
+      if (isLogoutCommand(trimmed)) {
+        // A standalone session can retain an old auth file from a previous
+        // team run.  Only revoke over the network when the credential matches
+        // the currently configured server; otherwise just clear it locally.
+        const configuredServer = await configService.resolveTeamServerUrl();
+        if (configuredServer.value) {
+          const credentials = await loadTeamCredentials(configuredServer.value);
+          if (credentials) await revokeTeamCredentials(credentials);
+          else await clearTeamCredentials();
+        } else {
+          // No configured server is the standalone boundary. Do not let
+          // revokeTeamCredentials() discover and contact a stale auth file.
+          await clearTeamCredentials();
+        }
+        chat.ephemeralLine(
+          '[/logout] 已登出并撤销本机设备授权；本地模型配置和 Session 未受影响。',
+        );
+        return;
+      }
+      // 发起一次登录尝试。普通用户只使用发行版/配置中的服务端地址。
+      const attemptTeamLogin = async (server?: string, sourceNote?: string) => {
+        if (sourceNote) chat.ephemeralLine(`[/login] ${sourceNote}`);
+        try {
+          const resolved = server
+            ? { value: server, source: 'explicit' }
+            : await configService.resolveTeamServerUrl();
+          if (!resolved.value)
+            throw new Error('KakadeAI 登录服务暂时不可用，请稍后重试');
+          const login = await beginTeamLogin(
+            resolved.value,
+            'minimal-agent TUI',
+          );
           chat.ephemeralLine(
-            '[/plan] 用法：/plan <目标>（= /workflow plan：调研→提问选择→产出 ./PLAN.md）',
+            `[/login] 已打开浏览器授权：${login.authorizeUrl}`,
           );
+          await openTeamBrowser(login.authorizeUrl);
+          await login.complete();
+          chat.ephemeralLine(
+            '[/login] 登录完成；使用 /login models 查看在线模型。',
+          );
+        } catch (error) {
+          chat.ephemeralLine(
+            `[/login] ${error instanceof Error ? error.message : String(error)}`,
+          );
+        }
+      };
+      const loginCommand = parseLoginCommand(trimmed);
+      if (loginCommand.matched) {
+        if (loginCommand.command === 'help') {
+          chat.ephemeralLine(loginHelpText());
+          return;
+        }
+        if (loginCommand.command === 'login') {
+          await attemptTeamLogin(loginCommand.server);
+          return;
+        }
+        const configuredServer = await configService.resolveTeamServerUrl();
+        const credentials = configuredServer.value
+          ? await loadTeamCredentials(configuredServer.value)
+          : null;
+        if (loginCommand.command === 'models') {
+          if (!credentials) {
+            chat.ephemeralLine(
+              '[/login models] 未登录；当前仅使用本机模型。输入 /login 登录。',
+            );
+            return;
+          }
+          try {
+            const models = await fetchOnlineModels(credentials);
+            chat.ephemeralLine(
+              models.length
+                ? models
+                    .map(
+                      (model) =>
+                        `${model.displayName} · ${model.model}${model.isDefault ? ' · 默认' : ''}${model.availability?.reason ? ` · ${model.availability.reason}` : ''}`,
+                    )
+                    .join('\n')
+                : '没有可用在线模型。',
+            );
+          } catch (error) {
+            chat.ephemeralLine(
+              `[/login models] ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+          return;
+        }
+        if (loginCommand.command === 'usage') {
+          if (!credentials) {
+            chat.ephemeralLine('[/login usage] 未登录。');
+            return;
+          }
+          try {
+            const subscription = await fetchTeamSubscription(credentials);
+            const usage = await fetchTeamUsage(credentials);
+            chat.ephemeralLine(
+              subscription
+                ? `[/login usage] ${subscription.planName} · ${subscription.status}\n请求 ${subscription.requestCount}/${subscription.requestLimit} · 输入 ${subscription.inputTokens}/${subscription.inputTokenLimit} · 输出 ${subscription.outputTokens}/${subscription.outputTokenLimit}\n模型记录 ${usage.length} 条`
+                : '[/login usage] 当前没有有效订阅。',
+            );
+          } catch (error) {
+            chat.ephemeralLine(
+              `[/login usage] ${error instanceof Error ? error.message : String(error)}`,
+            );
+          }
+          return;
+        }
+        if (loginCommand.command === 'status') {
+          if (!credentials) {
+            chat.ephemeralLine(
+              '[/login status] 未登录；当前仅使用本机模型。输入 /login 登录。',
+            );
+          } else {
+            try {
+              const online = await fetchOnlineModels(credentials);
+              chat.ephemeralLine(
+                `[/login status] 已连接 ${credentials.serverUrl}；可用在线模型 ${online.length} 个。/logout 登出。`,
+              );
+            } catch (error) {
+              chat.ephemeralLine(
+                `[/login status] 设备凭据存在，但在线服务不可用：${error instanceof Error ? error.message : String(error)}；当前使用本机模型。`,
+              );
+            }
+          }
+          return;
+        }
+        if (loginCommand.command === 'tools') {
+          const current = (await listSessionSummaries(getWorkingDir())).find(
+            (session) => session.id === chat.activeSessionId,
+          );
+          const value = loginCommand.value;
+          if (!value || value === 'list') {
+            chat.ephemeralLine(
+              `[/login tools] 当前 Session 类别：${current?.onlineToolCategories?.join(', ') || '未设置（使用服务器模型预设）'}\n可选：workspace web computer subagents integrations\n设置：/login tools workspace,web`,
+            );
+          } else {
+            const categories = [
+              ...new Set(value.split(/[ ,]+/).filter(Boolean)),
+            ];
+            const allowed = new Set([
+              'workspace',
+              'web',
+              'computer',
+              'subagents',
+              'integrations',
+            ]);
+            if (categories.some((category) => !allowed.has(category))) {
+              chat.ephemeralLine(
+                '[/login tools] 类别无效，可用：workspace web computer subagents integrations',
+              );
+              return;
+            }
+            await updateSessionMetadata(getWorkingDir(), chat.activeSessionId, {
+              onlineToolCategories: categories,
+            });
+            chat.ephemeralLine(
+              `[/login tools] 已设置当前 Session 工具类别：${categories.join(', ') || '无'}`,
+            );
+          }
           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 添加模型。');
+        const enabledModels: PickerModel[] = models.filter(
+          (m) => m.enabled && m.apiKey,
+        );
+        const configuredServer = await configService.resolveTeamServerUrl();
+        const credentials = configuredServer.value
+          ? await loadTeamCredentials(configuredServer.value)
+          : null;
+        const online = credentials
+          ? await fetchOnlineModels(credentials).catch((error) => {
+              chat.ephemeralLine(
+                `[/model] 在线模型暂时不可用：${error instanceof Error ? error.message : String(error)}；仍可选择本机模型。`,
+              );
+              return [];
+            })
+          : [];
+        const onlinePickerModels: PickerModel[] = online.map(toPickerModel);
+        const pickerModels = [...enabledModels, ...onlinePickerModels];
+        if (pickerModels.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);
+          const target = pickerModels.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')}`);
+            chat.ephemeralLine(
+              `[/model] 未找到模型 "${arg}"，可用模型：\n${pickerModels.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 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 });
+        const currentRef = currentSession?.preferredModel;
+        const currentId = currentRef
+          ? legacyModelId(currentRef)
+          : (currentSession?.modelId ?? snap.config?.baseModelId ?? null);
+        setBaseModelPicker({ models: pickerModels, currentId });
         return;
       }
 
@@ -645,42 +1063,70 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
 
         if (sub === 'on') {
           if (!advisor) {
-            chat.ephemeralLine(
-              '[/advisor] 未配置顾问模型，无法开启。',
-            );
+            chat.ephemeralLine('[/advisor] 未配置顾问模型，无法开启。');
           } else {
             await configService.savePatch({ advisor: { enabled: true } });
-            chat.ephemeralLine(`[/advisor] 顾问模型已开启（${advisor.provider.name}/${advisor.provider.model}）。`);
+            chat.ephemeralLine(
+              `[/advisor] 顾问模型已开启（${advisor.provider.name}/${advisor.provider.model}）。`,
+            );
           }
           return;
         }
 
         if (sub === 'off') {
-          if (advisor) await configService.savePatch({ advisor: { enabled: false } });
+          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) {
+          const enabledModels: PickerModel[] = models.filter(
+            (m) => m.enabled && m.apiKey,
+          );
+          const configuredServer = await configService.resolveTeamServerUrl();
+          const credentials = configuredServer.value
+            ? await loadTeamCredentials(configuredServer.value)
+            : null;
+          const online = credentials
+            ? await fetchOnlineModels(credentials).catch((error) => {
+                chat.ephemeralLine(
+                  `[/advisor] 在线顾问模型暂时不可用：${error instanceof Error ? error.message : String(error)}；仍可选择本机顾问模型。`,
+                );
+                return [];
+              })
+            : [];
+          const pickerModels = [...enabledModels, ...online.map(toPickerModel)];
+          if (pickerModels.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);
+            const target = pickerModels.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')}`);
+              chat.ephemeralLine(
+                `[/advisor] 未找到模型 "${note}"，可用模型：\n${pickerModels.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)}）。`);
+            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 });
+            setAdvisorModelPicker({
+              models: pickerModels,
+              currentId: snap.config?.advisor?.modelId ?? null,
+            });
           }
           return;
         }
@@ -688,11 +1134,15 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
         // sub === 'ask'：立即请求顾问意见。走 chat.runManualAdvisor 而不是裸 runAdvisor——
         // 它负责过程显示（LiveArea 进度行）与 ESC 中断，否则最长 180 秒 TUI 全静默。
         if (!advisor) {
-          chat.ephemeralLine('[/advisor] 未配置顾问模型：先用 /advisor select 选一个，或在 Desktop 设置 → 模型中配置。');
+          chat.ephemeralLine(
+            '[/advisor] 未配置顾问模型：先用 /advisor select 选一个，或在 Desktop 设置 → 模型中配置。',
+          );
           return;
         }
         if (!advisor.enabled) {
-          chat.ephemeralLine('[/advisor] 顾问模型当前已关闭；/advisor on 开启后再咨询。');
+          chat.ephemeralLine(
+            '[/advisor] 顾问模型当前已关闭；/advisor on 开启后再咨询。',
+          );
           return;
         }
         const result = await chat.runManualAdvisor(note);
@@ -725,7 +1175,6 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
       chat.activeSessionId,
       chat.submit,
       chat.runManualAdvisor,
-      chat.setProvider,
       chat.computerUseMode,
       chat.setComputerUseMode,
       chat.stopComputerUse,
@@ -735,7 +1184,6 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
       handleSessionCreate,
       openWorkspacePicker,
       handleBaseModelSelect,
-      handleAdvisorModelSelect,
     ],
   );
 
@@ -784,10 +1232,19 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
         <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>
+          <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。
+              请直接在目标应用中处理；敏感内容不会进入终端或模型。完成后输入
+              /computer resume，取消输入 /computer cancel。
             </Text>
           </Box>
         )}
@@ -802,8 +1259,13 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
         {/* 中断提示 */}
         {chat.interrupted && (
           <Box marginBottom={1}>
-            <Text color={theme.warning}>⚡ 操作被用户中断，等待新的任务输入...</Text>
-            <Text dimColor>  调整上一次计划：直接说调整内容 / 重新跑 /plan 目标 / 新任务直接说</Text>
+            <Text color={theme.warning}>
+              ⚡ 操作被用户中断，等待新的任务输入...
+            </Text>
+            <Text dimColor>
+              {' '}
+              调整上一次计划：直接说调整内容 / 重新跑 /plan 目标 / 新任务直接说
+            </Text>
           </Box>
         )}
 
@@ -812,7 +1274,10 @@ export function App({ provider, initialHistory }: Props): JSX.Element {
             或普通 InputBox——都用 useInput，同时挂会抢键 → 必须互斥渲染。
             选完/取消/关闭后各自状态归位，InputBox 自动回归。 */}
         {configMenuOpen ? (
-          <ConfigMenu mode="reconfigure" onDone={() => setConfigMenuOpen(false)} />
+          <ConfigMenu
+            mode="reconfigure"
+            onDone={() => setConfigMenuOpen(false)}
+          />
         ) : baseModelPicker ? (
           <ModelPicker
             models={baseModelPicker.models}