@ppdocs/mcp 3.12.0 → 3.13.0

package/dist/tools/tasks.js

@@ -1,6 +1,5 @@
 /**
- * 📝 kg_task (4→1) — 极简任务管理
- * AI 只需说人话写内容，后端负责所有格式化、分类、时间戳
+ * kg_task — 任务管理
  */
 import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
@@ -8,8 +7,7 @@ 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(创建,建议bindTo关联节点)|get(查询)|update(追加进度)|archive(归档)|delete(删除)。⚠️ 每完成一个步骤必须立即update!\n' +
-        '★ 涉及逻辑变更的任务，创建后必须先执行 design-first 工作流（kg_workflow(id:"design-first")），在流程图中完成设计并验证后才能编码。', {
+    server.tool('kg_task', '任务记录 — action: create(创建)|get(查询)|update(追加进度)|archive(归档)|delete(删除)', {
         action: z.enum(['create', 'get', 'update', 'archive', 'delete'])
             .describe('操作类型'),
         title: z.string().optional()
@@ -27,9 +25,9 @@ export function registerTaskTools(server, ctx) {
         summary: z.string().optional()
             .describe('经验总结Markdown (archive)'),
         difficulties: z.array(z.string()).optional()
-            .describe('遇到的困难 (archive)'),
+            .describe('遇到的困难 (archive, 可选)'),
         solutions: z.array(z.string()).optional()
-            .describe('解决方案 (archive)'),
+            .describe('解决方案 (archive, 可选)'),
         status: z.enum(['active', 'archived', 'all']).optional()
             .describe('状态筛选 (get, 默认active)'),
         bindTo: z.string().optional()
@@ -41,12 +39,10 @@ export function registerTaskTools(server, ctx) {
         switch (decoded.action) {
             case 'create': {
                 if (!decoded.title)
-                    return wrap('❌ create 需要 title');
-                if (!decoded.description)
-                    return wrap('❌ create 需要 description');
+                    return wrap('create 需要 title');
                 const task = await client().createTask({
                     title: decoded.title,
-                    description: decoded.description,
+                    description: decoded.description || '',
                     goals: decoded.goals || []
                 }, ctx.user);
                 // 自动绑定到流程图节点
@@ -64,22 +60,18 @@ export function registerTaskTools(server, ctx) {
                                     node.boundTasks.push(task.id);
                                 }
                                 await client().saveFlowchart(chartId, chart);
-                                bindMsg = `\n🔗 已绑定到节点: ${decoded.bindTo} [${chartId}]`;
+                                bindMsg = `\n已绑定到节点: ${decoded.bindTo} [${chartId}]`;
                             }
                             else {
-                                bindMsg = `\n⚠️ 节点 "${decoded.bindTo}" 不存在于流程图 "${chartId}"`;
+                                bindMsg = `\n节点 "${decoded.bindTo}" 不存在于流程图 "${chartId}"`;
                             }
                         }
                     }
                     catch {
-                        bindMsg = `\n⚠️ 绑定失败`;
+                        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}`);
+                return wrap(`任务已创建\nID: ${task.id}\n标题: ${task.title}\n验收标准: ${task.detail.goals.length}条${bindMsg}`);
             }
             case 'get': {
                 // 无参数 = 列出活跃任务
@@ -97,33 +89,33 @@ export function registerTaskTools(server, ctx) {
                         tasks = await client().listTasks(status);
                     }
                     if (tasks.length === 0)
-                        return wrap(`📋 ${status === 'archived' ? '归档' : '活跃'}任务为空`);
+                        return wrap(`${status === 'archived' ? '归档' : '活跃'}任务为空`);
                     const rows = tasks.map(t => {
-                        const icon = t.status === 'active' ? '🟢' : '⚪';
+                        const icon = t.status === 'active' ? '●' : '○';
                         const date = t.updated_at?.split('T')[0]?.slice(5) || '';
                         const log = (t.last_log || '').substring(0, 40);
                         return `| ${icon} | ${t.title} | ${t.id} | ${date} | ${log} |`;
                     }).join('\n');
-                    return wrap(`📋 共 ${tasks.length} 个任务\n\n| 状态 | 标题 | ID | 更新 | 最近日志 |\n|:-----|:-----|:---|:-----|:---------|\n${rows}`);
+                    return wrap(`共 ${tasks.length} 个任务\n\n| 状态 | 标题 | ID | 更新 | 最近日志 |\n|:-----|:-----|:---|:-----|:---------|\n${rows}`);
                 }
                 // 有 taskId = 获取详情 (结构化摘要)
                 if (decoded.taskId) {
                     const task = await client().getTask(decoded.taskId, 'smart');
                     if (!task)
-                        return wrap('❌ 任务未找到');
+                        return wrap('任务未找到');
                     const lines = [
-                        `📝 ${task.title}`,
+                        `${task.title}`,
                         `ID: ${task.id} | 状态: ${task.status}`,
                         `创建: ${task.created_at?.split('T')[0] || ''}`,
                     ];
                     if (task.detail?.description)
-                        lines.push(`\n📋 ${task.detail.description}`);
+                        lines.push(`\n${task.detail.description}`);
                     if (task.detail?.goals?.length) {
-                        lines.push(`\n🎯 验收标准:`);
+                        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条):`);
+                        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)}`);
                         }
@@ -152,18 +144,18 @@ export function registerTaskTools(server, ctx) {
                     if (!task)
                         return wrap('任务详情获取失败');
                     const lines = [
-                        `📝 ${task.title}`,
+                        `${task.title}`,
                         `ID: ${task.id} | 状态: ${task.status}`,
                         `创建: ${task.created_at?.split('T')[0] || ''}`,
                     ];
                     if (task.detail?.description)
-                        lines.push(`\n📋 ${task.detail.description}`);
+                        lines.push(`\n${task.detail.description}`);
                     if (task.detail?.goals?.length) {
-                        lines.push(`\n🎯 验收标准:`);
+                        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条):`);
+                        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)}`);
                         }
@@ -175,45 +167,38 @@ export function registerTaskTools(server, ctx) {
             }
             case 'update': {
                 if (!decoded.taskId)
-                    return wrap('❌ update 需要 taskId');
+                    return wrap('update 需要 taskId');
                 if (!decoded.content)
-                    return wrap('❌ update 需要 content');
+                    return wrap('update 需要 content');
                 // log_type 可选 — 不传则后端自动检测关键词
                 const task = await client().addTaskLog(decoded.taskId, decoded.content, decoded.log_type);
                 if (!task)
                     return wrap('更新失败(任务不存在或已归档)');
                 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}`);
