@ppdocs/mcp 3.2.22 → 3.2.23

package/dist/cli.js

@@ -412,30 +412,29 @@ function generateHooksConfig(cwd) {
         }
     };
 }
-/** 生成 MCP 权限配置 (允许全部 ppdocs-kg 方法) */
+/** 生成 MCP 权限配置 (允许全部 ppdocs-kg 工具) */
 function generateMcpPermissions() {
     const mcpMethods = [
-        // 知识图谱操作
-        'kg_create_node',
-        'kg_delete_node',
-        'kg_update_node',
-        'kg_update_root',
-        'kg_get_rules',
-        'kg_save_rules',
-        'kg_lock_node',
-        'kg_search',
-        'kg_find_path',
-        'kg_list_nodes',
-        'kg_get_relations',
-        'kg_read_node',
-        'kg_get_tree',
-        'kg_find_by_file',
-        // 任务管理
-        'task_create',
-        'task_list',
-        'task_get',
-        'task_add_log',
-        'task_complete',
+        // 初始化 + 导航
+        'kg_init',
+        'kg_status',
+        'kg_tree',
+        // 知识管理
+        'kg_doc',
+        'kg_projects',
+        'kg_rules',
+        // 工作流
+        'kg_task',
+        'kg_files',
+        'kg_discuss',
+        // 流程图
+        'kg_flowchart',
+        // 协作
+        'kg_meeting',
+        // 代码分析
+        'code_scan',
+        'code_smart_context',
+        'code_full_path',
     ];
     return mcpMethods.map(m => `mcp__ppdocs-kg__${m}`);
 }

package/dist/storage/httpClient.d.ts

