@tbox.cn/app-template-agent 0.1.0 → 0.7.4

package/apps/server/src/dev.ts

@@ -0,0 +1,81 @@
+/**
+ * vite dev 入口（仅 tsx 运行：pnpm dev；物理不进 tsup bundle——forbid-vite 插件拦截）。
+ * middlewareMode + 单端口：HTTP 与 HMR WS 全走应用端口（沙箱仅暴露一个端口亦可开发）。
+ * 部署形态一律走 dist/index.js（静态产物，零 HMR WS）。
+ */
+import { createServer } from 'http';
+import path from 'path';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'url';
+import { createServer as createViteServer } from 'vite';
+import { injectScript, isReady } from '@tbox.cn/app-sdk/platform';
+import { createLogger } from '@tbox.cn/app-sdk/server';
+import { app, registerUpgradeDelegate, start } from './app.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const serverLogger = createLogger('server');
+const clientRoot = path.resolve(__dirname, '../../client');
+
+// HMR WS 独立路径：dev 基础设施命名空间（双下划线呼应 /@vite/*），与业务命名空间（/ws*）
+// 解耦——delegate 只认领此路径，根路径归还业务路由。
+const HMR_WS_PATH = '/__vite_hmr';
+
+// HMR WS hub：永不 listen 的纯事件载体。hmr.server 在场 → vite 不自建 24678 独立端口，
+// 客户端 __HMR_PORT__=null → 按页面同源端口连接（公网端口映射无关）。vite 对 hub 仅
+// on/off('upgrade')（6.4.3 源码实证）；协议常量（vite-hmr/vite-ping）与认领路径
+// posix.join(base, hmr.path) 是 vite 契约面，由 scripts/smoke-dev-hmr.sh 守护。
+const hmrHub = createServer();
+
+const vite = await createViteServer({
+  root: clientRoot,
+  server: {
+    middlewareMode: true,
+    // 沙箱域名 Host 透传放行（dev-only；dist 物理不含 vite）。安全边界四条
+    // （cors() 既存全开 / 代理收敛公网入口 / token 轴不变 / /@fs 另有 deny）见 Agent Note 2026-09-09。
+    allowedHosts: true,
+    // /@fs 加固：默认 deny 不含服务端凭证目录（client 永不需要经 /@fs 读它）
+    fs: { deny: ['.env', '.env.*', '*.{crt,pem}', '**/.git/**', '**/config/credentials/**'] },
+    hmr: { server: hmrHub, path: HMR_WS_PATH },
+  },
+  // custom：不加 Vite 自己的 SPA fallback，由下方 app.use('*') 统一处理 HTML 路由
+  appType: 'custom',
+  optimizeDeps: { entries: [] },
+});
+
+// 升级委托：与 vite hmrServerWsListener 同条件（协议整串匹配 + pathname === 认领路径）。
+// viteHmrPath 与 vite 同一 resolved config、同式 posix.join 派生——恒等无漂移（字面比较
+// 在未来设 base 时有悬挂方向：delegate 认领转发而 vite 不接，socket 无人销毁）。协议轴
+// 必须保留：hub 是纯事件载体无 destroy，仅匹配 path 的非 vite 协议升级会转发后无人认领。
+// 未认领的升级回落 app 路由（业务 /ws、根路径归还业务、fail-fast 语义不变）。
+const viteHmrPath = path.posix.join(vite.config.base, HMR_WS_PATH);
+registerUpgradeDelegate((request, socket, head) => {
+  const protocol = request.headers['sec-websocket-protocol'];
+  if (protocol !== 'vite-hmr' && protocol !== 'vite-ping') return false;
+  const { pathname } = new URL(request.url || '/', 'http://localhost');
+  if (pathname !== viteHmrPath) return false;
+  hmrHub.emit('upgrade', request, socket, head);
+  return true;
+});
+
+// Vite 中间件：静态资源、模块转换、HMR（装配已在 ./app.js import 期完成）
+app.use(vite.middlewares);
+
+// HTML 路由兜底：非 /api、/ws 一律返回 index.html（经 Vite 转换 + inspector 注入）
+app.use('*', async (req, res, next) => {
+  if (req.originalUrl.startsWith('/api') || req.originalUrl.startsWith('/ws')) {
+    return next();
+  }
+  try {
+    const rawHtml = await readFile(path.join(clientRoot, 'index.html'), 'utf-8');
+    const template = await vite.transformIndexHtml(req.originalUrl, rawHtml);
+    const html = isReady() ? injectScript(template) : template;
+    res.status(200).set({ 'Content-Type': 'text/html' }).end(html);
+  } catch (e) {
+    next(e);
+  }
+});
+
+start().catch((err) => {
+  serverLogger.error('Failed to start:', err);
+  process.exit(1);
+});

