@ppdocs/mcp 3.2.18 → 3.2.20

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.18",
+  "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. 内容包含: 背景、问题、本方方案、期望对方行动