aifastdb-devplan 1.6.1 → 1.6.3

package/dist/dev-plan-graph-store.js

@@ -53,6 +53,7 @@ exports.DevPlanGraphStore = void 0;
 const aifastdb_1 = require("aifastdb");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const shard_config_1 = require("./shard-config");
 // ============================================================================
 // Constants
 // ============================================================================
@@ -63,16 +64,32 @@ const ET = {
     MAIN_TASK: 'devplan-main-task',
     SUB_TASK: 'devplan-sub-task',
     MODULE: 'devplan-module',
+    PROMPT: 'devplan-prompt',
+    MEMORY: 'devplan-memory',
 };
 /** Relation 类型常量 */
 const RT = {
     HAS_DOCUMENT: 'has_document',
     HAS_MAIN_TASK: 'has_main_task',
     HAS_SUB_TASK: 'has_sub_task',
+    HAS_MODULE: 'has_module',
     MODULE_HAS_TASK: 'module_has_task',
     MODULE_HAS_DOC: 'module_has_doc',
     TASK_HAS_DOC: 'task_has_doc',
     DOC_HAS_CHILD: 'doc_has_child',
+    TASK_HAS_PROMPT: 'task_has_prompt',
+    HAS_PROMPT: 'has_prompt',
+    HAS_MEMORY: 'has_memory',
+    MEMORY_FROM_TASK: 'memory_from_task',
+    // ---- Phase-37: 记忆网络关系类型 ----
+    /** 记忆 ↔ 记忆 语义关联（双向，带 similarity score 权重） */
+    MEMORY_RELATES: 'memory_relates',
+    /** 文档 → 记忆 来源关系（从文档提取的记忆） */
+    MEMORY_FROM_DOC: 'memory_from_doc',
+    /** 模块 → 记忆 归属关系（模块级记忆） */
+    MODULE_MEMORY: 'module_memory',
+    /** 记忆 → 记忆 替代/演化关系（新记忆替代旧记忆） */
+    MEMORY_SUPERSEDES: 'memory_supersedes',
 };
 // ============================================================================
 // Helper
