@ppdocs/mcp 2.6.31 → 2.7.2

package/dist/storage/httpClient.d.ts

@@ -4,7 +4,7 @@
  *
  * API URL 格式: http://localhost:20001/api/:projectId/:password/...
  */
-import type { NodeData, SearchResult, PathResult, BugfixRecord, Task, TaskSummary, TaskLogType, TaskExperience } from './types.js';
+import type { NodeData, Task, TaskSummary, TaskLogType, TaskExperience } from './types.js';
 export interface ListNodesFilter {
     status?: 'incomplete' | 'complete' | 'fixing' | 'refactoring' | 'deprecated';
     minEdges?: number;
@@ -27,33 +27,17 @@ export declare class PpdocsApiClient {
         codeStyle?: string[];
     }): Promise<NodeData | null>;
     deleteNode(nodeId: string): Promise<boolean>;
-    lockNode(nodeId: string, locked: boolean): Promise<NodeData | null>;
-    searchNodes(keywords: string[], limit?: number): Promise<SearchResult[]>;
-    findPath(startId: string, endId: string): Promise<PathResult | null>;
-    getRelations(nodeId: string): Promise<Array<{
-        nodeId: string;
-        title: string;
-        description: string;
-        edgeType: string;
-        direction: 'outgoing' | 'incoming';
-    }>>;
-    addBugfix(nodeId: string, bugfix: {
-        issue: string;
-        solution: string;
-        impact?: string;
-    }): Promise<BugfixRecord | null>;
+    getRulesApi(ruleType: string): Promise<string[]>;
+    saveRulesApi(ruleType: string, rules: string[]): Promise<boolean>;
     listTasks(status?: 'active' | 'archived'): Promise<TaskSummary[]>;
     getTask(taskId: string): Promise<Task | null>;
     createTask(task: {
         title: string;
         description: string;
         goals: string[];
-        related_nodes?: string[];
     }, creator: string): Promise<Task>;
     addTaskLog(taskId: string, logType: TaskLogType, content: string): Promise<Task | null>;
     completeTask(taskId: string, experience: TaskExperience): Promise<Task | null>;
-    getRulesApi(ruleType: string): Promise<string[]>;
-    saveRulesApi(ruleType: string, rules: string[]): Promise<boolean>;
 }
 export declare function initClient(apiUrl: string): void;
 export declare function listNodes(_projectId: string, filter?: ListNodesFilter): Promise<NodeData[]>;
@@ -69,30 +53,14 @@ export declare function updateRoot(_projectId: string, updates: {
     codeStyle?: string[];
 }): Promise<NodeData | null>;
 export declare function deleteNode(_projectId: string, nodeId: string): Promise<boolean>;
-export declare function lockNode(_projectId: string, nodeId: string, locked: boolean): Promise<NodeData | null>;
-export declare function searchNodes(_projectId: string, keywords: string[], limit?: number): Promise<SearchResult[]>;
-export declare function findPath(_projectId: string, startId: string, endId: string): Promise<PathResult | null>;
-export declare function getRelations(_projectId: string, nodeId: string): Promise<Array<{
-    nodeId: string;
-    title: string;
-    description: string;
-    edgeType: string;
-    direction: 'outgoing' | 'incoming';
-}>>;
-export declare function addBugfix(_projectId: string, nodeId: string, bugfix: {
-    issue: string;
-    solution: string;
-    impact?: string;
-}): Promise<BugfixRecord | null>;
+export declare function getRules(_projectId: string, ruleType: string): Promise<string[]>;
+export declare function saveRules(_projectId: string, ruleType: string, rules: string[]): Promise<boolean>;
 export declare function listTasks(_projectId: string, status?: 'active' | 'archived'): Promise<TaskSummary[]>;
 export declare function getTask(_projectId: string, taskId: string): Promise<Task | null>;
 export declare function createTask(_projectId: string, task: {
     title: string;
     description: string;
     goals: string[];
-    related_nodes?: string[];
 }, creator: string): Promise<Task>;
 export declare function addTaskLog(_projectId: string, taskId: string, logType: TaskLogType, content: string): Promise<Task | null>;
 export declare function completeTask(_projectId: string, taskId: string, experience: TaskExperience): Promise<Task | null>;
-export declare function getRules(_projectId: string, ruleType: string): Promise<string[]>;
-export declare function saveRules(_projectId: string, ruleType: string, rules: string[]): Promise<boolean>;

package/dist/storage/httpClient.js

@@ -231,64 +231,27 @@ export class PpdocsApiClient {
             return false;
         }
     }