+                return wrap(`进度已记录 [${lastLog?.log_type || 'progress'}]\n` +
+                    `${task.title} | 日志: ${task.logs.length}条`);
             }
             case 'archive': {
                 if (!decoded.taskId)
-                    return wrap('❌ archive 需要 taskId');
-                if (!decoded.summary)
-                    return wrap('❌ archive 需要 summary');
+                    return wrap('archive 需要 taskId');
                 const task = await client().completeTask(decoded.taskId, {
-                    summary: decoded.summary,
+                    summary: decoded.summary || '任务已完成',
                     difficulties: decoded.difficulties || [],
                     solutions: decoded.solutions || [],
                     references: []
                 });
                 if (!task)
                     return wrap('归档失败(任务不存在或已归档)');
-                return wrap(`✅ 任务已归档: ${task.title}`);
+                return wrap(`任务已归档: ${task.title}`);
             }
             case 'delete': {
                 if (!decoded.taskId)
-                    return wrap('❌ delete 需要 taskId');
+                    return wrap('delete 需要 taskId');
                 const ok = await client().deleteTask(decoded.taskId);
-                return wrap(ok ? `✅ 任务已删除 (ID: ${decoded.taskId})` : '❌ 删除失败(任务不存在)');
+                return wrap(ok ? `任务已删除 (ID: ${decoded.taskId})` : '删除失败(任务不存在)');
             }
             default:
-                return wrap(`❌ 未知 action: ${decoded.action}`);
+                return wrap(`未知 action: ${decoded.action}`);
         }
     }));
 }

package/dist/tools/workflow.js