@@ -34,14 +34,25 @@ export declare class PpdocsApiClient {
     getGlobalRulesMeta(): Promise<Record<string, RuleMeta>>;
     saveGlobalRulesMeta(meta: Record<string, RuleMeta>): Promise<boolean>;
     listTasks(status?: 'active' | 'archived'): Promise<TaskSummary[]>;
-    getTask(taskId: string): Promise<Task | null>;
+    getTask(taskId: string, mode?: 'smart' | 'full'): Promise<Task | null>;
     createTask(task: {
         title: string;
         description: string;
         goals: string[];
     }, creator: string): Promise<Task>;
-    addTaskLog(taskId: string, logType: TaskLogType, content: string): Promise<Task | null>;
+    addTaskLog(taskId: string, content: string, logType?: TaskLogType): Promise<Task | null>;
     completeTask(taskId: string, experience: TaskExperience): Promise<Task | null>;
+    deleteTask(taskId: string): Promise<boolean>;
+    listFlowcharts(): Promise<unknown[]>;
+    getFlowchart(chartId: string): Promise<unknown>;
+    batchAddToFlowchart(chartId: string, nodes: unknown[], edges: unknown[]): Promise<unknown>;
+    saveFlowchart(chartId: string, data: unknown): Promise<unknown>;
+    /** 原子更新单个节点 (后端自动处理并发) */
+    updateFlowchartNode(chartId: string, nodeId: string, node: unknown, changeDesc?: string): Promise<unknown>;
+    /** 原子删除单个节点 (后端自动清理关联边) */
+    deleteFlowchartNode(chartId: string, nodeId: string): Promise<unknown>;
+    getFlowchartOrphans(): Promise<unknown[]>;
+    getFlowchartHealth(): Promise<unknown[]>;
     /** 列出所有可访问的项目 */
     crossListProjects(): Promise<{
         id: string;
@@ -108,10 +119,6 @@ export declare class PpdocsApiClient {
     discussionComplete(id: string): Promise<boolean>;
     /** 删除讨论 (公开路由) */
     discussionDelete(id: string): Promise<boolean>;
-    /** 结案归档讨论 (认证路由) */
-    discussionClose(id: string, conclusion: string): Promise<{
-        archived_path: string;
-    }>;
     /** 列出公共文件 */
     publicFilesList(dir?: string): Promise<FileInfo[]>;
     /** 读取公共文件 (文本) */

package/dist/storage/httpClient.js

@@ -277,9 +277,10 @@ export class PpdocsApiClient {
         const query = status ? `?status=${status}` : '';
         return this.request(`/tasks${query}`);
     }
-    async getTask(taskId) {
+    async getTask(taskId, mode) {
         try {
-            return await this.request(`/tasks/${taskId}`);
+            const query = mode ? `?mode=${mode}` : '';
+            return await this.request(`/tasks/${taskId}${query}`);
         }
         catch {
             return null;
@@ -300,11 +301,14 @@ export class PpdocsApiClient {
             body: JSON.stringify(payload)
         });
     }
-    async addTaskLog(taskId, logType, content) {
+    async addTaskLog(taskId, content, logType) {
         try {
+            const body = { content };
+            if (logType)
+                body.log_type = logType;
             return await this.request(`/tasks/${taskId}/logs`, {
                 method: 'POST',
-                body: JSON.stringify({ log_type: logType, content })
+                body: JSON.stringify(body)
             });
         }
         catch {
@@ -322,6 +326,58 @@ export class PpdocsApiClient {
             return null;
         }
     }
+    async deleteTask(taskId) {
+        try {
+            await this.request(`/tasks/${taskId}`, { method: 'DELETE' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ============ 流程图管理 ============
+    async listFlowcharts() {
+        return this.request('/flowcharts');
+    }
+    async getFlowchart(chartId) {
+        try {
+            return await this.request(`/flowcharts/${chartId}`);
+        }
+        catch {
+            return null;
+        }
+    }
+    async batchAddToFlowchart(chartId, nodes, edges) {
+        return this.request(`/flowcharts/${chartId}/batch`, {
+            method: 'POST',
+            body: JSON.stringify({ nodes, edges })
+        });
+    }
+    async saveFlowchart(chartId, data) {
+        return this.request(`/flowcharts/${chartId}`, {
+            method: 'PUT',
+            body: JSON.stringify(data)
+        });
+    }
+    /** 原子更新单个节点 (后端自动处理并发) */
+    async updateFlowchartNode(chartId, nodeId, node, changeDesc) {
+        return this.request(`/flowcharts/${chartId}/nodes/${nodeId}`, {
+            method: 'PUT',
+            body: JSON.stringify({ node, change_desc: changeDesc || 'MCP update' })
+        });
+    }
+    /** 原子删除单个节点 (后端自动清理关联边) */
+    async deleteFlowchartNode(chartId, nodeId) {
+        return this.request(`/flowcharts/${chartId}/nodes/${nodeId}`, {
+            method: 'DELETE'
+        });
+    }
+    async getFlowchartOrphans() {
+        return this.request('/flowcharts/orphans');
+    }
+    async getFlowchartHealth() {
+        return this.request('/flowcharts/health');
+    }
     // ============ 跨项目只读访问 ============
     /** 列出所有可访问的项目 */
     async crossListProjects() {
@@ -539,13 +595,6 @@ export class PpdocsApiClient {
             method: 'DELETE',
         });
     }
-    /** 结案归档讨论 (认证路由) */
-    async discussionClose(id, conclusion) {
-        return this.request(`/discussions/${encodeURIComponent(id)}/close`, {
-            method: 'POST',
-            body: JSON.stringify({ conclusion }),
-        });
-    }
     // ============ 公共文件池 ============
     /** 列出公共文件 */
     async publicFilesList(dir) {

package/dist/tools/discussion.d.ts

@@ -1,8 +1,14 @@
 /**
- * 💬 kg_discuss (6→1)
- * 合并: list, read, create, reply, close, delete
+ * 💬 kg_discuss (8 actions)
+ * 合并: list, read, create, reply, close, delete, complete, history
  * 统一走 HTTP → Rust 后端 (单一写入者)
  * sender 格式: "projectId:user" (如 "p-ca3sgejg:张三")
+ *
+ * 权限模型:
+ *   list/history  — 任何人可列出(全局可见)
+ *   create        — 任何人可发起(指定参与项目ID)
+ *   read/reply    — 仅讨论组内成员(initiator + participants)
+ *   complete/close/delete — 仅发起人
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type McpContext } from './shared.js';

package/dist/tools/discussion.js

@@ -1,8 +1,14 @@
 /**
- * 💬 kg_discuss (6→1)
- * 合并: list, read, create, reply, close, delete
+ * 💬 kg_discuss (8 actions)
+ * 合并: list, read, create, reply, close, delete, complete, history
  * 统一走 HTTP → Rust 后端 (单一写入者)
  * sender 格式: "projectId:user" (如 "p-ca3sgejg:张三")
+ *
+ * 权限模型:
+ *   list/history  — 任何人可列出(全局可见)
+ *   create        — 任何人可发起(指定参与项目ID)
+ *   read/reply    — 仅讨论组内成员(initiator + participants)
+ *   complete/close/delete — 仅发起人
  */
 import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
@@ -11,6 +17,34 @@ import { wrap, safeTool } from './shared.js';
 function sender(ctx) {
     return `${ctx.projectId}:${ctx.user}`;
 }
+/** 提取 sender 中的 projectId */
+function senderProjectId(senderStr) {
+    return senderStr.split(':')[0] || senderStr;
+}
+/** 检查项目是否是讨论的成员 (发起方 或 参与方) */
+function isMember(brief, projectId) {
+    const initiatorPid = senderProjectId(brief.initiator);
+    if (initiatorPid === projectId)
+        return true;
+    return brief.participants.some(p => {
+        // participants 可能是 "projectId" 或 "projectId:user"
+        return senderProjectId(p) === projectId;
+    });
+}
+/** 检查是否是讨论的发起人 */
+function isInitiator(brief, me, projectId) {
+    return brief.initiator === me || senderProjectId(brief.initiator) === projectId;
+}
+/** 根据 ID 获取讨论摘要 (用于权限检查) */
+async function getBrief(discussionId) {
+    try {
+        const all = await getClient().discussionList();
+        return all.find(d => d.id === discussionId) || null;
+    }
+    catch {
+        return null;
+    }
+}
 function relativeTime(iso) {
     try {
         const diff = Date.now() - new Date(iso).getTime();
@@ -37,8 +71,11 @@ function formatList(items, ctx) {
     ];
     for (const d of items) {
         const others = d.participants.filter(p => p !== d.initiator).join(', ') || '—';
-        lines.push(`| ${d.id} | ${d.title} | ${d.initiator} | ${others} | ${d.summary} | ${d.status} | ${relativeTime(d.updatedAt)} |`);
+        const memberTag = isMember(d, ctx.projectId) ? '✅' : '🔒';
+        lines.push(`| ${d.id} | ${memberTag} ${d.title} | ${d.initiator} | ${others} | ${d.summary} | ${d.status} | ${relativeTime(d.updatedAt)} |`);
     }
+    lines.push('');
+    lines.push('✅ = 你是成员(可读写) | 🔒 = 非成员(仅可查看标题)');
     return lines.join('\n');
 }
 function formatDetailView(d) {
@@ -66,7 +103,7 @@ function formatDetailView(d) {
 }
 export function registerDiscussionTools(server, ctx) {
     const client = () => getClient();
-    server.tool('kg_discuss', '💬 跨项目讨论 — 发起、回复、归档协同讨论。action: list(列出活跃讨论)|read(读取详情,自动追踪已读)|create(发起)|reply(回复)|complete(标记完成)|close(结案归档)|delete(删除)|history(查看历史讨论)', {
+    server.tool('kg_discuss', '💬 跨项目讨论 — action: list|read|create|reply|complete|close|delete|history。权限: 仅成员可读写，仅发起人可删除/归档', {
         action: z.enum(['list', 'read', 'create', 'reply', 'complete', 'close', 'delete', 'history'])
             .describe('操作类型'),
         id: z.string().optional()
@@ -90,41 +127,15 @@ export function registerDiscussionTools(server, ctx) {
     }, async (args) => safeTool(async () => {
         const decoded = decodeObjectStrings(args);
         const me = sender(ctx);
+        const myPid = ctx.projectId;
         switch (decoded.action) {
+            // ============ 公开操作 ============
             case 'list': {
                 const active = await client().discussionList();
                 if (!Array.isArray(active) || active.length === 0)
                     return wrap(`当前无活跃的讨论 (本项目: ${me})`);
                 return wrap(formatList(active, ctx));
             }
-            case 'read': {
-                const readIds = decoded.ids || (decoded.id ? [decoded.id] : []);
-                if (readIds.length === 0)
-                    return wrap('❌ read 需要 id 或 ids');
-                const readMode = decoded.mode || 'auto';
-                const discussions = await client().discussionReadByIds(readIds, me, readMode);
-                if (!Array.isArray(discussions) || discussions.length === 0)
-                    return wrap('未找到对应的讨论记录');
-                return wrap(discussions.map(formatDetailView).join('\n\n━━━━━━━━━━━━━━━━━━━━\n\n'));
-            }
-            case 'create': {
-                if (!decoded.title)
-                    return wrap('❌ create 需要 title');
-                if (!decoded.participants)
-                    return wrap('❌ create 需要 participants');
-                if (!decoded.content)
-                    return wrap('❌ create 需要 content');
-                const result = await client().discussionCreate(decoded.title, me, decoded.participants, decoded.content, decoded.summary);
-                return wrap(`✅ 讨论已发起\nID: ${result.id}\n发起方: ${me}\n参与方: ${decoded.participants.join(', ')}`);
-            }
-            case 'reply': {
-                if (!decoded.id)
-                    return wrap('❌ reply 需要 id');
-                if (!decoded.content)
-                    return wrap('❌ reply 需要 content');
-                await client().discussionReply(decoded.id, me, decoded.content, decoded.summary, decoded.newSummary);
-                return wrap(`✅ 回复成功 (ID: ${decoded.id}, 身份: ${me})`);
-            }
             case 'history': {
                 const all = await client().discussionListAll(me);
                 if (!Array.isArray(all) || all.length === 0)
@@ -143,9 +154,72 @@ export function registerDiscussionTools(server, ctx) {
                 }
                 return wrap(lines.join('\n'));
             }
+            case 'create': {
+                if (!decoded.title)
+                    return wrap('❌ create 需要 title');
+                if (!decoded.participants)
+                    return wrap('❌ create 需要 participants');
+                if (!decoded.content)
+                    return wrap('❌ create 需要 content');
+                const result = await client().discussionCreate(decoded.title, me, decoded.participants, decoded.content, decoded.summary);
+                return wrap(`✅ 讨论已发起\nID: ${result.id}\n发起方: ${me}\n参与方: ${decoded.participants.join(', ')}\n\n🔒 权限: 仅以上项目可读写此讨论，仅发起方可删除/归档`);
+            }
+            // ============ 成员操作 (需验证成员身份) ============
+            case 'read': {
+                const readIds = decoded.ids || (decoded.id ? [decoded.id] : []);
+                if (readIds.length === 0)
+                    return wrap('❌ read 需要 id 或 ids');
+                // 权限检查: 逐个验证成员身份
+                const allActive = await client().discussionList();
+                const deniedIds = [];
+                const allowedIds = [];
+                for (const rid of readIds) {
+                    const brief = allActive.find(d => d.id === rid);
+                    if (!brief) {
+                        allowedIds.push(rid); // 找不到就放行(可能是历史讨论)
+                    }
+                    else if (isMember(brief, myPid)) {
+                        allowedIds.push(rid);
+                    }
+                    else {
+                        deniedIds.push(rid);
+                    }
+                }
+                if (deniedIds.length > 0 && allowedIds.length === 0) {
+                    return wrap(`🔒 无权限: 你 (${myPid}) 不是这些讨论的成员\n拒绝: ${deniedIds.join(', ')}`);
+                }
+                const readMode = decoded.mode || 'auto';
+                const discussions = await client().discussionReadByIds(allowedIds, me, readMode);
+                if (!Array.isArray(discussions) || discussions.length === 0)
+                    return wrap('未找到对应的讨论记录');
+                let result = discussions.map(formatDetailView).join('\n\n━━━━━━━━━━━━━━━━━━━━\n\n');
+                if (deniedIds.length > 0) {
+                    result += `\n\n🔒 已跳过 ${deniedIds.length} 个无权限的讨论: ${deniedIds.join(', ')}`;
+                }
+                return wrap(result);
+            }
+            case 'reply': {
+                if (!decoded.id)
+                    return wrap('❌ reply 需要 id');
+                if (!decoded.content)
+                    return wrap('❌ reply 需要 content');
+                // 权限检查: 仅成员可回复
+                const brief = await getBrief(decoded.id);
+                if (brief && !isMember(brief, myPid)) {
+                    return wrap(`🔒 无权限: 你 (${myPid}) 不是讨论 "${brief.title}" 的成员\n成员: ${brief.initiator}, ${brief.participants.join(', ')}`);
+                }
+                await client().discussionReply(decoded.id, me, decoded.content, decoded.summary, decoded.newSummary);
+                return wrap(`✅ 回复成功 (ID: ${decoded.id}, 身份: ${me})`);
+            }
+            // ============ 发起人操作 (需验证发起人身份) ============
             case 'complete': {
                 if (!decoded.id)
                     return wrap('❌ complete 需要 id');
+                // 权限检查: 仅发起人可标记完成
+                const brief = await getBrief(decoded.id);
+                if (brief && !isInitiator(brief, me, myPid)) {
+                    return wrap(`🔒 无权限: 仅发起人 (${brief.initiator}) 可标记完成\n你的身份: ${me}`);
+                }
                 await client().discussionComplete(decoded.id);
                 return wrap(`✅ 讨论已标记完成 (ID: ${decoded.id})`);
             }
@@ -154,12 +228,27 @@ export function registerDiscussionTools(server, ctx) {
                     return wrap('❌ close 需要 id');
                 if (!decoded.conclusion)
                     return wrap('❌ close 需要 conclusion');
-                const result = await client().discussionClose(decoded.id, decoded.conclusion);
-                return wrap(`✅ 讨论已结案并归档: \`${result.archived_path}\``);
+                // 权限检查: 仅发起人可归档
+                const brief = await getBrief(decoded.id);
+                if (brief && !isInitiator(brief, me, myPid)) {
+                    return wrap(`🔒 无权限: 仅发起人 (${brief.initiator}) 可归档讨论\n你的身份: ${me}`);
+                }
+                // 先追加结案总结
+                try {
+                    await client().discussionReply(decoded.id, me, `📋 结案总结:\n\n${decoded.conclusion}`, '结案总结');
+                }
+                catch { /* 忽略回复失败 */ }
+                await client().discussionComplete(decoded.id);
+                return wrap(`✅ 讨论已结案 (ID: ${decoded.id})\n📋 ${decoded.conclusion}`);
             }
             case 'delete': {
                 if (!decoded.id)
                     return wrap('❌ delete 需要 id');
+                // 权限检查: 仅发起人可删除
+                const brief = await getBrief(decoded.id);
+                if (brief && !isInitiator(brief, me, myPid)) {
+                    return wrap(`🔒 无权限: 仅发起人 (${brief.initiator}) 可删除讨论\n你的身份: ${me}`);
+                }
                 await client().discussionDelete(decoded.id);
                 return wrap(`✅ 讨论已删除 (ID: ${decoded.id})`);
             }

package/dist/tools/docs.js

@@ -10,7 +10,7 @@ import { wrap, safeTool, crossPrefix, formatDocMarkdown, formatTreeText, countTr
 export function registerDocTools(server, ctx) {
     const client = () => getClient();
     // ========== kg_doc: 文档 CRUD 统一入口 ==========
-    server.tool('kg_doc', '📄 知识文档操作 — 创建、读取、更新、删除、复制文档。action: create(创建)|read(读取)|update(更新)|delete(删除)|batch_update(批量更新)|copy(跨项目复制)', {
+    server.tool('kg_doc', '📄 参考文档 — action: create(创建,建议bindTo关联节点)|read|update|delete|batch_update|copy。⚠️ 不绑定节点的文档会成为孤岛!', {
         action: z.enum(['create', 'read', 'update', 'delete', 'batch_update', 'copy'])
             .describe('操作类型'),
         path: z.string().optional()
@@ -47,6 +47,10 @@ export function registerDocTools(server, ctx) {
             .describe('复制源路径 (copy, 单个或数组)'),
         targetPath: z.string().optional()
             .describe('复制目标路径前缀 (copy)'),
+        bindTo: z.string().optional()
+            .describe('绑定到流程图节点ID (create/update, 如"n_frontend")'),
+        bindChart: z.string().optional()
+            .describe('绑定目标流程图ID (create/update, 默认"main")'),
     }, async (args) => safeTool(async () => {
         const d = decodeObjectStrings(args);
         switch (d.action) {
@@ -63,7 +67,39 @@ export function registerDocTools(server, ctx) {
                     bugfixes: [],
                     status: d.status || '已完成'
                 });
-                return wrap(`✅ 文档已创建: ${d.path}\n\n${JSON.stringify(doc, null, 2)}`);
+                // 绑定到流程图节点
+                let bindMsg = '';
+                if (d.bindTo) {
+                    try {
+                        const chartId = d.bindChart || 'main';
+                        const chart = await client().getFlowchart(chartId);
+                        if (chart) {
+                            const node = chart.nodes?.find((n) => n.id === d.bindTo);
+                            if (node) {
+                                if (!node.boundDocs)
+                                    node.boundDocs = [];
+                                if (!node.boundDocs.includes(d.path)) {
+                                    node.boundDocs.push(d.path);
+                                }
+                                // Save back via PUT (use the existing save method)
+                                chart.id = chartId;
+                                await client().saveFlowchart(chartId, chart);
+                                bindMsg = `\n🔗 已绑定到节点: ${d.bindTo} [${chartId}]`;
+                            }
+                            else {
+                                bindMsg = `\n⚠️ 节点 "${d.bindTo}" 不存在于流程图 "${chartId}"`;
+                            }
+                        }
+                    }
+                    catch {
+                        bindMsg = `\n⚠️ 绑定失败(流程图操作异常)`;
+                    }
+                }
+                // 约束: 未绑定流程图节点 → 强制警告
+                if (!d.bindTo) {
+                    bindMsg = `\n\n⚠️ 【未关联知识锚点】文档未绑定到流程图节点!\n💡 建议: 使用 kg_flowchart(bind, nodeId, docs:["${d.path}"]) 绑定\n📌 孤立文档无法被 AI 通过节点关联发现`;
+                }
+                return wrap(`✅ 文档已创建: ${d.path}${bindMsg}`);
             }
             // ---- READ ----
             case 'read': {
@@ -109,7 +145,9 @@ export function registerDocTools(server, ctx) {
                 if (d.bugfixes !== undefined)
                     updates.bugfixes = d.bugfixes;
                 const doc = await client().updateDoc(d.path, updates);
-                return wrap(doc ? JSON.stringify(doc, null, 2) : '更新失败');
+                if (!doc)
+                    return wrap('更新失败');
+                return wrap(`✅ 文档已更新: ${d.path}\n状态: ${doc.status || '已完成'}\n摘要: ${doc.summary || ''}`);
             }
             // ---- DELETE ----
             case 'delete': {

package/dist/tools/flowchart.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 🔀 kg_flowchart — 逻辑流程图批量操作
+ * AI 一次提交所有节点+边, 后端原子处理, 返回孤立检测结果
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type McpContext } from './shared.js';
+export declare function registerFlowchartTools(server: McpServer, ctx: McpContext): void;

package/dist/tools/flowchart.js

@@ -0,0 +1,483 @@
+/**
+ * 🔀 kg_flowchart — 逻辑流程图批量操作
+ * AI 一次提交所有节点+边, 后端原子处理, 返回孤立检测结果
+ */
+import { z } from 'zod';
+import { getClient } from '../storage/httpClient.js';
+import { decodeObjectStrings } from '../utils.js';
+import { wrap, safeTool } from './shared.js';
+const NodeSchema = z.object({
+    id: z.string().describe('节点唯一ID'),
+    label: z.string().describe('节点标签'),
+    description: z.string().optional().describe('节点描述'),
+    nodeType: z.string().optional().describe('节点类型: super|process|data|entry'),
+    domain: z.string().optional().describe('领域: frontend|backend|mcp|system|infra'),
+    input: z.array(z.string()).optional(),
+    output: z.array(z.string()).optional(),
+    affiliation: z.string().optional().describe('父节点ID, 默认root'),
+});
+const EdgeSchema = z.object({
+    from: z.string().describe('起点节点ID'),
+    to: z.string().describe('终点节点ID'),
+    label: z.string().optional().describe('连线标签'),
+    edgeType: z.string().optional().describe('类型: call|event|data|reference'),
+});
+export function registerFlowchartTools(server, ctx) {
+    const client = () => getClient();
+    server.tool('kg_flowchart', '🔀 逻辑流程图(关系型知识锚点) — action: list|get|get_node(★爆炸式上下文)|update_node|delete_node|batch_add|bind|unbind|orphans|health', {
+        action: z.enum(['list', 'get', 'get_node', 'update_node', 'delete_node', 'batch_add', 'bind', 'unbind', 'orphans', 'health'])
+            .describe('操作类型'),
+        chartId: z.string().optional()
+            .describe('流程图ID (默认"main")'),
+        nodeId: z.string().optional()
+            .describe('节点ID (get_node/update_node/delete_node/bind/unbind)'),
+        // get_node 爆炸扩展控制 (全部默认开启, AI可选择性关闭)
+        expand: z.number().optional()
+            .describe('get_node: 连线扩展层数(默认3, 0=不扩展)'),
+        includeDocs: z.boolean().optional()
+            .describe('get_node: 显示绑定的参考文档摘要(默认true)'),
+        includeTasks: z.boolean().optional()
+            .describe('get_node: 显示绑定的任务摘要(默认true)'),
+        includeFiles: z.boolean().optional()
+            .describe('get_node: 显示绑定的代码文件(默认true)'),
+        includeDoc: z.boolean().optional()
+            .describe('get_node: 显示节点技术文档(默认true)'),
+        // update_node 更新字段
+        label: z.string().optional().describe('update_node: 新标签'),
+        description: z.string().optional().describe('update_node: 新描述'),
+        nodeType: z.string().optional().describe('update_node: 新类型'),
+        domain: z.string().optional().describe('update_node: 新领域'),
+        input: z.array(z.string()).optional().describe('update_node: 新输入 / bind的源代码文件'),
+        output: z.array(z.string()).optional().describe('update_node: 新输出'),
+        // bind/unbind
+        files: z.array(z.string()).optional()
+            .describe('源代码文件路径 (bind/unbind)'),
+        dirs: z.array(z.string()).optional()
+            .describe('源代码目录路径 (bind/unbind)'),
+        docs: z.array(z.string()).optional()
+            .describe('知识文档路径 (bind/unbind)'),
+        tasks: z.array(z.string()).optional()
+            .describe('任务ID (bind/unbind)'),
+        // batch_add
+        nodes: z.array(NodeSchema).optional()
+            .describe('批量添加的节点数组 (batch_add)'),
+        edges: z.array(EdgeSchema).optional()
+            .describe('批量添加的边数组 (batch_add)'),
+    }, async (args) => safeTool(async () => {
+        const decoded = decodeObjectStrings(args);
+        switch (decoded.action) {
+            case 'list': {
+                const charts = await client().listFlowcharts();
+                if (!charts || charts.length === 0)
+                    return wrap('📋 暂无流程图');
+                const list = charts
+                    .map(c => `• ${c.title} [${c.id}] — ${c.nodeCount}节点 ${c.edgeCount}连线`)
+                    .join('\n');
+                return wrap(`📋 流程图列表:\n\n${list}`);
+            }
+            case 'get': {
+                const chartId = decoded.chartId || 'main';
+                const chart = await client().getFlowchart(chartId);
+                if (!chart)
+                    return wrap(`❌ 流程图 "${chartId}" 不存在`);
+                const nodes = chart.nodes || [];
+                const edges = chart.edges || [];
+                const lines = [
+                    `📊 ${chart.title || chartId} [${chartId}]`,
+                    chart.parentChart ? `↩ 父图: ${chart.parentChart}` : '',
+                    ``,
+                    `### 节点 (${nodes.length})`,
+                    ...nodes.map((n) => `  • ${n.label} [${n.id}] (${n.nodeType}/${n.domain}) ${n.boundDocs?.length ? `📄${n.boundDocs.length}` : ''} ${n.boundTasks?.length ? `📝${n.boundTasks.length}` : ''} ${n.boundFiles?.length ? `📂${n.boundFiles.length}` : ''}`),
+                    ``,
+                    `### 连线 (${edges.length})`,
+                    ...edges.map((e) => `  ${e.from} →${e.label ? `[${e.label}]` : ''} ${e.to}`),
+                ].filter(Boolean);
+                return wrap(lines.join('\n'));
+            }
+            case 'get_node': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId)
+                    return wrap('❌ get_node 需要 nodeId');
+                const chart = await client().getFlowchart(chartId);
+                if (!chart)
+                    return wrap(`❌ 流程图 "${chartId}" 不存在`);
+                const allNodes = chart.nodes || [];
+                const allEdges = chart.edges || [];
+                const target = allNodes.find((n) => n.id === decoded.nodeId);
+                if (!target)
+                    return wrap(`❌ 节点 "${decoded.nodeId}" 不存在于 "${chartId}"`);
+                // 扩展参数 (全部默认开启)
+                const expandDepth = decoded.expand !== undefined ? Number(decoded.expand) : 3;
+                const showDocs = decoded.includeDocs !== false;
+                const showTasks = decoded.includeTasks !== false;
+                const showFiles = decoded.includeFiles !== false;
+                const showDoc = decoded.includeDoc !== false;
+                const nodeMap = new Map(allNodes.map((n) => [n.id, n]));
+                const lines = [];
+                // ======== 节点基础信息 ========
+                lines.push(`🔍 节点详情: ${target.label} [${target.id}]`);
+                lines.push(`类型: ${target.nodeType || 'process'} | 领域: ${target.domain || 'system'}`);
+                if (target.description)
+                    lines.push(`📝 ${target.description}`);
+                if (target.input?.length)
+                    lines.push(`📥 输入: ${target.input.join(', ')}`);
+                if (target.output?.length)
+                    lines.push(`📤 输出: ${target.output.join(', ')}`);
+                if (target.subFlowchart)
+                    lines.push(`📂 子流程图: ${target.subFlowchart}`);
+                if (target.lastUpdated)
+                    lines.push(`🕐 最后更新: ${target.lastUpdated}`);
+                lines.push('');
+                // ======== 节点技术文档 ========
+                if (showDoc && target.doc) {
+                    lines.push(`### 📖 技术文档`);
+                    lines.push(`版本: ${target.doc.version} | ${target.doc.date}`);
+                    if (target.doc.overview)
+                        lines.push(target.doc.overview);
+                    if (target.doc.details?.length) {
+                        for (const d of target.doc.details) {
+                            lines.push(`  **${d.section}**: ${d.content?.substring(0, 200)}`);
+                        }
+                    }
+                    lines.push('');
+                }
+                // ======== 爆炸扩展: N层关联节点 ========
+                if (expandDepth > 0) {
+                    const visited = new Set([target.id]);
+                    let frontier = [target.id];
+                    const layerResults = [];
+                    for (let depth = 1; depth <= expandDepth; depth++) {
+                        const nextFrontier = [];
+                        const layerLines = [];
+                        for (const currentId of frontier) {
+                            // 出边
+                            for (const e of allEdges) {
+                                if (e.from === currentId && !visited.has(e.to)) {
+                                    visited.add(e.to);
+                                    nextFrontier.push(e.to);
+                                    const neighbor = nodeMap.get(e.to);
+                                    const label = neighbor?.label || e.to;
+                                    layerLines.push(`  → ${label} [${e.to}] ${e.label ? `(${e.label})` : ''} ${e.edgeType ? `[${e.edgeType}]` : ''}`);
+                                }
+                                // 入边
+                                if (e.to === currentId && !visited.has(e.from)) {
+                                    visited.add(e.from);
+                                    nextFrontier.push(e.from);
+                                    const neighbor = nodeMap.get(e.from);
+                                    const label = neighbor?.label || e.from;
+                                    layerLines.push(`  ← ${label} [${e.from}] ${e.label ? `(${e.label})` : ''} ${e.edgeType ? `[${e.edgeType}]` : ''}`);
+                                }
+                            }
+                        }
+                        if (layerLines.length > 0)
+                            layerResults.push(layerLines);
+                        frontier = nextFrontier;
+                        if (frontier.length === 0)
+                            break;
+                    }
+                    if (layerResults.length > 0) {
+                        lines.push(`### 🔗 关联节点 (扩展${layerResults.length}层, 共${visited.size - 1}个)`);
+                        layerResults.forEach((layer, i) => {
+                            lines.push(`**L${i + 1}** (${layer.length}个):`);
+                            lines.push(...layer);
+                        });
+                        lines.push('');
+                    }
+                }
+                // ======== 绑定的参考文档 ========
+                if (showDocs && target.boundDocs?.length) {
+                    lines.push(`### 📄 绑定参考文档 (${target.boundDocs.length})`);
+                    for (const docPath of target.boundDocs) {
+                        try {
+                            const doc = await client().getDoc(docPath);
+                            if (doc) {
+                                lines.push(`  📄 ${docPath} — ${doc.summary || '无摘要'}`);
+                                if (doc.status)
+                                    lines.push(`     状态: ${doc.status}`);
+                            }
+                            else {
+                                lines.push(`  📄 ${docPath} (未找到)`);
+                            }
+                        }
+                        catch {
+                            lines.push(`  📄 ${docPath}`);
+                        }
+                    }
+                    lines.push('');
+                }
+                // ======== 绑定的任务 ========
+                if (showTasks && target.boundTasks?.length) {
+                    lines.push(`### 📝 绑定任务 (${target.boundTasks.length})`);
+                    for (const taskId of target.boundTasks) {
+                        try {
+                            const task = await client().getTask(taskId);
+                            if (task) {
+                                lines.push(`  📝 [${taskId}] ${task.title} — ${task.status}`);
+                            }
+                            else {
+                                lines.push(`  📝 [${taskId}] (未找到)`);
+                            }
+                        }
+                        catch {
+                            lines.push(`  📝 [${taskId}]`);
+                        }
+                    }
+                    lines.push('');
+                }
+                // ======== 绑定的代码文件 ========
+                if (showFiles) {
+                    const files = target.boundFiles || [];
+                    const dirs = target.boundDirs || [];
+                    if (files.length + dirs.length > 0) {
+                        lines.push(`### 📂 绑定代码 (${files.length}文件 ${dirs.length}目录)`);
+                        for (const f of files)
+                            lines.push(`  📄 ${f}`);
+                        for (const d of dirs)
+                            lines.push(`  📁 ${d}`);
+                        lines.push('');
+                    }
+                }
+                // ======== 版本历史 ========
+                if (target.versions?.length) {
+                    lines.push(`### 📋 版本历史 (${target.versions.length})`);
+                    for (const v of target.versions.slice(-5)) {
+                        lines.push(`  v${v.version} (${v.date}): ${v.changes}`);
+                    }
+                }
+                return wrap(lines.join('\n'));
+            }
+            case 'update_node': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId)
+                    return wrap('❌ update_node 需要 nodeId');
+                // 构建待更新的节点字段
+                const updates = { id: decoded.nodeId };
+                const changes = [];
+                if (decoded.label !== undefined) {
+                    updates.label = decoded.label;
+                    changes.push('label');
+                }
+                if (decoded.description !== undefined) {
+                    updates.description = decoded.description;
+                    changes.push('description');
+                }
+                if (decoded.nodeType !== undefined) {
+                    updates.nodeType = decoded.nodeType;
+                    changes.push('nodeType');
+                }
+                if (decoded.domain !== undefined) {
+                    updates.domain = decoded.domain;
+                    changes.push('domain');
+                }
+                if (decoded.input !== undefined) {
+                    updates.input = decoded.input;
+                    changes.push('input');
+                }
+                if (decoded.output !== undefined) {
+                    updates.output = decoded.output;
+                    changes.push('output');
+                }
+                if (changes.length === 0)
+                    return wrap('ℹ️ 无变更 — 请提供要更新的字段');
+                updates.lastUpdated = new Date().toISOString();
+                // 原子调用: PUT /flowcharts/:chartId/nodes/:nodeId
+                await client().updateFlowchartNode(chartId, decoded.nodeId, updates, `MCP更新: ${changes.join(', ')}`);
+                return wrap(`✅ 节点已更新: ${decoded.label || decoded.nodeId} [${chartId}/${decoded.nodeId}]\n更新字段: ${changes.join(', ')}`);
+            }
+            case 'delete_node': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId)
+                    return wrap('❌ delete_node 需要 nodeId');
+                // 原子调用: DELETE /flowcharts/:chartId/nodes/:nodeId (后端自动清理关联边)
+                await client().deleteFlowchartNode(chartId, decoded.nodeId);
+                return wrap(`✅ 节点已删除 [${chartId}/${decoded.nodeId}]`);
+            }
+            case 'batch_add': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodes || decoded.nodes.length === 0) {
+                    return wrap('❌ batch_add 需要 nodes 数组');
+                }
+                // 自动填充默认值 — AI 只需填 id+label+description
+                const fullNodes = decoded.nodes.map((n) => ({
+                    id: n.id,
+                    label: n.label,
+                    nodeType: n.nodeType || 'process',
+                    domain: n.domain || 'system',
+                    input: n.input || [],
+                    output: n.output || [],
+                    description: n.description || '',
+                    affiliation: n.affiliation || 'root',
+                    boundDocs: [],
+                    boundFiles: [],
+                    boundDirs: [],
+                    boundTasks: [],
+                    subFlowchart: null,
+                    position: null,
+                    versions: [],
+                    lastUpdated: '',
+                    lastQueried: '',
+                }));
+                const fullEdges = (decoded.edges || []).map((e) => ({
+                    from: e.from,
+                    to: e.to,
+                    label: e.label || null,
+                    edgeType: e.edgeType || 'call',
+                }));
+                const result = await client().batchAddToFlowchart(chartId, fullNodes, fullEdges);
+                // 构建报告
+                let report = `✅ 批量操作完成 [${chartId}]\n`;
+                report += `  添加: ${result.addedNodes.length}节点 ${result.addedEdges}连线\n`;
+                if (result.failedNodes.length > 0) {
+                    report += `\n❌ 失败节点:\n`;
+                    result.failedNodes.forEach(([id, reason]) => {
+                        report += `  • ${id}: ${reason}\n`;
+                    });
+                }
+                if (result.failedEdges.length > 0) {
+                    report += `\n❌ 失败连线:\n`;
+                    result.failedEdges.forEach(([from, to, reason]) => {
+                        report += `  • ${from} → ${to}: ${reason}\n`;
+                    });
+                }
+                if (result.orphanedNodes.length > 0) {
+                    report += `\n⚠️ 孤立节点 (无任何连线):\n`;
+                    result.orphanedNodes.forEach(id => {
+                        report += `  • ${id}\n`;
+                    });
+                }
+                else {
+                    report += `\n✅ 无孤立节点`;
+                }
+                return wrap(report);
+            }
+            case 'orphans': {
+                const orphans = await client().getFlowchartOrphans();
+                if (!orphans || orphans.length === 0) {
+                    return wrap('✅ 无孤立文档 — 所有文档均已绑定到流程图节点');
+                }
+                const list = orphans
+                    .map(o => `• ${o.docPath}${o.docSummary ? ` — ${o.docSummary}` : ''}`)
+                    .join('\n');
+                return wrap(`⚠️ 发现 ${orphans.length} 个孤立文档 (未绑定到任何流程图节点):\n\n${list}\n\n💡 使用 kg_doc(update, bindTo: "节点ID") 绑定`);
+            }
+            case 'health': {
+                const health = await client().getFlowchartHealth();
+                if (!health || health.length === 0) {
+                    return wrap('📊 暂无节点健康数据');
+                }
+                const items = health;
+                const stale = items.filter(h => h.status === 'stale');
+                const active = items.filter(h => h.status === 'active');
+                const normal = items.filter(h => h.status === 'normal');
+                let report = `📊 知识冷热分布 (${items.length}节点):\n`;
+                report += `  🟢 active (7天内查询): ${active.length}\n`;
+                report += `  🟡 normal (30天内): ${normal.length}\n`;
+                report += `  🔴 stale (30天+未查询): ${stale.length}\n`;
+                if (stale.length > 0) {
+                    report += `\n🔴 冷知识节点:\n`;
+                    stale.forEach(h => {
+                        report += `  • ${h.nodeLabel} [${h.chartId}/${h.nodeId}] — ${h.daysSinceQuery}天未查询\n`;
+                    });
+                }
+                return wrap(report);
+            }
+            case 'bind':
+            case 'unbind': {
+                const chartId = decoded.chartId || 'main';
+                if (!decoded.nodeId)
+                    return wrap(`❌ ${decoded.action} 需要 nodeId`);
+                const chart = await client().getFlowchart(chartId);
+                if (!chart)
+                    return wrap(`❌ 流程图 "${chartId}" 不存在`);
+                const node = chart.nodes?.find((n) => n.id === decoded.nodeId);
+                if (!node)
+                    return wrap(`❌ 节点 "${decoded.nodeId}" 不存在于流程图 "${chartId}"`);
+                const isBind = decoded.action === 'bind';
+                const changes = [];
+                const modify = (items, field, label) => {
+                    if (!items || items.length === 0)
+                        return;
+                    if (!node[field])
+                        node[field] = [];
+                    if (isBind) {
+                        let added = 0;
+                        for (const item of items) {
+                            if (!node[field].includes(item)) {
+                                node[field].push(item);
+                                added++;
+                            }
+                        }
+                        if (added > 0)
+                            changes.push(`+${added} ${label}`);
+                    }
+                    else {
+                        const before = node[field].length;
+                        node[field] = node[field].filter((x) => !items.includes(x));
+                        const removed = before - node[field].length;
+                        if (removed > 0)
+                            changes.push(`-${removed} ${label}`);
+                    }
+                };
+                modify(decoded.files, 'boundFiles', '文件');
+                modify(decoded.dirs, 'boundDirs', '目录');
+                modify(decoded.docs, 'boundDocs', '文档');
+                modify(decoded.tasks, 'boundTasks', '任务');
+                if (changes.length === 0) {
+                    return wrap(`ℹ️ 无变更 — 请提供 files/dirs/docs/tasks 参数`);
+                }
+                await client().saveFlowchart(chartId, chart);
+                // P2: 双向同步 — 更新参考文档的 adoptedBy
+                const docsList = decoded.docs;
+                if (docsList && docsList.length > 0) {
+                    const nodeId = decoded.nodeId;
+                    for (const docPath of docsList) {
+                        try {
+                            const doc = await client().getDoc(docPath);
+                            if (!doc?.content)
+                                continue;
+                            const content = doc.content;
+                            // 解析 frontmatter
+                            if (!content.startsWith('---'))
+                                continue;
+                            const endIdx = content.indexOf('---', 3);
+                            if (endIdx === -1)
+                                continue;
+                            const yaml = content.slice(3, endIdx);
+                            const body = content.slice(endIdx + 3);
+                            // 提取现有 adoptedBy
+                            const adoptedMatch = yaml.match(/adoptedBy:\s*\[(.*?)\]/);
+                            let adopted = [];
+                            if (adoptedMatch) {
+                                adopted = adoptedMatch[1].split(',').map(s => s.trim()).filter(Boolean);
+                            }
+                            // 修改 adoptedBy
+                            if (isBind) {
+                                if (!adopted.includes(nodeId))
+                                    adopted.push(nodeId);
+                            }
+                            else {
+                                adopted = adopted.filter(id => id !== nodeId);
+                            }
+                            // 重建 frontmatter
+                            const newAdoptedLine = `adoptedBy: [${adopted.join(', ')}]`;
+                            let newYaml;
+                            if (adoptedMatch) {
+                                newYaml = yaml.replace(/adoptedBy:\s*\[.*?\]/, newAdoptedLine);
+                            }
+                            else {
+                                newYaml = yaml.trimEnd() + '\n' + newAdoptedLine + '\n';
+                            }
+                            const newContent = `---${newYaml}---${body}`;
+                            await client().updateDoc(docPath, { content: newContent });
+                        }
+                        catch { /* 单个文档同步失败不阻断 */ }
+                    }
+                }
+                const icon = isBind ? '🔗' : '⛓️';
+                return wrap(`${icon} ${isBind ? '绑定' : '解绑'}完成 [${decoded.nodeId}]: ${changes.join(', ')}`);
+            }
+            default:
+                return wrap(`❌ 未知 action: ${decoded.action}`);
+        }
+    }));
+}

package/dist/tools/index.d.ts

@@ -2,12 +2,13 @@
  * MCP 工具注册入口
  * 14 个工具, 7 个子模块
  *
- * 🔗 初始化:   kg_init                       (1个)
- * 📊 导航:     kg_status, kg_tree          (2个)
- * 📚 知识:     kg_doc, kg_projects, kg_rules (3个)
- * 📝 工作流:   kg_task, kg_files, kg_discuss (3个)
- * 🔬 代码分析: code_scan, code_smart_context, code_full_path (3个)
- * 🏛️ 协作:    kg_meeting                    (1个)
+ * 🔗 初始化:   kg_init                                           (1个)
+ * 📊 导航:     kg_status, kg_tree                                (2个)
+ * 📚 知识:     kg_doc(参考文档), kg_projects, kg_rules            (3个)
+ * 📝 工作流:   kg_task(任务记录), kg_files, kg_discuss(讨论区)     (3个)
+ * 🔀 关系核心: kg_flowchart(逻辑流程图 — 关系型知识锚点)           (1个)
+ * 🔬 代码分析: code_scan, code_smart_context, code_full_path      (3个)
+ * 🏛️ 协作:    kg_meeting                                         (1个)
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare function registerTools(server: McpServer, projectId: string, user: string, onProjectChange?: (newProjectId: string, newApiUrl: string) => void): void;

package/dist/tools/index.js

@@ -2,12 +2,13 @@
  * MCP 工具注册入口
  * 14 个工具, 7 个子模块
  *
- * 🔗 初始化:   kg_init                       (1个)
- * 📊 导航:     kg_status, kg_tree          (2个)
- * 📚 知识:     kg_doc, kg_projects, kg_rules (3个)
- * 📝 工作流:   kg_task, kg_files, kg_discuss (3个)
- * 🔬 代码分析: code_scan, code_smart_context, code_full_path (3个)
- * 🏛️ 协作:    kg_meeting                    (1个)
+ * 🔗 初始化:   kg_init                                           (1个)
+ * 📊 导航:     kg_status, kg_tree                                (2个)
+ * 📚 知识:     kg_doc(参考文档), kg_projects, kg_rules            (3个)
+ * 📝 工作流:   kg_task(任务记录), kg_files, kg_discuss(讨论区)     (3个)
+ * 🔀 关系核心: kg_flowchart(逻辑流程图 — 关系型知识锚点)           (1个)
+ * 🔬 代码分析: code_scan, code_smart_context, code_full_path      (3个)
+ * 🏛️ 协作:    kg_meeting                                         (1个)
  */
 import { createContext } from './shared.js';
 import { registerInitTool } from './init.js';
@@ -20,6 +21,7 @@ import { registerFileTools } from './files.js';
 import { registerDiscussionTools } from './discussion.js';
 import { registerAnalyzerTools } from './analyzer.js';
 import { registerMeetingTools } from './meeting.js';
+import { registerFlowchartTools } from './flowchart.js';
 export function registerTools(server, projectId, user, onProjectChange) {
     // 创建共享可变上下文 — 所有工具捕获此对象引用
     const ctx = createContext(projectId, user);
@@ -39,4 +41,6 @@ export function registerTools(server, projectId, user, onProjectChange) {
     registerAnalyzerTools(server, ctx);
     // 🏛️ 多AI协作 (kg_meeting)
     registerMeetingTools(server, ctx);
+    // 🔀 流程图 (kg_flowchart)
+    registerFlowchartTools(server, ctx);
 }

package/dist/tools/rules.js

@@ -10,7 +10,7 @@ import { wrap, safeTool, crossPrefix } from './shared.js';
 export function registerRuleTools(server, ctx) {
     const client = () => getClient();
     server.tool('kg_rules', '📏 项目规则管理 — 读取或保存代码风格、审查规则等。action: get(读取规则)|save(保存规则)|get_meta(读取触发配置)|save_meta(保存触发配置)', {
-        action: z.enum(['get', 'save', 'get_meta', 'save_meta'])
+        action: z.enum(['get', 'save', 'get_meta', 'save_meta', 'delete'])
             .describe('操作类型'),
         ruleType: z.string().optional()
             .describe('规则类型(如 userStyles, codeStyle, reviewRules)。get/save 时使用，不传则获取全部'),
@@ -96,6 +96,24 @@ export function registerRuleTools(server, ctx) {
                     return wrap('❌ 保存失败');
                 return wrap(`✅ 触发配置已保存 (更新${Object.keys(decoded.meta).length}个类型, 共${Object.keys(merged).length}个类型)`);
             }
+            case 'delete': {
+                if (!decoded.ruleType)
+                    return wrap('❌ delete 需要 ruleType');
+                if (!decoded.rules || decoded.rules.length === 0)
+                    return wrap('❌ delete 需要 rules 数组(要删除的规则内容)');
+                const existing = await client().getRulesApi(decoded.ruleType);
+                const toDelete = new Set(decoded.rules.map((r) => r.trim()));
+                const filtered = existing.filter((r) => !toDelete.has(r.trim()));
+                const removed = existing.length - filtered.length;
+                if (removed === 0)
+                    return wrap('ℹ️ 未找到匹配的规则');
+                const success = await client().saveRulesApi(decoded.ruleType, filtered);
+                if (!success)
+                    return wrap('❌ 删除失败');
+                const meta = await client().getRulesMeta();
+                const label = meta[decoded.ruleType]?.label || decoded.ruleType;
+                return wrap(`✅ ${label}: 已删除${removed}条, 剩余${filtered.length}条`);
+            }
             default:
                 return wrap(`❌ 未知 action: ${decoded.action}`);
         }

package/dist/tools/tasks.d.ts

@@ -1,6 +1,6 @@
 /**
- * 📝 kg_task (4→1)
- * 合并: task_create, task_get, task_update, task_archive
+ * 📝 kg_task (4→1) — 极简任务管理
+ * AI 只需说人话写内容，后端负责所有格式化、分类、时间戳
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type McpContext } from './shared.js';

package/dist/tools/tasks.js

@@ -1,6 +1,6 @@
 /**
- * 📝 kg_task (4→1)
- * 合并: task_create, task_get, task_update, task_archive
+ * 📝 kg_task (4→1) — 极简任务管理
+ * AI 只需说人话写内容，后端负责所有格式化、分类、时间戳
  */
 import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
@@ -8,21 +8,21 @@ import { decodeObjectStrings } from '../utils.js';
 import { wrap, safeTool } from './shared.js';
 export function registerTaskTools(server, ctx) {
     const client = () => getClient();
-    server.tool('kg_task', '📝 任务管理 — 创建、查询、更新进展、归档。action: create(创建)|get(查询)|update(添加日志)|archive(归档)', {
-        action: z.enum(['create', 'get', 'update', 'archive'])
+    server.tool('kg_task', '📝 任务记录 — action: create(创建,建议bindTo关联节点)|get(查询)|update(追加进度)|archive(归档)|delete(删除)。⚠️ 每完成一个步骤必须立即update!', {
+        action: z.enum(['create', 'get', 'update', 'archive', 'delete'])
             .describe('操作类型'),
         title: z.string().optional()
-            .describe('任务标题 (create/get)'),
+            .describe('任务标题 (create/get按标题搜)'),
         description: z.string().optional()
             .describe('任务描述Markdown (create)'),
         goals: z.array(z.string()).optional()
             .describe('目标清单 (create)'),
         taskId: z.string().optional()
-            .describe('任务ID (update/archive)'),
+            .describe('任务ID (get/update/archive)'),
         log_type: z.enum(['progress', 'issue', 'solution', 'reference']).optional()
-            .describe('日志类型 (update)'),
+            .describe('日志类型 (update, 可选-不传则自动检测)'),
         content: z.string().optional()
-            .describe('日志内容Markdown (update)'),
+            .describe('日志内容Markdown (update, 内容长短由AI决定,支持完整Markdown)'),
         summary: z.string().optional()
             .describe('经验总结Markdown (archive)'),
         difficulties: z.array(z.string()).optional()
@@ -30,7 +30,11 @@ export function registerTaskTools(server, ctx) {
         solutions: z.array(z.string()).optional()
             .describe('解决方案 (archive)'),
         status: z.enum(['active', 'archived', 'all']).optional()
-            .describe('状态筛选 (get, 默认all)'),
+            .describe('状态筛选 (get, 默认active)'),
+        bindTo: z.string().optional()
+            .describe('绑定到流程图节点ID (create, 如"n_entry")'),
+        bindChart: z.string().optional()
+            .describe('绑定目标流程图ID (create, 默认"main")'),
     }, async (args) => safeTool(async () => {
         const decoded = decodeObjectStrings(args);
         switch (decoded.action) {
@@ -44,13 +48,85 @@ export function registerTaskTools(server, ctx) {
                     description: decoded.description,
                     goals: decoded.goals || []
                 }, ctx.user);
-                return wrap(JSON.stringify(task, null, 2));
+                // 自动绑定到流程图节点
+                let bindMsg = '';
+                if (decoded.bindTo) {
+                    try {
+                        const chartId = decoded.bindChart || 'main';
+                        const chart = await client().getFlowchart(chartId);
+                        if (chart) {
+                            const node = chart.nodes?.find((n) => n.id === decoded.bindTo);
+                            if (node) {
+                                if (!node.boundTasks)
+                                    node.boundTasks = [];
+                                if (!node.boundTasks.includes(task.id)) {
+                                    node.boundTasks.push(task.id);
+                                }
+                                await client().saveFlowchart(chartId, chart);
+                                bindMsg = `\n🔗 已绑定到节点: ${decoded.bindTo} [${chartId}]`;
+                            }
+                            else {
+                                bindMsg = `\n⚠️ 节点 "${decoded.bindTo}" 不存在于流程图 "${chartId}"`;
+                            }
+                        }
+                    }
+                    catch {
+                        bindMsg = `\n⚠️ 绑定失败`;
+                    }
+                }
+                // 约束: 未绑定流程图 → 强制警告
+                if (!decoded.bindTo) {
+                    bindMsg = `\n\n⚠️ 【未关联知识锚点】此任务未绑定到任何流程图节点!\n💡 建议: 使用 kg_flowchart(get) 查看节点列表, 然后用 kg_flowchart(bind, nodeId, tasks:["${task.id}"]) 绑定\n📌 不关联的任务会成为孤岛数据, 无法被其他AI发现`;
+                }
+                return wrap(`✅ 任务已创建\nID: ${task.id}\n标题: ${task.title}\n验收标准: ${task.detail.goals.length}条${bindMsg}`);
             }
             case 'get': {
-                if (!decoded.title)
-                    return wrap('❌ get 需要 title');
-                const filterStatus = decoded.status || 'all';
+                // 无参数 = 列出活跃任务
+                if (!decoded.taskId && !decoded.title) {
+                    const status = decoded.status || 'active';
+                    let tasks;
+                    if (status === 'all') {
+                        const [active, archived] = await Promise.all([
+                            client().listTasks('active'),
+                            client().listTasks('archived')
+                        ]);
+                        tasks = [...active, ...archived];
+                    }
+                    else {
+                        tasks = await client().listTasks(status);
+                    }
+                    if (tasks.length === 0)
+                        return wrap(`📋 ${status === 'archived' ? '归档' : '活跃'}任务为空`);
+                    const list = tasks.map(t => `• [${t.status}] ${t.title}\n  ID: ${t.id} | 更新: ${t.updated_at.split('T')[0]} | ${t.last_log || ''}`).join('\n');
+                    return wrap(`📋 共 ${tasks.length} 个任务:\n\n${list}`);
+                }
+                // 有 taskId = 获取详情 (结构化摘要)
+                if (decoded.taskId) {
+                    const task = await client().getTask(decoded.taskId, 'smart');
+                    if (!task)
+                        return wrap('❌ 任务未找到');
+                    const lines = [
+                        `📝 ${task.title}`,
+                        `ID: ${task.id} | 状态: ${task.status}`,
+                        `创建: ${task.created_at?.split('T')[0] || ''}`,
+                    ];
+                    if (task.detail?.description)
+                        lines.push(`\n📋 ${task.detail.description}`);
+                    if (task.detail?.goals?.length) {
+                        lines.push(`\n🎯 验收标准:`);
+                        task.detail.goals.forEach((g, i) => lines.push(`  ${i + 1}. ☐ ${g}`));
+                    }
+                    if (task.logs?.length) {
+                        lines.push(`\n📊 进度日志 (${task.logs.length}条, 最近3条):`);
+                        for (const log of task.logs.slice(-3)) {
+                            lines.push(`  [${log.log_type}] ${log.time?.split('T')[0] || ''}: ${log.content?.substring(0, 120)}`);
+                        }
+                    }
+                    return wrap(lines.join('\n'));
+                }
+                // 有 title = 按标题搜索
                 const searchTitle = decoded.title.toLowerCase();
+                const filterStatus = decoded.status || 'all';
                 let tasks;
                 if (filterStatus === 'all') {
                     const [active, archived] = await Promise.all([
@@ -66,26 +142,32 @@ export function registerTaskTools(server, ctx) {
                 if (matched.length === 0)
                     return wrap(`未找到匹配 "${decoded.title}" 的任务`);
                 if (matched.length === 1) {
-                    const task = await client().getTask(matched[0].id);
-                    return wrap(task ? JSON.stringify(task, null, 2) : '任务详情获取失败');
+                    const task = await client().getTask(matched[0].id, 'smart');
+                    if (!task)
+                        return wrap('任务详情获取失败');
+                    return wrap(`📝 ${task.title}\nID: ${task.id} | 状态: ${task.status}`);
                 }
-                const list = matched.map(t => ({
-                    id: t.id, title: t.title, status: t.status,
-                    creator: t.creator, created_at: t.created_at
-                }));
-                return wrap(`找到 ${matched.length} 个匹配任务:\n${JSON.stringify(list, null, 2)}\n\n请提供更精确的任务名称`);
+                const list = matched.map(t => `• [${t.status}] ${t.title}\n  ID: ${t.id}`).join('\n');
+                return wrap(`找到 ${matched.length} 个匹配任务:\n\n${list}\n\n请使用 taskId 获取详情`);
             }
             case 'update': {
                 if (!decoded.taskId)
                     return wrap('❌ update 需要 taskId');
-                if (!decoded.log_type)
-                    return wrap('❌ update 需要 log_type');
                 if (!decoded.content)
                     return wrap('❌ update 需要 content');
-                const task = await client().addTaskLog(decoded.taskId, decoded.log_type, decoded.content);
+                // log_type 可选 — 不传则后端自动检测关键词
+                const task = await client().addTaskLog(decoded.taskId, decoded.content, decoded.log_type);
                 if (!task)
                     return wrap('更新失败(任务不存在或已归档)');
-                return wrap(`✅ 日志已添加，任务共有 ${task.logs.length} 条日志`);
+                const lastLog = task.logs[task.logs.length - 1];
+                // 返回任务摘要 + 验收清单，让 AI 始终知道剩余目标
+                const goalsDisplay = task.detail.goals.length > 0
+                    ? task.detail.goals.map((g, i) => `  ${i + 1}. ☐ ${g}`).join('\n')
+                    : '  (无验收标准)';
+                return wrap(`✅ 进度已记录 [${lastLog?.log_type || 'progress'}]\n` +
+                    `📋 ${task.title} | 日志: ${task.logs.length}条\n` +
+                    `\n🎯 验收标准:\n${goalsDisplay}\n` +
+                    `\n⚠️ 提示: 每完成一个步骤请立即追加进度,确保时间线完整`);
             }
             case 'archive': {
                 if (!decoded.taskId)
@@ -104,6 +186,12 @@ export function registerTaskTools(server, ctx) {
             }
             default:
                 return wrap(`❌ 未知 action: ${decoded.action}`);
+            case 'delete': {
+                if (!decoded.taskId)
+                    return wrap('❌ delete 需要 taskId');
+                const ok = await client().deleteTask(decoded.taskId);
+                return wrap(ok ? `✅ 任务已删除 (ID: ${decoded.taskId})` : '❌ 删除失败(任务不存在)');
+            }
         }
     }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ppdocs/mcp",
-  "version": "3.2.22",
+  "version": "3.2.23",
   "description": "ppdocs MCP Server - Knowledge Graph for Claude",
   "type": "module",
   "main": "dist/index.js",