autosnippet 3.2.7 → 3.2.9

package/lib/http/routes/remote.js

@@ -1,29 +1,28 @@
 /**
- * Remote Command Router — 飞书 Bot → IDE 编程桥接
+ * Remote Command Router — 飞书 Bot ↔ IDE 编程桥接 + AI Agent 知识管理
  *
- * 架构（长连接模式）:
- *   Mac 本地启动 WSClient 长连接 → 飞书推送消息到本机
- *   → 解析系统命令 / 写入 remote_commands 队列
- *   → VSCode 扩展轮询 GET /pending → 注入 Copilot Chat
- *   → 扩展回写 POST /result → 飞书 Bot 回复用户
+ * 架构（自然语言路由模式 v2）:
+ *   飞书消息 → LarkTransport → IntentClassifier 意图分类
+ *     → bot_agent: 知识管理任务 → AgentRuntime 直接处理 → 飞书回复
+ *     → ide_agent: 编程任务 → remote_commands 队列 → VSCode 扩展 → Copilot Chat
+ *     → system: 状态/截图 → 本地直接处理
  *
- * 健壮性:
+ * 设计原则:
+ *   ✓ 零命令交互 — 全部使用自然语言，AI 自动判断意图
+ *   ✓ 双 Agent 分流 — 知识任务服务端处理，编程任务转发 IDE
  *   ✓ 飞书 WS 随路由加载自动启动
- *   ✓ 系统命令: /help /status /queue /cancel /clear /ping /screen
  *   ✓ 超时自动清理（pending 120s / running 600s）
  *   ✓ 消息去重 + 非文本提示
  *   ✓ SDK Client 回复 + REST 回退
  */
 
 import crypto from 'node:crypto';