-    async lockNode(nodeId, locked) {
+    // ============ 规则 API (独立文件存储) ============
+    async getRulesApi(ruleType) {
         try {
-            return await this.request(`/nodes/${nodeId}/lock`, {
-                method: 'PUT',
-                body: JSON.stringify({ locked })
-            });
+            return await this.request(`/rules/${ruleType}`);
         }
         catch {
-            return null;
+            return [];
         }
     }
-    // ============ 搜索与路径 ============
-    async searchNodes(keywords, limit = 20) {
-        return this.request('/search', {
-            method: 'POST',
-            body: JSON.stringify({ keywords, limit })
-        });
-    }
-    async findPath(startId, endId) {
+    async saveRulesApi(ruleType, rules) {
         try {
-            return await this.request('/path', {
-                method: 'POST',
-                body: JSON.stringify({ start_id: startId, end_id: endId })
+            await this.request(`/rules/${ruleType}`, {
+                method: 'PUT',
+                body: JSON.stringify(rules)
             });
+            return true;
         }
         catch {
-            return null;
+            return false;
         }
     }
-    async getRelations(nodeId) {
-        const result = await this.request(`/relations/${nodeId}`);
-        // 转换字段名 (API 返回 type，前端期望 edgeType)
-        return result.map(r => ({
-            nodeId: r.nodeId,
-            title: r.title,
-            description: r.description,
-            edgeType: r.type,
-            direction: r.direction
-        }));
-    }
-    // ============ Bugfix ============
-    async addBugfix(nodeId, bugfix) {
-        // 添加 bugfix 需要先获取节点，追加 bugfix，然后更新
-        const node = await this.getNode(nodeId);
-        if (!node || node.locked)
-            return null;
-        const newBugfix = {
-            id: `bug-${Date.now()}`,
-            date: new Date().toISOString(),
-            issue: bugfix.issue,
-            solution: bugfix.solution,
-            impact: bugfix.impact
-        };
-        const updated = await this.updateNode(nodeId, {
-            bugfixes: [newBugfix, ...(node.bugfixes || [])].slice(0, 20)
-        });
-        return updated ? newBugfix : null;
-    }
     // ============ 任务管理 ============
     async listTasks(status) {
         const query = status ? `?status=${status}` : '';
@@ -309,7 +272,7 @@ export class PpdocsApiClient {
             detail: {
                 description: task.description,
                 goals: task.goals,
-                related_nodes: task.related_nodes || []
+                related_nodes: []
             }
         };
         return this.request('/tasks', {
@@ -339,27 +302,6 @@ export class PpdocsApiClient {
             return null;
         }
     }
-    // ============ 规则 API (独立文件存储) ============
-    async getRulesApi(ruleType) {
-        try {
-            return await this.request(`/rules/${ruleType}`);
-        }
-        catch {
-            return [];
-        }
-    }
-    async saveRulesApi(ruleType, rules) {
-        try {
-            await this.request(`/rules/${ruleType}`, {
-                method: 'PUT',
-                body: JSON.stringify(rules)
-            });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
 }
 // ============ 模块级 API (兼容现有 tools/index.ts) ============
 let client = null;
@@ -391,20 +333,12 @@ export async function updateRoot(_projectId, updates) {
 export async function deleteNode(_projectId, nodeId) {
     return getClient().deleteNode(nodeId);
 }
-export async function lockNode(_projectId, nodeId, locked) {
-    return getClient().lockNode(nodeId, locked);
-}
-export async function searchNodes(_projectId, keywords, limit) {
-    return getClient().searchNodes(keywords, limit);
-}
-export async function findPath(_projectId, startId, endId) {
-    return getClient().findPath(startId, endId);
-}
-export async function getRelations(_projectId, nodeId) {
-    return getClient().getRelations(nodeId);
+// ============ 规则管理 (独立文件存储) ============
+export async function getRules(_projectId, ruleType) {
+    return getClient().getRulesApi(ruleType);
 }
-export async function addBugfix(_projectId, nodeId, bugfix) {
-    return getClient().addBugfix(nodeId, bugfix);
+export async function saveRules(_projectId, ruleType, rules) {
+    return getClient().saveRulesApi(ruleType, rules);
 }
 // ============ 任务管理 ============
 export async function listTasks(_projectId, status) {
@@ -422,10 +356,3 @@ export async function addTaskLog(_projectId, taskId, logType, content) {
 export async function completeTask(_projectId, taskId, experience) {
     return getClient().completeTask(taskId, experience);
 }
-// ============ 规则管理 (独立文件存储) ============
-export async function getRules(_projectId, ruleType) {
-    return getClient().getRulesApi(ruleType);
-}
-export async function saveRules(_projectId, ruleType, rules) {
-    return getClient().saveRulesApi(ruleType, rules);
-}

package/dist/storage/types.d.ts

@@ -75,25 +75,20 @@ export interface SearchResult {
     score: number;
     matches: string[];
 }
-export interface PathResult {
-    path: NodeData[];
-    edges: Edge[];
-}
 export type TaskLogType = 'progress' | 'issue' | 'solution' | 'reference';
 export interface TaskLog {
     time: string;
     log_type: TaskLogType;
     content: string;
 }
-export interface TaskReference {
-    title: string;
-    url?: string;
-}
 export interface TaskExperience {
     summary: string;
     difficulties: string[];
     solutions: string[];
-    references: TaskReference[];
+    references: Array<{
+        title: string;
+        url?: string;
+    }>;
 }
 export interface TaskDetail {
     description: string;

package/dist/tools/helpers.d.ts

@@ -12,53 +12,10 @@ export declare function wrap(text: string): {
         text: string;
     }[];
 };
-interface RelationItem {
-    id: string;
-    title: string;
-    edge: string;
-}
-/**
- * 递归获取节点的上下游关系
- */
-export declare function fetchRelations(projectId: string, nodeId: string, maxDepth: number): Promise<{
-    outgoing: RelationItem[];
-    incoming: RelationItem[];
-}>;
-interface SearchResultItem {
-    id: string;
-    title: string;
-    tags: string[];
-    status: string;
-    summary: string;
-    score: string;
-    matchType: 'hybrid' | 'semantic' | 'keyword';
-}
-/**
- * 融合关键词和语义搜索结果
- */
-export declare function mergeSearchResults(keywordResults: Array<{
-    id: string;
-    title: string;
-    tags: string[];
-    status: string;
-    summary: string;
-    score: number;
-}>, semanticResults: Array<{
-    id: string;
-    title: string;
-    tags: string[];
-    status: string;
-    summary: string;
-    similarity: number;
-}>, mode: 'hybrid' | 'keyword' | 'semantic', limit: number): SearchResultItem[];
 /**
  * 格式化节点为 Markdown 输出
  */
 export declare function formatNodeMarkdown(node: NodeData): string[];
-/**
- * 格式化关系输出
- */
-export declare function formatRelationsMarkdown(outgoing: RelationItem[], incoming: RelationItem[]): string[];
 interface TreeNode {
     name: string;
     type: 'folder' | 'node';

package/dist/tools/helpers.js

@@ -2,7 +2,6 @@
  * MCP 工具辅助函数
  * 提取自 index.ts，避免重复代码
  */
-import * as storage from '../storage/httpClient.js';
 // ==================== 通用包装 ====================
 /**
  * 包装返回结果为 MCP 格式
@@ -10,92 +9,6 @@ import * as storage from '../storage/httpClient.js';
 export function wrap(text) {
     return { content: [{ type: 'text', text }] };
 }
-/**
- * 递归获取节点的上下游关系
- */
-export async function fetchRelations(projectId, nodeId, maxDepth) {
-    const visited = new Set();
-    const outgoing = [];
-    const incoming = [];
-    async function recurse(currentNodeId, currentDepth, direction) {
-        if (currentDepth > maxDepth || visited.has(`${currentNodeId}-${direction}`))
-            return;
-        visited.add(`${currentNodeId}-${direction}`);
-        const relations = await storage.getRelations(projectId, currentNodeId);
-        for (const r of relations) {
-            if (r.direction === 'outgoing' && (direction === 'outgoing' || direction === 'both')) {
-                if (!outgoing.some(o => o.id === r.nodeId)) {
-                    outgoing.push({ id: r.nodeId, title: r.title, edge: r.edgeType });
-                    await recurse(r.nodeId, currentDepth + 1, 'outgoing');
-                }
-            }
-            if (r.direction === 'incoming' && (direction === 'incoming' || direction === 'both')) {
-                if (!incoming.some(i => i.id === r.nodeId)) {
-                    incoming.push({ id: r.nodeId, title: r.title, edge: r.edgeType });
-                    await recurse(r.nodeId, currentDepth + 1, 'incoming');
-                }
-            }
-        }
-    }
-    await recurse(nodeId, 1, 'both');
-    return { outgoing, incoming };
-}
-/**
- * 融合关键词和语义搜索结果
- */
-export function mergeSearchResults(keywordResults, semanticResults, mode, limit) {
-    const scoreMap = new Map();
-    // 合并关键词结果
-    for (const r of keywordResults) {
-        scoreMap.set(r.id, {
-            id: r.id,
-            title: r.title,
-            tags: r.tags,
-            status: r.status,
-            summary: r.summary,
-            keywordScore: r.score,
-            semanticScore: 0
-        });
-    }
-    // 合并语义结果
-    for (const r of semanticResults) {
-        const existing = scoreMap.get(r.id);
-        if (existing) {
-            existing.semanticScore = r.similarity;
-        }
-        else {
-            scoreMap.set(r.id, {
-                id: r.id,
-                title: r.title,
-                tags: r.tags,
-                status: r.status,
-                summary: r.summary,
-                keywordScore: 0,
-                semanticScore: r.similarity
-            });
-        }
-    }
-    // 计算综合得分并排序
-    const combined = Array.from(scoreMap.values()).map(item => {
-        // 混合权重: 语义 0.6 + 关键词 0.4
-        const finalScore = mode === 'keyword' ? item.keywordScore
-            : mode === 'semantic' ? item.semanticScore
-                : item.semanticScore * 0.6 + item.keywordScore * 0.4;
-        return { ...item, finalScore };
-    });
-    combined.sort((a, b) => b.finalScore - a.finalScore);
-    const topResults = combined.slice(0, limit);
-    return topResults.map(r => ({
-        id: r.id,
-        title: r.title,
-        tags: r.tags,
-        status: r.status,
-        summary: r.summary,
-        score: `${Math.round(r.finalScore * 100)}%`,
-        matchType: (r.keywordScore > 0 && r.semanticScore > 0 ? 'hybrid'
-            : r.semanticScore > 0 ? 'semantic' : 'keyword')
-    }));
-}
 // ==================== 节点格式化 ====================
 /**
  * 格式化节点为 Markdown 输出
@@ -154,23 +67,6 @@ export function formatNodeMarkdown(node) {
     }
     return lines;
 }
-/**
- * 格式化关系输出
- */
-export function formatRelationsMarkdown(outgoing, incoming) {
-    const lines = [];
-    if (outgoing.length > 0 || incoming.length > 0) {
-        lines.push('**上下游关系**');
-        if (outgoing.length > 0) {
-            lines.push(`- 依赖 (${outgoing.length}): ${outgoing.map(o => o.title).join(', ')}`);
-        }
-        if (incoming.length > 0) {
-            lines.push(`- 被依赖 (${incoming.length}): ${incoming.map(i => i.title).join(', ')}`);
-        }
-        lines.push('');
-    }
-    return lines;
-}
 /**
  * 构建目录树结构
  */

package/dist/tools/index.js

@@ -1,9 +1,8 @@
 import { z } from 'zod';
 import * as storage from '../storage/httpClient.js';
-import { decodeUnicodeEscapes, decodeObjectStrings, getRules, RULE_TYPE_LABELS } from '../utils.js';
-import * as vector from '../vector/index.js';
-// vectorManager 已弃用，向量索引由 Tauri 后端自动维护
-import { wrap, fetchRelations, mergeSearchResults, formatNodeMarkdown, formatRelationsMarkdown, buildDirectoryTree, formatTreeText, countTreeNodes } from './helpers.js';
+import { decodeObjectStrings, getRules, RULE_TYPE_LABELS } from '../utils.js';
+// 向量搜索已迁移至 Tauri 后端，通过 HTTP API 调用
+import { wrap, formatNodeMarkdown, buildDirectoryTree, formatTreeText, countTreeNodes } from './helpers.js';
 export function registerTools(server, projectId, _user) {
     // 1. 创建节点
     server.tool('kg_create_node', '创建知识节点。type: logic=逻辑/函数, data=数据结构, intro=概念介绍。⚠️ tags至少提供3个分类标签', {
@@ -139,129 +138,9 @@ export function registerTools(server, projectId, _user) {
         }
         return wrap(`✅ ${RULE_TYPE_LABELS[decoded.ruleType]}已保存 (${decoded.rules.length} 条)`);
     });
-    // 4. 锁定节点 (只能锁定，解锁需用户在前端手动操作)
-    server.tool('kg_lock_node', '锁定节点(锁定后只能读取，解锁需用户在前端手动操作)', {
+    // 5. 读取单个节点详情
+    server.tool('kg_read_node', '读取单个节点的完整内容(描述、关联文件、依赖、历史记录)', {
         nodeId: z.string().describe('节点ID')
-    }, async (args) => {
-        const node = await storage.lockNode(projectId, args.nodeId, true); // 强制锁定
-        return wrap(node ? JSON.stringify(node, null, 2) : '操作失败');
-    });
-    // 5. 搜索节点 (混合检索: 向量语义 + 关键词)
-    server.tool('kg_search', '智能搜索节点(语义+关键词混合)。支持中英文语义匹配，空白关键词[""]返回全部节点', {
-        keywords: z.array(z.string()).describe('搜索词列表(⚠️建议3个以上关键词提高准确率)，支持语义匹配(如"登录"可找到auth)'),
-        limit: z.number().optional().describe('返回数量(默认10)'),
-        mode: z.enum(['hybrid', 'keyword', 'semantic']).optional().describe('搜索模式: hybrid=混合(默认), keyword=仅关键词, semantic=仅语义')
-    }, async (args) => {
-        const limit = args.limit || 10;
-        const mode = (args.mode || 'hybrid');
-        const query = args.keywords.filter(k => k.trim()).join(' ');
-        // 空白关键词返回全部
-        if (!query) {
-            const results = await storage.searchNodes(projectId, args.keywords, limit);
-            const output = results.map(r => ({
-                id: r.node.id,
-                title: r.node.title,
-                tags: r.node.categories || [],
-                status: r.node.status,
-                summary: r.node.summary || '',
-                hitRate: `${Math.round(r.score)}%`
-            }));
-            return wrap(`${JSON.stringify(output, null, 2)}\n\n💡 需要详细内容请使用 kg_read_node(nodeId) 获取节点详情`);
-        }
-        // 获取关键词结果
-        let keywordResults = [];
-        if (mode === 'hybrid' || mode === 'keyword') {
-            const kResults = await storage.searchNodes(projectId, args.keywords, limit * 2);
-            keywordResults = kResults.map(r => ({
-                id: r.node.id,
-                title: r.node.title,
-                tags: r.node.categories || [],
-                status: r.node.status,
-                summary: r.node.summary || '',
-                score: r.score / 100
-            }));
-        }
-        // 获取语义结果 (需补全节点信息)
-        let semanticResults = [];
-        if (mode === 'hybrid' || mode === 'semantic') {
-            try {
-                // 向量索引由 Tauri 后端自动维护，MCP 直接读取
-                const rawSemantic = await vector.semanticSearch(projectId, query, limit * 2);
-                // 补全节点信息 (关键词结果中已有的复用，没有的获取)
-                const keywordMap = new Map(keywordResults.map(r => [r.id, r]));
-                for (const r of rawSemantic) {
-                    const existing = keywordMap.get(r.id);
-                    if (existing) {
-                        semanticResults.push({ ...existing, similarity: r.similarity });
-                    }
-                    else {
-                        const node = await storage.getNode(projectId, r.id);
-                        if (node) {
-                            semanticResults.push({
-                                id: r.id,
-                                title: r.title,
-                                tags: node.categories || [],
-                                status: node.status,
-                                summary: node.summary || '',
-                                similarity: r.similarity
-                            });
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                console.warn('[kg_search] Semantic search failed:', e);
-            }
-        }
-        // 融合排序
-        const output = mergeSearchResults(keywordResults, semanticResults, mode, limit);
-        const json = JSON.stringify(output, null, 2);
-        return wrap(`${json}\n\n💡 需要详细内容请使用 kg_read_node(nodeId) 获取节点详情\n🔍 搜索模式: ${mode}`);
-    });
-    // 6. 路径查找
-    server.tool('kg_find_path', '查找两节点间的依赖路径', {
-        startId: z.string().describe('起点节点ID'),
-        endId: z.string().describe('终点节点ID')
-    }, async (args) => {
-        const result = await storage.findPath(projectId, args.startId, args.endId);
-        if (!result)
-            return wrap('未找到路径');
-        const output = {
-            pathLength: result.path.length,
-            nodes: result.path.map(n => ({ id: n.id, title: n.title, type: n.type })),
-            edges: result.edges.map(e => ({ from: e.source, to: e.target, type: e.type }))
-        };
-        return wrap(JSON.stringify(output, null, 2));
-    });
-    // 7. 列出节点 (支持过滤)
-    server.tool('kg_list_nodes', '列出节点，支持按状态/连接数过滤。maxEdges=0 可查孤立节点', {
-        status: z.enum(['incomplete', 'complete', 'fixing', 'refactoring', 'deprecated']).optional().describe('状态过滤'),
-        minEdges: z.number().optional().describe('最小连接数(含)'),
-        maxEdges: z.number().optional().describe('最大连接数(含)，0=孤立节点')
-    }, async (args) => {
-        const filter = (args.status || args.minEdges !== undefined || args.maxEdges !== undefined)
-            ? { status: args.status, minEdges: args.minEdges, maxEdges: args.maxEdges }
-            : undefined;
-        const nodes = await storage.listNodes(projectId, filter);
-        const output = nodes.map(n => ({ id: n.id, title: n.title, type: n.type, status: n.status, locked: n.locked, summary: n.summary || '' }));
-        return wrap(JSON.stringify(output, null, 2));
-    });
-    // 8. 查询节点关系网 (支持多层)
-    server.tool('kg_get_relations', '获取节点的上下游关系(谁依赖它/它依赖谁)，支持多层查询', {
-        nodeId: z.string().describe('节点ID'),
-        depth: z.number().min(1).max(3).optional().describe('查询层数(默认1，最大3)')
-    }, async (args) => {
-        const maxDepth = Math.min(args.depth || 1, 3);
-        const { outgoing, incoming } = await fetchRelations(projectId, args.nodeId, maxDepth);
-        if (outgoing.length === 0 && incoming.length === 0) {
-            return wrap('该节点没有任何连线');
-        }
-        return wrap(JSON.stringify({ outgoing, incoming }, null, 2));
-    });
-    // 9. 读取单个节点详情
-    server.tool('kg_read_node', '读取单个节点的完整内容(描述、关联文件、依赖、历史记录)，可选包含上下游关系', {
-        nodeId: z.string().describe('节点ID'),
-        depth: z.number().min(0).max(3).optional().describe('关系查询层数(0=不含关系，1-3=含上下游关系，默认0)')
     }, async (args) => {
         const node = await storage.getNode(projectId, args.nodeId);
         if (!node) {
@@ -269,147 +148,109 @@ export function registerTools(server, projectId, _user) {
         }
         // 格式化节点基础信息
         const lines = formatNodeMarkdown(node);
-        // 上下游关系 (depth > 0 时获取)
-        const depth = args.depth || 0;
-        if (depth > 0) {
-            const { outgoing, incoming } = await fetchRelations(projectId, args.nodeId, depth);
-            lines.push(...formatRelationsMarkdown(outgoing, incoming));
-        }
         return wrap(lines.join('\n'));
     });
     // 10. 获取知识库树状图
     server.tool('kg_get_tree', '获取知识库的目录树结构(按 path 分组)', {}, async () => {
-        const nodes = await storage.listNodes(projectId);
-        const tree = buildDirectoryTree(nodes);
-        const treeText = formatTreeText(tree);
-        const nodeCount = countTreeNodes(tree);
-        return wrap(`共 ${nodeCount} 个节点\n\n${treeText}`);
+        try {
+            const nodes = await storage.listNodes(projectId);
+            const tree = buildDirectoryTree(nodes);
+            const treeText = formatTreeText(tree);
+            const nodeCount = countTreeNodes(tree);
+            return wrap(`共 ${nodeCount} 个节点\n\n${treeText}`);
+        }
+        catch (e) {
+            return wrap(JSON.stringify({
+                error: '无法获取知识库结构',
+                message: String(e),
+                tip: '请确保软件端已启动'
+            }, null, 2));
+        }
     });
-    // ===================== 任务管理工具 =====================
-    // 11. 创建任务
-    server.tool('task_create', '创建开发任务,记录目标和关联节点', {
+    // ===================== 任务管理 =====================
+    // 7. 创建任务
+    server.tool('task_create', '创建开发任务', {
         title: z.string().describe('任务标题'),
         description: z.string().describe('任务描述(Markdown)'),
-        goals: z.array(z.string()).optional().describe('目标清单'),
-        related_nodes: z.array(z.string()).optional().describe('关联节点ID')
+        goals: z.array(z.string()).optional().describe('目标清单')
     }, async (args) => {
-        // 解码 Unicode 转义 (修复 MCP 传参中文乱码)
         const decoded = decodeObjectStrings(args);
         const task = await storage.createTask(projectId, {
             title: decoded.title,
             description: decoded.description,
-            goals: decoded.goals || [],
-            related_nodes: decoded.related_nodes
+            goals: decoded.goals || []
         }, _user);
         return wrap(JSON.stringify(task, null, 2));
     });
-    // 11. 列出任务
-    server.tool('task_list', '列出任务(active=进行中,archived=已归档)', {
-        status: z.enum(['active', 'archived']).optional().describe('状态筛选')
+    // 8. 读取任务 (按名字搜索，支持当前/历史)
+    server.tool('task_get', '读取任务详情(按名字搜索，支持当前任务和历史任务)', {
+        title: z.string().describe('任务名称(模糊匹配)'),
+        status: z.enum(['active', 'archived', 'all']).optional().describe('状态筛选: active=进行中, archived=已归档, all=全部(默认)')
     }, async (args) => {
-        const tasks = await storage.listTasks(projectId, args.status);
-        const output = tasks.map(t => ({
+        const status = args.status || 'all';
+        const searchTitle = args.title.toLowerCase();
+        // 获取任务列表
+        let tasks;
+        if (status === 'all') {
+            const [active, archived] = await Promise.all([
+                storage.listTasks(projectId, 'active'),
+                storage.listTasks(projectId, 'archived')
+            ]);
+            tasks = [...active, ...archived];
+        }
+        else {
+            tasks = await storage.listTasks(projectId, status);
+        }
+        // 按名字模糊匹配
+        const matched = tasks.filter(t => t.title.toLowerCase().includes(searchTitle));
+        if (matched.length === 0) {
+            return wrap(`未找到匹配 "${args.title}" 的任务`);
+        }
+        // 如果只有一个匹配，返回完整详情
+        if (matched.length === 1) {
+            const task = await storage.getTask(projectId, matched[0].id);
+            return wrap(task ? JSON.stringify(task, null, 2) : '任务详情获取失败');
+        }
+        // 多个匹配，返回列表让用户选择
+        const list = matched.map(t => ({
             id: t.id,
             title: t.title,
             status: t.status,
             creator: t.creator,
-            created_at: t.created_at,
-            last_log: t.last_log
+            created_at: t.created_at
         }));
-        return wrap(JSON.stringify(output, null, 2));
+        return wrap(`找到 ${matched.length} 个匹配任务:\n${JSON.stringify(list, null, 2)}\n\n请提供更精确的任务名称`);
     });
-    // 12. 获取任务详情
-    server.tool('task_get', '获取任务完整信息(含全部日志)', {
-        taskId: z.string().describe('任务ID')
-    }, async (args) => {
-        const task = await storage.getTask(projectId, args.taskId);
-        if (!task) {
-            return wrap('任务不存在');
-        }
-        return wrap(JSON.stringify(task, null, 2));
-    });
-    // 13. 添加任务日志
-    server.tool('task_add_log', '记录任务进展/问题/方案/参考', {
+    // 9. 更新任务 (添加日志)
+    server.tool('task_update', '更新任务(添加进展日志)', {
         taskId: z.string().describe('任务ID'),
-        log_type: z.enum(['progress', 'issue', 'solution', 'reference']).describe('日志类型'),
+        log_type: z.enum(['progress', 'issue', 'solution', 'reference']).describe('日志类型: progress=进展, issue=问题, solution=方案, reference=参考'),
         content: z.string().describe('日志内容(Markdown)')
     }, async (args) => {
-        // 解码 Unicode 转义 (修复 MCP 传参中文乱码)
-        const decodedContent = decodeUnicodeEscapes(args.content);
-        const task = await storage.addTaskLog(projectId, args.taskId, args.log_type, decodedContent);
+        const decoded = decodeObjectStrings(args);
+        const task = await storage.addTaskLog(projectId, args.taskId, decoded.log_type, decoded.content);
         if (!task) {
-            return wrap('添加失败(任务不存在或已归档)');
+            return wrap('更新失败(任务不存在或已归档)');
         }
-        return wrap(`日志已添加，任务共有 ${task.logs.length} 条日志`);
+        return wrap(`✅ 日志已添加，任务共有 ${task.logs.length} 条日志`);
     });
-    // 14. 完成任务
-    server.tool('task_complete', '完成任务并归档,填写经验总结', {
+    // 10. 归档任务
+    server.tool('task_archive', '归档任务(完成并填写经验总结)', {
         taskId: z.string().describe('任务ID'),
         summary: z.string().describe('经验总结(Markdown)'),
         difficulties: z.array(z.string()).optional().describe('遇到的困难'),
-        solutions: z.array(z.string()).optional().describe('解决方案'),
-        references: z.array(z.object({
-            title: z.string(),
-            url: z.string().optional()
-        })).optional().describe('参考资料')
+        solutions: z.array(z.string()).optional().describe('解决方案')
     }, async (args) => {
-        // 解码 Unicode 转义 (修复 MCP 传参中文乱码)
-        const decoded = decodeObjectStrings({
-            summary: args.summary,
-            difficulties: args.difficulties || [],
-            solutions: args.solutions || [],
-            references: args.references || []
+        const decoded = decodeObjectStrings(args);
+        const task = await storage.completeTask(projectId, args.taskId, {
+            summary: decoded.summary,
+            difficulties: decoded.difficulties || [],
+            solutions: decoded.solutions || [],
+            references: []
         });
-        const task = await storage.completeTask(projectId, args.taskId, decoded);
         if (!task) {
-            return wrap('完成失败(任务不存在或已归档)');
+            return wrap('归档失败(任务不存在或已归档)');
         }
-        return wrap(`任务已完成归档: ${task.title}`);
-    });
-    // 15. 查询文件关联的节点
-    server.tool('kg_find_by_file', '查询哪些节点绑定了指定文件(删除/重命名前检查)', {
-        filePath: z.string().describe('文件相对路径，如 src/utils/format.ts')
-    }, async (args) => {
-        const nodes = await storage.listNodes(projectId);
-        const filePath = args.filePath.replace(/\\/g, '/'); // 统一为正斜杠
-        // 查找所有绑定了该文件的节点
-        const boundBy = [];
-        for (const node of nodes) {
-            if (node.relatedFiles && node.relatedFiles.length > 0) {
-                // 检查是否包含该文件 (支持部分匹配)
-                const hasFile = node.relatedFiles.some(f => {
-                    const normalizedF = f.replace(/\\/g, '/');
-                    return normalizedF === filePath ||
-                        normalizedF.endsWith('/' + filePath) ||
-                        filePath.endsWith('/' + normalizedF);
-                });
-                if (hasFile) {
-                    boundBy.push({
-                        id: node.id,
-                        title: node.title,
-                        type: node.type,
-                        status: node.status
-                    });
-                }
-            }
-        }
-        const result = {
-            file: filePath,
-            boundBy,
-            message: boundBy.length > 0
-                ? `⚠️ 该文件被 ${boundBy.length} 个节点引用，删除前请更新节点`
-                : '✅ 该文件无 KG 引用，可安全操作'
-        };
-        return wrap(JSON.stringify(result, null, 2));
-    });
-    // ===================== 向量索引管理 =====================
-    // 注意: 向量索引由 Tauri 后端自动维护，MCP 只提供只读查询
-    // 16. 查看索引状态 (只读)
-    server.tool('kg_index_stats', '查看向量索引状态', {}, async () => {
-        const stats = await vector.getIndexStats(projectId);
-        return wrap(JSON.stringify({
-            ...stats,
-            tip: '向量索引由软件端自动维护，节点增删改时自动更新'
-        }, null, 2));
+        return wrap(`✅ 任务已归档: ${task.title}`);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ppdocs/mcp",
-  "version": "2.6.31",
+  "version": "2.7.2",
   "description": "ppdocs MCP Server - Knowledge Graph for Claude",
   "type": "module",
   "main": "dist/index.js",
@@ -30,7 +30,6 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@xenova/transformers": "^2.17.2",
     "proper-lockfile": "^4.1.2",
     "zod": "^4.1.13"
   },

package/templates/commands/pp/DiagnosticProtocol.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/Execution_Task.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/commands/pp/Sentinel_4.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/SynchronizationProtocol.md

@@ -0,0 +1,90 @@
+# 🔄 "Neuro-Link" Synchronization Protocol (神经链路同步协议)
+
+本工作流旨在解决**“代码与图谱脱节”**的问题。
+无论是**新项目初始化**，还是**既有代码的变更**，必须强制同步至 PPDocs MCP，确保 AI 的记忆永远是最新的。
+
+---
+
+### 1.第一阶段：差异嗅探 (Delta Recognition) 📡
+🔹 **核心目标**：识别代码现实与图谱记忆之间的偏差。
+✏️ **动作**：
+*   **扫描代码库**：检测新增文件、修改的函数、重构的类。
+*   **查询图谱**：读取 PPDocs 当前状态。
+*   **计算差异**：生成 `Diff Report` (例如：代码有 Function A，图谱里没有)。
+× **禁区**：
+*   禁止忽略任何细微的逻辑变更。
+*   禁止在未对比图谱的情况下盲目写入。
+
+### 2.第二阶段：语义映射 (Semantic Mapping) 🧠
+🔹 **核心目标**：将冰冷的代码翻译为可视化的知识节点。
+✏️ **动作**：
+*   **逻辑提取**：AI 阅读代码，提炼核心业务逻辑（非逐行翻译，而是意译）。
+*   **节点定义**：将逻辑转换为 PPDocs 的 `Node` (节点) 和 `Document` (文档) 格式。
+*   **关系构建**：确定新节点与旧节点之间的连线 (Edge/Relationship)。
+× **禁区**：
+*   禁止生成无意义的节点（如 "Variable X changed"）。
+*   必须通过节点连线体现代码的模块化关系。
+
+### 3.第三阶段：图谱注入 (Graph Injection) 💉
+🔹 **核心目标**：调用 MCP 接口，实施持久化存储。
+✏️ **动作**：
+*   **PPDocs 调用**：使用 MCP 工具执行增删改操作 (CRUD)。
+    *   `Create_Node`: 新增模块。
+    *   `Update_Link`: 变更逻辑依赖。
+    *   `Delete_Node`: 清除废弃代码的幽灵节点。
+*   **原子化提交**：确保每次同步都是完整的，不会留下“断头”节点。
+× **禁区**：
+*   禁止手动修改数据，必须通过 MCP 工具。
+*   禁止产生孤立节点 (Orphan Nodes)。
+
+### 4.第四阶段：记忆回溯验证 (Memory Re-check) 🛡️
+🔹 **核心目标**：确保 AI 真的“记住”了。
+✏️ **动作**：
+*   **反向查询**：向 PPDocs 提问刚才更新的逻辑。
+*   **一致性校验**：如果 PPDocs 的回答与代码逻辑一致，标记为 ✅ Synced。
+*   **可视化确认**：输出 ASCII 或 Mermaid 结构图供人类确认。
+
+---
+
+### 📊 同步逻辑可视化图解 (ASCII)
+
+```text
+       +-------------------------+
+       |  💻 代码变更 / 新项目启动 |
+       +-----------+-------------+
+                   |
+                   v
+       +-----------+-------------+
+       |  📡 差异嗅探 (Sniffer)   | <---- PPDocs Current State
+       +-----------+-------------+
+                   |
+                   v
+           /-------+-------\
+          /   存在偏差?     \
+         v                   v
+   (🚫 NO: 结束)         (❗ YES: 需要同步)
+                           |
+                           v
+                 +---------+---------+
+                 |  🧠 语义映射分析   |
+                 | (Code -> Knowledge)|
+                 +---------+---------+
+                           |
+                           v
+                 +---------+---------+
+                 |  💉 PPDocs 注入    |
+                 | (Call MCP Tools)  |
+                 +---------+---------+
+                           |
+                           v
+                 +---------+---------+
+                 |  🛡️ 记忆回溯验证   |
+                 +---------+---------+
+                           |
+               /-----------+----------\
+              /    AI能否准确复述?     \
+             v                          v
+     +-------+-------+          +-------+-------+
+     | ✅ 同步完成    |          | ❌ 失败重试    |
+     | (Persistent)  |          | (Retry Loop)  |
+     +---------------+          +---------------+

package/templates/commands/pp/Zero_Defec_Genesis.md

@@ -0,0 +1,62 @@
+# 🛡️ "Zero-Defect Genesis" Protocol (零缺陷创生协议)
+
+这是一个严格的**“设计-审查-迭代”**自动化流程。只有通过所有安全检查的方案，才会最终呈现给您。
+
+---
+
+### 1.第一阶段：启动设计 (Design) 💡
+*   **动作**：接收任务目标。
+*   **执行**：生成初步的逻辑架构与执行步骤。
+*   **目标**：先有一个可行草稿。
+
+### 2.第二阶段：深度审查 (The Audit) 🧐
+在此阶段，方案必须经过**三道关卡**的严苛检查：
+1.  🎯 **预期核对**：方案能否 100% 达成既定目标？
+2.  🧩 **模块化检查**：结构是否清晰？是否像积木一样解耦，便于维护？
+3.  🛡️ **无害化验证**：是否引入了新的 Bug 或副作用？
+
+### 3.第三阶段：循环验证 (The Loop) 🔄
+*   ❌ **如果验证失败 (Fail)**：
+    *   触发**自动修复机制**。
+    *   针对审查出的问题进行修改。
+    *   **回退**至第二阶段重新审查。
+*   ✅ **如果验证通过 (Pass)**：
+    *   锁定当前版本，进入交付通道。
+
+### 4.第四阶段：最终交付 (Final Output) 🎉
+*   **输出**：经得起推敲的、模块化的、无错的最终方案。
+*   **动作**：展示给您进行最终确认。
+
+---
+
+### 📊 流程可视化图解 (ASCII)
+
+```text
+       +----------------------------+
+       |  💡 START: 初步方案设计     |
+       +-------------+--------------+
+                     |
+                     v
+       +-------------+--------------+
+       |    🧐  深度审查机制         |
+       |----------------------------|
+       |  1. 🎯 预期核对 (Target)   |
+       |  2. 🧩 结构检查 (Modular)  |
+       |  3. 🛡️ 风险排除 (Safety)   |
+       +-------------+--------------+
+                     |
+                     v
+             /-------+-------\
+            /    验证结论?    \
+           /-------------------\
+          /                     \
+    (❌ 失败: FAIL)         (✅ 通过: PASS)
+         |                         |
+         v                         v
+ +-------+-------+         +-------+-------+
+ | 🛠️ 迭代修复   |         | 🎉 最终交付   |
+ | (Auto-Fix)    |         | (Final Output)|
+ +-------+-------+         +---------------+
+         |
+         | (🔄 Return to Audit)
+         +-------------------------^