package/apps/server/src/index.ts

@@ -1,230 +1,35 @@
-import express from 'express';
-import cors from 'cors';
-import { createServer } from 'http';
+/**
+ * 静态入口（唯一 tsup entry → dist/index.js）：express.static 供给 client/dist。
+ * dist 形态恒静态——vite dev 仅存在于 src/dev.ts（tsx 运行，禁入 tsup entry，
+ * tsup.config.ts forbid-vite 插件拦截）。NODE_ENV 只影响 SDK 安全姿态（dev-login/密钥链）。
+ */
 import path from 'path';
+import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'url';
-import { registerAll } from './modules.js';
-import {
-  createWsServer,
-  createServerContext,
-  createEngineFromContext,
-  tboxTraceExporter,
-  extractImageUrls,
-  TBOX_FILE_URL_PREFIX,
-  createAuthRuntime,
-  createPlatformApiRouter,
-  createTtsProxy,
-  createModelProvider,
-  createPluginIntegration,
-  ConversationService,
-} from '@tbox.cn/app-sdk/server';
-import { installInspector, injectScript, isReady } from '@tbox.cn/app-sdk/platform';
-import { translateTool } from './tools/translate.js';
-import { INTENT_ROUTES, createAppIntentDispatcher } from './intent-routes.js';
+import express from 'express';
+import { createLogger } from '@tbox.cn/app-sdk/server';
+import { app, start } from './app.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const PORT = Number(process.env.PORT) || 8000;
-const HOST = process.env.HOST || '0.0.0.0';
-const isProduction = process.env.NODE_ENV === 'production';
-
-const AI_MODEL_NAME = process.env.APP_AI_MODEL_NAME || '';
-
-const AGENT_CONFIG = {
-  instructions: [
-    '你是一个通用 AI 助手。可以回答用户问题，也可以调用工具获取信息。用简洁、清晰的语言回复。',
-    '调用业务工具时正常按其 schema 传参，拿到结果后用自然语言回复用户；',
-    '是否向用户呈现卡片由系统自动决定，你不需要也不应该主动渲染 UI。',
-  ].join('\n'),
-};
-
-// 平台能力装配（003/006 平台轴，已下沉 @tbox.cn/app-sdk/server）
-const auth = createAuthRuntime();
-const { getModel } = createModelProvider();
-const pluginTools = createPluginIntegration();
-
-/** 懒初始化单例 ConversationService */
-let _conversationService: ConversationService | null = null;
-function getConversationService(): ConversationService | null {
-  if (!_conversationService) {
-    const apiKey = process.env.TBOX_API_KEY;
-    if (!apiKey) return null;
-    _conversationService = new ConversationService(apiKey);
-  }
-  return _conversationService;
-}
-
-// 进程级最后防线
-process.on('unhandledRejection', (reason) => {
-  console.error('[server] unhandledRejection:', reason);
-});
-process.on('uncaughtException', (err) => {
-  console.error('[server] uncaughtException:', err);
-});
-
-const app = express();
-app.use(cors());
-app.use(express.json());
+const serverLogger = createLogger('server');
 
