autosnippet 3.2.4 → 3.2.7

package/lib/external/mcp/handlers/task.js

@@ -1,14 +1,15 @@
 /**
- * MCP Handler — autosnippet_task (Task CRUD)
+ * MCP Handler — autosnippet_task (Unified Task & Decision Management)
  *
- * Operations: create / decompose / claim / close / fail / defer / progress
- *             ready / show / list / blocked / dep_add / dep_tree / stats
- *
- * Session entry point → autosnippet_ready
- * Decision management → autosnippet_decide
+ * Operations:
+ *   Session:   prime (session entry — loads decisions + ready tasks + stats)
+ *   Tasks:     create / ready / claim / close / fail / defer / progress
+ *              show / list / stats / blocked / decompose / dep_add / dep_tree
+ *   Decisions: record_decision / revise_decision / unpin_decision / list_decisions
  */
 
 import { envelope } from '../envelope.js';
+// guard is independent — no guardState dependency in task lifecycle
 
 /**
  * 统一入口
@@ -18,23 +19,35 @@ import { envelope } from '../envelope.js';
 export async function taskHandler(ctx, args) {
   const taskService = ctx.container.get('taskGraphService');
 
+  let result;
   switch (args.operation) {
+    // ── Session ──
+    case 'prime':
+      return _prime(taskService, args);
+    // ── Task CRUD ──
     case 'create':
-      return _create(taskService, args);
+      result = await _create(taskService, args);
+      break;
     case 'ready':
       return _ready(taskService, args);
     case 'claim':
-      return _claim(taskService, args);
+      result = await _claim(taskService, args);
+      break;
     case 'close':
-      return _close(taskService, args);
+      result = await _close(ctx, taskService, args);
+      break;
     case 'fail':
-      return _fail(taskService, args);
+      result = await _fail(taskService, args);
+      break;
     case 'defer':
-      return _defer(taskService, args);
+      result = await _defer(taskService, args);
+      break;
     case 'progress':
-      return _progress(taskService, args);
+      result = await _progress(taskService, args);
+      break;
     case 'decompose':
-      return _decompose(taskService, args);
+      result = await _decompose(taskService, args);
+      break;
     case 'show':
       return _show(taskService, args);
     case 'list':
@@ -47,13 +60,32 @@ export async function taskHandler(ctx, args) {
       return _depTree(taskService, args);
     case 'stats':
       return _stats(taskService);
+    // ── Decisions ──
+    case 'record_decision':
+      result = await _recordDecision(taskService, args);
+      break;
+    case 'revise_decision':
+      result = await _reviseDecision(taskService, args);
+      break;
+    case 'unpin_decision':
+      result = await _unpinDecision(taskService, args);
+      break;
+    case 'list_decisions':
+      return _listDecisions(taskService);
     default:
       return envelope({
         success: false,
-        message: `Unknown operation: ${args.operation}. Use autosnippet_ready for session context, autosnippet_decide for decisions.`,
+        message: `Unknown operation: ${args.operation}. Valid: prime, ready, create, claim, close, fail, defer, progress, decompose, dep_add, dep_tree, stats, list, record_decision, revise_decision, unpin_decision, list_decisions.`,
         meta: { tool: 'autosnippet_task' },
       });
   }
+
+  // ── 飞书任务进度通知（异步非阻塞）──
+  _notifyTaskProgress(args.operation, args, result).catch((err) => {
+    process.stderr.write(`[MCP/Task] Notify error: ${err?.message}\n`);
+  });
+
+  return result;
 }
 
 // ── create ──
@@ -113,10 +145,11 @@ async function _claim(svc, args) {
 
 // ── close ──
 
-async function _close(svc, args) {
+async function _close(ctx, svc, args) {
   if (!args.id) {
     return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
   }
+
   const { task, newlyReady } = await svc.close(args.id, args.reason || 'Completed');
   return envelope({
     success: true,
@@ -281,3 +314,316 @@ async function _stats(svc) {
     meta: { tool: 'autosnippet_task' },
   });
 }
+
+// ═══ Session (prime) ═══════════════════════════════════
+
+async function _prime(svc, args) {
+  const result = await svc.prime({
+    limit: args.limit || 10,
+    withKnowledge: args.withKnowledge !== false,
+  });
+
+  const decisionCount = (result.decisions || []).length;
+  const staleCount = (result.staleDecisions || []).length;
+  const decisionTitles = (result.decisions || []).map((d) => d.title).join('; ');
+  const statsLine = `${result.inProgress.length} in-progress, ${result.ready.length} ready, ${result.stats.total} total`;
+
+  // ── Behavioral Rules Reminder (survives compaction) ──
+  result._taskRules = {
+    reminder: [
+      '📋 TASK RULES (MANDATORY):',
+      '🔑 YOU are the task operator — user speaks naturally, you translate to task operations. NEVER tell user to run task commands.',
+      '• MUST prime on EVERY message BEFORE anything else',
+      '• MUST create task for non-trivial work (≥2 files OR ≥10 lines)',
+      '• MUST claim before coding, close when done with meaningful reason',
+      '• MUST handle unfinished tasks before starting new work (ask user: Continue/Defer/Abandon)',
+      '• NEVER skip prime, NEVER start new work with open in_progress tasks',
+      '• NEVER leave tasks in in_progress when session ends — close or defer ALL',
+      '• When in doubt → create a task. When idle → ready()',
+      '• Session end → close all tasks, defer incomplete, verify zero in_progress',
+    ].join('\n'),
+    translationHint: [
+      'User Says → You Run:',
+      '"fix bug"/"implement" → create→claim→code→close',
+      '"continue" → resume in-progress→close',
+      '"pause" → defer | "abandon" → fail | "break down" → decompose',
+      '"what\'s next" → ready() | "agreed" → record_decision',
+      'Quick question → No task. Just answer.',
+    ].join('\n'),
+  };
+
+  let message;
+  if (decisionCount > 0) {
+    const stalePart = staleCount > 0 ? ` ${staleCount} stale.` : '';
+    message = `⚠️ ${decisionCount} ACTIVE DECISION(S): [${decisionTitles}].${stalePart} ${statsLine}.`;
+  } else {
+    message = `${statsLine}.`;
+  }
+
+  // ── Resume Prompt: 有 inProgress 任务时，提示 Agent 让用户选择 ──
+  if (result.inProgress.length > 0) {
+    const taskList = result.inProgress.map((t) => {
+      const age = t.updatedAt
+        ? `${Math.floor((Date.now() / 1000 - t.updatedAt) / 86400)}d ago`
+        : '';
+      return `• **${t.id}** — ${t.title}${age ? ` (${age})` : ''}`;
+    }).join('\n');
+
+    result._resumePrompt = {
+      instruction: [
+        'There are unfinished tasks. You MUST present these options to the user BEFORE doing anything else:',
+        '',
+        '**Unfinished tasks:**',
+        taskList,
+        '',
+        'Ask the user to choose:',
+        '1. **Continue** — resume the unfinished task(s)',
+        '2. **Defer** — pause it and work on something else',
+        '3. **Abandon** — close/fail it and start fresh',
+        '',
+        'Wait for the user\'s answer. Do NOT auto-resume.',
+      ].join('\n'),
+      taskIds: result.inProgress.map((t) => t.id),
+    };
+
+    message += ` ⏸️ ${result.inProgress.length} unfinished task(s) — ask user before resuming.`;
+  }
+
+  return envelope({
+    success: true,
+    data: result,
+    message,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ═══ Decisions ═══════════════════════════════════════
+
+async function _recordDecision(svc, args) {
+  if (!args.title) {
+    return envelope({ success: false, message: 'title is required', meta: { tool: 'autosnippet_task' } });
+  }
+  if (!args.description) {
+    return envelope({ success: false, message: 'description is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const { task, isDuplicate } = await svc.recordDecision({
+    title: args.title,
+    description: args.description,
+    rationale: args.rationale || '',
+    tags: args.tags || [],
+    relatedTaskId: args.relatedTaskId || null,
+  });
+  return envelope({
+    success: true,
+    data: task.toJSON(),
+    message: isDuplicate
+      ? `⚠ Decision already recorded: ${task.id}`
+      : `✅ Decision pinned: ${task.id} — "${args.title}"`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+async function _reviseDecision(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id of old decision is required', meta: { tool: 'autosnippet_task' } });
+  }
+  if (!args.title) {
+    return envelope({ success: false, message: 'title of new decision is required', meta: { tool: 'autosnippet_task' } });
+  }
+  if (!args.description) {
+    return envelope({ success: false, message: 'description of new decision is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const result = await svc.reviseDecision({
+    oldDecisionId: args.id,
+    title: args.title,
+    description: args.description,
+    rationale: args.rationale || '',
+    reason: args.reason || '',
+  });
+  return envelope({
+    success: true,
+    data: {
+      newDecision: result.newDecision.toJSON(),
+      superseded: result.oldDecisionId,
+    },
+    message: `✅ Decision revised: ${result.oldDecisionId} → ${result.newDecision.id}`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+async function _unpinDecision(svc, args) {
+  if (!args.id) {
+    return envelope({ success: false, message: 'id is required', meta: { tool: 'autosnippet_task' } });
+  }
+  const task = await svc.unpinDecision(args.id, args.reason || '');
+  return envelope({
+    success: true,
+    data: task.toJSON(),
+    message: `Decision ${args.id} unpinned and closed`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+async function _listDecisions(svc) {
+  const decisions = await svc.list({ status: 'pinned', taskType: 'decision' }, { limit: 50 });
+  return envelope({
+    success: true,
+    data: decisions.map((d) => d.toJSON()),
+    message: `${decisions.length} active decision(s)`,
+    meta: { tool: 'autosnippet_task' },
+  });
+}
+
+// ═══ 飞书任务进度通知（通过 API Server 中转）═══════════════
+//
+// MCP Server 与 API Server 是独立进程。
+// 飞书 WSClient 连接在 API Server 中，因此通知需 HTTP 中转。
+// ═══════════════════════════════════════════════════════════
+
+const PRIORITY_LABELS = ['P0 紧急', 'P1 高', 'P2 中', 'P3 低', 'P4 微'];
+
+/**
+ * 通过 API Server 的 /api/v1/remote/notify 发送飞书通知
+ * @param {string} text
+ * @returns {Promise<boolean>}
+ */
+async function _sendLarkViaApi(text) {
+  try {
+    const port = process.env.PORT || 3000;
+    const resp = await fetch(`http://localhost:${port}/api/v1/remote/notify`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text }),
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!resp.ok) {
+      process.stderr.write(`[MCP/Task] Lark notify HTTP ${resp.status}\n`);
+      return false;
+    }
+    const body = await resp.json();
+    return body.success === true;
+  } catch (err) {
+    process.stderr.write(`[MCP/Task] Lark notify failed: ${err?.message}\n`);
+    return false;
+  }
+}
+
+/**
+ * 通过 API Server 截取 IDE 窗口截图并发送到飞书
+ * @param {string} [caption] — 可选文字说明
+ * @returns {Promise<boolean>}
+ */
+async function _sendScreenshotViaApi(caption = '') {
+  try {
+    const port = process.env.PORT || 3000;
+    const resp = await fetch(`http://localhost:${port}/api/v1/remote/screenshot`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ caption }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!resp.ok) {
+      process.stderr.write(`[MCP/Task] Screenshot HTTP ${resp.status}\n`);
+      return false;
+    }
+    const body = await resp.json();
+    return body.success === true;
+  } catch (err) {
+    process.stderr.write(`[MCP/Task] Screenshot failed: ${err?.message}\n`);
+    return false;
+  }
+}
+
+/**
+ * 根据任务操作向飞书发送进度通知（异步非阻塞）
+ * result 是 envelope() 返回的 { success, data, message, meta }
+ */
+async function _notifyTaskProgress(operation, args, result) {
+  if (!result || result.success === false) return;
+
+  const data = result.data;
+  let text = '';
+
+  switch (operation) {
+    case 'create': {
+      const title = data?.title || args.title || '';
+      const id = data?.id || '';
+      const type = data?.taskType || args.taskType || 'task';
+      const pri = PRIORITY_LABELS[data?.priority ?? args.priority ?? 2] || 'P2';
+      const dup = result.message?.includes('Duplicate') || result.message?.startsWith('⚠') ? ' (重复)' : '';
+      text = `📋 新任务${dup}: ${id}\n${title}\n类型: ${type} | ${pri}`;
+      break;
+    }
+    case 'claim': {
+      const id = data?.id || args.id;
+      const title = data?.title || '';
+      text = `🔨 开始执行: ${id}\n${title}`;
+      break;
+    }
+    case 'close': {
+      const closed = data?.closed || data;
+      const title = closed?.title || '';
+      const id = closed?.id || args.id;
+      const reason = closed?.closeReason || args.reason || '';
+      const readyCount = data?.newlyReady?.length || 0;
+      const readyInfo = readyCount > 0 ? `\n→ ${readyCount} 个任务新就绪` : '';
+      text = `✅ 完成: ${id}\n${title}\n原因: ${reason}${readyInfo}`;
+      break;
+    }
+    case 'fail': {
+      const title = data?.title || '';
+      const id = data?.id || args.id;
+      const reason = data?.lastFailReason || args.reason || '未知';
+      const count = data?.failCount || 0;
+      text = `❌ 失败: ${id}\n${title}\n原因: ${reason}${count > 1 ? ` (第${count}次)` : ''}`;
+      break;
+    }
+    case 'defer': {
+      const id = data?.id || args.id;
+      const title = data?.title || '';
+      text = `⏸️ 暂缓: ${id} — ${title}`;
+      break;
+    }
+    case 'progress': {
+      const id = data?.id || args.id;
+      const note = args.reason || args.description || '';
+      text = note
+        ? `📝 进度: ${id}\n${note.slice(0, 200)}`
+        : `📝 进度: ${id}`;
+      break;
+    }
+    case 'decompose': {
+      const epicId = args.id;
+      const count = Array.isArray(data) ? data.length : 0;
+      const subTitles = Array.isArray(data)
+        ? data.slice(0, 5).map((t, i) => `  ${i + 1}. ${t.title || t.id}`).join('\n')
+        : '';
+      text = `📂 拆解: ${epicId} → ${count} 个子任务${subTitles ? '\n' + subTitles : ''}`;
+      break;
+    }
+    case 'record_decision': {
+      const title = data?.title || args.title || '';
+      text = `📌 决策: ${title}`;
+      break;
+    }
+    case 'revise_decision': {
+      const oldId = data?.superseded || args.id;
+      const newTitle = data?.newDecision?.title || args.title;
+      text = `🔄 决策更新: ${oldId} → ${newTitle}`;
+      break;
+    }
+    case 'unpin_decision': {
+      const id = data?.id || args.id;
+      text = `🔓 决策取消: ${id}`;
+      break;
+    }
+    default:
+      return;
+  }
+
+  if (text) {
+    await _sendLarkViaApi(text);
+    // 发送文字通知后，附带 IDE 窗口截图
+    await _sendScreenshotViaApi();
+  }
+}