-import { execSync } from 'node:child_process';
-import { readFileSync, unlinkSync, existsSync, statSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { readFileSync, unlinkSync, existsSync } from 'node:fs';
 import express from 'express';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { getServiceContainer } from '../../injection/ServiceContainer.js';
 import { asyncHandler } from '../middleware/errorHandler.js';
+import { LarkTransport } from '../../service/agent/LarkTransport.js';
 
 const router = express.Router();
 const logger = Logger.getInstance();
@@ -120,7 +119,7 @@ let _larkClient = null;
 let _wsConnected = false;
 let _wsStarting = false;
 
-async function startLarkWS() {
+async function startLarkWS({ silent = false } = {}) {
   // 如果已连接且对象存在 → 直接返回
   if (_wsClient && _wsConnected) return { success: true, message: 'Already connected' };
   if (_wsStarting) return { success: true, message: 'Connection in progress' };
@@ -173,16 +172,18 @@ async function startLarkWS() {
 
     logger.info('[Remote/Lark] ✅ WebSocket long connection established');
 
-    // 向飞书发送上线通知（延迟 1 秒确保 chatId 已恢复）
-    setTimeout(() => {
-      sendLarkNotification([
-        '🟢 IDE 桥接已上线',
-        `时间: ${new Date().toLocaleString('zh-CN')}`,
-        `平台: macOS | Node ${process.version}`,
-        '',
-        '发送任意文字即可远程编程，/help 查看命令。',
-      ].join('\n')).catch(() => {});
-    }, 1000);
+    // 向飞书发送上线通知（仅首次启动，重连时静默）
+    if (!silent) {
+      setTimeout(() => {
+        sendLarkNotification([
+          '🟢 IDE 桥接已上线',
+          `时间: ${new Date().toLocaleString('zh-CN')}`,
+          `平台: macOS | Node ${process.version}`,
+          '',
+          '发送任意文字即可远程编程，/help 查看命令。',
+        ].join('\n')).catch(() => {});
+      }, 1000);
+    }
 
     return { success: true, message: 'Connected via WebSocket' };
   } catch (err) {
@@ -246,14 +247,12 @@ setInterval(async () => {
     }
   }
 
-  // WSClient 不存在或已标记断开 → 自动重连
+  // WSClient 不存在或已标记断开 → 自动重连（静默，不打扰用户）
   if (!_wsClient && !_wsStarting) {
     logger.info('[Remote/Lark] Connection lost, auto-reconnecting...');
-    const result = await startLarkWS();
+    const result = await startLarkWS({ silent: true });
     if (result.success) {
       logger.info('[Remote/Lark] ✅ Auto-reconnected successfully');
-      // 重连成功通知
-      sendLarkNotification('🔄 IDE 桥接重连成功').catch(() => {});
     } else {
       logger.warn(`[Remote/Lark] Auto-reconnect failed: ${result.message}`);
     }
@@ -286,60 +285,60 @@ setInterval(() => {
 }, CLEANUP_INTERVAL_MS);
 
 // ═══════════════════════════════════════════════════════
-//  系统命令处理
+//  LarkTransport — 自然语言意图路由
 // ═══════════════════════════════════════════════════════
 
-const SYSTEM_COMMANDS = {
-  '/help': handleHelp,
-  '/status': handleStatus,
-  '/check': handleStatus,
-  '/queue': handleQueue,
-  '/cancel': handleCancel,
-  '/clear': handleClear,
-  '/ping': handlePing,
-  '/screen': handleScreen,
-};
-
-function isSystemCommand(text) {
-  const cmd = text.split(/\s/)[0].toLowerCase();
-  return SYSTEM_COMMANDS[cmd] || null;
-}
+/** @type {LarkTransport|null} */
+let _larkTransport = null;
+
+/**
+ * 获取或创建 LarkTransport 实例
+ * 延迟初始化，等待 ServiceContainer 就绪
+ */
+function getLarkTransport() {
+  if (_larkTransport) return _larkTransport;
+
+  try {
+    const container = getServiceContainer();
+    const agentFactory = container.get('agentFactory');
+    const aiProvider = container.get('aiProvider');
+
+    if (!agentFactory) {
+      logger.warn('[Remote/Lark] AgentFactory not available, transport not ready');
+      return null;
+    }
 
-async function handleHelp(_args, messageId) {
-  await replyLark(messageId, [
-    '🤖 AutoSnippet 远程编程 — 命令帮助',
-    '',
-    '直接发送文字 → 注入 Copilot Agent Mode 执行编程',
-    '',
-    '系统命令：',
-    '  /status  — 连接诊断 + 队列状态',
-    '  /queue   — 查看待执行队列',
-    '  /cancel  — 取消所有 pending 指令',
-    '  /clear   — 清空历史记录',
-    '  /ping    — 测试连通性',
-    '  /screen  — 截取 IDE 画面发到飞书',
-    '  /help    — 显示此帮助',
-    '',
-    '💡 远程模式自动开启全局 Auto-Approve，',
-    '   Copilot 将自动执行工具调用/编辑/终端操作。',
-  ].join('\n'));
+    _larkTransport = new LarkTransport({
+      agentFactory,
+      aiProvider,
+      replyFn: replyLark,
+      sendFn: sendLarkNotification,
+      sendImageFn: sendLarkScreenshot,
+      getStatusFn: getStatusText,
+      enqueueIdeFn: enqueueIdeCommand,
+      isUserAllowed,
+    });
+
+    logger.info('[Remote/Lark] LarkTransport initialized');
+    return _larkTransport;
+  } catch (err) {
+    logger.warn(`[Remote/Lark] LarkTransport init failed: ${err.message}`);
+    return null;
+  }
 }
 
-async function handleStatus(_args, messageId) {
+/**
+ * 生成系统状态文本 (给 LarkTransport 系统操作使用)
+ */
+async function getStatusText() {
   const lines = ['📊 状态面板', ''];
   const now = Math.floor(Date.now() / 1000);
   let ideOk = false;
 
-  // 1. 飞书 WebSocket
   lines.push(`① 飞书 WebSocket: ${_wsConnected ? '✅ 已连接' : '❌ 断开'}`);
-
-  // 2. API 服务器
   lines.push('② API 服务器: ✅ 运行中 (port ' + (process.env.PORT || 3000) + ')');
-
-  // 3. 活跃会话
   lines.push(`③ 活跃会话: ${_activeChatId ? '✅ ' + _activeChatId.slice(0, 16) + '...' : '⚠️ 无活跃会话'}`);
 
-  // 4. IDE 扩展
   try {
     const db = getDb();
     ensureTable(db);
@@ -365,7 +364,6 @@ async function handleStatus(_args, messageId) {
       }
     }
 
-    // 5. 队列
     const counts = {};
     for (const s of ['pending', 'running', 'completed', 'timeout']) {
       counts[s] = db.prepare('SELECT COUNT(*) as c FROM remote_commands WHERE status = ?').get(s)?.c || 0;
@@ -376,165 +374,87 @@ async function handleStatus(_args, messageId) {
     lines.push('⑤ 队列: ❓ 查询失败');
   }
 
-  // 6. 通知通道
   lines.push(`⑥ 通知通道: ${isLarkNotificationReady() ? '✅ 就绪' : '❌ 未就绪'}`);
 
-  // 总结
   const allGood = _wsConnected && _activeChatId && ideOk && isLarkNotificationReady();
   lines.push('');
   lines.push(allGood ? '🟢 全链路正常，可以远程编程！' : '🟡 部分链路异常，请检查上方标记。');
 
-  await replyLark(messageId, lines.join('\n'));
+  return lines.join('\n');
 }
 
-async function handleQueue(_args, messageId) {
-  try {
-    const db = getDb();
-    ensureTable(db);
-    const rows = db.prepare(
-      "SELECT id, command, status, created_at FROM remote_commands WHERE status IN ('pending', 'running') ORDER BY created_at ASC LIMIT 10"
-    ).all();
-
-    if (rows.length === 0) {
-      await replyLark(messageId, '📋 队列为空，没有待执行的指令。');
-      return;
-    }
-
-    const lines = rows.map((r, i) => {
-      const icon = r.status === 'running' ? '🔄' : '⏳';
-      const cmd = r.command.length > 40 ? r.command.slice(0, 40) + '...' : r.command;
-      return `${i + 1}. ${icon} ${cmd}  (${r.id.slice(-8)})`;
-    });
+/**
+ * 写入 IDE 编程指令队列 (供 LarkTransport 的 ide_agent 路由使用)
+ *
+ * @param {string} command — 自然语言编程指令
+ * @param {Object} meta — { chatId, messageId, senderId, senderName }
+ * @returns {Promise<{id: string}>}
+ */
+async function enqueueIdeCommand(command, meta = {}) {
+  const db = getDb();
+  ensureTable(db);
+  const id = genId();
+  const now = Math.floor(Date.now() / 1000);
 
-    await replyLark(messageId, `📋 当前队列 (${rows.length} 条)\n\n${lines.join('\n')}`);
-  } catch (err) {
-    await replyLark(messageId, `❌ 查询失败: ${err.message}`);
+  if (meta.chatId) {
+    _activeChatId = meta.chatId;
+    _persistActiveChatId(meta.chatId);
   }
-}
 
-async function handleCancel(_args, messageId) {
-  try {
-    const db = getDb();
-    ensureTable(db);
-    const now = Math.floor(Date.now() / 1000);
-    const result = db.prepare(
-      'UPDATE remote_commands SET status = ?, completed_at = ? WHERE status = ?'
-    ).run('cancelled', now, 'pending');
-    await replyLark(messageId, `🗑 已取消 ${result.changes} 条待执行指令。`);
-  } catch (err) {
-    await replyLark(messageId, `❌ 取消失败: ${err.message}`);
-  }
-}
+  db.prepare(`
+    INSERT INTO remote_commands (id, source, chat_id, message_id, user_id, user_name, command, status, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?)
+  `).run(id, 'lark', meta.chatId || '', meta.messageId || '', meta.senderId || '', meta.senderName || 'lark_user', command, now);
 
-async function handleClear(_args, messageId) {
-  try {
-    const db = getDb();
-    ensureTable(db);
-    const result = db.prepare(
-      "DELETE FROM remote_commands WHERE status IN ('completed', 'timeout', 'cancelled')"
-    ).run();
-    await replyLark(messageId, `🧹 已清理 ${result.changes} 条历史记录。`);
-  } catch (err) {
-    await replyLark(messageId, `❌ 清理失败: ${err.message}`);
-  }
-}
+  logger.info(`[Remote/Lark] IDE command queued: ${id} — "${command.slice(0, 50)}"`);
+  wakeWaiters();
 
-async function handlePing(_args, messageId) {
-  await replyLark(messageId, `🏓 pong! (${new Date().toLocaleTimeString('zh-CN')})`);
+  return { id };
 }
 
-/**
- * /screen — 截取 IDE 窗口截图并发送到飞书
- */
-async function handleScreen(_args, messageId) {
-  await replyLark(messageId, '📸 正在截取 IDE 画面...');
-  try {
-    const result = await sendLarkScreenshot('');
-    if (!result.success) {
-      await replyLark(messageId, `❌ 截图失败: ${result.message}`);
-    }
-    // 成功时 sendLarkScreenshot 已自动发送图片消息
-  } catch (err) {
-    await replyLark(messageId, `❌ 截图异常: ${err.message}`);
-  }
+function getProjectRoot() {
+  const container = getServiceContainer();
+  return container.singletons?._projectRoot || process.env.ASD_PROJECT_DIR || process.cwd();
 }
 
 // ═══════════════════════════════════════════════════════
-//  飞书消息处理
+//  飞书消息处理 — 通过 LarkTransport 路由
 // ═══════════════════════════════════════════════════════
 
 async function handleLarkMessage(data) {
   const message = data?.message || data?.event?.message || {};
-  const sender = data?.sender || data?.event?.sender || {};
   const messageId = message.message_id;
   const chatId = message.chat_id;
-  const msgType = message.message_type;
 
   if (isDuplicate(messageId)) return;
 
-  // ── 发送者白名单校验 ──
-  const senderId = sender.sender_id?.user_id || sender.sender_id?.open_id || '';
-  if (!isUserAllowed(senderId)) {
-    logger.warn(`[Remote/Lark] Blocked unauthorized user: ${senderId}`);
-    await replyLark(messageId, '🔒 权限不足，你不在授权用户列表中。');
-    return;
-  }
-
-  if (msgType !== 'text') {
-    await replyLark(messageId, '🤖 目前只支持文本指令。\n发 /help 查看帮助。');
-    return;
-  }
-
-  let textContent = '';
-  try {
-    const content = JSON.parse(message.content || '{}');
-    textContent = (content.text || '').trim();
-  } catch {
-    textContent = '';
-  }
-  if (!textContent) return;
-
-  textContent = textContent.replace(/@_user_\d+/g, '').trim();
-  if (!textContent) return;
-
-  // ── 系统命令拦截 ──
-  const sysHandler = isSystemCommand(textContent);
-  if (sysHandler) {
-    const args = textContent.split(/\s+/).slice(1).join(' ');
-    await sysHandler(args, messageId);
-    return;
-  }
-
-  // ── 写入编程指令队列 ──
-  const db = getDb();
-  ensureTable(db);
-  const id = genId();
-  const now = Math.floor(Date.now() / 1000);
-
-  const userId = sender.sender_id?.user_id || sender.sender_id?.open_id || '';
-  const userName = sender.sender_id?.user_id || 'lark_user';
-
-  // 记录活跃会话（供主动通知使用）
+  // 更新活跃会话
   if (chatId) {
     _activeChatId = chatId;
     _persistActiveChatId(chatId);
   }
 
-  db.prepare(`
-    INSERT INTO remote_commands (id, source, chat_id, message_id, user_id, user_name, command, status, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, 'pending', ?)
-  `).run(id, 'lark', chatId || '', messageId || '', userId, userName, textContent, now);
-
-  logger.info(`[Remote/Lark] Command queued: ${id} — "${textContent.slice(0, 50)}"`);
-
-  // 立即唤醒 long-poll 等待中的扩展端
-  wakeWaiters();
-
-  // 查当前队列深度
-  const queueDepth = db.prepare("SELECT COUNT(*) as c FROM remote_commands WHERE status IN ('pending', 'running')").get()?.c || 1;
-  const queueInfo = queueDepth > 1 ? `\n\n当前队列: ${queueDepth} 条指令` : '';
-
-  await replyLark(messageId, `📝 收到，已加入执行队列。${queueInfo}`);
+  // 通过 LarkTransport 路由 (自然语言意图分类)
+  const transport = getLarkTransport();
+  if (transport) {
+    await transport.receive(data);
+  } else {
+    // Transport 未就绪 → 降级为旧队列模式
+    logger.warn('[Remote/Lark] Transport not ready, falling back to queue mode');
+    const sender = data?.sender || data?.event?.sender || {};
+    let text = '';
+    try {
+      const content = JSON.parse(message.content || '{}');
+      text = (content.text || '').trim().replace(/@_user_\d+/g, '').trim();
+    } catch { text = ''; }
+
+    if (text) {
+      const senderId = sender.sender_id?.user_id || sender.sender_id?.open_id || '';
+      const senderName = sender.sender_id?.user_id || 'lark_user';
+      await enqueueIdeCommand(text, { chatId, messageId, senderId, senderName });
+      await replyLark(messageId, '📝 收到，已加入执行队列。(Agent 模式未就绪)');
+    }
+  }
 }
 
 // ═══════════════════════════════════════════════════════
@@ -833,90 +753,49 @@ async function replyLark(messageId, text) {
 }
 
 // ═══════════════════════════════════════════════════════
-//  IDE 窗口截图 + 飞书发送
+//  IDE 窗口截图 + 飞书发送（ScreenCaptureKit，息屏可用）
 // ═══════════════════════════════════════════════════════
 
 /**
- * 获取 VSCode 主窗口 CGWindowID（macOS only）
- * 通过 swift 调用 CoreGraphics API 找到 owner 包含 "Code" 且面积最大的窗口
+ * 截取 IDE 窗口截图（通过 ScreenCaptureKit 原生 API，息屏时可用）
+ * @param {object} [opts]
+ * @param {string} [opts.windowTitle] — 窗口标题关键词（默认 "Code"）
+ * @returns {Promise<{path: string|null, error: string|null}>}
  */
-function _getVSCodeWindowId() {
+async function captureIDEScreenshot(opts = {}) {
   try {
-    const script = `
-import CoreGraphics
-let list = CGWindowListCopyWindowInfo(.optionOnScreenOnly, kCGNullWindowID) as! [[String: Any]]
-var best = 0, bestArea = 0
-for w in list {
-  guard let o = w["kCGWindowOwnerName"] as? String, o.contains("Code"),
-        let b = w["kCGWindowBounds"] as? [String: Double],
-        let width = b["Width"], let height = b["Height"],
-        let id = w["kCGWindowNumber"] as? Int,
-        width > 100, height > 100 else { continue }
-  let area = Int(width * height)
-  if area > bestArea { bestArea = area; best = id }
-}
-print(best)
-`;
-    const out = execSync(`swift -e '${script.replace(/'/g, "'\\''")}'`, {
-      timeout: 10000,
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-    const wid = parseInt(out, 10);
-    logger.info(`[Remote/Screenshot] VSCode windowId: ${wid}`);
-    return wid > 0 ? wid : 0;
-  } catch (err) {
-    const stderr = err.stderr ? err.stderr.toString().slice(0, 200) : '';
-    logger.warn(`[Remote/Screenshot] Failed to get VSCode windowId: ${err.message}${stderr ? ' | stderr: ' + stderr : ''}`);
-    return 0;
-  }
-}
+    const { screenshot } = await import('../../platform/ScreenCaptureService.js');
 
-/**
- * 截取 IDE 窗口截图
- * @returns {{ path: string|null, error: string|null }} 临时图片文件路径，或错误信息
- */
-function captureIDEScreenshot() {
-  const tmpFile = join(tmpdir(), `asd-screenshot-${Date.now()}.jpg`);
-
-  // ── 尝试方案列表（按优先级）──
-  const attempts = [];
+    // 统一使用窗口截取（desktopIndependentWindow，亮屏/息屏均可用）
+    // 优先截取 IDE 窗口
+    const windowTitle = opts.windowTitle || 'Code';
+    let result = await screenshot({ windowTitle, format: 'png' });
 
-  try {
-    const wid = _getVSCodeWindowId();
-    if (wid > 0) {
-      attempts.push({ label: 'window', cmd: `screencapture -x -t jpg -l${wid} "${tmpFile}"` });
+    // IDE 窗口未找到 → 尝试常见 IDE 名称
+    if (!result.success) {
+      for (const alt of ['Visual Studio', 'Cursor', 'Xcode', 'IntelliJ', 'WebStorm']) {
+        if (alt.toLowerCase() === windowTitle.toLowerCase()) continue;
+        result = await screenshot({ windowTitle: alt, format: 'png' });
+        if (result.success) break;
+      }
     }
-  } catch { /* swift failed, skip window capture */ }
 
-  // 全屏截图作为回退
-  attempts.push({ label: 'fullscreen', cmd: `screencapture -x -t jpg "${tmpFile}"` });
+    // 仍未找到 → 不指定窗口名，Swift 工具会自动选最大窗口
+    if (!result.success) {
+      logger.info(`[Remote/Screenshot] IDE window not found, capturing largest available window`);
+      result = await screenshot({ format: 'png' });
+    }
 
-  for (const { label, cmd } of attempts) {
-    try {
-      logger.info(`[Remote/Screenshot] Trying ${label}: ${cmd}`);
-      execSync(cmd, { timeout: 8000, stdio: ['pipe', 'pipe', 'pipe'] });
-      if (existsSync(tmpFile)) {
-        const { size } = statSync(tmpFile);
-        if (size > 0) {
-          logger.info(`[Remote/Screenshot] Captured via ${label}: ${tmpFile} (${size} bytes)`);
-          return { path: tmpFile, error: null };
-        }
-        // 文件存在但为空
-        logger.warn(`[Remote/Screenshot] ${label}: file created but empty`);
-        try { unlinkSync(tmpFile); } catch { /* ignore */ }
-      } else {
-        logger.warn(`[Remote/Screenshot] ${label}: file not created`);
-      }
-    } catch (err) {
-      const stderr = err.stderr ? err.stderr.toString().slice(0, 300) : '';
-      const detail = `${err.message}${stderr ? ' | stderr: ' + stderr : ''}`;
-      logger.warn(`[Remote/Screenshot] ${label} failed: ${detail}`);
-      // 继续尝试下一种方案
+    if (result.success) {
+      logger.info(`[Remote/Screenshot] Captured: ${result.path} (${result.width}x${result.height})`);
+      return { path: result.path, error: null };
     }
-  }
 
-  return { path: null, error: '所有截图方案均失败。请在「系统设置 → 隐私与安全性 → 屏幕录制」中授权启动 asd ui 的终端应用（如 iTerm2、Terminal.app）。' };
+    return { path: null, error: result.error || 'Screenshot failed' };
+  } catch (err) {
+    logger.warn(`[Remote/Screenshot] ScreenCaptureKit error: ${err.message}`);
+    return { path: null, error: err.message };
+  }
 }
 
 /**
@@ -1007,8 +886,8 @@ export async function sendLarkScreenshot(caption = '') {
     return { success: false, message: 'Lark not connected or no active chat' };
   }
 
-  // 1. 截图
-  const capture = captureIDEScreenshot();
+  // 1. 截图（ScreenCaptureKit，息屏可用）
+  const capture = await captureIDEScreenshot();
   if (!capture.path) {
     return { success: false, message: capture.error || 'Screenshot capture failed' };
   }

package/lib/http/routes/violations.js

@@ -91,58 +91,4 @@ router.post(
   })
 );
 
-/**
- * POST /api/v1/violations/rules/generate
- * AI 根据语义描述生成 Guard 规则
- */
-router.post(
-  '/rules/generate',
-  asyncHandler(async (req, res) => {
-    const { description } = req.body;
-
-    if (!description || typeof description !== 'string' || !description.trim()) {
-      throw new ValidationError('description is required');
-    }
-
-    const container = getServiceContainer();
-    const chatAgent = container.get('chatAgent');
-    const result = await chatAgent.executeTool('generate_guard_rule', {
-      description: description.trim(),
-      language: 'objc',
-      severity: 'warning',
-    });
-
-    if (result?.error) {
-      throw new ValidationError(result.error);
-    }
-
-    // 从 generate_guard_rule 工具返回的 rule 中提取并规范化
-    const rule = result.rule || result;
-
-    const normalized = {
-      ruleId: String(rule.name || rule.ruleId || '')
-        .trim()
-        .replace(/\s+/g, '-'),
-      message: String(rule.description || rule.message || '').trim(),
-      severity: rule.severity === 'error' ? 'error' : 'warning',
-      pattern: String(rule.pattern || '').trim(),
-      languages:
-        Array.isArray(rule.languages) && rule.languages.length > 0
-          ? rule.languages
-          : ['objc', 'swift'],
-      note: rule.note != null ? String(rule.note).trim() : rule.description_cn || '',
-      dimension: ['file', 'target', 'project'].includes(rule.dimension) ? rule.dimension : '',
-    };
-
-    if (!normalized.ruleId || !normalized.message || !normalized.pattern) {
-      throw new ValidationError('AI 返回的规则缺少 ruleId、message 或 pattern');
-    }
-
-    res.json({
-      success: true,
-      data: normalized,
-    });
-  })
-);
-
 export default router;

package/lib/http/utils/sse-sessions.js

@@ -2,7 +2,7 @@
  * SSE Session Manager — 基于 EventSource 的流式会话管理
  *
  * 架构:
- *   POST /chat/stream → 创建 session + 后台执行 ChatAgent → 返回 { sessionId }
+ *   POST /chat/stream → 创建 session + 后台执行 AgentRuntime → 返回 { sessionId }
  *   GET  /chat/events/:sessionId → EventSource 端点, 回放缓冲事件 + 实时推送
  *
  * 为什么不用 fetch + ReadableStream:

package/lib/infrastructure/logging/Logger.js

@@ -2,9 +2,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import winston from 'winston';
 
-// ChatAgent 相关标签 — 终端高亮显示
+// Agent 系统相关标签 — 终端高亮显示
 const AGENT_TAGS = [
-  'ChatAgent',
+  'AgentRuntime',
+  'AgentFactory',
   'ToolRegistry',
   'SignalCollector',
   'SkillAdvisor',
@@ -38,7 +39,7 @@ const LEVEL_COLORS = {
 
 /**
  * 精简 Console 格式
- * - ChatAgent 相关日志: 高亮 cyan/magenta，显示完整信息
+ * - Agent 相关日志: 高亮 cyan/magenta，显示完整信息
  * - warn/error: 醒目颜色完整显示
  * - HTTP 日志: 精简并降低视觉权重
  * - 其他 info/debug: 一行精简格式
@@ -65,7 +66,7 @@ const compactConsoleFormat = winston.format.printf(({ level, message, timestamp,
   );
 
   if (isAgentLog) {
-    // ChatAgent 日志 — 高亮显示
+    // Agent 日志 — 高亮显示
     const metaStr =
       Object.keys(meta).length > 0
         ? ` ${JSON.stringify(meta, null, 0).replace(/"/g, '').replace(/,/g, ', ')}`

package/lib/infrastructure/monitoring/PerformanceMonitor.js

@@ -120,8 +120,9 @@ export class PerformanceMonitor {
       this.metrics.responseTimes.shift();
     }
 
-    // 慢请求记录
-    if (duration > this.config.slowRequestThreshold) {
+    // 慢请求记录（排除设计上就是长耗时的 long-poll 端点）
+    const isLongPoll = route.includes('/remote/wait');
+    if (duration > this.config.slowRequestThreshold && !isLongPoll) {
       this.metrics.slowRequests.push({
         ...requestData,
         duration,