-// 🔒 平台基础设施 — 禁止 AI 删除或修改（@infrastructure-locked）
-installInspector(app);
-
-// 非 prod 默认开启 dev-login：对暴露公网的实例给出可见警示（生产必须 NODE_ENV=production）
-if (auth.config.devLoginEnabled) {
-  console.warn(
-    '[AUTH] dev-login 已开启（非 production 默认）。若本实例暴露公网，请设 NODE_ENV=production 或 AUTH_DEV_LOGIN_DISABLED=true。',
+const clientDistPath = path.join(__dirname, '../../client/dist');
+if (!existsSync(path.join(clientDistPath, 'index.html'))) {
+  serverLogger.warn(
+    `client/dist 缺失（${clientDistPath}）——页面将不可用（API/WS 不受影响）；请先执行 pnpm build:client`,
   );
 }
 
-// 自注册闭环：模块路由挂载到 /api/m/<moduleId>/（在 apiRouter 之前，避免被 /api 兜底 404 截获）
-// ctx 为模块级单例：registerAll 在 start() 内执行，ApiRouteRegistry 共享 root 保证延迟注册即时生效
-const ctx = createServerContext();
-
-// 全局 /api 鉴权（H2 挂载顺序契约）：除 public（login/dev-login/health）外一律要求 Bearer token；
-// optional 模式缺失 token → 匿名身份（写通道仍被 action gateway 拒绝）
-// ⚠️ 必须先于 /api/m、/api/action、createPlatformApiRouter 挂载，保证全 API 面受鉴权约束
-app.use('/api', auth.middleware);
-
-app.use('/api/m', ctx.routes.mount());
-
-// 业务动作网关（004 D3/C2）：POST /api/action — SDK 黑盒唯一写入口（幂等/防重放/签名槽位；
-// 006 D11：匿名写拒绝，不随 AUTH_MODE 变）
-app.use('/api/action', ctx.actions.middleware());
-
-// API 路由（平台路由面：auth/health/tbox/conversation + 404 兜底；卡片恢复内部化）
-app.use('/api', createPlatformApiRouter({ ctx, auth }));
-
-// 从 ServerContext 构造 ChatEngine（自注册闭环组装端）
-async function createEngine() {
-  return createEngineFromContext(ctx, {
-    instructions: AGENT_CONFIG.instructions,
-    model: getModel(AI_MODEL_NAME),
-    traceExporter: tboxTraceExporter,
-    modelName: AI_MODEL_NAME,
-    fileUrlPrefix: TBOX_FILE_URL_PREFIX,
-    // B21：意图路由接线（业务意图表 + handlerDispatch）
-    intentRoutes: INTENT_ROUTES,
-    handlerDispatch: createAppIntentDispatcher(ctx),
-    loadPlugins: async () => {
-      const loaded = await pluginTools.loadTools({
-        reservedToolIds: Object.keys(ctx.tools.getAll()),
-      });
-      return { tools: loaded.tools, references: loaded.references };
-    },
-    saveMessage: async ({ conversationId, query, answer, mediaItems, outerBusinessId, cards }) => {
-      const agentId = process.env.TBOX_APP_ID;
-      const service = getConversationService();
-      if (!service || !agentId) return undefined;
-      const imageUrls = extractImageUrls(mediaItems, TBOX_FILE_URL_PREFIX);
-      return await service.saveMessage({
-        conversationId,
-        agentId,
-        query,
-        answer,
-        ...(outerBusinessId && { outerBusinessId }),
-        ...(imageUrls.length > 0 && {
-          multiModalInputs: { imageUrls },
-        }),
-        // P3 W1：卡片快照随消息持久化（MessageEmbedded，004 D1）。
-        // 若平台拒绝 inputs（V1 验证失败），此处切换为 extraParams 字符串或 FileCardPersistenceBackend 落盘。
-        ...(cards && cards.length > 0 && { inputs: { cards } }),
-      });
-    },
-  });
-}
-
-if (isProduction) {
-  const clientDistPath = path.join(__dirname, '../../client/dist');
-  app.use(express.static(clientDistPath));
-  app.get('*', (req, res) => {
-    if (!req.path.startsWith('/api')) {
-      res.sendFile(path.join(clientDistPath, 'index.html'));
-    } else {
-      res.status(404).json({ error: 'Not Found' });
-    }
-  });
-} else {
-  // 开发环境：Vite middlewareMode 单进程
-  const { createServer: createViteServer } = await import('vite');
-  const { readFile } = await import('fs/promises');
-  const clientRoot = path.resolve(__dirname, '../../client');
-  const vite = await createViteServer({
-    root: clientRoot,
-    server: { middlewareMode: true },
-    // custom：不添加 Vite 自己的 SPA fallback / 404 处理器，
-    // 由下方 app.use('*') 统一处理 HTML 路由，避免 Vite 的 404 先返回。
-    appType: 'custom',
-    optimizeDeps: { entries: [] },
-  });
-
-  // Vite 中间件：处理静态资源、模块转换、HMR
-  app.use(vite.middlewares);
-
-  // HTML 路由兜底：非 /api、/ws 的请求一律返回 index.html（经 Vite 转换 + inspector 注入）
-  app.use('*', async (req, res, next) => {
-    if (req.originalUrl.startsWith('/api') || req.originalUrl.startsWith('/ws')) {
-      return next();
-    }
-    try {
-      const rawHtml = await readFile(path.join(clientRoot, 'index.html'), 'utf-8');
-      const template = await vite.transformIndexHtml(req.originalUrl, rawHtml);
-      const html = isReady() ? injectScript(template) : template;
-      res.status(200).set({ 'Content-Type': 'text/html' }).end(html);
-    } catch (e) {
-      next(e);
-    }
-  });
-}
-
-const httpServer = createServer(app);
-
-async function start() {
-  // 注册业务模块（自注册闭环）
-  await registerAll(ctx);
-
-  // 模板演示工具（apps 级工具，P3 建议迁入模块）：不参与模块体系，直接注册
-  ctx.tools.register(translateTool);
-
-  const engine = await createEngine();
-
-  const chatWss = createWsServer(engine, { auth: auth.wsAuth });
-  const ttsWss = createTtsProxy();
-
-  httpServer.on('error', (err: NodeJS.ErrnoException) => {
-    if (err.code === 'EADDRINUSE') {
-      console.error(`[server] Port ${PORT} is already in use.`);
-    } else if (err.code === 'EACCES') {
-      console.error(`[server] Permission denied while binding ${HOST}:${PORT}.`);
-    } else {
-      console.error('[server] Failed to start HTTP server:', err);
-    }
-    process.exit(1);
-  });
-
-  httpServer.on('upgrade', (request, socket, head) => {
-    socket.on('error', (e) => console.warn('[upgrade] socket error:', e.message));
-    const { pathname } = new URL(request.url || '/', 'http://localhost');
-
-    if (pathname === '/ws') {
-      chatWss.handleUpgrade(request, socket, head, (ws) => {
-        chatWss.emit('connection', ws, request);
-      });
-    } else if (pathname === '/ws/tts') {
-      ttsWss.handleUpgrade(request, socket, head, (ws) => {
-        ttsWss.emit('connection', ws, request);
-      });
-    } else {
-      socket.destroy();
-    }
-  });
-
-  httpServer.listen(PORT, HOST, () => {
-    console.log(`🚀 Server running at http://${HOST}:${PORT}`);
-    console.log(`📡 WebSocket endpoint: ws://${HOST}:${PORT}/ws`);
-    console.log(`🔊 TTS endpoint: ws://${HOST}:${PORT}/ws/tts`);
-  });
-}
+app.use(express.static(clientDistPath));
+app.get('*', (req, res) => {
+  if (!req.path.startsWith('/api')) {
+    res.sendFile(path.join(clientDistPath, 'index.html'));
+  } else {
+    res.status(404).json({ error: 'Not Found' });
+  }
+});
 
 start().catch((err) => {
-  console.error('[server] Failed to start:', err);
+  serverLogger.error('Failed to start:', err);
   process.exit(1);
-});
+});