package/lib/external/mcp/tools.js

@@ -1,8 +1,8 @@
 /**
  * MCP 工具定义 — V3 整合版 (18 agent + 4 admin = 22 工具)
  *
- * 从 39 → 22 工具（参数路由合并同类工具 + 外部 Agent 冷启动新架构 + TaskGraph 三工具拆分）。
- * TaskGraph 拆分: autosnippet_ready + autosnippet_decide + autosnippet_task
+ * 从 39 → 22 工具（参数路由合并同类工具 + 外部 Agent 冷启动新架构 + TaskGraph 统一入口）。
+ * TaskGraph: autosnippet_task (统一入口，含 prime/decision/task CRUD)
  * 每个工具声明增加 tier 字段（agent / admin）。
  * tools.js 只包含 JSON Schema 声明 + Gateway 映射，不含业务逻辑。
  *
@@ -45,16 +45,7 @@ export const TOOL_GATEWAY_MAP = {
   autosnippet_submit_knowledge: { action: 'knowledge:create', resource: 'knowledge' },
   autosnippet_submit_knowledge_batch: { action: 'knowledge:create', resource: 'knowledge' },
   autosnippet_save_document: { action: 'knowledge:create', resource: 'knowledge' },
-  // decide 写操作（record/revise/unpin）
-  autosnippet_decide: {
-    resolver: (args) =>
-      ({
-        record: { action: 'task:create', resource: 'tasks' },
-        revise: { action: 'task:update', resource: 'tasks' },
-        unpin: { action: 'task:update', resource: 'tasks' },
-      })[args?.operation] || null, // list 只读
-  },
-  // task 写操作（create/claim/close/fail/defer/decompose/dep_add）
+  // task 写操作（create/claim/close/fail/defer/decompose/dep_add + decision 写操作）
   autosnippet_task: {
     resolver: (args) =>
       ({
@@ -66,7 +57,10 @@ export const TOOL_GATEWAY_MAP = {
         progress: { action: 'task:update', resource: 'tasks' },
         decompose: { action: 'task:create', resource: 'tasks' },
         dep_add: { action: 'task:update', resource: 'tasks' },
-      })[args?.operation] || null, // ready/show/list/blocked/dep_tree/stats 只读
+        record_decision: { action: 'task:create', resource: 'tasks' },
+        revise_decision: { action: 'task:update', resource: 'tasks' },
+        unpin_decision: { action: 'task:update', resource: 'tasks' },
+      })[args?.operation] || null, // prime/ready/show/list/blocked/dep_tree/stats/list_decisions 只读
   },
   // admin 工具
   autosnippet_enrich_candidates: { action: 'knowledge:update', resource: 'knowledge' },
@@ -216,32 +210,27 @@ export const TOOLS = [
     },
   },
 
-  // 6. Guard 检查（2 → 1）
+  // 6. Guard 检查（统一入口）
   {
     name: 'autosnippet_guard',
     tier: 'agent',
-    description: '代码规范检查。传 code=单文件检查，传 files[]=多文件批量审计（自动路由）。',
+    description:
+      '代码规范检查 & 质量门禁。\n' +
+      '• 无参数 → 自动从 git diff 检测增量文件并检查（编码后推荐用法）\n' +
+      '• files: ["path/to/file.m", ...] → 检查指定文件\n' +
+      '• code: "..." → 单文件内联检查\n' +
+      '每个 violation 内联 recipe 修复指南（doClause + coreCode），直接按指示修复后再次调用。',
     inputSchema: {
       type: 'object',
       properties: {
-        code: { type: 'string', description: '待检查代码（单文件模式，与 files 二选一）' },
-        language: { type: 'string', description: '编程语言' },
-        filePath: { type: 'string', description: '文件路径（单文件模式）' },
         files: {
           type: 'array',
-          items: {
-            type: 'object',
-            properties: { path: { type: 'string' }, content: { type: 'string' } },
-            required: ['path'],
-          },
-          description: '文件列表（批量模式，与 code 二选一）',
-        },
-        scope: {
-          type: 'string',
-          enum: ['file', 'target', 'project'],
-          default: 'project',
-          description: '审计范围（批量模式）',
+          items: { type: 'string' },
+          description: '待检查文件路径列表（string[]）。省略则自动从 git diff 检测增量文件。',
         },
+        code: { type: 'string', description: '待检查代码（单文件模式，与 files 二选一）' },
+        language: { type: 'string', description: '编程语言（单文件模式）' },
+        filePath: { type: 'string', description: '文件路径提示（单文件模式，用于语言检测）' },
       },
       required: [],
     },
@@ -538,68 +527,26 @@ export const TOOLS = [
     inputSchema: { type: 'object', properties: {}, required: [] },
   },
 
-  // 13. autosnippet_ready — Agent 会话入口（like beads_ready）
-  {
-    name: 'autosnippet_ready',
-    tier: 'agent',
-    description:
-      'Session entry point. Call FIRST at conversation start to load project context, active decisions, and available tasks.\n' +
-      'Returns: in-progress tasks, ready tasks (with knowledge context), pinned decisions, and stats.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        limit: { type: 'number', default: 10, description: 'Max ready tasks to return' },
-        withKnowledge: { type: 'boolean', default: true, description: 'Attach knowledge context to ready tasks' },
-      },
-      required: [],
-    },
-  },
-
-  // 14. autosnippet_decide — 决策管理
-  {
-    name: 'autosnippet_decide',
-    tier: 'agent',
-    description:
-      'Decision management. Record, revise or unpin project decisions that persist across conversations.\n' +
-      'Call record when you and user reach agreement. Decisions are shown in every autosnippet_ready call.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        operation: {
-          type: 'string',
-          enum: ['record', 'revise', 'unpin', 'list'],
-          description: 'record=pin new decision, revise=supersede old, unpin=close, list=show active',
-        },
-        title: { type: 'string', description: 'Decision title (record/revise)' },
-        description: { type: 'string', description: 'Decision description (record/revise)' },
-        rationale: { type: 'string', description: 'Why this decision (record/revise)' },
-        tags: { type: 'array', items: { type: 'string' }, description: 'Classification tags (record)' },
-        relatedTaskId: { type: 'string', description: 'Related task ID (record)' },
-        id: { type: 'string', description: 'Decision ID (revise/unpin)' },
-        reason: { type: 'string', description: 'Reason for revision/unpin' },
-      },
-      required: ['operation'],
-    },
-  },
-
-  // 15. autosnippet_task — 任务 CRUD
+  // 13. autosnippet_task — 统一任务管理（含 prime/decision/CRUD）
   {
     name: 'autosnippet_task',
     tier: 'agent',
     description:
-      'Task CRUD operations. Create tasks, claim work, close completed, track dependencies.\n' +
-      'For session context use autosnippet_ready. For decisions use autosnippet_decide.',
+      'Unified task & decision management. Includes session context (prime), task CRUD, and decision persistence.\n' +
+      'Call prime FIRST at every conversation start to load decisions + tasks + knowledge context.',
     inputSchema: {
       type: 'object',
       properties: {
         operation: {
           type: 'string',
           enum: [
-            'create', 'ready', 'claim', 'close', 'fail', 'defer',
+            'prime', 'ready',
+            'create', 'claim', 'close', 'fail', 'defer',
             'progress', 'show', 'list', 'stats',
             'blocked', 'decompose', 'dep_add', 'dep_tree',
+            'record_decision', 'revise_decision', 'unpin_decision', 'list_decisions',
           ],
-          description: 'Operation type',
+          description: 'prime=session entry (CALL FIRST) | ready=ready tasks | record_decision/revise_decision/unpin_decision/list_decisions=decision management | create/claim/close/fail/defer/progress/decompose=task CRUD',
         },
         title: { type: 'string', description: 'Task title (create)' },
         description: { type: 'string', description: 'Task description (create/progress)' },
@@ -612,8 +559,12 @@ export const TOOLS = [
           description: 'Task type (create)',
         },
         parentId: { type: 'string', description: 'Parent task ID (create subtask)' },
-        id: { type: 'string', description: 'Task ID (claim/close/fail/defer/show/dep_add/dep_tree/progress)' },
-        reason: { type: 'string', description: 'Reason (close/fail/defer)' },
+        id: { type: 'string', description: 'Task ID (claim/close/fail/defer/show/dep_add/dep_tree/progress/revise_decision/unpin_decision)' },
+        reason: { type: 'string', description: 'Reason (close/fail/defer/unpin_decision)' },
+        rationale: { type: 'string', description: 'Why this decision (record_decision/revise_decision)' },
+        tags: { type: 'array', items: { type: 'string' }, description: 'Classification tags (record_decision)' },
+        relatedTaskId: { type: 'string', description: 'Related task ID (record_decision)' },
+
         dependsOn: { type: 'string', description: 'Dependency target task ID (dep_add)' },
         depType: {
           type: 'string',

package/lib/http/HttpServer.js

@@ -38,6 +38,7 @@ import skillsRouter from './routes/skills.js';
 import snippetRouter from './routes/snippets.js';
 import spmRouter from './routes/spm.js';
 import taskRouter from './routes/task.js';
+import remoteRouter from './routes/remote.js';
 import violationsRouter from './routes/violations.js';
 import wikiRouter from './routes/wiki.js';
 
@@ -302,6 +303,9 @@ export class HttpServer {
     // Wiki 路由
     this.app.use(`${apiPrefix}/wiki`, wikiRouter);
 
+    // Remote 路由（飞书 Bot → IDE 远程指令桥接）
+    this.app.use(`${apiPrefix}/remote`, remoteRouter);
+
     // 根路径 — 返回 API 元信息（避免外部探测产生无意义 404）
     this.app.all('/', (req, res) => {
       res.json({