aifastdb-devplan 1.6.2 → 1.6.3

package/dist/mcp-server/index.js

@@ -456,6 +456,38 @@ const TOOLS = [
             required: ['projectName'],
         },
     },
+    {
+        name: 'devplan_cleanup_duplicates',
+        description: 'Phase-21: Scan and cleanup duplicate entities in the WAL. Deduplicates main tasks (by taskId), sub-tasks (by taskId), modules (by moduleId), and documents (by section+subSection). Keeps the entity with the highest status priority (completed > in_progress > pending > cancelled) and latest updatedAt. Use dryRun=true to preview without changes.\nPhase-21: 扫描并清理 WAL 中的重复 Entity。按业务键去重（mainTask 按 taskId，subTask 按 taskId，module 按 moduleId，doc 按 section+subSection）。保留状态优先级最高 + updatedAt 最新的 Entity。使用 dryRun=true 可预览而不实际修改。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                dryRun: {
+                    type: 'boolean',
+                    description: 'If true, only report which duplicates would be cleaned without actually deleting them (default: false)\n为 true 时仅报告哪些重复 Entity 会被清理，不实际删除（默认 false）',
+                },
+            },
+            required: ['projectName'],
+        },
+    },
+    {
+        name: 'devplan_repair_counts',
+        description: 'Phase-45: Repair all main task sub-task counts and auto-complete status. Recalculates totalSubtasks/completedSubtasks from actual sub-task data and auto-completes main tasks where all sub-tasks are done but status is still in_progress. Fixes data inconsistencies caused by updateEntity routing issues.\nPhase-45: 修复所有主任务的子任务计数和自动完成状态。从实际子任务数据重新计算 totalSubtasks/completedSubtasks，并自动完成所有子任务已完成但状态仍为 in_progress 的主任务。修复因 updateEntity 路由问题导致的数据不一致。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+            },
+            required: ['projectName'],
+        },
+    },
     {
         name: 'devplan_create_module',
         description: 'Create/register a feature module in the dev plan. Modules represent independent functional areas of the project (e.g., "vector-store", "permission-system"). Main tasks and documents can be associated with modules.\n在开发计划中创建/注册功能模块。模块代表项目的独立功能区域（如 "vector-store"、"permission-system"）。主任务和文档可以关联到模块。',
@@ -813,6 +845,253 @@ const TOOLS = [
             required: ['projectName'],
         },
     },
