@ppdocs/mcp 3.2.19 → 3.2.20

package/dist/storage/httpClient.d.ts

@@ -104,6 +104,33 @@ export declare class PpdocsApiClient {
     analyzerImpactTree(projectPath: string, symbolName: string, depth?: number): Promise<unknown>;
     /** 获取文件 360° 上下文 */
     analyzerContext(projectPath: string, filePath: string): Promise<unknown>;
+    /** 智能上下文: 代码+文档+规则+任务全关联 */
+    analyzerSmartContext(projectPath: string, symbolName: string): Promise<unknown>;
+    /** 全关联路径: 两个符号之间的代码+文档路径 */
+    analyzerFullPath(projectPath: string, symbolA: string, symbolB: string, maxDepth?: number): Promise<unknown>;
+    private publicRequest;
+    /** 列出活跃讨论 (公开路由) */
+    discussionList(): Promise<unknown>;
+    /** 创建讨论 (公开路由) */
+    discussionCreate(title: string, initiator: string, participants: string[], content: string): Promise<{
+        id: string;
+    }>;
+    /** 批量读取讨论 (公开路由) */
+    discussionReadByIds(ids: string[]): Promise<unknown>;
+    /** 回复讨论 (公开路由) */
+    discussionReply(id: string, sender: string, content: string, newSummary?: string): Promise<boolean>;
+    /** 删除讨论 (公开路由) */
+    discussionDelete(id: string): Promise<boolean>;
+    /** 结案归档讨论 (认证路由) */
+    discussionClose(id: string, conclusion: string): Promise<{
+        archived_path: string;
+    }>;
+    meetingJoin(agentId: string, agentType: string): Promise<unknown>;
+    meetingLeave(agentId: string): Promise<unknown>;
+    meetingPost(agentId: string, content: string, msgType?: string): Promise<unknown>;
+    meetingClaim(agentId: string, filePath: string): Promise<unknown>;
+    meetingRelease(agentId: string, filePath: string): Promise<unknown>;
+    meetingStatus(): Promise<unknown>;
 }
 export declare function initClient(apiUrl: string): void;
 export declare function getClient(): PpdocsApiClient;

package/dist/storage/httpClient.js

@@ -509,6 +509,108 @@ export class PpdocsApiClient {
             body: JSON.stringify({ project_path: projectPath, file_path: filePath }),
         });
     }
+    /** 智能上下文: 代码+文档+规则+任务全关联 */
+    async analyzerSmartContext(projectPath, symbolName) {
+        return this.request('/analyzer/smart-context', {
+            method: 'POST',
+            body: JSON.stringify({ project_path: projectPath, symbol_name: symbolName }),
+        });
+    }
+    /** 全关联路径: 两个符号之间的代码+文档路径 */
+    async analyzerFullPath(projectPath, symbolA, symbolB, maxDepth = 3) {
+        return this.request('/analyzer/full-path', {
+            method: 'POST',
+            body: JSON.stringify({ project_path: projectPath, symbol_a: symbolA, symbol_b: symbolB, max_depth: maxDepth }),
+        });
+    }
+    // ============ 公开路由请求工具 (无需项目认证) ============
+    async publicRequest(path, options) {
+        const response = await fetch(`${this.serverUrl}${path}`, {
+            headers: { 'Content-Type': 'application/json' },
+            ...options,
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: response.statusText }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        const json = await response.json();
+        if (!json.success)
+            throw new Error(json.error || 'Unknown error');
+        return json.data;
+    }
+    // ============ 讨论系统 ============
+    /** 列出活跃讨论 (公开路由) */
+    async discussionList() {
+        return this.publicRequest('/api/discussions');
+    }
+    /** 创建讨论 (公开路由) */
+    async discussionCreate(title, initiator, participants, content) {
+        return this.publicRequest('/api/discussions', {
+            method: 'POST',
+            body: JSON.stringify({ title, initiator, participants, content }),
+        });
+    }
+    /** 批量读取讨论 (公开路由) */
+    async discussionReadByIds(ids) {
+        return this.publicRequest('/api/discussions/read', {
+            method: 'POST',
+            body: JSON.stringify({ ids }),
+        });
+    }
+    /** 回复讨论 (公开路由) */
+    async discussionReply(id, sender, content, newSummary) {
+        return this.publicRequest(`/api/discussions/${encodeURIComponent(id)}/reply`, {
+            method: 'POST',
+            body: JSON.stringify({ sender, content, new_summary: newSummary }),
+        });
+    }
+    /** 删除讨论 (公开路由) */
+    async discussionDelete(id) {
+        return this.publicRequest(`/api/discussions/${encodeURIComponent(id)}`, {
+            method: 'DELETE',
+        });
+    }
+    /** 结案归档讨论 (认证路由) */
+    async discussionClose(id, conclusion) {
+        return this.request(`/discussions/${encodeURIComponent(id)}/close`, {
+            method: 'POST',
+            body: JSON.stringify({ conclusion }),
+        });
+    }
+    // ============ 多AI协作会议 ============
+    async meetingJoin(agentId, agentType) {
+        return this.request('/meeting/join', {
+            method: 'POST',
+            body: JSON.stringify({ agent_id: agentId, agent_type: agentType }),
+        });
+    }
+    async meetingLeave(agentId) {
+        return this.request('/meeting/leave', {
+            method: 'POST',
+            body: JSON.stringify({ agent_id: agentId }),
+        });
+    }
+    async meetingPost(agentId, content, msgType = 'status') {
+        return this.request('/meeting/post', {
+            method: 'POST',
+            body: JSON.stringify({ agent_id: agentId, content, msg_type: msgType }),
+        });
+    }
+    async meetingClaim(agentId, filePath) {
+        return this.request('/meeting/claim', {
+            method: 'POST',
+            body: JSON.stringify({ agent_id: agentId, file_path: filePath }),
+        });
+    }
+    async meetingRelease(agentId, filePath) {
+        return this.request('/meeting/release', {
+            method: 'POST',
+            body: JSON.stringify({ agent_id: agentId, file_path: filePath }),
+        });
+    }
+    async meetingStatus() {
+        return this.request('/meeting/status');
+    }
 }
 // ============ 模块级 API ============
 let client = null;

package/dist/tools/analyzer.d.ts

@@ -5,4 +5,5 @@
  * 让 AI Agent 通过 MCP 工具直接查询代码结构、依赖关系和影响范围
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function registerAnalyzerTools(server: McpServer, projectId: string): void;
+import { type McpContext } from './shared.js';
+export declare function registerAnalyzerTools(server: McpServer, ctx: McpContext): void;

package/dist/tools/analyzer.js