package/apps/server/src/intent-routes.ts

@@ -2,9 +2,10 @@ import type { IntentRoute, HandlerResult, ServerContext } from '@tbox.cn/app-sdk
 
 /**
  * 业务意图表（B21：intent-framework hybrid 接线——SDK 框架 + 源码意图表，003 §3.3）。
- * chat() 先 matchIntent（最长关键词命中）；命中则经 handlerDispatch 出卡/文字，不走 LLM。
+ * chat() 先 matchIntent（统一检索层 BM25 竞争：长词 OR ≥2 token 规则，score 降序 + id 字典序）；
+ * handler 缺省直接出卡/文字，也可用 continueWith 续接完整 Agent。
  *
- * 示例（商圈应用启用积分抵扣停车意图）：
+ * 示例（商圈应用启用积分抵扣停车意图，handlerId 对应已装模块的 handler id）：
  *   { id: 'points-parking', keywords: ['积分抵扣停车', '停车抵扣'], handlerId: 'points-parking', action: 'run' }
  * 本模板默认空表（保持 LLM + tool calling 主路径）；业务方在此声明意图路由。
  */
@@ -17,7 +18,13 @@ export const INTENT_ROUTES: IntentRoute[] = [];
  * P2-3：用户原始输入以 payload.content 传入，handler 侧可经 payload.content 取用。
  */
 export function createAppIntentDispatcher(ctx: ServerContext) {
-  return async (route: IntentRoute, content: string): Promise<HandlerResult | undefined> => {
-    return ctx.handlers.dispatch(route.handlerId, route.action, { content }, ctx);
+  // 上下文统一化：第三参 reqCtx（引擎意图分发注入的运行上下文）透传 handlers.dispatch
+  // 第五参——意图 handler 经 handle 第四参消费；断链 = 意图路径恒「缺少运行上下文」。
+  return async (
+    route: IntentRoute,
+    content: string,
+    reqCtx?: import('@tbox.cn/app-contracts').RequestContext,
+  ): Promise<HandlerResult | undefined> => {
+    return ctx.handlers.dispatch(route.handlerId, route.action, { content }, ctx, reqCtx);
   };
 }

package/apps/server/src/modules.ts

@@ -8,23 +8,30 @@
 import type { ServerContext, InferModuleCards } from '@tbox.cn/app-sdk/server';
 
 // @tbox:imports-begin
+// SDK 装配框架（非模块行，CLI 增量维护保留非标行）
+import { registerServerModules } from '@tbox.cn/app-sdk/server';
 import { serverModule as moduleWeather } from '@app/module-weather/server';
+import { serverModule as providerCustom } from '@app/provider-custom/server';
 // @tbox:imports-end
 
 // @tbox:register-begin
+// base 模板出厂预装 provider-custom（自定义 API 落点）+ weather 演示模块
 const modules = [
   moduleWeather,
+  providerCustom,
 ];
 // @tbox:register-end
 
 // 自由区：可做装配级定制——条件注册、顺序调整、包裹中间件
 // const dynamicModule = process.env.ENABLE_X ? xModule : null;
 
-/** 注册所有已安装模块（服务端装配——勿与 apps/client/src/modules.ts 混淆） */
-export function registerAll(ctx: ServerContext): void {
-  for (const m of modules) {
-    m.register(ctx);
-  }
+/**
+ * 注册所有已安装模块（服务端装配——勿与 apps/client/src/modules.ts 混淆）。
+ * 010 下沉：声明式字段自动注册（skills/preTools）与 async register 等待由
+ * SDK registerServerModules 承载——未来新增声明式字段只改 SDK，本文件零改动。
+ */
+export function registerAll(ctx: ServerContext): Promise<void> {
+  return registerServerModules(ctx, modules);
 }
 
 // 类型从运行时装配数组自动推导：增删模块后 CardType 自动收缩/扩展（002 §6.7）

package/apps/server/src/pre-tools.ts

@@ -0,0 +1,25 @@
+// 铁律：不直接 import @mastra/core，经 @tbox.cn/app-sdk/server 的 definePreTool 入口（单例铁律）
+import { definePreTool } from '@tbox.cn/app-sdk/server';
+import { clockTool } from './tools/clock.js';
+
+/**
+ * 应用级前置工具声明（010）：BuildEngineOptions.preTools 通道。
+ *
+ * 声明形态（详见 README「前置 Tool 加速执行」节）：
+ *   ① tool —— 工具实例引用（单一真源，id/description 派生）
+ *   ② routing —— 结构化路由：{ mode: 'keywords', terms } 宽召回词表（与 skill 同源打分）
+ *                 或 { mode: 'always' } 必选候选（decide 门控；慎用防每轮噪音）
+ *   ③ decide —— 决策即构造：{ decision: 'run', args } = 预执行 / { decision: 'skip' } = 不生效
+ *
+ * 演示形态：零参工程化——词表命中即生效（decide 恒 run 空参）。
+ * 词表刻意排除「今天/时间」等泛词，防止与天气类 preTool 叠加误触发（词表精度示范）。
+ */
+export const APP_PRE_TOOLS = [
+  definePreTool(clockTool, {
+    routing: {
+      mode: 'keywords',
+      terms: ['几点', '几点了', '现在时间', '日期', '星期几'],
+    },
+    decide: () => ({ decision: 'run', args: {} }),
+  }),
+];

package/apps/server/src/tools/clock.ts

@@ -0,0 +1,24 @@
+// 铁律：不直接 import @mastra/core，经 @tbox.cn/app-sdk/server 的 createTool 入口（单例铁律）
+import { createTool } from '@tbox.cn/app-sdk/server';
+import { z } from 'zod';
+
+/**
+ * 当前时间工具 — 前置工具（pre-tool）演示：零参工具，参数无需模型抽取，
+ * 词表命中即可工程化预执行（见 apps/server/src/pre-tools.ts）。
+ */
+export const clockTool = createTool({
+  id: 'getCurrentTime',
+  description: '查询当前日期和时间',
+  inputSchema: z.object({}),
+  outputSchema: z.object({
+    iso: z.string(),
+    zh: z.string(),
+  }),
+  execute: async () => {
+    const now = new Date();
+    return {
+      iso: now.toISOString(),
+      zh: now.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' }),
+    };
+  },
+});

package/apps/server/src/tools/translate.ts

@@ -12,10 +12,11 @@ export const translateTool = createTool({
     '中英文互译工具。当用户需要翻译文本时调用此工具。自动检测源语言并翻译为目标语言：中文→英文，英文→中文。',
   inputSchema: z.object({
     text: z.string().describe('要翻译的文本'),
+    // D11 参数规范：仅 string 形态（LLM 生成字符串最可靠）；非法值工具内回落自动检测
     targetLang: z
-      .enum(['zh', 'en'])
+      .string()
       .optional()
-      .describe('目标语言，不传则自动检测：中文输入翻译为英文，英文输入翻译为中文'),
+      .describe('目标语言（zh 或 en），不传则自动检测：中文输入翻译为英文，英文输入翻译为中文'),
   }),
   outputSchema: z.object({
     original: z.string(),
@@ -24,9 +25,14 @@ export const translateTool = createTool({
     targetLang: z.string(),
   }),
   execute: async ({ text, targetLang }) => {
-    // 简单语言检测：包含中文字符则认为是中文
+    // 简单语言检测：包含中文字符则认为是中文；非法 targetLang 回落自动检测
     const isChinese = /[\u4e00-\u9fff]/.test(text);
-    const detectedTarget = targetLang || (isChinese ? 'en' : 'zh');
+    const detectedTarget =
+      targetLang === 'zh' || targetLang === 'en'
+        ? targetLang
+        : isChinese
+          ? 'en'
+          : 'zh';
     const sourceLang = isChinese ? 'zh' : 'en';
 
     // 注意：这里返回指令让 LLM 来做实际翻译

package/apps/server/tests/cards-registry.test.ts

@@ -1,9 +1,11 @@
 // 卡片 / 工具 registry 一致性守护测试（自注册闭环版）。
 // 通过 registerAll(ctx) 收集真实注册状态，替代原手写 registry 静态断言。
+// v2 出卡协议：tool→card 绑定（allowedTools/cardResolver）退场——出卡由工具出参
+// cards 字段运行期声明，registry 仅余 cardType 注册与 dataSchema 校验职责。
 // 注：C 方案下卡片渲染在 client（React 组件），server 无 template.html，故移除原 C12（模板占位符 ∈ schema）。
 import { describe, it, expect } from 'vitest';
 import { diagnosePlugins } from '@tbox.cn/agent-plugin/doctor';
-import { createServerContext, buildToolCardBindings, createPluginIntegration } from '@tbox.cn/app-sdk/server';
+import { createServerContext, createPluginIntegration } from '@tbox.cn/app-sdk/server';
 import { registerAll } from '../src/modules.js';
 
 describe('工具 / 卡片 registry 一致性（自注册闭环）', () => {
@@ -15,24 +17,22 @@ describe('工具 / 卡片 registry 一致性（自注册闭环）', () => {
     }
   });
 
-  it('C3: 自动生成的 binding 的每个 cardType 都在 ctx.cards 注册', async () => {
+  it('C3: 每张卡 meta.cardType === ctx.cards 的 key', async () => {
     const ctx = createServerContext();
     await registerAll(ctx);
-    const cards = ctx.cards.getAll();
-    for (const binding of buildToolCardBindings(cards)) {
-      expect(Object.keys(cards)).toContain(binding.cardType);
+    for (const [key, meta] of Object.entries(ctx.cards.getAll())) {
+      expect((meta as { cardType?: string }).cardType).toBe(key);
     }
   });
 
-  it('C3: 工具卡片 binding 与静态工具、插件配置一致（不访问网络）', async () => {
+  it('C3: 插件配置诊断（无卡片绑定，v2 协议下 bindings 恒空）', async () => {
     const ctx = createServerContext();
     await registerAll(ctx);
-    const cards = ctx.cards.getAll();
     const diagnostics = diagnosePlugins({
       config: createPluginIntegration().readConfig(),
-      bindings: buildToolCardBindings(cards),
+      bindings: [],
       staticToolIds: Object.keys(ctx.tools.getAll()),
-      cardTypes: Object.keys(cards),
+      cardTypes: Object.keys(ctx.cards.getAll()),
       apiKeyConfigured: true,
     });
     expect(diagnostics.filter((item) => item.level === 'error')).toEqual([]);
@@ -44,12 +44,4 @@ describe('工具 / 卡片 registry 一致性（自注册闭环）', () => {
       warnings: [],
     });
   });
-
-  it('C3: 每张卡 meta.cardType === ctx.cards 的 key', async () => {
-    const ctx = createServerContext();
-    await registerAll(ctx);
-    for (const [key, meta] of Object.entries(ctx.cards.getAll())) {
-      expect((meta as { cardType?: string }).cardType).toBe(key);
-    }
-  });
 });