+    // ========================================================================
+    // Memory Tools (Cursor 长期记忆)
+    // ========================================================================
+    {
+        name: 'devplan_memory_save',
+        description: 'Save a memory entry to the dev plan for long-term Cursor context. Memories are automatically embedded for semantic recall. Types: decision (architecture decisions), pattern (code patterns), bugfix (bug fixes), insight (learnings), preference (user/project preferences), summary (session summaries).\n保存一条记忆到开发计划，为 Cursor 提供长期上下文。记忆会自动向量化以支持语义召回。类型：decision（架构决策）、pattern（代码模式）、bugfix（Bug修复）、insight（开发洞察）、preference（偏好约定）、summary（会话摘要）。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                memoryType: {
+                    type: 'string',
+                    enum: ['decision', 'pattern', 'bugfix', 'insight', 'preference', 'summary'],
+                    description: 'Memory type\n记忆类型',
+                },
+                content: {
+                    type: 'string',
+                    description: 'Memory content (Markdown supported)\n记忆内容（支持 Markdown）',
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional: Custom tags for categorization\n可选：分类标签',
+                },
+                relatedTaskId: {
+                    type: 'string',
+                    description: 'Optional: Related main task ID (e.g., "phase-24")\n可选：关联的主任务 ID',
+                },
+                importance: {
+                    type: 'number',
+                    description: 'Optional: Importance score 0~1 (default: 0.5)\n可选：重要性评分 0~1（默认 0.5）',
+                },
+                sourceId: {
+                    type: 'string',
+                    description: 'Optional: Source ID tracking which document/task this memory was generated from. Used by devplan_memory_generate for dedup. Format: taskId (e.g., "phase-7") or "section|subSection" (e.g., "overview", "technical_notes|security"). **IMPORTANT**: When saving memories from devplan_memory_generate candidates, ALWAYS pass the candidate\'s `sourceId` field here to enable proper dedup tracking.\n可选：记忆来源 ID，标记该记忆由哪个文档/任务生成。用于 devplan_memory_generate 的去重。格式：taskId（如 "phase-7"）或 "section|subSection"（如 "overview"）。**重要**：从 devplan_memory_generate 候选项保存记忆时，务必传入候选项的 sourceId 以启用去重追踪。',
+                },
+                moduleId: {
+                    type: 'string',
+                    description: 'Optional: Associate with a feature module (e.g., "vector-store"). Automatically creates MODULE_MEMORY relation to integrate the memory into the module-level knowledge graph.\n可选：关联到功能模块（如 "vector-store"）。自动创建 MODULE_MEMORY 关系，将记忆融入模块级知识图谱。',
+                },
+            },
+            required: ['projectName', 'memoryType', 'content'],
+        },
+    },
+    {
+        name: 'devplan_memory_recall',
+        description: 'Intelligently recall memories relevant to a query using semantic vector search. Automatically updates hit counts for recalled memories. Falls back to literal matching when semantic search is unavailable.\n通过语义向量搜索智能召回与查询相关的记忆。自动更新被召回记忆的命中次数。语义搜索不可用时退化为字面匹配。\n\n**Unified Recall (统一召回)**: By default, also searches document sections and merges results via RRF fusion. Each result includes `sourceKind` ("memory" or "doc") to indicate its origin. Set `includeDocs=false` to search memories only.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                query: {
+                    type: 'string',
+                    description: 'Search query text\n搜索查询文本',
+                },
+                memoryType: {
+                    type: 'string',
+                    enum: ['decision', 'pattern', 'bugfix', 'insight', 'preference', 'summary'],
+                    description: 'Optional: Filter by memory type\n可选：按记忆类型过滤',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Optional: Maximum results (default: 10)\n可选：最大返回数（默认 10）',
+                },
+                minScore: {
+                    type: 'number',
+                    description: 'Optional: Minimum relevance score 0~1 (default: 0)\n可选：最低相关性评分（默认 0）',
+                },
+                includeDocs: {
+                    type: 'boolean',
+                    description: 'Whether to include document sections in recall results via unified search (default: true). Set to false to search memories only.\n是否通过统一召回包含文档搜索结果（默认 true）。设为 false 仅搜索记忆。',
+                },
+                graphExpand: {
+                    type: 'boolean',
+                    description: 'Whether to expand results via MEMORY_RELATES graph traversal (default: true). When enabled, related memories connected through the memory network are also discovered and RRF-fused with vector results.\n是否通过 MEMORY_RELATES 图谱遍历扩展结果（默认 true）。启用时，通过记忆网络关联的记忆也会被发现并与向量结果 RRF 融合。',
+                },
+            },
+            required: ['projectName', 'query'],
+        },
+    },
+    {
+        name: 'devplan_memory_list',
+        description: 'List saved memories with optional filters.\n列出已保存的记忆，支持过滤。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                memoryType: {
+                    type: 'string',
+                    enum: ['decision', 'pattern', 'bugfix', 'insight', 'preference', 'summary'],
+                    description: 'Optional: Filter by memory type\n可选：按记忆类型过滤',
+                },
+                relatedTaskId: {
+                    type: 'string',
+                    description: 'Optional: Filter by related task ID\n可选：按关联任务 ID 过滤',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Optional: Maximum results (default: all)\n可选：最大返回数（默认全部）',
+                },
+            },
+            required: ['projectName'],
+        },
+    },
+    {
+        name: 'devplan_memory_delete',
+        description: 'Delete a specific memory entry by ID.\n按 ID 删除一条记忆。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                memoryId: {
+                    type: 'string',
+                    description: 'Memory ID to delete\n要删除的记忆 ID',
+                },
+            },
+            required: ['projectName', 'memoryId'],
+        },
+    },
+    {
+        name: 'devplan_memory_clear',
+        description: 'Batch clear all memories for a project. Optionally filter by memoryType. Use this before re-importing memories with the fixed batch generator.\n批量清除项目的所有记忆。可选按 memoryType 过滤。用于重新导入记忆前的清理。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                memoryType: {
+                    type: 'string',
+                    enum: ['decision', 'pattern', 'bugfix', 'insight', 'preference', 'summary'],
+                    description: 'Optional: Only clear memories of this type. Omit to clear ALL memories.\n可选：仅清除指定类型的记忆。省略则清除全部。',
+                },
+                confirm: {
+                    type: 'boolean',
+                    description: 'Must be true to confirm deletion. Safety guard.\n必须为 true 以确认删除操作。安全保护。',
+                },
+            },
+            required: ['projectName', 'confirm'],
+        },
+    },
+    {
+        name: 'devplan_memory_clusters',
+        description: 'Get memory topic clusters based on MEMORY_RELATES graph connectivity. Automatically groups semantically related memories into themed clusters using connected component analysis. Returns cluster themes, member counts, and memory summaries.\n基于 MEMORY_RELATES 图谱连通性获取记忆主题集群。自动将语义关联的记忆按连通分量聚合为主题集群。返回集群主题、成员数量和记忆摘要。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+            },
+            required: ['projectName'],
+        },
+    },
+    {
+        name: 'devplan_memory_context',
+        description: 'Get comprehensive project context for a new Cursor session. Aggregates recent tasks, relevant memories (via semantic search), project preferences, and recent decisions. This is the PRIMARY tool for session initialization.\n获取新 Cursor 会话的综合项目上下文。聚合最近任务、相关记忆（语义搜索）、项目偏好和最近决策。这是会话初始化的核心工具。\n\n**Unified Recall**: When a query is provided, automatically searches both memories AND documents, returning merged results. Also includes `relatedDocs` field with key document summaries (overview, core_concepts).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                query: {
+                    type: 'string',
+                    description: 'Optional: Query text for semantic memory recall\n可选：用于语义召回的查询文本',
+                },
+                maxMemories: {
+                    type: 'number',
+                    description: 'Optional: Maximum memories to include (default: 10)\n可选：最大记忆数（默认 10）',
+                },
+            },
+            required: ['projectName'],
+        },
+    },
+    {
+        name: 'devplan_memory_generate',
+        description: 'Generate memory candidates from existing documents and completed tasks. Returns structured candidates that the AI can review and selectively save as memories via devplan_memory_save. This tool aggregates raw data; the AI provides the intelligence to extract meaningful memories.\n从已有文档和已完成任务中生成记忆候选项。返回结构化候选项供 AI 审查后通过 devplan_memory_save 批量保存为记忆。此工具聚合原始数据，AI 负责提取有意义的记忆。\n\n**Batch AI Workflow (批量 AI 处理工作流)**:\nWhen user says "批量生成记忆" / "全量导入记忆" / "batch generate memories":\n1. Call this tool with limit=5 to get a small batch\n2. For EACH candidate: read its content, extract 1-3 key insights, determine the best memoryType\n3. Call devplan_memory_save for each with AI-refined content (concise, 1-3 sentences), **MUST pass sourceId from candidate.sourceId**\n4. Check stats.remaining — if > 0, repeat from step 1\n5. Continue until remaining === 0\n\n**Memory Tree / suggestedRelations (记忆树 / 建议关联)**:\nEach candidate may include a `suggestedRelations` array with `{ targetSourceId, relationType, weight, reason }` entries.\nThese represent inferred connections between candidates (e.g., task→doc DERIVED_FROM, consecutive phases TEMPORAL_NEXT, same-module RELATES).\n`targetSourceId` references another candidate\'s `sourceId`. After saving all memories, map sourceId→entityId and build relations via the graph.\nThis transforms flat memories into a connected Memory Tree graph.\n\n**CRITICAL — sourceId dedup tracking**: Each candidate has a `sourceId` field (e.g., "phase-7" for tasks, "overview" or "technical_notes|security" for docs). When calling devplan_memory_save, you MUST pass `sourceId: candidate.sourceId` so that subsequent calls to devplan_memory_generate can skip already-processed sources. Without sourceId, the same candidates will keep appearing.\n\nThe stats.remaining field tells how many more eligible candidates exist beyond the current batch.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                source: {
+                    type: 'string',
+                    enum: ['tasks', 'docs', 'both'],
+                    description: 'Data source: "tasks" for completed phases, "docs" for documents, "both" for all (default: "both")\n数据源："tasks" 已完成阶段、"docs" 文档、"both" 全部（默认 "both"）',
+                },
+                taskId: {
+                    type: 'string',
+                    description: 'Optional: Extract from a specific phase only (e.g., "phase-7")\n可选：仅从指定阶段提取（如 "phase-7"）',
+                },
+                section: {
+                    type: 'string',
+                    description: 'Optional: Extract from a specific document section only\n可选：仅从指定文档章节提取',
+                },
+                subSection: {
+                    type: 'string',
+                    description: 'Optional: Extract from a specific document sub-section\n可选：仅从指定子章节提取',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Optional: Maximum candidates to return (default: 50). For AI batch workflow, use limit=5 to process in small batches. stats.remaining shows how many more are available.\n可选：最大候选项数（默认 50）。AI 批量工作流建议用 limit=5 分小批处理。stats.remaining 显示剩余待处理数。',
+                },
+            },
+            required: ['projectName'],
+        },
+    },
+    {
+        name: 'devplan_memory_lifecycle',
+        description: 'Run memory lifecycle management scan using DynamicNode promote/demote. Long-idle memories are demoted to shadow state (excluded from vector search but preserved in graph). Re-accessed memories are auto-promoted back. This implements biological memory forgetting and reinforcement.\n运行记忆生命周期管理扫描。长期未访问的记忆降级为 shadow 状态（不参与向量搜索但保留在图谱中），被重新访问时自动恢复。实现生物记忆的遗忘与强化机制。',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectName: {
+                    type: 'string',
+                    description: `Project name (default: "${dev_plan_factory_1.DEFAULT_PROJECT_NAME}")\n项目名称（默认："${dev_plan_factory_1.DEFAULT_PROJECT_NAME}"）`,
+                },
+                demoteIdleTimeoutSecs: {
+                    type: 'number',
+                    description: 'Idle seconds before demotion to shadow (default: 2592000 = 30 days)\n降级前的闲置秒数（默认 2592000 = 30 天）',
+                },
+                promoteHitThreshold: {
+                    type: 'number',
+                    description: 'Minimum hit count to promote from shadow (default: 3)\n从 shadow 恢复的最低命中次数（默认 3）',
+                },
+            },
+            required: ['projectName'],
+        },
+    },
 ];
 /**
  * 解析 projectName
@@ -1014,6 +1293,7 @@ async function handleToolCall(name, args) {
             }
             const plan = getDevPlan(args.projectName);
             try {
+                // Phase-23: createMainTask 内部已幂等处理（upsertEntityByProp），无需额外检查
                 const mainTask = plan.createMainTask({
                     projectName: args.projectName,
                     taskId: args.taskId,
@@ -1047,6 +1327,7 @@ async function handleToolCall(name, args) {
             }
             const plan = getDevPlan(args.projectName);
             try {
+                // Phase-23: addSubTask 内部已幂等处理（upsertEntityByProp），无需额外检查
                 const subTask = plan.addSubTask({
                     projectName: args.projectName,
                     taskId: args.taskId,
@@ -1366,6 +1647,57 @@ async function handleToolCall(name, args) {
                 throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, err instanceof Error ? err.message : String(err));
             }
         }
+        case 'devplan_cleanup_duplicates': {
+            if (!args.projectName) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Missing required: projectName');
+            }
+            const plan = getDevPlan(args.projectName);
+            const dryRun = args.dryRun ?? false;
+            if (typeof plan.cleanupDuplicates !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Duplicate cleanup requires "graph" engine. Project "${args.projectName}" uses a different engine.`);
+            }
+            try {
+                const result = plan.cleanupDuplicates(dryRun);
+                return JSON.stringify({
+                    success: true,
+                    dryRun,
+                    cleaned: result.cleaned,
+                    details: result.details,
+                    summary: result.cleaned === 0
+                        ? '✅ No duplicate entities found. WAL is clean.'
+                        : dryRun
+                            ? `⚠️ Found ${result.cleaned} duplicate entities (dry run, no changes made)`
+                            : `🧹 Cleaned ${result.cleaned} duplicate entities from WAL`,
+                });
+            }
+            catch (err) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, err instanceof Error ? err.message : String(err));
+            }
+        }
+        case 'devplan_repair_counts': {
+            if (!args.projectName) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Missing required: projectName');
+            }
+            const plan = getDevPlan(args.projectName);
+            if (typeof plan.repairAllMainTaskCounts !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Repair counts requires "graph" engine. Project "${args.projectName}" uses a different engine.`);
+            }
+            try {
+                const result = plan.repairAllMainTaskCounts();
+                return JSON.stringify({
+                    success: true,
+                    repaired: result.repaired,
+                    autoCompleted: result.autoCompleted,
+                    details: result.details,
+                    summary: result.repaired === 0
+                        ? '✅ All main task counts are correct. No repair needed.'
+                        : `🔧 Repaired ${result.repaired} main tasks (${result.autoCompleted} auto-completed)`,
+                });
+            }
+            catch (err) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, err instanceof Error ? err.message : String(err));
+            }
+        }
         case 'devplan_create_module': {
             if (!args.projectName || !args.moduleId || !args.name) {
                 throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Missing required: projectName, moduleId, name');
@@ -1825,6 +2157,207 @@ async function handleToolCall(name, args) {
                 prompts,
             }, null, 2);
         }
+        // ==================================================================
+        // Memory Tools (Cursor 长期记忆)
+        // ==================================================================
+        case 'devplan_memory_save': {
+            const projectName = args.projectName;
+            const content = args.content;
+            const memoryType = args.memoryType;
+            if (!content) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Missing required: content');
+            }
+            if (!memoryType) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Missing required: memoryType');
+            }
+            const validTypes = ['decision', 'pattern', 'bugfix', 'insight', 'preference', 'summary'];
+            if (!validTypes.includes(memoryType)) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, `Invalid memoryType: "${memoryType}". Must be one of: ${validTypes.join(', ')}`);
+            }
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.saveMemory !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory features require "graph" engine. Project "${projectName}" uses a different engine.`);
+            }
+            const memory = plan.saveMemory({
+                projectName,
+                content,
+                memoryType: memoryType,
+                importance: args.importance,
+                tags: args.tags,
+                relatedTaskId: args.relatedTaskId,
+                sourceId: args.sourceId,
+                moduleId: args.moduleId,
+                source: args.source || 'cursor',
+            });
+            return JSON.stringify({
+                status: 'saved',
+                memory,
+            }, null, 2);
+        }
+        case 'devplan_memory_recall': {
+            const projectName = args.projectName;
+            const query = args.query;
+            if (!query) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Missing required: query');
+            }
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.recallMemory !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory features require "graph" engine. Project "${projectName}" uses a different engine.`);
+            }
+            const includeDocs = args.includeDocs !== undefined ? args.includeDocs : true;
+            const graphExpand = args.graphExpand !== undefined ? args.graphExpand : true;
+            const memories = plan.recallMemory(query, {
+                memoryType: args.memoryType,
+                limit: args.limit,
+                minScore: args.minScore,
+                includeDocs,
+                graphExpand,
+            });
+            // 统计来源分布
+            const memoryCount = memories.filter((m) => m.sourceKind === 'memory' || !m.sourceKind).length;
+            const docCount = memories.filter((m) => m.sourceKind === 'doc').length;
+            return JSON.stringify({
+                projectName,
+                query,
+                count: memories.length,
+                memoryCount,
+                docCount,
+                unifiedRecall: includeDocs,
+                memories,
+            }, null, 2);
+        }
+        case 'devplan_memory_list': {
+            const projectName = args.projectName;
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.listMemories !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory features require "graph" engine. Project "${projectName}" uses a different engine.`);
+            }
+            const memories = plan.listMemories({
+                memoryType: args.memoryType,
+                limit: args.limit,
+            });
+            return JSON.stringify({
+                projectName,
+                count: memories.length,
+                filter: {
+                    memoryType: args.memoryType || null,
+                    limit: args.limit || null,
+                },
+                memories,
+            }, null, 2);
+        }
+        case 'devplan_memory_delete': {
+            const projectName = args.projectName;
+            const memoryId = args.memoryId;
+            if (!memoryId) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Missing required: memoryId');
+            }
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.deleteMemory !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory features require "graph" engine. Project "${projectName}" uses a different engine.`);
+            }
+            const success = plan.deleteMemory(memoryId);
+            return JSON.stringify({
+                status: success ? 'deleted' : 'not_found',
+                memoryId,
+            }, null, 2);
+        }
+        case 'devplan_memory_clear': {
+            const projectName = args.projectName;
+            const confirm = args.confirm;
+            if (confirm !== true) {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidParams, 'Safety guard: confirm must be true to clear memories. Set confirm: true to proceed.');
+            }
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.clearAllMemories !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory features require "graph" engine. Project "${projectName}" uses a different engine.`);
+            }
+            const memoryType = args.memoryType;
+            const result = plan.clearAllMemories(memoryType);
+            return JSON.stringify({
+                status: 'cleared',
+                ...result,
+                memoryType: memoryType || 'all',
+                projectName,
+            }, null, 2);
+        }
+        case 'devplan_memory_clusters': {
+            const projectName = args.projectName;
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.getMemoryClusters !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory clusters require "graph" engine. Project "${projectName}" uses a different engine.`);
+            }
+            const clusters = plan.getMemoryClusters();
+            const totalMemories = clusters.reduce((sum, c) => sum + c.memoryCount, 0);
+            return JSON.stringify({
+                projectName,
+                totalClusters: clusters.length,
+                totalMemories,
+                clusters: clusters.map((c) => ({
+                    clusterId: c.clusterId,
+                    theme: c.theme,
+                    memoryCount: c.memoryCount,
+                    topMemoryTypes: c.topMemoryTypes,
+                    memories: c.memories.map((m) => ({
+                        id: m.id,
+                        memoryType: m.memoryType,
+                        content: m.content.length > 100 ? m.content.slice(0, 100) + '...' : m.content,
+                        importance: m.importance,
+                        tags: m.tags,
+                    })),
+                })),
+            }, null, 2);
+        }
+        case 'devplan_memory_context': {
+            const projectName = args.projectName;
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.getMemoryContext !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory features require "graph" engine. Project "${projectName}" uses a different engine.`);
+            }
+            const context = plan.getMemoryContext(args.query, args.maxMemories);
+            return JSON.stringify({
+                projectName,
+                context,
+            }, null, 2);
+        }
+        case 'devplan_memory_generate': {
+            const projectName = args.projectName;
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.generateMemoryCandidates !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory generation requires "graph" engine. Project "${projectName}" uses a different engine.`);
+            }
+            const result = plan.generateMemoryCandidates({
+                source: args.source,
+                taskId: args.taskId,
+                section: args.section,
+                subSection: args.subSection,
+                limit: args.limit,
+            });
+            return JSON.stringify(result, null, 2);
+        }
+        case 'devplan_memory_lifecycle': {
+            const projectName = args.projectName;
+            const plan = (0, dev_plan_factory_1.createDevPlan)(projectName);
+            if (typeof plan.runMemoryLifecycle !== 'function') {
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InvalidRequest, `Memory lifecycle requires "graph" engine with dynamicScan support. Project "${projectName}" may use a different engine or older aifastdb version.`);
+            }
+            const report = plan.runMemoryLifecycle({
+                demoteIdleTimeoutSecs: args.demoteIdleTimeoutSecs,
+                promoteHitThreshold: args.promoteHitThreshold,
+            });
+            if (report === null) {
+                return JSON.stringify({
+                    status: 'unsupported',
+                    message: 'dynamicScan not available in current aifastdb version. Please upgrade to aifastdb >= 2.8.0.',
+                });
+            }
+            return JSON.stringify({
+                status: 'completed',
+                projectName,
+                report,
+                message: `Scanned ${report.scanned} memories: ${report.promoted} promoted, ${report.demoted} demoted (${report.durationMs}ms)`,
+            });
+        }
         default:
             throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
     }