@@ -16,7 +16,7 @@ const SYMBOL_ICONS = {
 const SEVERITY_ICONS = {
     critical: '🔴', warning: '🟡', info: '🟢',
 };
-export function registerAnalyzerTools(server, projectId) {
+export function registerAnalyzerTools(server, ctx) {
     const client = () => getClient();
     // ===== code_scan: 扫描项目代码 =====
     server.tool('code_scan', '📡 扫描项目代码, 构建索引。返回文件数、符号数、语言统计。★首次使用 code_query/code_impact/code_context 前必须先执行★', {
@@ -94,19 +94,19 @@ export function registerAnalyzerTools(server, projectId) {
         projectPath: z.string().describe('项目源码的绝对路径'),
         filePath: z.string().describe('目标文件的相对路径(如"src/services/auth.ts")'),
     }, async (args) => safeTool(async () => {
-        const ctx = await client().analyzerContext(args.projectPath, args.filePath);
-        if (!ctx) {
+        const fileCtx = await client().analyzerContext(args.projectPath, args.filePath);
+        if (!fileCtx) {
             return wrap(`未找到文件 "${args.filePath}"。请确认路径正确, 路径格式为相对路径(如 src/main.ts)`);
         }
         const lines = [
-            `📄 ${ctx.filePath}`,
-            `语言: ${ctx.language} | ${ctx.linesTotal} 行`,
+            `📄 ${fileCtx.filePath}`,
+            `语言: ${fileCtx.language} | ${fileCtx.linesTotal} 行`,
             ``,
         ];
         // 定义的符号
-        if (ctx.symbolsDefined.length > 0) {
-            lines.push(`### 🔤 定义的符号 (${ctx.symbolsDefined.length})`);
-            for (const sym of ctx.symbolsDefined) {
+        if (fileCtx.symbolsDefined.length > 0) {
+            lines.push(`### 🔤 定义的符号 (${fileCtx.symbolsDefined.length})`);
+            for (const sym of fileCtx.symbolsDefined) {
                 const icon = SYMBOL_ICONS[sym.kind] || '?';
                 const exp = sym.exported ? ' [export]' : '';
                 lines.push(`  ${icon} ${sym.name}${exp}  L${sym.lineStart}-L${sym.lineEnd}`);
@@ -114,18 +114,18 @@ export function registerAnalyzerTools(server, projectId) {
             lines.push('');
         }
         // 导入
-        if (ctx.imports.length > 0) {
-            lines.push(`### 📥 导入 (${ctx.imports.length})`);
-            for (const imp of ctx.imports) {
+        if (fileCtx.imports.length > 0) {
+            lines.push(`### 📥 导入 (${fileCtx.imports.length})`);
+            for (const imp of fileCtx.imports) {
                 const specs = imp.specifiers.length > 0 ? `{ ${imp.specifiers.join(', ')} }` : '*';
                 lines.push(`  → ${imp.source}  ${specs}  L${imp.line}`);
             }
             lines.push('');
         }
         // 被谁引用
-        if (ctx.importedBy.length > 0) {
-            lines.push(`### 📤 被引用 (${ctx.importedBy.length})`);
-            for (const by of ctx.importedBy) {
+        if (fileCtx.importedBy.length > 0) {
+            lines.push(`### 📤 被引用 (${fileCtx.importedBy.length})`);
+            for (const by of fileCtx.importedBy) {
                 const specs = by.specifiers.length > 0 ? `{ ${by.specifiers.join(', ')} }` : '';
                 lines.push(`  ← ${by.filePath}  ${specs}`);
             }
@@ -260,4 +260,117 @@ export function registerAnalyzerTools(server, projectId) {
         }
         return wrap(lines.join('\n'));
     }));
+    // ===== code_smart_context: 代码+文档全关联上下文 =====
+    server.tool('code_smart_context', '🔍 代码+文档全关联上下文 — 输入一个函数名，一次调用返回：代码依赖、关联文档、匹配规则、活跃任务、影响范围摘要。需先运行 code_scan', {
+        projectPath: z.string().describe('项目源码的绝对路径'),
+        symbolName: z.string().describe('要查询的符号名称(如"handleLogin", "AuthService")'),
+    }, async (args) => safeTool(async () => {
+        const smartCtx = await client().analyzerSmartContext(args.projectPath, args.symbolName);
+        if (!smartCtx) {
+            return wrap(`未找到符号 "${args.symbolName}"。请确认名称正确且已运行 code_scan`);
+        }
+        const lines = [
+            `🔍 智能上下文: ${smartCtx.symbol.name}`,
+            ``,
+        ];
+        // 符号信息
+        const icon = SYMBOL_ICONS[smartCtx.symbol.kind] || '?';
+        const exp = smartCtx.symbol.exported ? ' [export]' : '';
+        lines.push(`### ${icon} 符号信息`);
+        lines.push(`  ${smartCtx.symbol.name}${exp} (${smartCtx.symbol.kind})`);
+        lines.push(`  📍 ${smartCtx.symbol.filePath}:${smartCtx.symbol.lineStart}-${smartCtx.symbol.lineEnd}`);
+        if (smartCtx.symbol.signature)
+            lines.push(`  📝 ${smartCtx.symbol.signature}`);
+        lines.push('');
+        // 文件上下文
+        lines.push(`### 📄 文件上下文: ${smartCtx.fileContext.filePath}`);
+        lines.push(`  语言: ${smartCtx.fileContext.language} | ${smartCtx.fileContext.linesTotal} 行`);
+        lines.push(`  定义: ${smartCtx.fileContext.symbolsDefined.length} 个符号 | 导入: ${smartCtx.fileContext.imports.length} | 被引用: ${smartCtx.fileContext.importedBy.length}`);
+        lines.push('');
+        // 影响范围
+        if (smartCtx.impactSummary.totalFiles > 0) {
+            lines.push(`### 💥 影响范围: ${smartCtx.impactSummary.totalFiles} 个文件`);
+            for (const f of smartCtx.impactSummary.l1Files.slice(0, 10)) {
+                lines.push(`  🔴 ${f}`);
+            }
+            lines.push('');
+        }
+        // 关联文档
+        if (smartCtx.relatedDocs.length > 0) {
+            lines.push(`### 📚 关联知识文档 (${smartCtx.relatedDocs.length})`);
+            for (const doc of smartCtx.relatedDocs) {
+                lines.push(`  📄 ${doc.path} — ${doc.summary}`);
+            }
+            lines.push('');
+        }
+        // 匹配规则
+        if (smartCtx.matchedRules.length > 0) {
+            lines.push(`### 📏 匹配规则 (${smartCtx.matchedRules.length})`);
+            for (const rule of smartCtx.matchedRules) {
+                lines.push(`  [${rule.ruleType}] ${rule.content.substring(0, 100)}`);
+            }
+            lines.push('');
+        }
+        // 活跃任务
+        if (smartCtx.activeTasks.length > 0) {
+            lines.push(`### 📝 活跃任务 (${smartCtx.activeTasks.length})`);
+            for (const task of smartCtx.activeTasks) {
+                lines.push(`  🔵 [${task.id}] ${task.title}`);
+            }
+        }
+        return wrap(lines.join('\n'));
+    }));
+    // ===== code_full_path: 全关联路径 =====
+    server.tool('code_full_path', '🔗 全关联路径 — 两个符号之间不仅返回代码引用链路，还返回共享的KG文档、共同导入、祖先模块。需先运行 code_scan', {
+        projectPath: z.string().describe('项目源码的绝对路径'),
+        symbolA: z.string().describe('起点符号名(如 "handleLogin")'),
+        symbolB: z.string().describe('终点符号名(如 "AuthService")'),
+        maxDepth: z.number().optional().describe('最大搜索深度(1-5, 默认3)'),
+    }, async (args) => safeTool(async () => {
+        const result = await client().analyzerFullPath(args.projectPath, args.symbolA, args.symbolB, args.maxDepth ?? 3);
+        if (!result) {
+            return wrap(`❌ 无法构建路径。请确认两个符号名称正确且已运行 code_scan`);
+        }
+        const lines = [
+            `🔗 全关联路径`,
+            ``,
+            `📍 ${result.symbolA.name} (${result.symbolA.kind}) → ${result.symbolA.filePath}:${result.symbolA.lineStart}`,
+            `📍 ${result.symbolB.name} (${result.symbolB.kind}) → ${result.symbolB.filePath}:${result.symbolB.lineStart}`,
+            ``,
+            `📊 ${result.pathSummary}`,
+            ``,
+        ];
+        // 代码路径
+        if (result.codePath.length > 0) {
+            lines.push(`### 🔗 代码引用链路 (${result.codePath.length} 步)`);
+            for (const step of result.codePath.slice(0, 20)) {
+                lines.push(`  L${step.depth} ${step.filePath} [${step.refKind}] ← ${step.symbolName}`);
+            }
+            lines.push('');
+        }
+        // 共享文档
+        if (result.sharedDocs.length > 0) {
+            lines.push(`### 📚 共享KG文档 (${result.sharedDocs.length})`);
+            for (const doc of result.sharedDocs) {
+                lines.push(`  📄 ${doc.path} — ${doc.summary}`);
+            }
+            lines.push('');
+        }
+        // 共同导入
+        if (result.commonImports.length > 0) {
+            lines.push(`### 📥 共同导入 (${result.commonImports.length})`);
+            for (const imp of result.commonImports) {
+                lines.push(`  → ${imp}`);
+            }
+            lines.push('');
+        }
+        // 共同祖先
+        if (result.commonAncestors.length > 0) {
+            lines.push(`### 📁 共同祖先目录`);
+            for (const anc of result.commonAncestors) {
+                lines.push(`  📂 ${anc}`);
+            }
+        }
+        return wrap(lines.join('\n'));
+    }));
 }

package/dist/tools/discussion.d.ts

@@ -1,7 +1,8 @@
 /**
  * 💬 kg_discuss (6→1)
- * 合并: kg_discussion_list, kg_discussion_read, kg_discussion_create,
- *       kg_discussion_reply, kg_discussion_close_and_archive, kg_discussion_delete
+ * 合并: list, read, create, reply, close, delete
+ * 统一走 HTTP → Rust 后端 (单一写入者)
+ * sender 格式: "projectId:user" (如 "p-ca3sgejg:张三")
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type McpContext } from './shared.js';

package/dist/tools/discussion.js

@@ -1,13 +1,61 @@
 /**
  * 💬 kg_discuss (6→1)
- * 合并: kg_discussion_list, kg_discussion_read, kg_discussion_create,
- *       kg_discussion_reply, kg_discussion_close_and_archive, kg_discussion_delete
+ * 合并: list, read, create, reply, close, delete
+ * 统一走 HTTP → Rust 后端 (单一写入者)
+ * sender 格式: "projectId:user" (如 "p-ca3sgejg:张三")
  */
 import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
 import { decodeObjectStrings } from '../utils.js';
 import { wrap, safeTool } from './shared.js';
-import { DiscussionManager } from '../storage/discussion.js';
+function sender(ctx) {
+    return `${ctx.projectId}:${ctx.user}`;
+}
+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(', ') || '—';
+        lines.push(`| ${d.id} | ${d.title} | ${d.initiator} | ${others} | ${d.summary} | ${d.status} | ${relativeTime(d.updatedAt)} |`);
+    }
+    return lines.join('\n');
+}
+function formatDetail(d) {
+    const msgs = d.messages || [];
+    const lines = [
+        `💬 ${d.title}`,
+        `发起: ${d.initiator} | 参与: ${d.participants.length}方 | 状态: ${d.status}`,
+        `📌 ${d.summary}`,
+        ``,
+    ];
+    msgs.forEach((m, i) => {
+        lines.push(`--- 消息 ${i + 1}/${msgs.length} [${m.sender}] ${relativeTime(m.timestamp)} ---`);
+        lines.push(m.content);
+        lines.push('');
+    });
+    return lines.join('\n');
+}
 export function registerDiscussionTools(server, ctx) {
     const client = () => getClient();
     server.tool('kg_discuss', '💬 跨项目讨论 — 发起、回复、归档协同讨论。action: list(列出活跃讨论)|read(读取详情)|create(发起)|reply(回复)|close(结案归档)|delete(删除)', {
@@ -29,23 +77,22 @@ export function registerDiscussionTools(server, ctx) {
             .describe('更新进展摘要 (reply)'),
     }, async (args) => safeTool(async () => {
         const decoded = decodeObjectStrings(args);
+        const me = sender(ctx);
         switch (decoded.action) {
             case 'list': {
-                const cleaned = DiscussionManager.cleanExpired(7);
-                const active = DiscussionManager.listActive();
-                const cleanMsg = cleaned > 0 ? `\n⚠️ 已自动清理 ${cleaned} 条超过7天不活跃的讨论` : '';
-                if (active.length === 0)
-                    return wrap(`当前无活跃的讨论 (本项目ID: ${ctx.projectId})${cleanMsg}`);
-                return wrap(`本项目ID: ${ctx.projectId}\n活跃讨论区 (${active.length} 个):${cleanMsg}\n\n` + JSON.stringify(active, null, 2));
+                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 discussions = DiscussionManager.readByIds(readIds);
-                if (discussions.length === 0)
+                const discussions = await client().discussionReadByIds(readIds);
+                if (!Array.isArray(discussions) || discussions.length === 0)
                     return wrap('未找到对应的讨论记录');
-                return wrap(JSON.stringify(discussions, null, 2));
+                return wrap(discussions.map(formatDetail).join('\n\n━━━━━━━━━━━━━━━━━━━━\n\n'));
             }
             case 'create': {
                 if (!decoded.title)
@@ -54,55 +101,30 @@ export function registerDiscussionTools(server, ctx) {
                     return wrap('❌ create 需要 participants');
                 if (!decoded.content)
                     return wrap('❌ create 需要 content');
-                const count = DiscussionManager.activeCount();
-                if (count >= 10)
-                    return wrap('❌ 活跃讨论已达上限(10条)');
-                const id = DiscussionManager.create(decoded.title, ctx.projectId, decoded.participants, decoded.content);
-                return wrap(`✅ 讨论已发起，ID: ${id}\n发起方: ${ctx.projectId}\n参与方: ${decoded.participants.join(', ')}`);
+                const result = await client().discussionCreate(decoded.title, me, decoded.participants, decoded.content);
+                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');
-                const success = DiscussionManager.reply(decoded.id, ctx.projectId, decoded.content, decoded.newSummary);
-                return wrap(success ? `✅ 回复成功 (ID: ${decoded.id})` : `❌ 回复失败，讨论不存在或已关闭`);
+                await client().discussionReply(decoded.id, me, decoded.content, decoded.newSummary);
+                return wrap(`✅ 回复成功 (ID: ${decoded.id}, 身份: ${me})`);
             }
             case 'close': {
                 if (!decoded.id)
                     return wrap('❌ close 需要 id');
                 if (!decoded.conclusion)
                     return wrap('❌ close 需要 conclusion');
-                const topic = DiscussionManager.getAndRemove(decoded.id);
-                if (!topic)
-                    return wrap('❌ 讨论不存在或已被归档清理');
-                let md = `# 跨项目协同: ${topic.title}\n\n`;
-                md += `**发起方**: ${topic.initiator}\n`;
-                md += `**参与方**: ${topic.participants.join(', ')}\n`;
-                md += `**结案总结**: ${decoded.conclusion}\n\n`;
-                md += `## 讨论还原 (Timeline)\n\n`;
-                for (const msg of topic.messages) {
-                    md += `### [${msg.sender}] (${msg.timestamp})\n${msg.content}\n\n`;
-                }
-                const safeTitle = topic.title.replace(/[\/\\?%*:|"<>]/g, '_');
-                const path = `/跨项目协同记录/${decoded.id}_${safeTitle}`;
-                try {
-                    await client().createDoc(path, {
-                        summary: decoded.conclusion, content: md,
-                        versions: [{ version: 1.0, date: new Date().toISOString(), changes: '结案归档' }],
-                        bugfixes: [], status: '已完成'
-                    });
-                    return wrap(`✅ 讨论已结案并归档: \`${path}\``);
-                }
-                catch (err) {
-                    return wrap(`⚠️ 讨论已清除，但归档失败: ${err}\n\n${md}`);
-                }
+                const result = await client().discussionClose(decoded.id, decoded.conclusion);
+                return wrap(`✅ 讨论已结案并归档: \`${result.archived_path}\``);
             }
             case 'delete': {
                 if (!decoded.id)
                     return wrap('❌ delete 需要 id');
-                const success = DiscussionManager.delete(decoded.id);
-                return wrap(success ? `✅ 讨论已删除 (ID: ${decoded.id})` : `❌ 讨论不存在或已被删除`);
+                await client().discussionDelete(decoded.id);
+                return wrap(`✅ 讨论已删除 (ID: ${decoded.id})`);
             }
             default:
                 return wrap(`❌ 未知 action: ${decoded.action}`);

package/dist/tools/docs.d.ts

@@ -4,4 +4,5 @@
  *       kg_get_tree, kg_get_docs_by_status
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function registerDocTools(server: McpServer, projectId: string): void;
+import { type McpContext } from './shared.js';
+export declare function registerDocTools(server: McpServer, ctx: McpContext): void;

package/dist/tools/docs.js

@@ -7,7 +7,7 @@ import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
 import { decodeObjectStrings } from '../utils.js';
 import { wrap, safeTool, crossPrefix, formatDocMarkdown, formatTreeText, countTreeDocs } from './shared.js';
-export function registerDocTools(server, projectId) {
+export function registerDocTools(server, ctx) {
     const client = () => getClient();
     // ========== kg_doc: 文档 CRUD 统一入口 ==========
     server.tool('kg_doc', '📄 知识文档操作 — 创建、读取、更新、删除、复制文档。action: create(创建)|read(读取)|update(更新)|delete(删除)|batch_update(批量更新)|copy(跨项目复制)', {

package/dist/tools/index.d.ts

@@ -1,12 +1,13 @@
 /**
  * MCP 工具注册入口
- * 精简后: 14 个工具, 6 个子模块
+ * 18 个工具, 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_query, code_impact, code_context, code_path (5个)
+ * 🔬 代码分析: code_scan, code_query, code_impact, code_context, code_path, code_smart_context, code_full_path (7个)
+ * 🏛️ 协作:    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

@@ -1,12 +1,13 @@
 /**
  * MCP 工具注册入口
- * 精简后: 14 个工具, 6 个子模块
+ * 18 个工具, 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_query, code_impact, code_context, code_path (5个)
+ * 🔬 代码分析: code_scan, code_query, code_impact, code_context, code_path, code_smart_context, code_full_path (7个)
+ * 🏛️ 协作:    kg_meeting                    (1个)
  */
 import { createContext } from './shared.js';
 import { registerInitTool } from './init.js';
@@ -18,6 +19,7 @@ import { registerTaskTools } from './tasks.js';
 import { registerFileTools } from './files.js';
 import { registerDiscussionTools } from './discussion.js';
 import { registerAnalyzerTools } from './analyzer.js';
+import { registerMeetingTools } from './meeting.js';
 export function registerTools(server, projectId, user, onProjectChange) {
     // 创建共享可变上下文 — 所有工具捕获此对象引用
     const ctx = createContext(projectId, user);
@@ -26,13 +28,15 @@ export function registerTools(server, projectId, user, onProjectChange) {
     // 📊 导航 (kg_status + kg_tree在docs中)
     registerStatusTool(server, ctx);
     // 📚 知识 (kg_doc + kg_tree + kg_projects + kg_rules)
-    registerDocTools(server, ctx.projectId);
+    registerDocTools(server, ctx);
     registerProjectTools(server, ctx);
     registerRuleTools(server, ctx);
     // 📝 工作流 (kg_task + kg_files + kg_discuss)
-    registerTaskTools(server, ctx.projectId, ctx.user);
+    registerTaskTools(server, ctx);
     registerFileTools(server);
     registerDiscussionTools(server, ctx);
-    // 🔬 代码分析 (不变)
-    registerAnalyzerTools(server, ctx.projectId);
+    // 🔬 代码分析 (code_scan, code_query, code_impact, code_context, code_path, code_smart_context, code_full_path)
+    registerAnalyzerTools(server, ctx);
+    // 🏛️ 多AI协作 (kg_meeting)
+    registerMeetingTools(server, ctx);
 }

package/dist/tools/meeting.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 多AI协作会议工具
+ * kg_meeting: join | leave | post | claim | release | status
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type McpContext } from './shared.js';
+export declare function registerMeetingTools(server: McpServer, ctx: McpContext): void;

package/dist/tools/meeting.js

@@ -0,0 +1,97 @@
+/**
+ * 多AI协作会议工具
+ * kg_meeting: join | leave | post | claim | release | status
+ */
+import { z } from 'zod';
+import { getClient } from '../storage/httpClient.js';
+import { wrap, safeTool } from './shared.js';
+function formatStatus(status) {
+    const lines = [
+        `🏛️ 会议室: ${status.projectId}`,
+        ``,
+    ];
+    // 参与者
+    if (status.agents.length > 0) {
+        lines.push(`### 👥 参与者 (${status.agents.length})`);
+        for (const agent of status.agents) {
+            const ago = Math.floor((Date.now() / 1000 - agent.lastHeartbeat) / 60);
+            lines.push(`  🤖 ${agent.agentId} (${agent.agentType}) — 心跳 ${ago}分钟前`);
+        }
+        lines.push('');
+    }
+    else {
+        lines.push('📭 会议室为空');
+        lines.push('');
+    }
+    // 文件锁
+    const locks = Object.entries(status.fileLocks);
+    if (locks.length > 0) {
+        lines.push(`### 🔒 文件锁定 (${locks.length})`);
+        for (const [file, owner] of locks) {
+            lines.push(`  📄 ${file} ← ${owner}`);
+        }
+        lines.push('');
+    }
+    // 最近消息
+    if (status.recentMessages.length > 0) {
+        lines.push(`### 💬 最近消息 (${status.recentMessages.length})`);
+        for (const msg of status.recentMessages.slice(-10)) {
+            const time = new Date(msg.timestamp * 1000).toLocaleTimeString();
+            const icon = msg.msgType === 'decision' ? '⚡' : msg.msgType === 'question' ? '❓' : '💬';
+            lines.push(`  ${icon} [${time}] ${msg.agentId}: ${msg.content}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function registerMeetingTools(server, ctx) {
+    const client = () => getClient();
+    server.tool('kg_meeting', '🏛️ 多AI协作会议 — 多个AI编辑器同时操作同一项目时，通过"会议室"共享状态、认领文件、发布决策。action: join(加入)|leave(离开)|post(发消息)|claim(认领文件)|release(释放文件)|status(查看状态)', {
+        action: z.enum(['join', 'leave', 'post', 'claim', 'release', 'status']).describe('操作类型'),
+        agentId: z.string().optional().describe('Agent标识(如"cursor-1", "claude-code-2")。join/leave/post/claim/release 必填'),
+        agentType: z.string().optional().describe('Agent类型(如"cursor", "claude", "kiro")。join 时使用'),
+        content: z.string().optional().describe('消息内容 (post 时必填)'),
+        msgType: z.enum(['status', 'decision', 'question']).optional().describe('消息类型 (post, 默认status)'),
+        filePath: z.string().optional().describe('文件路径 (claim/release 时必填)'),
+    }, async (args) => safeTool(async () => {
+        switch (args.action) {
+            case 'join': {
+                if (!args.agentId)
+                    return wrap('❌ join 需要 agentId');
+                const status = await client().meetingJoin(args.agentId, args.agentType || 'unknown');
+                return wrap(`✅ ${args.agentId} 已加入会议\n\n${formatStatus(status)}`);
+            }
+            case 'leave': {
+                if (!args.agentId)
+                    return wrap('❌ leave 需要 agentId');
+                const status = await client().meetingLeave(args.agentId);
+                return wrap(`✅ ${args.agentId} 已离开会议\n\n${formatStatus(status)}`);
+            }
+            case 'post': {
+                if (!args.agentId || !args.content)
+                    return wrap('❌ post 需要 agentId 和 content');
+                const status = await client().meetingPost(args.agentId, args.content, args.msgType || 'status');
+                return wrap(`✅ 消息已发送\n\n${formatStatus(status)}`);
+            }
+            case 'claim': {
+                if (!args.agentId || !args.filePath)
+                    return wrap('❌ claim 需要 agentId 和 filePath');
+                const status = await client().meetingClaim(args.agentId, args.filePath);
+                return wrap(`✅ ${args.agentId} 已认领 ${args.filePath}\n\n${formatStatus(status)}`);
+            }
+            case 'release': {
+                if (!args.agentId || !args.filePath)
+                    return wrap('❌ release 需要 agentId 和 filePath');
+                const status = await client().meetingRelease(args.agentId, args.filePath);
+                return wrap(`✅ ${args.agentId} 已释放 ${args.filePath}\n\n${formatStatus(status)}`);
+            }
+            case 'status': {
+                const status = await client().meetingStatus();
+                if (!status)
+                    return wrap('📭 该项目暂无活跃会议');
+                return wrap(formatStatus(status));
+            }
+            default:
+                return wrap(`❌ 未知 action: ${args.action}`);
+        }
+    }));
+}

package/dist/tools/tasks.d.ts

@@ -3,4 +3,5 @@
  * 合并: task_create, task_get, task_update, task_archive
  */
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function registerTaskTools(server: McpServer, projectId: string, user: string): void;
+import { type McpContext } from './shared.js';
+export declare function registerTaskTools(server: McpServer, ctx: McpContext): void;

package/dist/tools/tasks.js

@@ -6,7 +6,7 @@ import { z } from 'zod';
 import { getClient } from '../storage/httpClient.js';
 import { decodeObjectStrings } from '../utils.js';
 import { wrap, safeTool } from './shared.js';
-export function registerTaskTools(server, projectId, user) {
+export function registerTaskTools(server, ctx) {
     const client = () => getClient();
     server.tool('kg_task', '📝 任务管理 — 创建、查询、更新进展、归档。action: create(创建)|get(查询)|update(添加日志)|archive(归档)', {
         action: z.enum(['create', 'get', 'update', 'archive'])
@@ -43,7 +43,7 @@ export function registerTaskTools(server, projectId, user) {
                     title: decoded.title,
                     description: decoded.description,
                     goals: decoded.goals || []
-                }, user);
+                }, ctx.user);
                 return wrap(JSON.stringify(task, null, 2));
             }
             case 'get': {

package/package.json

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

package/templates/commands/pp/audit.md

@@ -0,0 +1,87 @@
+# 🛡️ "Sentinel-4" 多智能体审计协议 任务成果审查或代码审查
+
+本工作流启用**4个独立智能体**并行工作，对任务成果进行“死刑级”严格审查。
+
+---
+
+### 1.智能体部署 (Agent Deployment) 🤖
+四个专家智能体同时介入，各司其职：
+
+#### 🕵️ 智能体 A：逻辑审计官 (Logic Auditor)
+*   **职责**：对照预期目标。
+*   **检查点**：
+    *   🔹 流程是否完全闭环？
+    *   🔹 是否存在逻辑断层？
+
+#### 🧹 智能体 B：代码清洁工 (Code Janitor)
+*   **职责**：通过静态分析寻找“垃圾”。
+*   **检查点**：
+    *   × **死代码 (Dead Code)**：检测未被调用的函数/变量。
+    *   × **新旧混合**：确保没有注释掉的旧逻辑残留。
+    *   × **冗余**：消除任何重复逻辑。
+
+#### ⚡ 智能体 C：极简架构师 (Minimalist Architect)
+*   **职责**：强制执行“单行原则”与模块化。
+*   **检查点**：
+    *   🔹 **解耦**：模块之间是否彻底分离？
+    *   🔹 **行数**：两行能写完的，是否用了三行？（臃肿判定）
+
+#### 📚 智能体 D：知识图谱守护者 (Graph Keeper)
+*   **职责**：真理一致性校验。
+*   **检查点**：
+    *   × **偏差**：代码逻辑是否违背了知识图谱中的标准定义？
+
+---
+
+### 2.综合裁决 (Synthesis & Verdict) ⚖️
+*   **汇总**：收集 4 个智能体的 Flag（报错）。
+*   **判定**：
+    *   只要有 **1个** 智能体亮红灯 🔴 -> **驳回重构**。
+    *   全员亮绿灯 🟢 -> **生成最终报告**。
+
+---
+
+### 3.最终交付：审查报告 (Final Report) 📝
+报告将以“简单自然语言 + 可视化图标”输出：
+*   **状态**：✅ 通过 / ❌ 驳回
+*   **评分**：代码纯净度 (0-100%)
+*   **风险点**：(如果有)
+*   **改进建议**：(针对性优化)
+
+---
+
+### 📊 审计流程可视化图解 (ASCII)
+
+```text
+               +----------------------+
+               |  📦 提交任务成果      |
+               +----------+-----------+
+                          |
+                          v
+               +----------+-----------+
+               |   ⚡  并行分发        |
+               +----------+-----------+
+             /      /     |     \      \
+            v      v      v      v      v
+      +--------+ +--------+ +--------+ +--------+
+      | 🕵️ A   | | 🧹 B   | | ⚡ C   | | 📚 D   |
+      | 逻辑   | | 代码   | | 极简   | | 图谱   |
+      +--------+ +--------+ +--------+ +--------+
+           |        |        |        |
+           +--------+--------+--------+
+                    |
+                    v
+           +--------+--------+
+           |  ⚖️ 综合裁决     |
+           +--------+--------+
+                    |
+            /-------+-------\
+           /    发现问题?    \
+          v                   v
+  +-----------+         +------------+
+  | ❌ 驳回    |         | 📝 生成报告 |
+  | (Reject)  |         | (Success)  |
+  +-----------+         +------------+
+       |
+       v
+(To: Iteration Loop)

package/templates/commands/pp/diagnose.md

@@ -0,0 +1,82 @@
+# 🔍 "Deep-Trace" Diagnostic Protocol (深层溯源诊断协议)
+
+核心理念：**先在宏观地图（图谱）上定位，再在微观战场（代码）上排查，绝不盲目翻看代码。**
+
+---
+
+### 1.第一阶段：知识锚定 (Knowledge Anchoring) ⚓️
+🔹 **核心目标**：在动手之前，通过 PPDocs 明确“正确应该是什么样”。
+✏️ **动作**：
+*   **查询图谱**：输入问题关键词，提取标准业务逻辑。
+*   **建立基准**：以图谱中的描述作为“真理标准 (Truth)”。
+× **禁区**：
+*   禁止在未查询图谱前，直接跳入代码库阅读（防止陷入细节泥潭）。
+
+### 2.第二阶段：抽象映射 (Abstract Mapping) 🗺️
+🔹 **核心目标**：利用链式思维 (CoT)，绘制高层级逻辑流。
+✏️ **动作**：
+*   **绘制流程**：忽略实现细节，仅画出模块间的输入/输出流转（数据流）。
+*   **可视化**：生成 ASCII 或 Mermaid 流程图，展示当前链路。
+*   **标记疑点**：在流程图上圈出逻辑可能断裂的节点。
+
+### 3.第三阶段：靶点锁定 (Target Locking) 🎯
+🔹 **核心目标**：将问题范围从“整个项目”缩小到“单一节点”。
+✏️ **动作**：
+*   **定位区域**：确定问题具体发生在 PPDocs 的哪个 `Node`（节点）或 `Edge`（连线）上。
+*   **隔离上下文**：只关注该节点的前置依赖（Pre-requisites）和后置影响（Post-effects）。
+
+### 4.第四阶段：双层取证 (Dual-Layer Forensics) 🕵️
+🔹 **核心目标**：对比“理论（图谱）”与“现实（代码）”的差异。
+✏️ **动作**：
+*   **左眼看图谱**：阅读 PPDocs 中该节点的逻辑定义。
+*   **右眼看代码**：审查该节点对应的实际代码实现。
+*   **寻找裂痕**：
+    *   🔴 **代码错误 (Bug)**：图谱逻辑正确，代码实现错误。
+    *   🟠 **设计缺陷 (Design Flaw)**：代码符合图谱，但结果依然错误（图谱本身逻辑有误）。
+    *   🟡 **文档脱节 (Sync Issue)**：代码逻辑正确且有效，但图谱未记载（需同步）。
+
+### 5.第五阶段：分析结案 (Verdict) 📝
+🔹 **核心目标**：输出可执行的诊断报告。
+✏️ **动作**：
+*   输出标准化的**《问题诊断报告》**。
+*   **流转**：将报告作为输入，传递给 **[任务方案生成工作流]** 进行修复。
+
+---
+
+### 📊 诊断逻辑可视化图解 (ASCII)
+
+```text
+       +-------------------------+
+       |   🚨 问题触发 (Issue)    |
+       +------------+------------+
+                    |
+                    v
+       +------------+------------+
+       |  ⚓️ 知识锚定 (PPDocs)   | <--- 获取标准逻辑 (Truth)
+       +------------+------------+
+                    |
+                    v
+           [ 🗺️ 抽象逻辑层 ]
+       +-------------------------+
+       |   Step1 -> Step2 ...    | (绘制链式流程)
+       |           |             |
+       |         [ ? ] <---------+--- 🎯 锁定可疑节点
+       +-----------+-------------+
+                   |
+                   v
+       +-----------+-------------+
+       |  🕵️ 双层取证 (Compare)   |
+       +-----+-------------+-----+
+             |             |
+       (📜 PPDocs) vs (💻 Code)
+             |             |
+             +------+------+
+                    |
+                    v
+            /-------+-------\
+           /    根本原因?    \
+          v                   v
+  +--------------+     +--------------+
+  | 🐛 代码 Bug   |     | 📐 设计/文档错 |
+  | (Fix Code)   |     | (Fix Graph)  |
+  +--------------+     +--------------+

package/templates/commands/pp/discuss.md

@@ -0,0 +1,90 @@
+# 💬 Discussion Responder (讨论响应协议)
+
+本工作流用于检查、分析、回复跨项目讨论。可手动触发或会话启动时自动检查。
+
+---
+
+## 标准流程
+
+### Step 1: 扫描待处理讨论
+```
+kg_discuss({ action: "list" })
+```
+- 过滤涉及本项目的讨论 (sender 含本项目ID)
+- 无讨论 → 输出 "当前无待处理讨论" → 结束
+
+### Step 2: 展示摘要
+以表格展示所有待处理讨论:
+
+| ID | 标题 | 发起方 | 摘要 | 回复数 | 更新时间 |
+|:---|:---|:---|:---|:---:|:---|
+
+用户选择要处理的讨论 (可多选)
+
+### Step 3: 读取详情 + 知识锚定
+```
+kg_discuss({ action: "read", id: "选中ID" })
+```
+
+**并行执行**:
+1. 阅读讨论全部消息, 理解各方立场
+2. `kg_search` 检索相关知识节点, 获取本项目的标准逻辑
+3. `kg_get_rules(ruleType: "codeStyle")` 获取编码规范 (如涉及代码)
+
+### Step 4: 分析与回复
+**分析框架**:
+| 维度 | 检查 |
+|:---|:---|
+| 技术可行性 | 本项目能否支持对方提出的方案? |
+| 影响范围 | 改动会影响本项目哪些模块? |
+| 替代方案 | 是否有更优解? |
+| 依赖关系 | 需要对方先做什么? 本方需要先做什么? |
+
+**回复**:
+```
+kg_discuss({
+  action: "reply",
+  id: "讨论ID",
+  content: "基于分析的回复内容",
+  newSummary: "更新摘要 (可选, 如有阶段性结论)"
+})
+```
+
+### Step 5: 结案判断
+如果所有方已达成共识:
+```
+kg_discuss({
+  action: "close",
+  id: "讨论ID",
+  conclusion: "结案总结 (含最终方案 + 各方责任)"
+})
+```
+归档文档自动存入知识图谱。
+
+---
+
+## 回复质量标准
+| 要求 | 说明 |
+|:---|:---|
+| **有据可查** | 引用知识图谱节点或代码文件支撑观点 |
+| **明确立场** | 同意/反对/有条件同意, 不含糊 |
+| **可执行** | 回复中包含具体行动项, 非空谈 |
+| **格式规范** | Markdown 格式, 要点用列表, 代码用代码块 |
+
+---
+
+## 发起新讨论
+当本项目需要向其他项目发起协商:
+```
+kg_discuss({
+  action: "create",
+  title: "讨论标题",
+  participants: ["目标项目ID"],
+  content: "问题描述 + 本方立场 + 期望回复"
+})
+```
+
+**发起前检查**:
+1. `kg_search` 确认问题确实需要跨项目协商
+2. 明确参与方 (通过 `kg_projects` 查看可用项目)
+3. 内容包含: 背景、问题、本方方案、期望对方行动

package/templates/commands/pp/execute.md

@@ -0,0 +1,84 @@
+# ⚡️ "Ockham's Blade" Execution Protocol (奥卡姆之刃执行协议)
+
+该工作流旨在执行已确认的方案。核心原则：**拒绝冗余，一行搞定，模块解耦，逻辑确权。**
+
+---
+
+### 1.第一阶段：逻辑确权 (Knowledge Anchor) 🧠
+🔹 **核心目标**：消除所有不确定性，确保逻辑绝对正确。
+✏️ **动作**：
+*   解析任务需求。
+*   遇到模糊逻辑，立即查询**知识图谱 (Knowledge Graph)** 确认标准流程。
+× **禁区**：
+*   禁止基于猜测编写代码。
+*   禁止模糊定义的变量。
+
+### 2.第二阶段：架构定义 (Structure & Taxonomy) 🏗️
+🔹 **核心目标**：目录清晰，分类准确，模块独立。
+✏️ **动作**：
+*   构建标准目录树 (Directory Tree)。
+*   定义原子化模块 (Atomic Modules)。
+*   确保接口通用，支持复用调用。
+× **禁区**：
+*   禁止模块间产生强耦合 (Zero Coupling)。
+*   禁止混乱的文件层级。
+
+### 3.第三阶段：极简实现 (Minimalist Coding) 🚀
+🔹 **核心目标**：不造轮子，极致压缩代码行数。
+✏️ **动作**：
+*   最大化调用现有库与复用功能。
+*   利用链式调用、推导式等语法特性。
+× **禁区**：
+*   **能一行代码解决的问题，严格禁止使用第二行。**
+*   禁止重复造轮子 (DRY Principle)。
+
+### 4.第四阶段：最终交付 (Delivery) 📦
+🔹 **核心目标**：输出可直接运行、可维护的成果。
+✏️ **动作**：
+*   输出标准化的文件结构。
+*   交付模块化源码。
+
+---
+
+### 📊 执行逻辑可视化图解 (ASCII)
+
+```text
+       +-----------------------+
+       |   🚀 任务启动 (Start)  |
+       +-----------+-----------+
+                   |
+                   v
+       +-----------+-----------+
+       |  🧠 逻辑是否清晰?      | <-----+
+       +-----------+-----------+       |
+        (❌ NO)    | (✅ YES)         |
+          |        v                   |
+   +------+-----+  +----------------+  |
+   | 🔍 查图谱   |  | 🏗️ 架构设计     |  |
+   +------------+  +-------+--------+  |
+                           |           |
+                           v           |
+                   +-------+--------+  |
+                   | ♻️ 存在轮子?    |  |
+                   +-------+--------+  |
+                  /                  \ |
+            (YES)/                    \(NO)
+                v                      v
+        +-------+-------+      +-------+-------+
+        | ✏️ 直接调用    |      | ✏️ 原子编写    |
+        +-------+-------+      +-------+-------+
+                |                      |
+                +----------+-----------+
+                           |
+                           v
+                   +-------+-------+
+                   | 📏 极简审查    | <-----+
+                   +-------+-------+       |
+                           |               |
+               /-----------+----------\    |
+              /    是否多于一行?       \   |
+             v                          v  |
+     +-------+-------+          +-------+--+----+
+     | ✅ 达标        |          | × 删减 (Trim) |
+     | (Delivery)    |          |   压缩代码     |
+     +---------------+          +---------------+

package/templates/hooks/SystemPrompt.md

@@ -1,5 +1,8 @@
 你是严谨的软件架构师，围绕**用户知识图谱软件**工作，确保每个变动有据可查，每次成功沉淀为知识节点。
 
+## 会话启动检查
+每次会话开始时, 执行 `kg_discuss({ action: "list" })` 检查是否有涉及本项目的待回复讨论。如有, 主动提醒用户: "发现 N 条待处理讨论, 是否需要查看?"
+
 ## 核心宪法
 | 原则 | 要求 |
 |:---|:---|
@@ -100,3 +103,16 @@ task_create → task_add_log(progress/issue/solution/reference) → task_complet
 |:---|:---|:---|:---|
 | 复用 | 重复造轮子 | 调用utils | 无 |
 | 结构 | 混杂views | 迁移services | 需改引用 |
+
+---
+
+## 工作流速查
+| 命令 | 用途 | 场景 |
+|:---|:---|:---|
+| `/pp:init` | 项目知识图谱初始化 | 新项目接入 |
+| `/pp:sync` | 代码↔知识图谱同步 | 代码变更后 |
+| `/pp:diagnose` | 深度问题诊断 | 排查 Bug |
+| `/pp:execute` | 任务极简执行 | 已确认方案的编码 |
+| `/pp:review` | 代码质量审查 | 轻量级审查 |
+| `/pp:audit` | 多Agent严格审计 | 重要交付前 |
+| `/pp:discuss` | 讨论响应与协作 | 跨项目协商 |

package/dist/storage/discussion.d.ts

@@ -1,33 +0,0 @@
-export interface DiscussionMessage {
-    id: string;
-    sender: string;
-    content: string;
-    timestamp: string;
-}
-export interface DiscussionTopic {
-    id: string;
-    title: string;
-    initiator: string;
-    participants: string[];
-    summary: string;
-    status: 'active' | 'completed';
-    created_at: string;
-    updated_at: string;
-    messages: DiscussionMessage[];
-}
-export declare class DiscussionManager {
-    private static getFilePath;
-    private static readAll;
-    private static writeAll;
-    static listActive(): Omit<DiscussionTopic, 'messages'>[];
-    static readByIds(ids: string[]): DiscussionTopic[];
-    static create(title: string, initiator: string, participants: string[], content: string): string;
-    static reply(id: string, sender: string, content: string, newSummary?: string): boolean;
-    static getAndRemove(id: string): DiscussionTopic | null;
-    /** 按ID删除讨论（不归档，直接删除） */
-    static delete(id: string): boolean;
-    /** 清理过期讨论（默认7天不活跃） */
-    static cleanExpired(days?: number): number;
-    /** 获取活跃讨论数量 */
-    static activeCount(): number;
-}

package/dist/storage/discussion.js

@@ -1,116 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-export class DiscussionManager {
-    static getFilePath() {
-        const dir = path.join(os.homedir(), '.ppdocs');
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        return path.join(dir, 'discussions.json');
-    }
-    static readAll() {
-        try {
-            const file = this.getFilePath();
-            if (!fs.existsSync(file))
-                return [];
-            return JSON.parse(fs.readFileSync(file, 'utf-8'));
-        }
-        catch {
-            return [];
-        }
-    }
-    static writeAll(data) {
-        fs.writeFileSync(this.getFilePath(), JSON.stringify(data, null, 2), 'utf-8');
-    }
-    static listActive() {
-        return this.readAll()
-            .filter(t => t.status === 'active')
-            .map(({ messages, ...rest }) => rest);
-    }
-    static readByIds(ids) {
-        return this.readAll().filter(t => ids.includes(t.id));
-    }
-    static create(title, initiator, participants, content) {
-        const id = `req_${Math.random().toString(36).substring(2, 9)}`;
-        const now = new Date().toISOString();
-        // 确保发起方始终在参与列表中
-        const allParticipants = participants.includes(initiator) ? [...participants] : [initiator, ...participants];
-        const topic = {
-            id,
-            title,
-            initiator,
-            participants: allParticipants,
-            summary: "等待各方回复中...",
-            status: 'active',
-            created_at: now,
-            updated_at: now,
-            messages: [{
-                    id: `msg_${Math.random().toString(36).substring(2, 9)}`,
-                    sender: initiator,
-                    content,
-                    timestamp: now
-                }]
-        };
-        const all = this.readAll();
-        all.push(topic);
-        this.writeAll(all);
-        return id;
-    }
-    static reply(id, sender, content, newSummary) {
-        const all = this.readAll();
-        const topic = all.find(t => t.id === id);
-        if (!topic || topic.status !== 'active')
-            return false;
-        const now = new Date().toISOString();
-        topic.messages.push({
-            id: `msg_${Math.random().toString(36).substring(2, 9)}`,
-            sender,
-            content,
-            timestamp: now
-        });
-        topic.updated_at = now;
-        if (newSummary) {
-            topic.summary = newSummary;
-        }
-        // Auto add to participants if not exists
-        if (!topic.participants.includes(sender)) {
-            topic.participants.push(sender);
-        }
-        this.writeAll(all);
-        return true;
-    }
-    static getAndRemove(id) {
-        const all = this.readAll();
-        const index = all.findIndex(t => t.id === id);
-        if (index === -1)
-            return null;
-        const topic = all.splice(index, 1)[0];
-        this.writeAll(all);
-        return topic;
-    }
-    /** 按ID删除讨论（不归档，直接删除） */
-    static delete(id) {
-        const all = this.readAll();
-        const index = all.findIndex(t => t.id === id);
-        if (index === -1)
-            return false;
-        all.splice(index, 1);
-        this.writeAll(all);
-        return true;
-    }
-    /** 清理过期讨论（默认7天不活跃） */
-    static cleanExpired(days = 7) {
-        const all = this.readAll();
-        const cutoff = Date.now() - days * 86400000;
-        const before = all.length;
-        const filtered = all.filter(t => new Date(t.updated_at).getTime() > cutoff);
-        if (filtered.length < before) {
-            this.writeAll(filtered);
-        }
-        return before - filtered.length;
-    }
-    /** 获取活跃讨论数量 */
-    static activeCount() {
-        return this.readAll().filter(t => t.status === 'active').length;
-    }
-}