@@ -113,22 +130,15 @@ class DevPlanGraphStore {
         // 必须在 SocialGraphV2 构造之前执行，否则 recover() 会找不到旧数据
         DevPlanGraphStore.migrateWalDirNames(config.graphPath);
         // 构建 SocialGraphV2 配置
+        // shardCount 由 SocialGraphV2 自动从 shardNames.length 推导（aifastdb >= 2.7.0）
+        // 所有分片定义集中在 shard-config.ts（单一数据源）
         const graphConfig = {
             path: config.graphPath,
-            shardCount: config.shardCount || 4,
             walEnabled: true,
             mode: 'balanced',
-            shardNames: ['tasks', 'relations', 'docs', 'modules'],
-            // 显式路由：DevPlan 实体类型 → 对应分片
-            typeShardMapping: {
-                'devplan-project': 0, // 项目根节点 → tasks shard
-                'devplan-main-task': 0, // 主任务     → tasks shard
-                'devplan-sub-task': 0, // 子任务     → tasks shard
-                'devplan-doc': 2, // 文档片段   → docs shard
-                'devplan-module': 3, // 功能模块   → modules shard
-                '_default': 0, // 未知类型   → tasks shard (fallback)
-            },
-            relationShardId: 1, // 所有关系   → relations shard
+            shardNames: shard_config_1.DEVPLAN_SHARD_NAMES,
+            typeShardMapping: shard_config_1.DEVPLAN_TYPE_SHARD_MAPPING,
+            relationShardId: shard_config_1.DEVPLAN_RELATION_SHARD_ID,
         };
         // 如果启用语义搜索，配置 SocialGraphV2 的向量搜索
         const dimension = config.embeddingDimension || 384;
@@ -200,21 +210,25 @@ class DevPlanGraphStore {
     // WAL Directory Migration (旧分片名 → 语义化新名)
     // ==========================================================================
     /**
-     * 一次性迁移：将旧 WAL 目录名重命名为语义化新名。
+     * WAL 目录迁移 + 分片目录补全。
+     *
+     * 1. 旧名重命名（幂等）：
+     *    - shard_0_entities → shard_0_tasks
+     *    - shard_2_index    → shard_2_docs
+     *    - shard_3_meta     → shard_3_modules
      *
-     * 映射表：
-     * - shard_0_entities → shard_0_tasks
-     * - shard_2_index    → shard_2_docs
-     * - shard_3_meta     → shard_3_modules
-     * - shard_1_relations 不变
+     * 2. 确保所有预期的分片目录存在（Phase-36: shard_5_memory）：
+     *    SocialGraphV2 (Rust) 根据磁盘上的目录数确定分片数量，
+     *    如果新增分片目录不存在会导致 index out of bounds panic。
+     *    因此必须在 SocialGraphV2 构造之前创建缺失的目录。
      *
      * 该方法必须在 `new SocialGraphV2(config)` 之前调用。
-     * 幂等：如果旧目录不存在或新目录已存在则跳过。
      */
     static migrateWalDirNames(graphPath) {
         const walBase = path.join(graphPath, 'wal');
         if (!fs.existsSync(walBase))
             return; // 全新安装，无需迁移
+        // ── Step 1: 旧名 → 新名 重命名 ──
         const renames = [
             ['shard_0_entities', 'shard_0_tasks'],
             ['shard_2_index', 'shard_2_docs'],
@@ -233,23 +247,33 @@ class DevPlanGraphStore {
                 }
             }
         }
+        // ── Step 2: 确保所有预期分片目录存在 ──
+        // 当新增分片时（如 shard_5_memory），旧项目缺少对应目录，
+        // 必须提前创建空目录，否则 Rust SocialGraphV2 会 panic。
+        // 分片列表从 shard-config.ts 自动推导，不再硬编码。
+        for (const shardName of shard_config_1.DEVPLAN_EXPECTED_SHARD_DIRS) {
+            const shardDir = path.join(walBase, shardName);
+            if (!fs.existsSync(shardDir)) {
+                try {
+                    fs.mkdirSync(shardDir, { recursive: true });
+                    console.error(`[DevPlan] Created missing shard dir: ${shardName}`);
+                }
+                catch (e) {
+                    console.warn(`[DevPlan] Failed to create shard dir ${shardName}: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+        }
     }
     // ==========================================================================
     // Project Entity
     // ==========================================================================
     ensureProjectEntity() {
-        const existing = this.findProjectEntity();
-        if (existing) {
-            this.projectEntityId = existing.id;
-        }
-        else {
-            const entity = this.graph.addEntity(this.projectName, ET.PROJECT, {
-                projectName: this.projectName,
-                createdAt: Date.now(),
-            });
-            this.projectEntityId = entity.id;
-            this.graph.flush();
-        }
+        const entity = this.graph.upsertEntityByProp(ET.PROJECT, 'projectName', this.projectName, this.projectName, {
+            projectName: this.projectName,
+            createdAt: Date.now(),
+        });
+        this.projectEntityId = entity.id;
+        this.graph.flush();
     }
     findProjectEntity() {
         const entities = this.graph.listEntitiesByType(ET.PROJECT);
@@ -261,20 +285,104 @@ class DevPlanGraphStore {
         }
         return this.projectEntityId;
     }
-    // ==========================================================================
-    // Generic Entity Helpers
-    // ==========================================================================
+    /**
+     * 通用 Entity 去重：按指定 property key 分组，每组只保留"最优"实体。
+     *
+     * 胜出规则：
+     * 1. status 优先级高者胜（completed > in_progress > pending > cancelled）
+     * 2. 同 status 时 updatedAt 最新者胜
+     *
+     * 适用于 mainTask（按 taskId 去重）、subTask（按 taskId 去重）、
+     * module（按 moduleId 去重）等场景。
+     */
+    deduplicateEntities(entities, propKey) {
+        const bestMap = new Map();
+        for (const e of entities) {
+            const key = e.properties?.[propKey];
+            if (!key) {
+                // 无 key 的 entity 直接保留
+                bestMap.set(e.id, e);
+                continue;
+            }
+            const existing = bestMap.get(key);
+            if (!existing) {
+                bestMap.set(key, e);
+                continue;
+            }
+            // 比较状态优先级
+            const existStatus = DevPlanGraphStore.STATUS_PRIORITY[existing.properties?.status] ?? 1;
+            const newStatus = DevPlanGraphStore.STATUS_PRIORITY[e.properties?.status] ?? 1;
+            if (newStatus > existStatus) {
+                bestMap.set(key, e);
+            }
+            else if (newStatus === existStatus) {
+                // 同状态：updatedAt 更大者胜
+                const existUpdated = Number(existing.properties?.updatedAt) || 0;
+                const newUpdated = Number(e.properties?.updatedAt) || 0;
+                if (newUpdated > existUpdated) {
+                    bestMap.set(key, e);
+                }
+            }
+        }
+        return Array.from(bestMap.values());
+    }
+    /**
+     * 查找所有重复 Entity（按指定 property key 分组，返回非胜出者列表）。
+     * 用于清理 WAL 中的冗余记录。
+     */
+    findDuplicateEntities(entityType, propKey) {
+        const entities = this.findEntitiesByType(entityType);
+        const groups = new Map();
+        for (const e of entities) {
+            const key = e.properties?.[propKey];
+            if (!key)
+                continue;
+            if (!groups.has(key))
+                groups.set(key, []);
+            groups.get(key).push(e);
+        }
+        const duplicates = [];
+        for (const [, group] of groups) {
+            if (group.length <= 1)
+                continue;
+            // 找出胜者（deduplicateEntities 返回的唯一值）
+            const winner = this.deduplicateEntities(group, propKey)[0];
+            for (const e of group) {
+                if (e.id !== winner.id) {
+                    duplicates.push(e);
+                }
+            }
+        }
+        return duplicates;
+    }
     /** 按 entityType 列出所有实体并按属性过滤 */
     findEntitiesByType(entityType) {
         return this.graph.listEntitiesByType(entityType).filter((e) => e.properties?.projectName === this.projectName);
     }
-    /** 按属性在指定类型中查找唯一实体 */
+    /**
+     * 按属性在指定类型中查找唯一实体。
+     *
+     * Phase-21 改进：当同一 key+value 有多个 Entity（WAL 重复），
+     * 选择状态优先级最高 + updatedAt 最新的那个（而非随机第一个）。
+     */
     findEntityByProp(entityType, key, value) {
         const entities = this.findEntitiesByType(entityType);
-        return entities.find((e) => e.properties?.[key] === value) || null;
+        const matches = entities.filter((e) => e.properties?.[key] === value);
+        if (matches.length === 0)
+            return null;
+        if (matches.length === 1)
+            return matches[0];
+        // 多个匹配 → 去重取最优
+        return this.deduplicateEntities(matches, key)[0] || null;
     }
     /** 获取实体的出向关系 */
     getOutRelations(entityId, relationType) {
+        // Phase-44: 优先使用 outgoingByType（直接查询分片，O(出度)），
+        //           避免 listRelations 的全量扫描 O(关系总数)
+        const g = this.graph;
+        if (relationType && typeof g.outgoingByType === 'function') {
+            return g.outgoingByType(entityId, relationType);
+        }
         const filter = { sourceId: entityId };
         if (relationType)
             filter.relationType = relationType;
@@ -282,6 +390,12 @@ class DevPlanGraphStore {
     }
     /** 获取实体的入向关系 */
     getInRelations(entityId, relationType) {
+        // Phase-44: 优先使用 incomingByType（直接查询分片，O(入度)），
+        //           避免 listRelations 的全量扫描 O(关系总数)
+        const g = this.graph;
+        if (relationType && typeof g.incomingByType === 'function') {
+            return g.incomingByType(entityId, relationType);
+        }
         const filter = { targetId: entityId };
         if (relationType)
             filter.relationType = relationType;
@@ -343,6 +457,7 @@ class DevPlanGraphStore {
             estimatedHours: p.estimatedHours || undefined,
             relatedSections: p.relatedSections || [],
             moduleId: p.moduleId || undefined,
+            relatedPromptIds: p.relatedPromptIds || [],
             totalSubtasks: p.totalSubtasks || 0,
             completedSubtasks: p.completedSubtasks || 0,
             status: p.status || 'pending',
@@ -453,10 +568,14 @@ class DevPlanGraphStore {
             this.graph.flush();
             return existing.id;
         }
-        // 新建文档
-        const entity = this.graph.addEntity(input.title, ET.DOC, {
+        // 新建文档 — upsert by sectionKey 防止重复
+        const sectionKey = input.subSection
+            ? `${input.section}|${input.subSection}`
+            : input.section;
+        const entity = this.graph.upsertEntityByProp(ET.DOC, 'sectionKey', sectionKey, input.title, {
             projectName: this.projectName,
             section: input.section,
+            sectionKey,
             title: input.title,
             content: input.content,
             version,
@@ -515,7 +634,9 @@ class DevPlanGraphStore {
         return null;
     }
     listSections() {
-        return this.findEntitiesByType(ET.DOC).map((e) => this.entityToDevPlanDoc(e));
+        const entities = this.findEntitiesByType(ET.DOC);
+        // Phase-23: 引擎层 upsertEntityByProp(sectionKey) 已保证不会新增重复，无需上层去重
+        return entities.map((e) => this.entityToDevPlanDoc(e));
     }
     updateSection(section, content, subSection) {
         const existing = this.getSection(section, subSection);
@@ -672,12 +793,13 @@ class DevPlanGraphStore {
     createMainTask(input) {
         const existing = this.getMainTask(input.taskId);
         if (existing) {
-            throw new Error(`Main task "${input.taskId}" already exists for project "${this.projectName}"`);
+            // 已存在 → 返回现有任务（幂等）
+            return existing;
         }
         const now = Date.now();
         // 如果未指定 order，自动分配为当前最大 order + 1
         const order = input.order != null ? input.order : this.getNextMainTaskOrder();
-        const entity = this.graph.addEntity(input.title, ET.MAIN_TASK, {
+        const entity = this.graph.upsertEntityByProp(ET.MAIN_TASK, 'taskId', input.taskId, input.title, {
             projectName: this.projectName,
             taskId: input.taskId,
             title: input.title,
@@ -685,6 +807,7 @@ class DevPlanGraphStore {
             description: input.description || '',
             estimatedHours: input.estimatedHours || 0,
             relatedSections: input.relatedSections || [],
+            relatedPromptIds: input.relatedPromptIds || [],
             moduleId: input.moduleId || null,
             totalSubtasks: 0,
             completedSubtasks: 0,
@@ -713,6 +836,15 @@ class DevPlanGraphStore {
                 }
             }
         }
+        // task -> prompt 关系（通过 relatedPromptIds 建立）
+        if (input.relatedPromptIds?.length) {
+            for (const promptId of input.relatedPromptIds) {
+                const promptEntity = this.graph.getEntity(promptId);
+                if (promptEntity && promptEntity.entity_type === ET.PROMPT) {
+                    this.graph.putRelation(entity.id, promptEntity.id, RT.TASK_HAS_PROMPT);
+                }
+            }
+        }
         this.graph.flush();
         return this.entityToMainTask(entity);
     }
@@ -741,30 +873,35 @@ class DevPlanGraphStore {
         const completedAt = finalStatus === 'completed' ? (existing.completedAt || now) : null;
         const finalModuleId = input.moduleId || existing.moduleId;
         const finalOrder = input.order != null ? input.order : existing.order;
-        this.graph.updateEntity(existing.id, {
-            name: input.title,
-            properties: {
-                title: input.title,
-                priority: input.priority,
-                description: input.description || existing.description || '',
-                estimatedHours: input.estimatedHours || existing.estimatedHours || 0,
-                relatedSections: input.relatedSections || existing.relatedSections || [],
-                moduleId: finalModuleId || null,
-                status: finalStatus,
-                order: finalOrder,
-                updatedAt: now,
-                completedAt,
-            },
+        // Phase-45: 使用 upsertEntityByProp 代替 updateEntity（修复分片路由不一致）
+        const upsertedEntity = this.graph.upsertEntityByProp(ET.MAIN_TASK, 'taskId', input.taskId, input.title, {
+            projectName: this.projectName,
+            taskId: input.taskId,
+            title: input.title,
+            priority: input.priority,
+            description: input.description || existing.description || '',
+            estimatedHours: input.estimatedHours || existing.estimatedHours || 0,
+            relatedSections: input.relatedSections || existing.relatedSections || [],
+            relatedPromptIds: input.relatedPromptIds || existing.relatedPromptIds || [],
+            moduleId: finalModuleId || null,
+            totalSubtasks: existing.totalSubtasks,
+            completedSubtasks: existing.completedSubtasks,
+            status: finalStatus,
+            order: finalOrder,
+            createdAt: existing.createdAt,
+            updatedAt: now,
+            completedAt,
         });
+        const upsertedId = upsertedEntity?.id || existing.id;
         // 更新模块关系
         if (finalModuleId && finalModuleId !== existing.moduleId) {
-            this.updateModuleTaskRelation(existing.id, existing.moduleId, finalModuleId);
+            this.updateModuleTaskRelation(upsertedId, existing.moduleId, finalModuleId);
         }
         // 更新 task -> doc 关系
         const newRelatedSections = input.relatedSections || existing.relatedSections || [];
         if (newRelatedSections.length) {
             // 删除旧的 TASK_HAS_DOC 关系
-            const oldDocRels = this.getOutRelations(existing.id, RT.TASK_HAS_DOC);
+            const oldDocRels = this.getOutRelations(upsertedId, RT.TASK_HAS_DOC);
             for (const rel of oldDocRels) {
                 this.graph.deleteRelation(rel.id);
             }
@@ -773,13 +910,12 @@ class DevPlanGraphStore {
                 const [sec, sub] = sk.split('|');
                 const docEntity = this.findDocEntityBySection(sec, sub);
                 if (docEntity) {
-                    this.graph.putRelation(existing.id, docEntity.id, RT.TASK_HAS_DOC);
+                    this.graph.putRelation(upsertedId, docEntity.id, RT.TASK_HAS_DOC);
                 }
             }
         }
         this.graph.flush();
-        const updated = this.graph.getEntity(existing.id);
-        return updated ? this.entityToMainTask(updated) : existing;
+        return this.getMainTask(input.taskId) || existing;
     }
     getMainTask(taskId) {
         const entity = this.findEntityByProp(ET.MAIN_TASK, 'taskId', taskId);
@@ -787,6 +923,7 @@ class DevPlanGraphStore {
     }
     listMainTasks(filter) {
         let entities = this.findEntitiesByType(ET.MAIN_TASK);
+        // Phase-23: 引擎层 upsertEntityByProp 已保证不会新增重复，无需上层去重
         if (filter?.status) {
             entities = entities.filter((e) => e.properties.status === filter.status);
         }
@@ -805,16 +942,29 @@ class DevPlanGraphStore {
             return null;
         const now = Date.now();
         const completedAt = status === 'completed' ? now : mainTask.completedAt;
-        this.graph.updateEntity(mainTask.id, {
-            properties: {
-                status,
-                updatedAt: now,
-                completedAt,
-            },
+        // Phase-45: 使用 upsertEntityByProp 代替 updateEntity
+        // 原因：updateEntity 依赖 UUID 直接查找，在分片路由变更后可能写入错误分片，
+        //       导致更新不可见。upsertEntityByProp 按属性查找实体，路由始终正确。
+        this.graph.upsertEntityByProp(ET.MAIN_TASK, 'taskId', taskId, mainTask.title, {
+            projectName: this.projectName,
+            taskId,
+            title: mainTask.title,
+            priority: mainTask.priority,
+            description: mainTask.description || '',
+            estimatedHours: mainTask.estimatedHours || 0,
+            relatedSections: mainTask.relatedSections || [],
+            relatedPromptIds: mainTask.relatedPromptIds || [],
+            moduleId: mainTask.moduleId || null,
+            totalSubtasks: mainTask.totalSubtasks,
+            completedSubtasks: mainTask.completedSubtasks,
+            status,
+            order: mainTask.order,
+            createdAt: mainTask.createdAt,
+            updatedAt: now,
+            completedAt,
         });
         this.graph.flush();
-        const updated = this.graph.getEntity(mainTask.id);
-        return updated ? this.entityToMainTask(updated) : null;
+        return this.getMainTask(taskId);
     }
     // ==========================================================================
     // Sub Task Operations
@@ -822,7 +972,8 @@ class DevPlanGraphStore {
     addSubTask(input) {
         const existing = this.getSubTask(input.taskId);
         if (existing) {
-            throw new Error(`Sub task "${input.taskId}" already exists for project "${this.projectName}"`);
+            // 已存在 → 返回现有子任务（幂等）
+            return existing;
         }
         const mainTask = this.getMainTask(input.parentTaskId);
         if (!mainTask) {
@@ -831,7 +982,7 @@ class DevPlanGraphStore {
         const now = Date.now();
         // 如果未指定 order，自动分配为当前父任务下最大 order + 1
         const order = input.order != null ? input.order : this.getNextSubTaskOrder(input.parentTaskId);
-        const entity = this.graph.addEntity(input.title, ET.SUB_TASK, {
+        const entity = this.graph.upsertEntityByProp(ET.SUB_TASK, 'taskId', input.taskId, input.title, {
             projectName: this.projectName,
             taskId: input.taskId,
             parentTaskId: input.parentTaskId,
@@ -863,7 +1014,7 @@ class DevPlanGraphStore {
             }
             const now = Date.now();
             const order = input.order != null ? input.order : this.getNextSubTaskOrder(input.parentTaskId);
-            const entity = this.graph.addEntity(input.title, ET.SUB_TASK, {
+            const entity = this.graph.upsertEntityByProp(ET.SUB_TASK, 'taskId', input.taskId, input.title, {
                 projectName: this.projectName,
                 taskId: input.taskId,
                 parentTaskId: input.parentTaskId,
@@ -927,6 +1078,7 @@ class DevPlanGraphStore {
     }
     listSubTasks(parentTaskId, filter) {
         let entities = this.findEntitiesByType(ET.SUB_TASK).filter((e) => e.properties.parentTaskId === parentTaskId);
+        // Phase-23: 引擎层 upsertEntityByProp 已保证不会新增重复，无需上层去重
         if (filter?.status) {
             entities = entities.filter((e) => e.properties.status === filter.status);
         }
@@ -943,18 +1095,25 @@ class DevPlanGraphStore {
             ? (options?.completedAtCommit || subTask.completedAtCommit)
             : (status === 'pending' ? null : subTask.completedAtCommit);
         const revertReason = options?.revertReason || (status === 'pending' ? null : subTask.revertReason);
-        this.graph.updateEntity(subTask.id, {
-            properties: {
-                status,
-                updatedAt: now,
-                completedAt,
-                completedAtCommit: completedAtCommit || null,
-                revertReason: revertReason || null,
-            },
+        // Phase-45: 使用 upsertEntityByProp 代替 updateEntity（修复分片路由不一致）
+        this.graph.upsertEntityByProp(ET.SUB_TASK, 'taskId', taskId, subTask.title, {
+            projectName: this.projectName,
+            taskId,
+            parentTaskId: subTask.parentTaskId,
+            title: subTask.title,
+            description: subTask.description || '',
+            estimatedHours: subTask.estimatedHours || 0,
+            relatedFiles: subTask.relatedFiles || [],
+            status,
+            order: subTask.order,
+            createdAt: subTask.createdAt,
+            updatedAt: now,
+            completedAt,
+            completedAtCommit: completedAtCommit || null,
+            revertReason: revertReason || null,
         });
         this.graph.flush();
-        const updated = this.graph.getEntity(subTask.id);
-        return updated ? this.entityToSubTask(updated) : null;
+        return this.getSubTask(taskId);
     }
     // ==========================================================================
     // Completion Workflow
@@ -1100,11 +1259,12 @@ class DevPlanGraphStore {
     createModule(input) {
         const existing = this.getModule(input.moduleId);
         if (existing) {
-            throw new Error(`Module "${input.moduleId}" already exists for project "${this.projectName}"`);
+            // 已存在 → 返回现有模块（幂等）
+            return existing;
         }
         const now = Date.now();
         const status = input.status || 'active';
-        const entity = this.graph.addEntity(input.name, ET.MODULE, {
+        const entity = this.graph.upsertEntityByProp(ET.MODULE, 'moduleId', input.moduleId, input.name, {
             projectName: this.projectName,
             moduleId: input.moduleId,
             name: input.name,
@@ -1136,6 +1296,7 @@ class DevPlanGraphStore {
     }
     listModules(filter) {
         let entities = this.findEntitiesByType(ET.MODULE);
+        // Phase-23: 引擎层 upsertEntityByProp 已保证不会新增重复，无需上层去重
         if (filter?.status) {
             entities = entities.filter((e) => e.properties.status === filter.status);
         }
@@ -1274,143 +1435,1828 @@ class DevPlanGraphStore {
         };
     }
     // ==========================================================================
-    // Utility
+    // Prompt Operations (用户 Prompt 日志)
     // ==========================================================================
-    sync() {
+    /**
+     * 保存一条 Prompt
+     *
+     * 自动分配 promptIndex (当天内自增序号)。
+     * 如果指定了 relatedTaskId，自动建立 task_has_prompt 关系。
+     */
+    savePrompt(input) {
+        const now = Date.now();
+        const today = new Date(now).toISOString().slice(0, 10); // YYYY-MM-DD
+        // 获取当天已有 prompt 数量，分配自增序号
+        const existingToday = this.listPrompts({ date: today });
+        const promptIndex = existingToday.length + 1;
+        // 生成简短标签作为 entity name
+        const namePreview = input.content.slice(0, 50).replace(/\n/g, ' ');
+        const entityName = `Prompt #${promptIndex} (${today})`;
+        const entity = this.graph.addEntity(entityName, ET.PROMPT, {
+            projectName: this.projectName,
+            promptIndex,
+            content: input.content,
+            aiInterpretation: input.aiInterpretation || '',
+            summary: input.summary || '',
+            relatedTaskId: input.relatedTaskId || null,
+            tags: input.tags || [],
+            date: today,
+            createdAt: now,
+        });
+        // project -> prompt 关系
+        this.graph.putRelation(this.getProjectId(), entity.id, RT.HAS_PROMPT);
+        // task -> prompt 关系
+        if (input.relatedTaskId) {
+            const taskEntity = this.findEntityByProp(ET.MAIN_TASK, 'taskId', input.relatedTaskId);
+            if (taskEntity) {
+                this.graph.putRelation(taskEntity.id, entity.id, RT.TASK_HAS_PROMPT);
+                // 同时更新主任务的 relatedPromptIds 数组
+                const taskProps = taskEntity.properties;
+                const existingIds = taskProps.relatedPromptIds || [];
+                if (!existingIds.includes(entity.id)) {
+                    this.graph.updateEntity(taskEntity.id, {
+                        properties: {
+                            ...taskProps,
+                            relatedPromptIds: [...existingIds, entity.id],
+                            updatedAt: now,
+                        },
+                    });
+                }
+            }
+        }
         this.graph.flush();
+        return this.entityToPrompt(entity);
     }
-    getProjectName() {
-        return this.projectName;
-    }
-    syncWithGit(dryRun = false) {
-        const currentHead = this.getCurrentGitCommit();
-        if (!currentHead) {
-            return {
-                checked: 0,
-                reverted: [],
-                currentHead: 'unknown',
-                error: 'Git not available or not in a Git repository',
-            };
+    /**
+     * 列出 Prompt（支持按日期、关联任务过滤）
+     */
+    listPrompts(filter) {
+        // 如果按关联任务过滤，通过关系查询
+        if (filter?.relatedTaskId) {
+            return this.getTaskRelatedPrompts(filter.relatedTaskId);
+        }
+        const entities = this.findEntitiesByType(ET.PROMPT);
+        let prompts = entities
+            .filter((e) => {
+            const p = e.properties;
+            if (p.projectName !== this.projectName)
+                return false;
+            if (filter?.date && p.date !== filter.date)
+                return false;
+            return true;
+        })
+            .map((e) => this.entityToPrompt(e));
+        // 按 createdAt 降序排列（最新的在前）
+        prompts.sort((a, b) => b.createdAt - a.createdAt);
+        if (filter?.limit && filter.limit > 0) {
+            prompts = prompts.slice(0, filter.limit);
         }
-        const mainTasks = this.listMainTasks();
-        const reverted = [];
-        let checked = 0;
-        for (const mt of mainTasks) {
-            const subs = this.listSubTasks(mt.taskId);
-            for (const sub of subs) {
-                if (sub.status !== 'completed' || !sub.completedAtCommit)
-                    continue;
-                checked++;
-                if (!this.isAncestor(sub.completedAtCommit, currentHead)) {
-                    const reason = `Commit ${sub.completedAtCommit} not found in current branch (HEAD: ${currentHead})`;
-                    if (!dryRun) {
-                        this.updateSubTaskStatus(sub.taskId, 'pending', { revertReason: reason });
-                        this.refreshMainTaskCounts(sub.parentTaskId);
-                        const parentMain = this.getMainTask(sub.parentTaskId);
-                        if (parentMain && parentMain.status === 'completed') {
-                            this.updateMainTaskStatus(sub.parentTaskId, 'in_progress');
-                        }
-                    }
-                    reverted.push({
-                        taskId: sub.taskId,
-                        title: sub.title,
-                        parentTaskId: sub.parentTaskId,
-                        completedAtCommit: sub.completedAtCommit,
-                        reason,
-                    });
-                }
+        return prompts;
+    }
+    /**
+     * 获取主任务关联的所有 Prompt
+     */
+    getTaskRelatedPrompts(taskId) {
+        const taskEntity = this.findEntityByProp(ET.MAIN_TASK, 'taskId', taskId);
+        if (!taskEntity)
+            return [];
+        const rels = this.getOutRelations(taskEntity.id, RT.TASK_HAS_PROMPT);
+        const prompts = [];
+        for (const rel of rels) {
+            const promptEntity = this.graph.getEntity(rel.target);
+            if (promptEntity && promptEntity.entity_type === ET.PROMPT) {
+                prompts.push(this.entityToPrompt(promptEntity));
             }
         }
-        return { checked, reverted, currentHead };
+        // 按 createdAt 升序排列
+        prompts.sort((a, b) => a.createdAt - b.createdAt);
+        return prompts;
+    }
+    /**
+     * Entity → Prompt 转换
+     */
+    entityToPrompt(e) {
+        const p = e.properties;
+        return {
+            id: e.id,
+            projectName: this.projectName,
+            promptIndex: p.promptIndex || 0,
+            content: p.content || '',
+            aiInterpretation: p.aiInterpretation || undefined,
+            summary: p.summary || undefined,
+            relatedTaskId: p.relatedTaskId || undefined,
+            tags: p.tags || [],
+            createdAt: p.createdAt || e.created_at,
+        };
     }
     // ==========================================================================
-    // Graph Export (核心差异能力)
+    // Memory Operations (Cursor 长期记忆)
     // ==========================================================================
     /**
-     * 导出 DevPlan 的图结构用于可视化
+     * 保存一条记忆
      *
-     * 返回 vis-network 兼容的 { nodes, edges } 格式。
+     * - 记忆存储为 devplan-memory 实体
+     * - 如启用语义搜索，自动 embed content 并索引到 HNSW
+     * - 关联 project → memory 和可选的 memory → task 关系
      */
-    exportGraph(options) {
-        const includeDocuments = options?.includeDocuments !== false;
-        const includeModules = options?.includeModules !== false;
-        const includeNodeDegree = options?.includeNodeDegree !== false;
-        const enableBackendDegreeFallback = options?.enableBackendDegreeFallback !== false;
-        const nodes = [];
-        const edges = [];
-        // 项目根节点
-        nodes.push({
-            id: this.getProjectId(),
-            label: this.projectName,
-            type: 'project',
-            properties: { entityType: ET.PROJECT },
-        });
-        // 主任务节点
-        const mainTasks = this.listMainTasks();
-        for (const mt of mainTasks) {
-            nodes.push({
-                id: mt.id,
-                label: mt.title,
-                type: 'main-task',
+    saveMemory(input) {
+        const now = Date.now();
+        // ---- 去重检测 ----
+        const existingDup = this.findDuplicateMemory(input);
+        if (existingDup) {
+            // 已存在相同记忆 → 更新而非新建
+            const oldProps = existingDup.properties;
+            this.graph.updateEntity(existingDup.id, {
                 properties: {
-                    taskId: mt.taskId,
-                    priority: mt.priority,
-                    status: mt.status,
-                    totalSubtasks: mt.totalSubtasks,
-                    completedSubtasks: mt.completedSubtasks,
-                    completedAt: mt.completedAt || null,
+                    ...oldProps,
+                    content: input.content,
+                    memoryType: input.memoryType,
+                    tags: input.tags || oldProps.tags || [],
+                    importance: input.importance ?? oldProps.importance ?? 0.5,
+                    sourceId: input.sourceId || oldProps.sourceId || null,
+                    updatedAt: now,
                 },
             });
-            edges.push({
-                from: this.getProjectId(),
-                to: mt.id,
-                label: RT.HAS_MAIN_TASK,
-            });
-            // 子任务节点
-            const subTasks = this.listSubTasks(mt.taskId);
-            for (const st of subTasks) {
-                nodes.push({
-                    id: st.id,
-                    label: st.title,
-                    type: 'sub-task',
-                    properties: {
-                        taskId: st.taskId,
-                        parentTaskId: st.parentTaskId,
-                        status: st.status,
-                        completedAt: st.completedAt || null,
-                    },
-                });
-                edges.push({
-                    from: mt.id,
-                    to: st.id,
-                    label: RT.HAS_SUB_TASK,
-                });
+            // 重新索引向量
+            if (this.semanticSearchReady && this.synapse) {
+                try {
+                    const embedding = this.synapse.embed(input.content);
+                    this.graph.indexEntity(existingDup.id, embedding);
+                }
+                catch (e) {
+                    console.warn(`[DevPlan] Failed to re-index memory ${existingDup.id}: ${e instanceof Error ? e.message : String(e)}`);
+                }
             }
-            // task -> doc 关系
-            const taskDocRels = this.getOutRelations(mt.id, RT.TASK_HAS_DOC);
-            for (const rel of taskDocRels) {
-                edges.push({
-                    from: mt.id,
-                    to: rel.target,
-                    label: RT.TASK_HAS_DOC,
-                });
+            this.graph.flush();
+            const updated = this.graph.getEntity(existingDup.id);
+            return this.entityToMemory(updated || existingDup);
+        }
+        // ---- 新建记忆 ----
+        const entityName = `Memory: ${input.memoryType} — ${input.content.slice(0, 40)}`;
+        const entity = this.graph.addEntity(entityName, ET.MEMORY, {
+            projectName: this.projectName,
+            memoryType: input.memoryType,
+            content: input.content,
+            tags: input.tags || [],
+            relatedTaskId: input.relatedTaskId || null,
+            sourceId: input.sourceId || null,
+            importance: input.importance ?? 0.5,
+            hitCount: 0,
+            lastAccessedAt: null,
+            createdAt: now,
+            updatedAt: now,
+        });
+        // project → memory 关系
+        this.graph.putRelation(this.getProjectId(), entity.id, RT.HAS_MEMORY);
+        // memory → task 关系（可选）
+        if (input.relatedTaskId) {
+            const taskEntity = this.findEntityByProp(ET.MAIN_TASK, 'taskId', input.relatedTaskId);
+            if (taskEntity) {
+                this.graph.putRelation(entity.id, taskEntity.id, RT.MEMORY_FROM_TASK);
             }
         }
-        // 文档节点
-        if (includeDocuments) {
-            const docs = this.listSections();
-            for (const doc of docs) {
-                nodes.push({
-                    id: doc.id,
-                    label: doc.title,
-                    type: 'document',
-                    properties: {
-                        section: doc.section,
-                        subSection: doc.subSection,
-                        version: doc.version,
-                        parentDoc: doc.parentDoc || null,
-                        childDocs: doc.childDocs || [],
-                    },
+        // 向量索引（如启用语义搜索）
+        let embedding = null;
+        if (this.semanticSearchReady && this.synapse) {
+            try {
+                embedding = this.synapse.embed(input.content);
+                this.graph.indexEntity(entity.id, embedding);
+            }
+            catch (e) {
+                console.warn(`[DevPlan] Failed to index memory ${entity.id}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        // ---- Phase-37: 自动建立记忆间关联（MEMORY_RELATES） ----
+        if (embedding && this.semanticSearchReady) {
+            this.autoLinkSimilarMemories(entity.id, embedding);
+        }
+        // ---- Phase-37: 从文档生成的记忆自动建立 MEMORY_FROM_DOC 关系 ----
+        if (input.sourceId) {
+            this.autoLinkMemoryToDoc(entity.id, input.sourceId);
+        }
+        // ---- Phase-37: 模块级记忆自动建立 MODULE_MEMORY 关系 ----
+        if (input.moduleId) {
+            this.autoLinkMemoryToModule(entity.id, input.moduleId);
+        }
+        this.graph.flush();
+        return this.entityToMemory(entity);
+    }
+    /**
+     * Phase-37→44: 自动建立记忆间语义关联
+     *
+     * 用向量搜索找到最相似的 N 条已有记忆（minScore >= 0.7），
+     * 建立 MEMORY_RELATES 双向关系，权重为 similarity score。
+     *
+     * Phase-44: 使用 applyMutations 批量创建关系（单次 Rust 调用），
+     * 替代逐条 putRelation 的多次跨层调用。
+     */
+    autoLinkSimilarMemories(newMemoryId, embedding, maxLinks = 3, minScore = 0.7) {
+        try {
+            const hits = this.graph.searchEntitiesByVector(embedding, maxLinks + 5, ET.MEMORY);
+            // 收集需要创建的关系
+            const relationsToCreate = [];
+            for (const hit of hits) {
+                if (relationsToCreate.length >= maxLinks)
+                    break;
+                if (hit.entityId === newMemoryId)
+                    continue;
+                if (hit.score < minScore)
+                    continue;
+                const target = this.graph.getEntity(hit.entityId);
+                if (!target)
+                    continue;
+                const p = target.properties;
+                if (p.projectName !== this.projectName)
+                    continue;
+                relationsToCreate.push({ targetId: hit.entityId, score: hit.score });
+            }
+            if (relationsToCreate.length === 0)
+                return;
+            // Phase-44: 尝试使用 applyMutations 批量创建（单次 Rust 调用）
+            const g = this.graph;
+            if (typeof g.applyMutations === 'function') {
+                const mutations = [];
+                for (const { targetId, score } of relationsToCreate) {
+                    // 正向关系
+                    mutations.push({
+                        type: 'PutRelation',
+                        relation: {
+                            source: newMemoryId,
+                            target: targetId,
+                            relation_type: RT.MEMORY_RELATES,
+                            weight: score,
+                        },
+                    });
+                    // 反向关系（双向）
+                    mutations.push({
+                        type: 'PutRelation',
+                        relation: {
+                            source: targetId,
+                            target: newMemoryId,
+                            relation_type: RT.MEMORY_RELATES,
+                            weight: score,
+                        },
+                    });
+                }
+                g.applyMutations(mutations).catch((e) => {
+                    console.warn(`[DevPlan] applyMutations for memory links failed: ${e}`);
+                });
+            }
+            else {
+                // Fallback: 逐条创建
+                for (const { targetId, score } of relationsToCreate) {
+                    this.graph.putRelation(newMemoryId, targetId, RT.MEMORY_RELATES, score, true);
+                }
+            }
+            console.log(`[DevPlan] Memory ${newMemoryId.slice(0, 8)}... auto-linked to ${relationsToCreate.length} similar memories`);
+        }
+        catch (e) {
+            console.warn(`[DevPlan] autoLinkSimilarMemories failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    /**
+     * Phase-37: 从文档生成的记忆自动建立 MEMORY_FROM_DOC 关系
+     *
+     * 当 sourceId 格式为 "section" 或 "section|subSection" 时，
+     * 找到对应的文档 Entity 并建立 MEMORY_FROM_DOC 关系。
+     */
+    autoLinkMemoryToDoc(memoryId, sourceId) {
+        try {
+            // sourceId 格式："section" 或 "section|subSection"
+            // 任务格式："phase-7"（以 phase- 或 T 开头的不是文档）
+            if (sourceId.startsWith('phase-') || sourceId.startsWith('T'))
+                return;
+            // 解析 section 和 subSection
+            const parts = sourceId.split('|');
+            const section = parts[0];
+            const subSection = parts[1];
+            // 查找文档 Entity
+            const docs = this.findEntitiesByType(ET.DOC);
+            const docEntity = docs.find((e) => {
+                const p = e.properties;
+                if (p.projectName !== this.projectName)
+                    return false;
+                if (p.section !== section)
+                    return false;
+                if (subSection && p.subSection !== subSection)
+                    return false;
+                if (!subSection && p.subSection)
+                    return false;
+                return true;
+            });
+            if (docEntity) {
+                this.graph.putRelation(docEntity.id, memoryId, RT.MEMORY_FROM_DOC);
+            }
+        }
+        catch (e) {
+            console.warn(`[DevPlan] autoLinkMemoryToDoc failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    /**
+     * Phase-37: 模块级记忆自动建立 MODULE_MEMORY 关系
+     */
+    autoLinkMemoryToModule(memoryId, moduleId) {
+        try {
+            const modEntity = this.findEntityByProp(ET.MODULE, 'moduleId', moduleId);
+            if (modEntity) {
+                this.graph.putRelation(modEntity.id, memoryId, RT.MODULE_MEMORY);
+            }
+        }
+        catch (e) {
+            console.warn(`[DevPlan] autoLinkMemoryToModule failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    /**
+     * 查找重复记忆 — 按 relatedTaskId + memoryType 或内容指纹去重
+     *
+     * 匹配规则（任一命中即视为重复）：
+     * 1. 相同 relatedTaskId + 相同 memoryType
+     * 2. 内容前 80 字符指纹相同 + 相同 memoryType
+     */
+    findDuplicateMemory(input) {
+        const allMemories = this.findEntitiesByType(ET.MEMORY);
+        const inputFingerprint = input.content.slice(0, 80).toLowerCase().trim();
+        for (const e of allMemories) {
+            const p = e.properties;
+            if (p.projectName !== this.projectName)
+                continue;
+            if (p.memoryType !== input.memoryType)
+                continue;
+            // 规则 1: 相同 relatedTaskId
+            if (input.relatedTaskId && p.relatedTaskId === input.relatedTaskId) {
+                return e;
+            }
+            // 规则 2: 内容指纹相同
+            const existingFingerprint = (p.content || '').slice(0, 80).toLowerCase().trim();
+            if (inputFingerprint.length > 10 && existingFingerprint === inputFingerprint) {
+                return e;
+            }
+        }
+        return null;
+    }
+    /**
+     * 智能召回记忆 — 语义向量搜索 + 图谱遍历扩展 + RRF 融合
+     *
+     * Phase-38 增强: 向量搜索结果沿 MEMORY_RELATES 关系扩展，发现关联记忆。
+     * 如语义搜索不可用，退化为字面匹配。
+     * 命中的记忆自动更新 hitCount 和 lastAccessedAt。
+     */
+    recallMemory(query, options) {
+        const limit = options?.limit || 10;
+        const minScore = options?.minScore || 0;
+        const includeDocs = options?.includeDocs !== false; // 默认 true
+        const graphExpand = options?.graphExpand !== false; // 默认 true
+        const now = Date.now();
+        // ---- 1. 记忆召回（向量搜索） ----
+        let memoryResults = [];
+        // 尝试语义搜索
+        if (this.semanticSearchReady && this.synapse) {
+            try {
+                const embedding = this.synapse.embed(query);
+                const hits = this.graph.searchEntitiesByVector(embedding, limit * 3, ET.MEMORY);
+                for (const hit of hits) {
+                    if (minScore > 0 && hit.score < minScore)
+                        continue;
+                    const entity = this.graph.getEntity(hit.entityId);
+                    if (!entity)
+                        continue;
+                    const p = entity.properties;
+                    if (p.projectName !== this.projectName)
+                        continue;
+                    if (options?.memoryType && p.memoryType !== options.memoryType)
+                        continue;
+                    // 更新访问统计
+                    this.graph.updateEntity(entity.id, {
+                        properties: {
+                            ...p,
+                            hitCount: (p.hitCount || 0) + 1,
+                            lastAccessedAt: now,
+                        },
+                    });
+                    memoryResults.push({
+                        ...this.entityToMemory(entity),
+                        hitCount: (p.hitCount || 0) + 1,
+                        lastAccessedAt: now,
+                        score: hit.score,
+                        sourceKind: 'memory',
+                    });
+                    if (memoryResults.length >= limit)
+                        break;
+                }
+                if (memoryResults.length > 0) {
+                    this.graph.flush();
+                }
+            }
+            catch (e) {
+                console.warn(`[DevPlan] Semantic memory recall failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        // 如果语义搜索无结果，fallback 到字面匹配
+        if (memoryResults.length === 0) {
+            const entities = this.findEntitiesByType(ET.MEMORY);
+            const queryLower = query.toLowerCase();
+            for (const e of entities) {
+                const p = e.properties;
+                if (p.projectName !== this.projectName)
+                    continue;
+                if (options?.memoryType && p.memoryType !== options.memoryType)
+                    continue;
+                const content = (p.content || '').toLowerCase();
+                const tags = (p.tags || []).join(' ').toLowerCase();
+                if (content.includes(queryLower) || tags.includes(queryLower)) {
+                    this.graph.updateEntity(e.id, {
+                        properties: {
+                            ...p,
+                            hitCount: (p.hitCount || 0) + 1,
+                            lastAccessedAt: now,
+                        },
+                    });
+                    memoryResults.push({
+                        ...this.entityToMemory(e),
+                        hitCount: (p.hitCount || 0) + 1,
+                        lastAccessedAt: now,
+                        score: 0.5,
+                        sourceKind: 'memory',
+                    });
+                }
+            }
+            memoryResults.sort((a, b) => b.importance - a.importance);
+            memoryResults = memoryResults.slice(0, limit);
+            if (memoryResults.length > 0) {
+                this.graph.flush();
+            }
+        }
+        // ---- 1.5 Phase-38: 图谱关联扩展 ----
+        if (graphExpand && memoryResults.length > 0) {
+            const graphExpanded = this.expandMemoriesByGraph(memoryResults, options?.memoryType, limit);
+            if (graphExpanded.length > 0) {
+                // 用 RRF 融合向量结果和图谱扩展结果
+                memoryResults = this.rrfMergeMemories(memoryResults, graphExpanded, limit);
+            }
+        }
+        // ---- 1.6 Phase-44: 赫布学习 — 共同激活的记忆自动增强连接 ----
+        if (memoryResults.length >= 2) {
+            this.hebbianStrengthen(memoryResults.filter(m => m.sourceKind === 'memory'));
+        }
+        // ---- 2. 文档召回（统一召回） ----
+        if (!includeDocs || options?.memoryType) {
+            // 如果不需要文档或指定了 memoryType 过滤，直接返回记忆结果
+            return memoryResults;
+        }
+        let docResults = [];
+        try {
+            const docHits = this.searchSectionsAdvanced(query, {
+                mode: this.semanticSearchReady ? 'hybrid' : 'literal',
+                limit: Math.max(5, Math.floor(limit / 2)),
+                minScore: minScore > 0 ? minScore : undefined,
+            });
+            for (const doc of docHits) {
+                // 将文档结果包装为 ScoredMemory 格式（统一接口）
+                const contentSnippet = (doc.content || '').substring(0, 300);
+                docResults.push({
+                    id: `doc:${doc.section}${doc.subSection ? '|' + doc.subSection : ''}`,
+                    projectName: this.projectName,
+                    memoryType: this.docSectionToMemoryType(doc.section),
+                    content: contentSnippet + (doc.content && doc.content.length > 300 ? '...' : ''),
+                    tags: [doc.section, ...(doc.subSection ? [doc.subSection] : [])],
+                    relatedTaskId: undefined,
+                    importance: 0.6,
+                    hitCount: 0,
+                    lastAccessedAt: null,
+                    createdAt: doc.updatedAt || 0,
+                    updatedAt: doc.updatedAt || 0,
+                    score: doc.score || 0.4,
+                    sourceKind: 'doc',
+                    docSection: doc.section,
+                    docSubSection: doc.subSection || undefined,
+                    docTitle: doc.title,
+                });
+            }
+        }
+        catch (e) {
+            console.warn(`[DevPlan] Document recall failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        // ---- 3. RRF 融合排序 ----
+        if (docResults.length === 0)
+            return memoryResults;
+        if (memoryResults.length === 0)
+            return docResults.slice(0, limit);
+        return this.rrfMergeResults(memoryResults, docResults, limit);
+    }
+    /**
+     * 文档 section 类型 → 建议的 memoryType 映射
+     */
+    docSectionToMemoryType(section) {
+        const mapping = {
+            overview: 'summary',
+            core_concepts: 'insight',
+            api_design: 'pattern',
+            technical_notes: 'insight',
+            config: 'preference',
+            examples: 'pattern',
+            changelog: 'summary',
+            milestones: 'summary',
+        };
+        return mapping[section] || 'insight';
+    }
+    /**
+     * RRF (Reciprocal Rank Fusion) 合并记忆和文档结果
+     *
+     * 记忆权重略高（rank 常数更小），因为记忆是经过提炼的知识。
+     */
+    rrfMergeResults(memoryResults, docResults, limit) {
+        const k_memory = 30; // 记忆 RRF 常数（越小权重越高）
+        const k_doc = 50; // 文档 RRF 常数
+        const scoreMap = new Map();
+        for (let i = 0; i < memoryResults.length; i++) {
+            const item = memoryResults[i];
+            const rrfScore = 1.0 / (k_memory + i + 1);
+            scoreMap.set(item.id, { item, rrfScore });
+        }
+        for (let i = 0; i < docResults.length; i++) {
+            const item = docResults[i];
+            const rrfScore = 1.0 / (k_doc + i + 1);
+            const existing = scoreMap.get(item.id);
+            if (existing) {
+                existing.rrfScore += rrfScore;
+            }
+            else {
+                scoreMap.set(item.id, { item, rrfScore });
+            }
+        }
+        // Phase-39: 对记忆类结果施加热度加权（文档不受影响）
+        const merged = Array.from(scoreMap.values())
+            .map(({ item, rrfScore }) => {
+            if (item.sourceKind === 'memory' || !item.sourceKind) {
+                const hotness = this.computeMemoryHotness(item);
+                const hotnessMultiplier = 0.5 + hotness; // [0.5, 1.5]
+                return { item, rrfScore: rrfScore * hotnessMultiplier };
+            }
+            return { item, rrfScore };
+        })
+            .sort((a, b) => b.rrfScore - a.rrfScore)
+            .slice(0, limit)
+            .map(({ item, rrfScore }) => ({ ...item, score: rrfScore }));
+        return merged;
+    }
+    /**
+     * Phase-38→44: 沿 MEMORY_RELATES 图谱关系扩展发现关联记忆
+     *
+     * Phase-44 增强: 优先使用 extractSubgraph 在 Rust 层完成 N-hop 遍历，
+     * 避免 JS 层逐跳手动查询的 N 次跨层调用开销。
+     *
+     * 从向量搜索命中的记忆出发，沿 MEMORY_RELATES 关系探索 1-2 跳，
+     * 发现未被向量搜索直接命中但图谱关联的记忆。
+     * 关联分数 = 原始记忆分数 × 关系权重^depth × 衰减因子
+     */
+    expandMemoriesByGraph(seedMemories, memoryType, limit = 10) {
+        const g = this.graph;
+        // Phase-44: 优先使用 extractSubgraph — 单次 Rust 调用完成 N-hop 遍历
+        if (typeof g.extractSubgraph === 'function') {
+            return this.expandMemoriesBySubgraph(seedMemories, memoryType, limit);
+        }
+        // Fallback: 手动逐跳遍历（旧版 aifastdb 兼容）
+        return this.expandMemoriesByManualTraversal(seedMemories, memoryType, limit);
+    }
+    /**
+     * Phase-44: 用 extractSubgraph 实现高效图谱扩展
+     *
+     * 对每个种子记忆调用 extractSubgraph(seedId, {max_hops:2, direction:'both',
+     * relation_type_filter:['memory_relates'], entity_type_filter:['devplan-memory']}),
+     * Rust 层在分片内一次性完成 BFS 遍历，返回子图的 entities + depth_map。
+     */
+    expandMemoriesBySubgraph(seedMemories, memoryType, limit = 10) {
+        const g = this.graph;
+        const seenIds = new Set(seedMemories.map((m) => m.id));
+        const expanded = [];
+        const hopDecay = 0.7;
+        for (const seed of seedMemories.slice(0, 5)) {
+            try {
+                const subgraph = g.extractSubgraph(seed.id, {
+                    max_hops: 2,
+                    direction: 'both',
+                    relation_type_filter: [RT.MEMORY_RELATES],
+                    entity_type_filter: [ET.MEMORY],
+                    max_nodes: limit * 2,
+                });
+                if (!subgraph || !subgraph.entities || !subgraph.depth_map)
+                    continue;
+                // 遍历子图中的实体，按 depth 计算衰减分数
+                const entityEntries = Object.entries(subgraph.entities);
+                for (const [entityId, entity] of entityEntries) {
+                    if (seenIds.has(entityId))
+                        continue;
+                    if (!entity)
+                        continue;
+                    const p = entity.properties || {};
+                    if (p.projectName !== this.projectName)
+                        continue;
+                    if (memoryType && p.memoryType !== memoryType)
+                        continue;
+                    seenIds.add(entityId);
+                    const depth = subgraph.depth_map[entityId] || 1;
+                    const expandedScore = seed.score * Math.pow(hopDecay, depth);
+                    expanded.push({
+                        ...this.entityToMemory(entity),
+                        score: expandedScore,
+                        sourceKind: 'memory',
+                    });
+                    if (expanded.length >= limit)
+                        break;
+                }
+            }
+            catch (e) {
+                console.warn(`[DevPlan] extractSubgraph failed for ${seed.id}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            if (expanded.length >= limit)
+                break;
+        }
+        return expanded;
+    }
+    /**
+     * Phase-38 原始实现: 手动逐跳遍历（Fallback）
+     */
+    expandMemoriesByManualTraversal(seedMemories, memoryType, limit = 10) {
+        const seenIds = new Set(seedMemories.map((m) => m.id));
+        const expanded = [];
+        const hopDecay = 0.7;
+        for (const seed of seedMemories.slice(0, 5)) {
+            const outRels = this.getOutRelations(seed.id, RT.MEMORY_RELATES);
+            const inRels = this.getInRelations(seed.id, RT.MEMORY_RELATES);
+            const allRels = [...outRels, ...inRels];
+            for (const rel of allRels) {
+                const neighborId = rel.source === seed.id ? rel.target : rel.source;
+                if (seenIds.has(neighborId))
+                    continue;
+                const neighbor = this.graph.getEntity(neighborId);
+                if (!neighbor)
+                    continue;
+                const p = neighbor.properties;
+                if (p.projectName !== this.projectName)
+                    continue;
+                if (memoryType && p.memoryType !== memoryType)
+                    continue;
+                seenIds.add(neighborId);
+                const relWeight = rel.weight || 0.5;
+                const expandedScore = seed.score * relWeight * hopDecay;
+                expanded.push({
+                    ...this.entityToMemory(neighbor),
+                    score: expandedScore,
+                    sourceKind: 'memory',
+                });
+                if (expanded.length >= limit)
+                    break;
+                // 2跳
+                const hop2OutRels = this.getOutRelations(neighborId, RT.MEMORY_RELATES);
+                const hop2InRels = this.getInRelations(neighborId, RT.MEMORY_RELATES);
+                for (const hop2Rel of [...hop2OutRels, ...hop2InRels]) {
+                    const hop2Id = hop2Rel.source === neighborId ? hop2Rel.target : hop2Rel.source;
+                    if (seenIds.has(hop2Id))
+                        continue;
+                    const hop2Entity = this.graph.getEntity(hop2Id);
+                    if (!hop2Entity)
+                        continue;
+                    const hp = hop2Entity.properties;
+                    if (hp.projectName !== this.projectName)
+                        continue;
+                    if (memoryType && hp.memoryType !== memoryType)
+                        continue;
+                    seenIds.add(hop2Id);
+                    const hop2Weight = hop2Rel.weight || 0.5;
+                    const hop2Score = expandedScore * hop2Weight * hopDecay;
+                    expanded.push({
+                        ...this.entityToMemory(hop2Entity),
+                        score: hop2Score,
+                        sourceKind: 'memory',
+                    });
+                    if (expanded.length >= limit)
+                        break;
+                }
+            }
+            if (expanded.length >= limit)
+                break;
+        }
+        return expanded;
+    }
+    /**
+     * Phase-44: 赫布学习 — 共同激活的记忆自动增强连接权重
+     *
+     * "Neurons that fire together, wire together."
+     * 当多条记忆在同一次召回中被共同激活，增强它们之间 MEMORY_RELATES 关系的权重。
+     *
+     * - 使用 adjustRelationWeight（Rust 原子操作），delta = +0.05
+     * - 仅增强已有 MEMORY_RELATES 连接（不创建新连接）
+     * - 上限 top5 记忆的 C(5,2) = 10 对，避免大量关系更新
+     */
+    hebbianStrengthen(coActivatedMemories) {
+        const g = this.graph;
+        if (typeof g.adjustRelationWeight !== 'function')
+            return;
+        if (coActivatedMemories.length < 2)
+            return;
+        const HEBBIAN_DELTA = 0.05;
+        const top = coActivatedMemories.slice(0, 5); // 最多取 top5
+        // 遍历所有对，检查是否有 MEMORY_RELATES 连接
+        for (let i = 0; i < top.length; i++) {
+            for (let j = i + 1; j < top.length; j++) {
+                const a = top[i].id;
+                const b = top[j].id;
+                // 检查 a→b 或 b→a 是否有 MEMORY_RELATES 关系
+                const outRels = this.getOutRelations(a, RT.MEMORY_RELATES);
+                const rel = outRels.find((r) => r.target === b);
+                if (rel) {
+                    g.adjustRelationWeight(rel.id, a, HEBBIAN_DELTA).catch(() => { });
+                }
+                // 检查反向 b→a
+                const reverseRels = this.getOutRelations(b, RT.MEMORY_RELATES);
+                const reverseRel = reverseRels.find((r) => r.target === a);
+                if (reverseRel) {
+                    g.adjustRelationWeight(reverseRel.id, b, HEBBIAN_DELTA).catch(() => { });
+                }
+            }
+        }
+    }
+    /**
+     * Phase-39: 计算记忆热度分数 — 模拟遗忘曲线
+     *
+     * 综合 hitCount + 时间衰减 + importance，输出 0~1 的热度值。
+     * - 高频访问 + 近期访问 → 热度高
+     * - 长期未访问 → 热度衰减（半衰期 7 天）
+     * - importance 作为基线加成
+     */
+    computeMemoryHotness(memory) {
+        const now = Date.now();
+        const HALF_LIFE_MS = 7 * 24 * 60 * 60 * 1000; // 7天半衰期
+        const LN2 = Math.LN2;
+        // 时间衰减：基于最后访问时间（如无访问则用创建时间）
+        const lastAccess = memory.lastAccessedAt || memory.createdAt;
+        const elapsed = Math.max(0, now - lastAccess);
+        const timeDecay = Math.exp(-(LN2 / HALF_LIFE_MS) * elapsed); // 0~1
+        // 频率分数：hitCount 的对数缩放，避免过高值主导
+        const freqScore = Math.min(1, Math.log2(1 + (memory.hitCount || 0)) / 5); // log2(32)/5 = 1.0
+        // importance 基线 (0~1)
+        const importanceBase = memory.importance || 0.5;
+        // 综合: importance 40% + frequency 30% + recency 30%
+        return importanceBase * 0.4 + freqScore * 0.3 + timeDecay * 0.3;
+    }
+    /**
+     * Phase-38 + Phase-39: RRF 融合记忆向量搜索结果和图谱扩展结果
+     *
+     * Phase-39 增强：热度加权融合 — 每条记忆的 RRF 分数乘以热度系数（0.5~1.5），
+     * 高频+近期记忆获得排序提升，冷门记忆自动下沉。
+     */
+    rrfMergeMemories(vectorResults, graphResults, limit) {
+        const k_vector = 20; // 向量搜索 RRF 常数（权重更高）
+        const k_graph = 40; // 图谱扩展 RRF 常数
+        const scoreMap = new Map();
+        for (let i = 0; i < vectorResults.length; i++) {
+            const item = vectorResults[i];
+            const rrfScore = 1.0 / (k_vector + i + 1);
+            scoreMap.set(item.id, { item, rrfScore });
+        }
+        for (let i = 0; i < graphResults.length; i++) {
+            const item = graphResults[i];
+            const rrfScore = 1.0 / (k_graph + i + 1);
+            const existing = scoreMap.get(item.id);
+            if (existing) {
+                existing.rrfScore += rrfScore;
+            }
+            else {
+                scoreMap.set(item.id, { item, rrfScore });
+            }
+        }
+        // Phase-39: 热度加权 — hotness 映射到 [0.5, 1.5] 的乘法系数
+        return Array.from(scoreMap.values())
+            .map(({ item, rrfScore }) => {
+            const hotness = this.computeMemoryHotness(item);
+            const hotnessMultiplier = 0.5 + hotness; // [0.5, 1.5]
+            return { item, rrfScore: rrfScore * hotnessMultiplier };
+        })
+            .sort((a, b) => b.rrfScore - a.rrfScore)
+            .slice(0, limit)
+            .map(({ item, rrfScore }) => ({ ...item, score: rrfScore }));
+    }
+    /**
+     * 列出记忆（支持过滤）
+     */
+    listMemories(filter) {
+        // 如果按关联任务过滤，通过关系查询
+        if (filter?.relatedTaskId) {
+            return this.getTaskRelatedMemories(filter.relatedTaskId, filter);
+        }
+        const entities = this.findEntitiesByType(ET.MEMORY);
+        let memories = entities
+            .filter((e) => {
+            const p = e.properties;
+            if (p.projectName !== this.projectName)
+                return false;
+            if (filter?.memoryType && p.memoryType !== filter.memoryType)
+                return false;
+            return true;
+        })
+            .map((e) => this.entityToMemory(e));
+        // 按 updatedAt 降序排列（最新的在前）
+        memories.sort((a, b) => b.updatedAt - a.updatedAt);
+        if (filter?.limit && filter.limit > 0) {
+            memories = memories.slice(0, filter.limit);
+        }
+        return memories;
+    }
+    /**
+     * 删除一条记忆
+     */
+    deleteMemory(memoryId) {
+        try {
+            const entity = this.graph.getEntity(memoryId);
+            if (!entity || entity.entity_type !== ET.MEMORY)
+                return false;
+            const p = entity.properties;
+            if (p.projectName !== this.projectName)
+                return false;
+            this.graph.deleteEntity(memoryId);
+            this.graph.flush();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 批量清除当前项目的所有记忆
+     *
+     * @param memoryType - 可选：仅清除指定类型的记忆。省略则清除所有。
+     * @returns { deleted: number } 实际删除的数量
+     */
+    clearAllMemories(memoryType) {
+        const entities = this.findEntitiesByType(ET.MEMORY);
+        const toDelete = entities.filter((e) => {
+            const p = e.properties;
+            if (p.projectName !== this.projectName)
+                return false;
+            if (memoryType && p.memoryType !== memoryType)
+                return false;
+            return true;
+        });
+        let deleted = 0;
+        for (const e of toDelete) {
+            try {
+                this.graph.deleteEntity(e.id);
+                deleted++;
+            }
+            catch {
+                // 跳过单条删除失败
+            }
+        }
+        if (deleted > 0) {
+            this.graph.flush();
+        }
+        return { deleted };
+    }
+    /**
+     * 获取新会话上下文 — 核心工具
+     *
+     * 聚合以下信息为 Cursor 提供全面的项目上下文：
+     * 1. 最近的 in_progress / completed 主任务
+     * 2. 与查询相关的记忆（语义召回）
+     * 3. 所有 preference 类型记忆
+     * 4. 最近的 decision 类型记忆
+     */
+    getMemoryContext(query, maxMemories) {
+        const limit = maxMemories || 10;
+        // 1. 最近任务
+        const allTasks = this.listMainTasks();
+        const recentTasks = allTasks
+            .filter((t) => t.status === 'in_progress' || t.status === 'completed')
+            .sort((a, b) => (b.completedAt || b.updatedAt) - (a.completedAt || a.updatedAt))
+            .slice(0, 5)
+            .map((t) => ({
+            taskId: t.taskId,
+            title: t.title,
+            status: t.status,
+            completedAt: t.completedAt,
+        }));
+        // 2. 相关记忆（统一召回：同时搜索记忆 + 文档）
+        let relevantMemories = [];
+        if (query) {
+            relevantMemories = this.recallMemory(query, { limit, includeDocs: true });
+        }
+        // 3. 项目偏好
+        const projectPreferences = this.listMemories({ memoryType: 'preference' });
+        // 4. 最近决策
+        const recentDecisions = this.listMemories({ memoryType: 'decision', limit: 5 });
+        // 5. 总记忆数
+        const allMemories = this.findEntitiesByType(ET.MEMORY);
+        const totalMemories = allMemories.filter((e) => e.properties.projectName === this.projectName).length;
+        // 6. 关键文档摘要（自动纳入 overview / core_concepts）
+        const relatedDocs = [];
+        const KEY_SECTIONS = ['overview', 'core_concepts'];
+        const DOC_SUMMARY_MAX_LEN = 500;
+        try {
+            const allSections = this.listSections();
+            for (const sec of allSections) {
+                if (KEY_SECTIONS.includes(sec.section)) {
+                    const doc = this.getSection(sec.section, sec.subSection);
+                    if (doc && doc.content) {
+                        const summary = doc.content.length > DOC_SUMMARY_MAX_LEN
+                            ? doc.content.substring(0, DOC_SUMMARY_MAX_LEN) + '...'
+                            : doc.content;
+                        relatedDocs.push({
+                            section: doc.section,
+                            subSection: doc.subSection || undefined,
+                            title: doc.title,
+                            summary,
+                        });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // 非关键路径，忽略错误
+        }
+        // 7. Phase-38: 模块级关联记忆 — 图谱遍历 in_progress 任务 → 模块 → MODULE_MEMORY
+        const moduleMemories = this.getModuleMemoriesFromActiveTasks(recentTasks);
+        // 8. Phase-40: 记忆主题集群概览（仅摘要，不含完整记忆）
+        let memoryClusters;
+        try {
+            const clusters = this.getMemoryClusters();
+            // 只保留有意义的集群（2条以上记忆，排除 uncategorized）
+            const significantClusters = clusters
+                .filter((c) => c.clusterId > 0 && c.memoryCount >= 2)
+                .map((c) => ({
+                clusterId: c.clusterId,
+                theme: c.theme,
+                memoryCount: c.memoryCount,
+                topMemoryTypes: c.topMemoryTypes,
+            }));
+            if (significantClusters.length > 0) {
+                memoryClusters = significantClusters;
+            }
+        }
+        catch (_e) {
+            // 非关键路径，忽略错误
+        }
+        return {
+            projectName: this.projectName,
+            recentTasks,
+            relevantMemories,
+            projectPreferences,
+            recentDecisions,
+            totalMemories,
+            relatedDocs: relatedDocs.length > 0 ? relatedDocs : undefined,
+            moduleMemories: moduleMemories.length > 0 ? moduleMemories : undefined,
+            memoryClusters,
+        };
+    }
+    /**
+     * Phase-38: 从进行中的任务出发，通过图谱遍历获取模块级记忆
+     *
+     * 路径: in_progress task → MODULE_HAS_TASK(反向) → module → MODULE_MEMORY → memories
+     */
+    getModuleMemoriesFromActiveTasks(recentTasks) {
+        const results = [];
+        const seenModuleIds = new Set();
+        // 只从 in_progress 任务出发
+        const activeTasks = recentTasks.filter((t) => t.status === 'in_progress');
+        for (const task of activeTasks) {
+            const taskEntity = this.findEntityByProp(ET.MAIN_TASK, 'taskId', task.taskId);
+            if (!taskEntity)
+                continue;
+            // 查找该任务所属的模块（反向: module → MODULE_HAS_TASK → task）
+            const inRels = this.getInRelations(taskEntity.id, RT.MODULE_HAS_TASK);
+            for (const rel of inRels) {
+                const moduleEntity = this.graph.getEntity(rel.source);
+                if (!moduleEntity)
+                    continue;
+                const mp = moduleEntity.properties;
+                const moduleId = mp.moduleId;
+                if (!moduleId || seenModuleIds.has(moduleId))
+                    continue;
+                seenModuleIds.add(moduleId);
+                // 获取模块下的所有记忆（module → MODULE_MEMORY → memory）
+                const memRels = this.getOutRelations(moduleEntity.id, RT.MODULE_MEMORY);
+                const memories = [];
+                for (const memRel of memRels) {
+                    const memEntity = this.graph.getEntity(memRel.target);
+                    if (!memEntity)
+                        continue;
+                    const memP = memEntity.properties;
+                    if (memP.projectName !== this.projectName)
+                        continue;
+                    memories.push(this.entityToMemory(memEntity));
+                }
+                if (memories.length > 0) {
+                    results.push({
+                        moduleId,
+                        moduleName: mp.name || moduleId,
+                        memories: memories.slice(0, 10), // 每模块最多10条
+                    });
+                }
+            }
+        }
+        return results;
+    }
+    // ============================================================================
+    // Phase-40: 记忆主题集群 — 基于 MEMORY_RELATES 连通分量聚类
+    // ============================================================================
+    /**
+     * Phase-40: 获取记忆主题集群
+     *
+     * 基于 MEMORY_RELATES 关系图的连通分量检测，自动将语义关联的记忆
+     * 聚合为主题集群。每个集群包含一个自动生成的主题标签和成员记忆列表。
+     *
+     * 算法：BFS 连通分量检测（适合中小规模记忆网络）
+     */
+    getMemoryClusters() {
+        // 1. 获取所有本项目的记忆
+        const allEntities = this.findEntitiesByType(ET.MEMORY);
+        const projectMemories = allEntities.filter((e) => e.properties.projectName === this.projectName);
+        if (projectMemories.length === 0)
+            return [];
+        // 2. 构建邻接表（基于 MEMORY_RELATES 关系）
+        const adjacency = new Map();
+        for (const mem of projectMemories) {
+            adjacency.set(mem.id, new Set());
+        }
+        for (const mem of projectMemories) {
+            const outRels = this.getOutRelations(mem.id, RT.MEMORY_RELATES);
+            const inRels = this.getInRelations(mem.id, RT.MEMORY_RELATES);
+            for (const rel of [...outRels, ...inRels]) {
+                const neighborId = rel.source === mem.id ? rel.target : rel.source;
+                if (adjacency.has(neighborId)) {
+                    adjacency.get(mem.id).add(neighborId);
+                    adjacency.get(neighborId).add(mem.id);
+                }
+            }
+        }
+        // 3. BFS 连通分量检测
+        const visited = new Set();
+        const components = [];
+        for (const mem of projectMemories) {
+            if (visited.has(mem.id))
+                continue;
+            const component = [];
+            const queue = [mem.id];
+            visited.add(mem.id);
+            while (queue.length > 0) {
+                const current = queue.shift();
+                component.push(current);
+                const neighbors = adjacency.get(current) || new Set();
+                for (const neighbor of neighbors) {
+                    if (!visited.has(neighbor)) {
+                        visited.add(neighbor);
+                        queue.push(neighbor);
+                    }
+                }
+            }
+            components.push(component);
+        }
+        // 4. 转化为集群结果（按大小降序排列，孤立记忆归入"未分类"）
+        const clusters = [];
+        // 实体 ID → Memory 的快速查找
+        const entityMap = new Map(projectMemories.map((e) => [e.id, e]));
+        let clusterId = 0;
+        const isolatedMemories = [];
+        for (const component of components.sort((a, b) => b.length - a.length)) {
+            const memories = component
+                .map((id) => entityMap.get(id))
+                .filter(Boolean)
+                .map((e) => this.entityToMemory(e));
+            if (component.length <= 1) {
+                // 孤立记忆收集，后续归入"未分类"集群
+                isolatedMemories.push(...memories);
+                continue;
+            }
+            clusterId++;
+            // 统计 memoryType 分布，取出现最多的类型
+            const typeCounts = new Map();
+            for (const m of memories) {
+                typeCounts.set(m.memoryType, (typeCounts.get(m.memoryType) || 0) + 1);
+            }
+            const topMemoryTypes = Array.from(typeCounts.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 3)
+                .map(([t]) => t);
+            // 自动主题：取高频 tags + 高频 memoryType
+            const tagCounts = new Map();
+            for (const m of memories) {
+                for (const tag of m.tags || []) {
+                    tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+                }
+            }
+            const topTags = Array.from(tagCounts.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 3)
+                .map(([t]) => t);
+            const theme = topTags.length > 0
+                ? topTags.join(' / ')
+                : `${topMemoryTypes[0] || 'mixed'} cluster`;
+            clusters.push({
+                clusterId,
+                theme,
+                memoryCount: memories.length,
+                topMemoryTypes,
+                memories,
+            });
+        }
+        // 孤立记忆归入"未分类"集群（如果有的话）
+        if (isolatedMemories.length > 0) {
+            clusters.push({
+                clusterId: 0,
+                theme: 'uncategorized',
+                memoryCount: isolatedMemories.length,
+                topMemoryTypes: ['mixed'],
+                memories: isolatedMemories,
+            });
+        }
+        return clusters;
+    }
+    /**
+     * 获取任务关联的记忆
+     */
+    getTaskRelatedMemories(taskId, filter) {
+        const taskEntity = this.findEntityByProp(ET.MAIN_TASK, 'taskId', taskId);
+        if (!taskEntity)
+            return [];
+        // 查找所有指向该任务的 memory_from_task 关系（反向查询）
+        const allMemories = this.findEntitiesByType(ET.MEMORY);
+        const memories = [];
+        for (const e of allMemories) {
+            const p = e.properties;
+            if (p.projectName !== this.projectName)
+                continue;
+            if (p.relatedTaskId !== taskId)
+                continue;
+            if (filter?.memoryType && p.memoryType !== filter.memoryType)
+                continue;
+            memories.push(this.entityToMemory(e));
+        }
+        memories.sort((a, b) => b.updatedAt - a.updatedAt);
+        return memories;
+    }
+    /**
+     * Entity → Memory 转换
+     */
+    entityToMemory(e) {
+        const p = e.properties;
+        return {
+            id: e.id,
+            projectName: this.projectName,
+            memoryType: p.memoryType || 'insight',
+            content: p.content || '',
+            tags: p.tags || [],
+            relatedTaskId: p.relatedTaskId || undefined,
+            sourceId: p.sourceId || undefined,
+            importance: p.importance ?? 0.5,
+            hitCount: p.hitCount || 0,
+            lastAccessedAt: p.lastAccessedAt || null,
+            createdAt: p.createdAt || e.created_at,
+            updatedAt: p.updatedAt || p.createdAt || e.created_at,
+        };
+    }
+    // ==========================================================================
+    // Memory Generation (从文档/任务提取记忆候选项)
+    // ==========================================================================
+    /**
+     * 记忆生成器 — 从已有文档和已完成任务中提取记忆候选项
+     *
+     * 聚合逻辑：
+     * 1. 任务: 每个已完成阶段 → 1 条 summary 候选项（phase 标题 + 子任务列表）
+     * 2. 文档: 每篇文档 → 1 条候选项（section 类型 → 建议 memoryType 映射）
+     * 3. 去重: 检查已有记忆，已有记忆的候选项直接跳过不返回
+     *
+     * AI 收到候选项后，分析 content 并调用 devplan_memory_save 批量生成记忆。
+     */
+    // ============================================================================
+    // Phase-44: 记忆生命周期管理 — DynamicNode promote/demote
+    // ============================================================================
+    /**
+     * Phase-44: 运行记忆生命周期扫描 — 基于 DynamicNode 的 promote/demote
+     *
+     * 调用 SocialGraphV2 的 dynamicScan 对记忆实体执行生命周期管理：
+     * - promote: 长期未访问的高热度记忆恢复活跃
+     * - demote: 长期未召回的低价值记忆降级为 shadow 状态
+     * - shadow 记忆不参与向量搜索，但仍保留在图谱中
+     * - 被重新访问时通过 dynamicPromote 恢复
+     *
+     * @param config 配置选项
+     * @returns 扫描报告（promoted/demoted/scanned 计数）
+     */
+    runMemoryLifecycle(config) {
+        const g = this.graph;
+        if (typeof g.dynamicScan !== 'function') {
+            return null; // aifastdb 版本不支持
+        }
+        try {
+            const result = g.dynamicScan({
+                promote_hit_threshold: config?.promoteHitThreshold ?? 3,
+                demote_idle_timeout_secs: config?.demoteIdleTimeoutSecs ?? 2592000, // 30 天
+                scan_entity_types: [ET.MEMORY],
+                preserve_entity_types: [ET.PROJECT, ET.DOC, ET.MAIN_TASK, ET.SUB_TASK, ET.MODULE],
+            });
+            if (result && result.demoted > 0) {
+                // demoted 的记忆实体需要从向量索引中移除
+                // 以防止 shadow 记忆出现在搜索结果中
+                const allMemories = this.findEntitiesByType(ET.MEMORY);
+                for (const mem of allMemories) {
+                    const p = mem.properties;
+                    if (p.projectName !== this.projectName)
+                        continue;
+                    if (typeof g.isShadowEntity === 'function' && g.isShadowEntity(mem.id)) {
+                        try {
+                            this.graph.removeEntityVector(mem.id);
+                        }
+                        catch { /* entity might not have vector */ }
+                    }
+                }
+            }
+            return {
+                promoted: result?.promoted ?? 0,
+                demoted: result?.demoted ?? 0,
+                scanned: result?.scanned ?? 0,
+                durationMs: result?.duration_ms ?? 0,
+            };
+        }
+        catch (e) {
+            console.warn(`[DevPlan] runMemoryLifecycle failed: ${e instanceof Error ? e.message : String(e)}`);
+            return null;
+        }
+    }
+    generateMemoryCandidates(options) {
+        const source = options?.source || 'both';
+        const limit = options?.limit || 50;
+        // 获取已有记忆，用于去重检查
+        const existingMemories = this.listMemories ? this.listMemories() : [];
+        const memoryByTaskId = new Set();
+        const memoryBySourceId = new Set();
+        const memoryContentSet = new Set();
+        for (const m of existingMemories) {
+            if (m.relatedTaskId)
+                memoryByTaskId.add(m.relatedTaskId);
+            // Phase-35: sourceId 去重 — 最可靠的匹配方式
+            if (m.sourceId)
+                memoryBySourceId.add(m.sourceId);
+            // 用前 50 字符作内容指纹（fallback，对旧记忆仍有效）
+            memoryContentSet.add(m.content.slice(0, 50).toLowerCase());
+        }
+        const allEligible = [];
+        let totalCompletedPhases = 0;
+        let totalDocuments = 0;
+        let phasesWithMemory = 0;
+        let docsWithMemory = 0;
+        let skippedWithMemory = 0;
+        // ========== 任务来源 ==========
+        if (source === 'tasks' || source === 'both') {
+            const allTasks = this.listMainTasks();
+            const completedTasks = options?.taskId
+                ? allTasks.filter((t) => t.taskId === options.taskId)
+                : allTasks.filter((t) => t.status === 'completed');
+            totalCompletedPhases = completedTasks.length;
+            for (const task of completedTasks) {
+                // Phase-35: 三重去重检查 — sourceId > relatedTaskId > tags
+                const hasMemory = memoryBySourceId.has(task.taskId) || memoryByTaskId.has(task.taskId);
+                if (hasMemory) {
+                    phasesWithMemory++;
+                    skippedWithMemory++;
+                    continue; // 已有记忆 → 跳过不列出
+                }
+                // 聚合子任务列表
+                const subTasks = this.listSubTasks(task.taskId);
+                const subTaskLines = subTasks
+                    .map((st) => `  - [${st.status === 'completed' ? '✅' : '⬜'}] ${st.taskId}: ${st.title}`)
+                    .join('\n');
+                const content = [
+                    `## ${task.title}`,
+                    `- 状态: ${task.status}`,
+                    `- 优先级: ${task.priority}`,
+                    task.description ? `- 描述: ${task.description}` : '',
+                    task.estimatedHours ? `- 预计工时: ${task.estimatedHours}h` : '',
+                    task.completedAt ? `- 完成时间: ${new Date(task.completedAt).toISOString().slice(0, 10)}` : '',
+                    `- 子任务 (${task.completedSubtasks}/${task.totalSubtasks}):`,
+                    subTaskLines,
+                ].filter(Boolean).join('\n');
+                // 推断重要性：P0 高优先级 → 0.8, P1 → 0.6, P2 → 0.5
+                const importanceMap = { P0: 0.8, P1: 0.6, P2: 0.5 };
+                allEligible.push({
+                    sourceType: 'task',
+                    sourceId: task.taskId,
+                    sourceTitle: task.title,
+                    content,
+                    suggestedMemoryType: 'summary',
+                    suggestedImportance: importanceMap[task.priority] || 0.6,
+                    suggestedTags: [task.taskId, task.priority],
+                    hasExistingMemory: false,
+                });
+            }
+        }
+        // ========== 文档来源 ==========
+        if (source === 'docs' || source === 'both') {
+            let docs = this.listSections();
+            // 可选过滤
+            if (options?.section) {
+                docs = docs.filter((d) => d.section === options.section);
+                if (options?.subSection) {
+                    docs = docs.filter((d) => d.subSection === options.subSection);
+                }
+            }
+            totalDocuments = docs.length;
+            // section → suggestedMemoryType 映射
+            const sectionToMemoryType = {
+                overview: 'summary',
+                core_concepts: 'pattern',
+                api_design: 'pattern',
+                file_structure: 'pattern',
+                config: 'preference',
+                examples: 'pattern',
+                technical_notes: 'insight',
+                api_endpoints: 'pattern',
+                milestones: 'summary',
+                changelog: 'summary',
+                custom: 'insight',
+            };
+            // section → suggestedImportance 映射
+            const sectionToImportance = {
+                overview: 0.7,
+                core_concepts: 0.8,
+                api_design: 0.7,
+                file_structure: 0.5,
+                config: 0.5,
+                examples: 0.4,
+                technical_notes: 0.7,
+                api_endpoints: 0.5,
+                milestones: 0.6,
+                changelog: 0.4,
+                custom: 0.5,
+            };
+            for (const doc of docs) {
+                const docKey = doc.subSection
+                    ? `${doc.section}|${doc.subSection}`
+                    : doc.section;
+                // Phase-35: 三重去重检查 — sourceId（最可靠） > 内容指纹（fallback）
+                const hasMemoryBySourceId = memoryBySourceId.has(docKey);
+                const contentFingerprint = doc.content.slice(0, 50).toLowerCase();
+                const hasMemoryByFingerprint = memoryContentSet.has(contentFingerprint);
+                const hasMemory = hasMemoryBySourceId || hasMemoryByFingerprint;
+                if (hasMemory) {
+                    docsWithMemory++;
+                    skippedWithMemory++;
+                    continue; // 已有记忆 → 跳过不列出
+                }
+                // 截取内容摘要（最多 800 字符，保留完整行）
+                let contentPreview = doc.content;
+                if (contentPreview.length > 800) {
+                    contentPreview = contentPreview.slice(0, 800);
+                    const lastNewline = contentPreview.lastIndexOf('\n');
+                    if (lastNewline > 400)
+                        contentPreview = contentPreview.slice(0, lastNewline);
+                    contentPreview += '\n... (内容截断，完整文档可通过 devplan_get_section 获取)';
+                }
+                const content = [
+                    `## ${doc.title}`,
+                    `- 文档类型: ${doc.section}${doc.subSection ? ' → ' + doc.subSection : ''}`,
+                    `- 版本: ${doc.version}`,
+                    doc.relatedTaskIds?.length
+                        ? `- 关联任务: ${doc.relatedTaskIds.join(', ')}`
+                        : '',
+                    `\n### 内容摘要\n`,
+                    contentPreview,
+                ].filter(Boolean).join('\n');
+                const suggestedType = sectionToMemoryType[doc.section] || 'insight';
+                const suggestedImportance = sectionToImportance[doc.section] || 0.5;
+                // 从标题推断更精确的类型
+                const titleLower = doc.title.toLowerCase();
+                let refinedType = suggestedType;
+                if (titleLower.includes('决策') || titleLower.includes('decision') || titleLower.includes('选择'))
+                    refinedType = 'decision';
+                else if (titleLower.includes('修复') || titleLower.includes('fix') || titleLower.includes('bug'))
+                    refinedType = 'bugfix';
+                else if (titleLower.includes('优化') || titleLower.includes('性能') || titleLower.includes('performance'))
+                    refinedType = 'insight';
+                const tags = [doc.section];
+                if (doc.subSection)
+                    tags.push(doc.subSection);
+                if (doc.relatedTaskIds)
+                    tags.push(...doc.relatedTaskIds);
+                allEligible.push({
+                    sourceType: 'document',
+                    sourceId: docKey,
+                    sourceTitle: doc.title,
+                    content,
+                    suggestedMemoryType: refinedType,
+                    suggestedImportance: suggestedImportance,
+                    suggestedTags: tags,
+                    hasExistingMemory: false,
+                });
+            }
+        }
+        // ========== Phase-44: 构建 suggestedRelations ==========
+        // 为候选项之间推断关联关系，帮助 AI 用 applyMutations 构建记忆子图
+        const candidateIdSet = new Set(allEligible.map(c => c.sourceId));
+        for (const candidate of allEligible) {
+            const relations = [];
+            if (candidate.sourceType === 'task') {
+                // 任务 → 关联文档: DERIVED_FROM
+                const taskEntity = this.listMainTasks().find(t => t.taskId === candidate.sourceId);
+                if (taskEntity?.relatedSections) {
+                    for (const docRef of taskEntity.relatedSections) {
+                        if (candidateIdSet.has(docRef)) {
+                            relations.push({ targetSourceId: docRef, relationType: 'mem:DERIVED_FROM', weight: 0.7, reason: 'task references this document' });
+                        }
+                    }
+                }
+                // 任务 → 同模块任务: RELATES
+                if (taskEntity?.moduleId) {
+                    for (const other of allEligible) {
+                        if (other.sourceId !== candidate.sourceId && other.sourceType === 'task') {
+                            const otherTask = this.listMainTasks().find(t => t.taskId === other.sourceId);
+                            if (otherTask?.moduleId === taskEntity.moduleId) {
+                                relations.push({ targetSourceId: other.sourceId, relationType: 'mem:RELATES', weight: 0.5, reason: `same module: ${taskEntity.moduleId}` });
+                            }
+                        }
+                    }
+                }
+                // 任务 → 相邻阶段: TEMPORAL_NEXT (phase-N → phase-N+1)
+                const phaseMatch = candidate.sourceId.match(/^phase-(\d+)/);
+                if (phaseMatch) {
+                    const nextPhaseId = `phase-${parseInt(phaseMatch[1]) + 1}`;
+                    if (candidateIdSet.has(nextPhaseId)) {
+                        relations.push({ targetSourceId: nextPhaseId, relationType: 'mem:TEMPORAL_NEXT', weight: 0.6, reason: 'consecutive phases' });
+                    }
+                }
+            }
+            else if (candidate.sourceType === 'document') {
+                // 文档 → 关联任务: DERIVED_FROM
+                const docEntity = this.listSections().find(d => {
+                    const key = d.subSection ? `${d.section}|${d.subSection}` : d.section;
+                    return key === candidate.sourceId;
+                });
+                if (docEntity?.relatedTaskIds) {
+                    for (const taskId of docEntity.relatedTaskIds) {
+                        if (candidateIdSet.has(taskId)) {
+                            relations.push({ targetSourceId: taskId, relationType: 'mem:DERIVED_FROM', weight: 0.7, reason: 'document references this task' });
+                        }
+                    }
+                }
+                // 文档 → 父文档: CONTAINS (反向)
+                if (docEntity?.parentDoc) {
+                    if (candidateIdSet.has(docEntity.parentDoc)) {
+                        relations.push({ targetSourceId: docEntity.parentDoc, relationType: 'mem:CONTAINS', weight: 0.8, reason: 'child document of parent' });
+                    }
+                }
+                // 文档 → 同section文档: RELATES
+                if (docEntity) {
+                    for (const other of allEligible) {
+                        if (other.sourceId !== candidate.sourceId && other.sourceType === 'document') {
+                            const otherDoc = this.listSections().find(d => {
+                                const key = d.subSection ? `${d.section}|${d.subSection}` : d.section;
+                                return key === other.sourceId;
+                            });
+                            if (otherDoc && otherDoc.section === docEntity.section && otherDoc.subSection !== docEntity.subSection) {
+                                relations.push({ targetSourceId: other.sourceId, relationType: 'mem:RELATES', weight: 0.4, reason: `same section: ${docEntity.section}` });
+                            }
+                        }
+                    }
+                }
+            }
+            if (relations.length > 0) {
+                candidate.suggestedRelations = relations;
+            }
+        }
+        // 按 limit 截取，计算 remaining
+        const candidates = allEligible.slice(0, limit);
+        const remaining = Math.max(0, allEligible.length - limit);
+        return {
+            candidates,
+            stats: {
+                totalCompletedPhases,
+                totalDocuments,
+                phasesWithMemory,
+                docsWithMemory,
+                skippedWithMemory,
+                candidatesReturned: candidates.length,
+                remaining,
+            },
+        };
+    }
+    // ==========================================================================
+    // Utility
+    // ==========================================================================
+    /**
+     * Phase-21: 清理 WAL 中的重复 Entity。
+     *
+     * 扫描所有实体类型，按业务键去重，删除多余（低优先级）的 Entity。
+     * 返回被清理的 Entity 数量和详情。
+     *
+     * @param dryRun - 若为 true，仅报告而不实际删除
+     */
+    cleanupDuplicates(dryRun = false) {
+        const details = [];
+        // 定义各实体类型的去重键
+        const typeKeyMap = [
+            { entityType: ET.MAIN_TASK, propKey: 'taskId' },
+            { entityType: ET.SUB_TASK, propKey: 'taskId' },
+            { entityType: ET.MODULE, propKey: 'moduleId' },
+        ];
+        for (const { entityType, propKey } of typeKeyMap) {
+            const duplicates = this.findDuplicateEntities(entityType, propKey);
+            for (const dup of duplicates) {
+                const propVal = dup.properties?.[propKey] || 'unknown';
+                // 找出胜者
+                const entities = this.findEntitiesByType(entityType).filter((e) => e.properties?.[propKey] === propVal);
+                const winner = this.deduplicateEntities(entities, propKey)[0];
+                details.push({
+                    entityType,
+                    propKey: `${propKey}=${propVal}`,
+                    duplicateId: dup.id,
+                    keptId: winner?.id || 'unknown',
+                });
+                if (!dryRun) {
+                    // 删除重复 Entity 的所有关系
+                    const relations = this.graph.getEntityRelations(dup.id);
+                    for (const rel of relations) {
+                        this.graph.deleteRelation(rel.id);
+                    }
+                    // 删除重复 Entity
+                    this.graph.deleteEntity(dup.id);
+                }
+            }
+        }
+        // 文档去重（按 section+subSection 组合键）
+        const docEntities = this.findEntitiesByType(ET.DOC);
+        const docGroups = new Map();
+        for (const e of docEntities) {
+            const p = e.properties;
+            const key = sectionKey(p.section, p.subSection || undefined);
+            if (!docGroups.has(key))
+                docGroups.set(key, []);
+            docGroups.get(key).push(e);
+        }
+        for (const [key, group] of docGroups) {
+            if (group.length <= 1)
+                continue;
+            // 保留 updatedAt 最新的
+            group.sort((a, b) => (Number(b.properties?.updatedAt) || 0) - (Number(a.properties?.updatedAt) || 0));
+            const winner = group[0];
+            for (let i = 1; i < group.length; i++) {
+                details.push({
+                    entityType: ET.DOC,
+                    propKey: `section=${key}`,
+                    duplicateId: group[i].id,
+                    keptId: winner.id,
+                });
+                if (!dryRun) {
+                    const relations = this.graph.getEntityRelations(group[i].id);
+                    for (const rel of relations) {
+                        this.graph.deleteRelation(rel.id);
+                    }
+                    this.graph.deleteEntity(group[i].id);
+                }
+            }
+        }
+        if (!dryRun && details.length > 0) {
+            this.graph.flush();
+        }
+        return { cleaned: details.length, details };
+    }
+    sync() {
+        this.graph.flush();
+    }
+    getProjectName() {
+        return this.projectName;
+    }
+    syncWithGit(dryRun = false) {
+        const currentHead = this.getCurrentGitCommit();
+        if (!currentHead) {
+            return {
+                checked: 0,
+                reverted: [],
+                currentHead: 'unknown',
+                error: 'Git not available or not in a Git repository',
+            };
+        }
+        const mainTasks = this.listMainTasks();
+        const reverted = [];
+        let checked = 0;
+        for (const mt of mainTasks) {
+            const subs = this.listSubTasks(mt.taskId);
+            for (const sub of subs) {
+                if (sub.status !== 'completed' || !sub.completedAtCommit)
+                    continue;
+                checked++;
+                if (!this.isAncestor(sub.completedAtCommit, currentHead)) {
+                    const reason = `Commit ${sub.completedAtCommit} not found in current branch (HEAD: ${currentHead})`;
+                    if (!dryRun) {
+                        this.updateSubTaskStatus(sub.taskId, 'pending', { revertReason: reason });
+                        this.refreshMainTaskCounts(sub.parentTaskId);
+                        const parentMain = this.getMainTask(sub.parentTaskId);
+                        if (parentMain && parentMain.status === 'completed') {
+                            this.updateMainTaskStatus(sub.parentTaskId, 'in_progress');
+                        }
+                    }
+                    reverted.push({
+                        taskId: sub.taskId,
+                        title: sub.title,
+                        parentTaskId: sub.parentTaskId,
+                        completedAtCommit: sub.completedAtCommit,
+                        reason,
+                    });
+                }
+            }
+        }
+        return { checked, reverted, currentHead };
+    }
+    // ==========================================================================
+    // Graph Export (核心差异能力)
+    // ==========================================================================
+    /**
+     * 导出 DevPlan 的图结构用于可视化
+     *
+     * 返回 vis-network 兼容的 { nodes, edges } 格式。
+     */
+    exportGraph(options) {
+        const includeDocuments = options?.includeDocuments !== false;
+        const includeModules = options?.includeModules !== false;
+        const includeNodeDegree = options?.includeNodeDegree !== false;
+        const enableBackendDegreeFallback = options?.enableBackendDegreeFallback !== false;
+        const includePrompts = options?.includePrompts !== false;
+        const nodes = [];
+        const edges = [];
+        // 项目根节点
+        nodes.push({
+            id: this.getProjectId(),
+            label: this.projectName,
+            type: 'project',
+            properties: { entityType: ET.PROJECT },
+        });
+        // 主任务节点
+        const mainTasks = this.listMainTasks();
+        for (const mt of mainTasks) {
+            nodes.push({
+                id: mt.id,
+                label: mt.title,
+                type: 'main-task',
+                properties: {
+                    taskId: mt.taskId,
+                    priority: mt.priority,
+                    status: mt.status,
+                    totalSubtasks: mt.totalSubtasks,
+                    completedSubtasks: mt.completedSubtasks,
+                    completedAt: mt.completedAt || null,
+                },
+            });
+            edges.push({
+                from: this.getProjectId(),
+                to: mt.id,
+                label: RT.HAS_MAIN_TASK,
+            });
+            // 子任务节点
+            const subTasks = this.listSubTasks(mt.taskId);
+            for (const st of subTasks) {
+                nodes.push({
+                    id: st.id,
+                    label: st.title,
+                    type: 'sub-task',
+                    properties: {
+                        taskId: st.taskId,
+                        parentTaskId: st.parentTaskId,
+                        status: st.status,
+                        completedAt: st.completedAt || null,
+                    },
+                });
+                edges.push({
+                    from: mt.id,
+                    to: st.id,
+                    label: RT.HAS_SUB_TASK,
+                });
+            }
+            // task -> doc 关系
+            const taskDocRels = this.getOutRelations(mt.id, RT.TASK_HAS_DOC);
+            for (const rel of taskDocRels) {
+                edges.push({
+                    from: mt.id,
+                    to: rel.target,
+                    label: RT.TASK_HAS_DOC,
+                });
+            }
+            // task -> prompt 关系
+            if (includePrompts) {
+                const taskPromptRels = this.getOutRelations(mt.id, RT.TASK_HAS_PROMPT);
+                for (const rel of taskPromptRels) {
+                    edges.push({
+                        from: mt.id,
+                        to: rel.target,
+                        label: RT.TASK_HAS_PROMPT,
+                    });
+                }
+            }
+        }
+        // Prompt 节点（默认包含，可视化页面可传 includePrompts=false 排除）
+        if (includePrompts) {
+            const prompts = this.listPrompts();
+            for (const prompt of prompts) {
+                nodes.push({
+                    id: prompt.id,
+                    label: `Prompt #${prompt.promptIndex}`,
+                    type: 'prompt',
+                    properties: {
+                        promptIndex: prompt.promptIndex,
+                        summary: prompt.summary || '',
+                        relatedTaskId: prompt.relatedTaskId || null,
+                        createdAt: prompt.createdAt,
+                    },
+                });
+                edges.push({
+                    from: this.getProjectId(),
+                    to: prompt.id,
+                    label: RT.HAS_PROMPT,
+                });
+            }
+        }
+        // Memory 节点
+        {
+            const memories = this.listMemories ? this.listMemories() : [];
+            const memoryIdSet = new Set();
+            for (const mem of memories) {
+                memoryIdSet.add(mem.id);
+                const label = `${mem.memoryType}: ${mem.content.slice(0, 30)}...`;
+                nodes.push({
+                    id: mem.id,
+                    label,
+                    type: 'memory',
+                    properties: {
+                        memoryType: mem.memoryType,
+                        importance: mem.importance,
+                        hitCount: mem.hitCount,
+                        tags: mem.tags || [],
+                        createdAt: mem.createdAt,
+                    },
+                });
+                edges.push({
+                    from: this.getProjectId(),
+                    to: mem.id,
+                    label: RT.HAS_MEMORY,
+                });
+                // memory → task 边
+                if (mem.relatedTaskId) {
+                    const taskEntity = this.findEntityByProp(ET.MAIN_TASK, 'taskId', mem.relatedTaskId);
+                    if (taskEntity) {
+                        edges.push({
+                            from: mem.id,
+                            to: taskEntity.id,
+                            label: RT.MEMORY_FROM_TASK,
+                        });
+                    }
+                }
+            }
+            // Phase-37: 记忆网络关系 — MEMORY_RELATES / MEMORY_FROM_DOC / MODULE_MEMORY / MEMORY_SUPERSEDES
+            const memoryRelTypes = [RT.MEMORY_RELATES, RT.MEMORY_FROM_DOC, RT.MODULE_MEMORY, RT.MEMORY_SUPERSEDES];
+            const edgeDedup = new Set();
+            for (const memId of memoryIdSet) {
+                for (const relType of memoryRelTypes) {
+                    const rels = this.getOutRelations(memId, relType);
+                    for (const rel of rels) {
+                        const key = `${rel.source}-${rel.target}-${relType}`;
+                        if (edgeDedup.has(key))
+                            continue;
+                        edgeDedup.add(key);
+                        edges.push({
+                            from: rel.source,
+                            to: rel.target,
+                            label: relType,
+                            properties: rel.weight != null ? { weight: rel.weight } : undefined,
+                        });
+                    }
+                    // 也检查入边（双向关系如 MEMORY_RELATES 的另一方向）
+                    const inRels = this.getInRelations(memId, relType);
+                    for (const rel of inRels) {
+                        const key = `${rel.source}-${rel.target}-${relType}`;
+                        if (edgeDedup.has(key))
+                            continue;
+                        edgeDedup.add(key);
+                        edges.push({
+                            from: rel.source,
+                            to: rel.target,
+                            label: relType,
+                            properties: rel.weight != null ? { weight: rel.weight } : undefined,
+                        });
+                    }
+                }
+            }
+        }
+        // 文档节点
+        if (includeDocuments) {
+            const docs = this.listSections();
+            for (const doc of docs) {
+                nodes.push({
+                    id: doc.id,
+                    label: doc.title,
+                    type: 'document',
+                    properties: {
+                        section: doc.section,
+                        subSection: doc.subSection,
+                        version: doc.version,
+                        parentDoc: doc.parentDoc || null,
+                        childDocs: doc.childDocs || [],
+                    },
                 });
                 // 子文档不连接项目节点，仅通过 doc_has_child 连接父文档
                 if (!doc.parentDoc) {
@@ -1450,6 +3296,12 @@ class DevPlanGraphStore {
                         mainTaskCount: mod.mainTaskCount,
                     },
                 });
+                // 项目→模块 关系（确保每个模块都与项目节点相连，不会成为孤立节点）
+                edges.push({
+                    from: this.getProjectId(),
+                    to: mod.id,
+                    label: RT.HAS_MODULE,
+                });
                 // 模块→主任务 关系
                 const moduleTasks = this.listMainTasks({ moduleId: mod.moduleId });
                 for (const mt of moduleTasks) {
@@ -1461,6 +3313,83 @@ class DevPlanGraphStore {
                 }
             }
         }
+        // Phase-41: 记忆节点 + 全部记忆关系
+        const allMemoryEntities = this.findEntitiesByType(ET.MEMORY)
+            .filter((e) => e.properties.projectName === this.projectName);
+        for (const memEntity of allMemoryEntities) {
+            const mem = this.entityToMemory(memEntity);
+            nodes.push({
+                id: mem.id,
+                label: `${mem.memoryType}: ${mem.content.slice(0, 30)}...`,
+                type: 'memory',
+                properties: {
+                    memoryType: mem.memoryType,
+                    content: mem.content.length > 120 ? mem.content.slice(0, 120) + '...' : mem.content,
+                    importance: mem.importance,
+                    hitCount: mem.hitCount,
+                    tags: mem.tags,
+                    relatedTaskId: mem.relatedTaskId || null,
+                    sourceId: mem.sourceId || null,
+                },
+            });
+            // project → memory (HAS_MEMORY)
+            edges.push({
+                from: this.getProjectId(),
+                to: mem.id,
+                label: RT.HAS_MEMORY,
+            });
+            // memory → task (MEMORY_FROM_TASK)
+            if (mem.relatedTaskId) {
+                const taskEntity = this.findEntityByProp(ET.MAIN_TASK, 'taskId', mem.relatedTaskId);
+                if (taskEntity) {
+                    edges.push({
+                        from: mem.id,
+                        to: taskEntity.id,
+                        label: RT.MEMORY_FROM_TASK,
+                    });
+                }
+            }
+            // memory ↔ memory (MEMORY_RELATES，仅导出出向避免重复)
+            const memRelates = this.getOutRelations(mem.id, RT.MEMORY_RELATES);
+            for (const rel of memRelates) {
+                // 仅导出 source < target 的一侧，避免双向重复
+                if (mem.id < rel.target) {
+                    edges.push({
+                        from: mem.id,
+                        to: rel.target,
+                        label: RT.MEMORY_RELATES,
+                        properties: rel.weight != null ? { weight: rel.weight } : undefined,
+                    });
+                }
+            }
+            // doc → memory (MEMORY_FROM_DOC，反向查找)
+            const fromDocRels = this.getInRelations(mem.id, RT.MEMORY_FROM_DOC);
+            for (const rel of fromDocRels) {
+                edges.push({
+                    from: rel.source,
+                    to: mem.id,
+                    label: RT.MEMORY_FROM_DOC,
+                });
+            }
+            // module → memory (MODULE_MEMORY，反向查找)
+            const moduleMemRels = this.getInRelations(mem.id, RT.MODULE_MEMORY);
+            for (const rel of moduleMemRels) {
+                edges.push({
+                    from: rel.source,
+                    to: mem.id,
+                    label: RT.MODULE_MEMORY,
+                });
+            }
+            // memory → memory (MEMORY_SUPERSEDES)
+            const supersedesRels = this.getOutRelations(mem.id, RT.MEMORY_SUPERSEDES);
+            for (const rel of supersedesRels) {
+                edges.push({
+                    from: mem.id,
+                    to: rel.target,
+                    label: RT.MEMORY_SUPERSEDES,
+                });
+            }
+        }
         if (includeNodeDegree) {
             // 优先走 SocialGraphV2 原生 exportGraph(includeNodeDegree) 的 degree 结果
             const nativeDegreeMap = {};
@@ -1506,6 +3435,197 @@ class DevPlanGraphStore {
         }
         return { nodes, edges };
     }
+    /**
+     * 分页导出图谱数据 (Phase-9 T9.1)
+     *
+     * 利用 Rust 层 SocialGraphV2 的 exportGraphPaginated() 分页 API，
+     * 避免全量加载 + 内存切片。真正的分页下推到数据库层。
+     *
+     * @param offset 分页偏移量
+     * @param limit 每页节点数
+     * @param options 可选参数
+     * @returns 分页图谱数据
+     */
+    exportGraphPaginated(offset, limit, options) {
+        const includeDocuments = options?.includeDocuments !== false;
+        const includeModules = options?.includeModules !== false;
+        const includeNodeDegree = options?.includeNodeDegree !== false;
+        // Build entity type filter for Rust layer
+        const entityTypes = [];
+        entityTypes.push(ET.PROJECT, ET.MAIN_TASK, ET.SUB_TASK);
+        if (includeDocuments)
+            entityTypes.push(ET.DOC);
+        if (includeModules)
+            entityTypes.push(ET.MODULE);
+        if (options?.entityTypes?.length) {
+            // Use user-specified filter if provided
+            entityTypes.length = 0;
+            entityTypes.push(...options.entityTypes);
+        }
+        try {
+            // Call Rust SocialGraphV2.exportGraphPaginated via NAPI
+            const result = this.graph.exportGraphPaginated({
+                offset,
+                limit,
+                entityTypes,
+                includeNodeDegree,
+                includeEdgeMeta: false,
+            });
+            if (result && typeof result === 'object') {
+                const rustNodes = result.nodes || [];
+                const rustEdges = result.edges || [];
+                // Transform Rust GraphNode -> DevPlanGraphNode
+                // Rust GraphNode only carries `group: NodeGroup` (numeric 0/1/2) — all DevPlan
+                // entities map to Tag(2), losing type information. We must resolve entity_type
+                // via getEntity() for correct visualization (module=diamond, doc=box, etc.).
+                const currentProjectId = this.getProjectId();
+                const nodes = [];
+                for (const n of rustNodes) {
+                    const data = n.data || {};
+                    // Try multiple sources for entity_type string
+                    let etStr = n.entity_type || n.entityType
+                        || data.entity_type || data.entityType;
+                    // If still not found, look up the actual entity (fast hash lookup)
+                    if (!etStr || typeof etStr !== 'string') {
+                        try {
+                            const entity = this.graph.getEntity(n.id);
+                            if (entity) {
+                                etStr = entity.entity_type || entity.entityType;
+                            }
+                        }
+                        catch { /* ignore — fall through to group */ }
+                    }
+                    const devPlanType = this.mapGroupToDevPlanType(etStr || n.group);
+                    // Filter out project nodes that don't belong to the current project.
+                    // The Rust layer returns ALL entities matching the type filter, which may
+                    // include stale project nodes from other projects (e.g. "devplan-db").
+                    if (devPlanType === 'project' && n.id !== currentProjectId) {
+                        continue;
+                    }
+                    nodes.push({
+                        id: n.id,
+                        label: n.label || n.id,
+                        type: devPlanType,
+                        degree: includeNodeDegree ? (n.degree ?? 0) : undefined,
+                        properties: data,
+                    });
+                }
+                // Transform Rust GraphEdge -> DevPlanGraphEdge
+                const edges = rustEdges.map((e) => ({
+                    from: e.from,
+                    to: e.to,
+                    label: e.label || e.relation_type || '',
+                }));
+                return {
+                    nodes,
+                    edges,
+                    totalNodes: result.total_nodes ?? result.totalNodes ?? nodes.length,
+                    totalEdges: result.total_edges ?? result.totalEdges ?? edges.length,
+                    offset: result.offset ?? offset,
+                    limit: result.limit ?? limit,
+                    hasMore: result.has_more ?? result.hasMore ?? false,
+                };
+            }
+        }
+        catch {
+            // If NAPI method not available, fall back to in-memory pagination
+        }
+        // Fallback: full load + in-memory pagination
+        const fullGraph = this.exportGraph({
+            includeDocuments,
+            includeModules,
+            includeNodeDegree,
+            enableBackendDegreeFallback: true,
+        });
+        const allNodes = fullGraph.nodes;
+        const pageNodes = allNodes.slice(offset, offset + limit);
+        const pageNodeIds = new Set(pageNodes.map((n) => n.id));
+        const pageEdges = fullGraph.edges.filter((e) => pageNodeIds.has(e.from) && pageNodeIds.has(e.to));
+        return {
+            nodes: pageNodes,
+            edges: pageEdges,
+            totalNodes: allNodes.length,
+            totalEdges: fullGraph.edges.length,
+            offset,
+            limit,
+            hasMore: offset + limit < allNodes.length,
+        };
+    }
+    /**
+     * 导出紧凑二进制格式 (Phase-9 T9.3)
+     *
+     * 利用 Rust 层 CompactGraphExport 格式，返回 Buffer。
+     * 比 JSON 小 5x+，解析速度接近零。
+     *
+     * @returns Node.js Buffer 或 null (如果 NAPI 方法不可用)
+     */
+    exportGraphCompact() {
+        try {
+            const buf = this.graph.exportGraphCompact({
+                maxNodes: 1000000,
+                includeTags: true,
+                includeCompanies: true,
+                includeNodeDegree: true,
+                includeEdgeMeta: false,
+            });
+            if (buf && buf.length > 16) {
+                return buf;
+            }
+        }
+        catch {
+            // NAPI method not available
+        }
+        return null;
+    }
+    /**
+     * 获取实体组聚合摘要 (Phase-9 T9.4)
+     *
+     * 利用 Rust 层 group_entities_summary() 返回按类型分组的统计信息。
+     * 远比加载全部实体开销小，适合低缩放级别的集群视图。
+     *
+     * @returns 聚合结果或 null (如果 NAPI 方法不可用)
+     */
+    getEntityGroupSummary() {
+        try {
+            const result = this.graph.getEntityGroupSummary();
+            if (result && typeof result === 'object') {
+                return {
+                    groups: (result.groups || []).map((g) => ({
+                        entityType: g.entity_type ?? g.entityType ?? '',
+                        count: g.count ?? 0,
+                        sampleIds: g.sample_ids ?? g.sampleIds ?? [],
+                    })),
+                    totalEntities: result.total_entities ?? result.totalEntities ?? 0,
+                    totalRelations: result.total_relations ?? result.totalRelations ?? 0,
+                };
+            }
+        }
+        catch {
+            // NAPI method not available
+        }
+        return null;
+    }
+    /**
+     * Map Rust NodeGroup name to DevPlan node type
+     */
+    mapGroupToDevPlanType(group) {
+        // Rust NodeGroup: 0=Person, 1=Company, 2=Tag
+        // But in DevPlan context, entity_type matters more
+        // We rely on the entity's entity_type property
+        if (typeof group === 'string') {
+            if (group.includes('project'))
+                return 'project';
+            if (group.includes('main-task') || group.includes('main_task'))
+                return 'main-task';
+            if (group.includes('sub-task') || group.includes('sub_task'))
+                return 'sub-task';
+            if (group.includes('doc'))
+                return 'document';
+            if (group.includes('module'))
+                return 'module';
+        }
+        return 'sub-task'; // default fallback
+    }
     // ==========================================================================
     // Private Helpers
     // ==========================================================================
@@ -1558,16 +3678,90 @@ class DevPlanGraphStore {
         if (mainTask.totalSubtasks === subs.length && mainTask.completedSubtasks === completedCount) {
             return mainTask;
         }
-        this.graph.updateEntity(mainTask.id, {
-            properties: {
-                totalSubtasks: subs.length,
-                completedSubtasks: completedCount,
-                updatedAt: Date.now(),
-            },
+        const now = Date.now();
+        // Phase-45: 使用 upsertEntityByProp 代替 updateEntity（修复分片路由不一致）
+        this.graph.upsertEntityByProp(ET.MAIN_TASK, 'taskId', mainTaskId, mainTask.title, {
+            projectName: this.projectName,
+            taskId: mainTaskId,
+            title: mainTask.title,
+            priority: mainTask.priority,
+            description: mainTask.description || '',
+            estimatedHours: mainTask.estimatedHours || 0,
+            relatedSections: mainTask.relatedSections || [],
+            relatedPromptIds: mainTask.relatedPromptIds || [],
+            moduleId: mainTask.moduleId || null,
+            totalSubtasks: subs.length,
+            completedSubtasks: completedCount,
+            status: mainTask.status,
+            order: mainTask.order,
+            createdAt: mainTask.createdAt,
+            updatedAt: now,
+            completedAt: mainTask.completedAt,
         });
         this.graph.flush();
-        const updated = this.graph.getEntity(mainTask.id);
-        return updated ? this.entityToMainTask(updated) : mainTask;
+        return this.getMainTask(mainTaskId) || mainTask;
+    }
+    /**
+     * Phase-45: 修复存量数据 — 遍历所有主任务，重新计算子任务计数和自动完成状态。
+     * 用于修复因 updateEntity 路由不一致导致的 completedSubtasks=0 和 status=in_progress 的 Bug。
+     * @returns 修复报告
+     */
+    repairAllMainTaskCounts() {
+        const allMainTasks = this.listMainTasks();
+        const report = { repaired: 0, autoCompleted: 0, details: [] };
+        for (const mt of allMainTasks) {
+            if (mt.status === 'cancelled')
+                continue;
+            const subs = this.listSubTasks(mt.taskId);
+            const completedCount = subs.filter((s) => s.status === 'completed').length;
+            const totalCount = subs.length;
+            let needsRepair = false;
+            let needsAutoComplete = false;
+            // 检查计数是否正确
+            if (mt.totalSubtasks !== totalCount || mt.completedSubtasks !== completedCount) {
+                needsRepair = true;
+            }
+            // 检查是否应自动完成
+            if (totalCount > 0 && completedCount >= totalCount && mt.status !== 'completed') {
+                needsAutoComplete = true;
+                needsRepair = true;
+            }
+            if (!needsRepair)
+                continue;
+            const now = Date.now();
+            const finalStatus = needsAutoComplete ? 'completed' : mt.status;
+            const finalCompletedAt = needsAutoComplete ? now : mt.completedAt;
+            this.graph.upsertEntityByProp(ET.MAIN_TASK, 'taskId', mt.taskId, mt.title, {
+                projectName: this.projectName,
+                taskId: mt.taskId,
+                title: mt.title,
+                priority: mt.priority,
+                description: mt.description || '',
+                estimatedHours: mt.estimatedHours || 0,
+                relatedSections: mt.relatedSections || [],
+                relatedPromptIds: mt.relatedPromptIds || [],
+                moduleId: mt.moduleId || null,
+                totalSubtasks: totalCount,
+                completedSubtasks: completedCount,
+                status: finalStatus,
+                order: mt.order,
+                createdAt: mt.createdAt,
+                updatedAt: now,
+                completedAt: finalCompletedAt,
+            });
+            report.repaired++;
+            if (needsAutoComplete) {
+                report.autoCompleted++;
+                report.details.push({ taskId: mt.taskId, action: `auto-completed (${completedCount}/${totalCount} subtasks done)` });
+            }
+            else {
+                report.details.push({ taskId: mt.taskId, action: `counts fixed: ${mt.completedSubtasks}→${completedCount}/${totalCount}` });
+            }
+        }
+        if (report.repaired > 0) {
+            this.graph.flush();
+        }
+        return report;
     }
     autoUpdateMilestones(completedMainTask) {
         const milestonesDoc = this.getSection('milestones');
@@ -1771,4 +3965,14 @@ class DevPlanGraphStore {
     }
 }
 exports.DevPlanGraphStore = DevPlanGraphStore;
+// ==========================================================================
+// Generic Entity Helpers
+// ==========================================================================
+/** 任务状态优先级映射（用于去重时选择"胜出"实体） */
+DevPlanGraphStore.STATUS_PRIORITY = {
+    cancelled: 0,
+    pending: 1,
+    in_progress: 2,
+    completed: 3,
+};
 //# sourceMappingURL=dev-plan-graph-store.js.map