@@ -4,9 +4,8 @@ import { decodeObjectStrings } from '../utils.js';
 import { safeTool, wrap } from './shared.js';
 export function registerWorkflowTools(server, _ctx) {
     const client = () => getClient();
-    server.tool('kg_workflow', '📘 文档工作流 — AI 的标准操作手册。每个工作流是一份 Markdown 文档，定义了特定场景下 AI 应该遵循的步骤和规范。\n' +
-        '调用方式：空参数=列出所有工作流；传 id=获取工作流正文；save/delete 需显式 action。\n' +
-        '典型用法：拿到任务后先 kg_workflow() 看有无相关工作流，有则 kg_workflow(id:"xxx") 读取并遵循执行。', {
+    server.tool('kg_workflow', '文档工作流。AI 的标准操作手册，每个工作流定义特定场景下应遵循的步骤。空参数=列出全部；传id=获取正文；save/delete需显式action。' +
+        'actions: list|get|save|delete', {
         action: z.enum(['list', 'get', 'save', 'delete']).optional().describe('省略时自动推断：无参数=list，有id=get'),
         id: z.string().optional().describe('工作流 ID'),
         scope: z.enum(['all', 'global', 'project']).optional().describe('范围：all(默认)|global|project'),

package/package.json

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

package/dist/tools/discussion.d.ts

@@ -1,15 +0,0 @@
-/**
- * 💬 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';
-export declare function registerDiscussionTools(server: McpServer, ctx: McpContext): void;

package/dist/tools/discussion.js

@@ -1,264 +0,0 @@
-/**
- * 💬 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';
-import { decodeObjectStrings } from '../utils.js';
-import { wrap, safeTool } from './shared.js';
-function sender(ctx) {
-    return `${ctx.projectId}:${ctx.user}:${ctx.agentId}`;
-}
-/** 提取 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();
-        if (diff < 60000)
-            return '刚刚';
-        if (diff < 3600000)
-            return `${Math.floor(diff / 60000)}分钟前`;
-        if (diff < 86400000)
-            return `${Math.floor(diff / 3600000)}小时前`;
-        return `${Math.floor(diff / 86400000)}天前`;
-    }
-    catch {
-        return iso;
-    }
-}
-function formatList(items, ctx) {
-    const lines = [
-        `本项目: ${sender(ctx)}`,
-        ``,
-        `📋 活跃讨论 (${items.length}个)`,
-        ``,
-        `| ID | 标题 | 发起方 | 参与方 | 摘要 | 回复 | 更新 |`,
-        `|:---|:---|:---|:---|:---|:---:|:---|`,
-    ];
-    for (const d of items) {
-        const others = d.participants.filter(p => p !== d.initiator).join(', ') || '—';
-        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) {
-    const msgs = d.messages || [];
-    const lines = [
-        `💬 ${d.title}`,
-        `发起: ${d.initiator} | 参与: ${d.participants.length}方 | 状态: ${d.status}`,
-        `📌 ${d.summary}`,
-        `📊 总消息: ${d.totalCount} | 未读: ${d.unreadCount}`,
-        ``,
-    ];
-    msgs.forEach((m, i) => {
-        const readTag = m.isRead ? '📖' : '🆕';
-        lines.push(`--- ${readTag} 消息 ${i + 1}/${msgs.length} [${m.sender}] ${relativeTime(m.timestamp)} ---`);
-        // 已读且无 content → 显示摘要
-        if (m.isRead && !m.content) {
-            lines.push(`[摘要] ${m.summary}`);
-        }
-        else {
-            lines.push(m.content || m.summary || '(无内容)');
-        }
-        lines.push('');
-    });
-    return lines.join('\n');
-}
-export function registerDiscussionTools(server, ctx) {
-    const client = () => getClient();
-    server.tool('kg_discuss', '💬 跨项目讨论 — action 可选: 省略时无 id/ids 则列出讨论，有 id/ids 则读取详情。亦可显式指定 list|read|create|reply|complete|close|delete|history。权限: 仅成员可读写，仅发起人可删除/归档', {
-        action: z.enum(['list', 'read', 'create', 'reply', 'complete', 'close', 'delete', 'history']).optional()
-            .describe('操作类型（可选：省略时根据 id/ids 自动为 read，否则为 list）'),
-        id: z.string().optional()
-            .describe('讨论哈希ID (read/reply/complete/close/delete)'),
-        ids: z.array(z.string()).optional()
-            .describe('批量读取的讨论ID数组 (read)'),
-        title: z.string().optional()
-            .describe('讨论标题 (create)'),
-        participants: z.array(z.string()).optional()
-            .describe('参与项目ID数组 (create, 不含自己)'),
-        summary: z.string().optional()
-            .describe('消息摘要 (create/reply, 不传则自动截取content前50字)'),
-        content: z.string().optional()
-            .describe('消息详细内容Markdown (create/reply)'),
-        conclusion: z.string().optional()
-            .describe('结案总结 (close)'),
-        newSummary: z.string().optional()
-            .describe('更新讨论进展摘要 (reply)'),
-        mode: z.enum(['auto', 'full']).optional()
-            .describe('读取模式 (read, 默认auto: 已读消息仅返回摘要)'),
-    }, async (args) => safeTool(async () => {
-        const decoded = decodeObjectStrings(args);
-        const me = sender(ctx);
-        const myPid = ctx.projectId;
-        // 智能默认：未指定 action 时，有 id/ids → read，否则 → list
-        let action = decoded.action;
-        if (!action) {
-            const hasIds = Boolean(decoded.id) || (Array.isArray(decoded.ids) && decoded.ids.length > 0);
-            action = hasIds ? 'read' : 'list';
-        }
-        switch (action) {
-            // ============ 公开操作 ============
-            case 'list': {
-                const all = await client().discussionList();
-                if (!Array.isArray(all))
-                    return wrap(`当前无活跃的讨论 (本项目: ${me})`);
-                const active = all.filter(d => isMember(d, myPid));
-                if (active.length === 0)
-                    return wrap(`当前无参与的活跃讨论 (本项目: ${myPid})`);
-                return wrap(formatList(active, ctx));
-            }
-            case 'history': {
-                const all = await client().discussionListAll(me);
-                if (!Array.isArray(all) || all.length === 0)
-                    return wrap(`暂无参与过的讨论记录 (身份: ${me})`);
-                const lines = [
-                    `本项目: ${me}`,
-                    ``,
-                    `📋 讨论历史 (${all.length}个)`,
-                    ``,
-                    `| ID | 标题 | 发起方 | 状态 | 消息数 | 更新 |`,
-                    `|:---|:---|:---|:---|:---:|:---|`,
-                ];
-                for (const d of all) {
-                    const statusIcon = d.status === 'active' ? '🟢' : '⚪';
-                    lines.push(`| ${d.id} | ${d.title} | ${d.initiator} | ${statusIcon} ${d.status} | ${d.messageCount ?? 0} | ${relativeTime(d.updatedAt)} |`);
-                }
-                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})`);
-            }
-            case 'close': {
-                if (!decoded.id)
-                    return wrap('❌ close 需要 id');
-                if (!decoded.conclusion)
-                    return wrap('❌ close 需要 conclusion');
-                // 权限检查: 仅发起人可归档
-                const brief = await getBrief(decoded.id);
-                if (brief && !isInitiator(brief, me, myPid)) {
-                    return wrap(`🔒 无权限: 仅发起人 (${brief.initiator}) 可归档讨论\n你的身份: ${me}`);
-                }
-                const result = await client().discussionClose(decoded.id, decoded.conclusion);
-                const archivePath = result?.archived_path ? `\n📦 已归档: ${result.archived_path}` : '';
-                return wrap(`✅ 讨论已结案并归档 (ID: ${decoded.id})\n📋 ${decoded.conclusion}${archivePath}`);
-            }
-            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})`);
-            }
-            default:
-                return wrap(`❌ 未知 action: ${action}`);
-        }
-    }));
-}

package/dist/tools/doc_query.d.ts

@@ -1,10 +0,0 @@
-/**
- * kg_doc — 文档查询视图
- * 纯查询工具，数据来源为流程图节点的 docEntries + description
- * 不创建独立文档，只是提供面向文档的查询入口
- *
- * read 默认返回当前文档，history=true 返回历史列表，index=N 返回指定历史条目
- */
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type McpContext } from './shared.js';
-export declare function registerDocQueryTools(server: McpServer, _ctx: McpContext): void;