context-mcp-server 1.0.7 → 1.0.8

package/src/guard.js

@@ -1,7 +1,13 @@
 import { resolve, sep } from 'node:path';
+import { realpathSync } from 'node:fs';
+
+// Follow symlinks to get the true path; fall back to resolve() if path doesn't exist yet.
+function safeStat(p) {
+  try { return realpathSync(p); } catch { return resolve(p); }
+}
 
 /**
- * Resolves `inputPath` and asserts it falls within `allowedRoot`.
+ * Resolves `inputPath` (following symlinks) and asserts it falls within `allowedRoot`.
  * Throws if no root is configured or if the path escapes the root.
  * Returns the resolved absolute path on success.
  */
@@ -11,8 +17,8 @@ export function guardPath(inputPath, allowedRoot) {
       'Project root not configured. Call context with action:"resume" and include rootPath to enable file/git access.'
     );
   }
-  const resolved = resolve(inputPath);
-  const root = resolve(allowedRoot);
+  const resolved = safeStat(inputPath);
+  const root = safeStat(allowedRoot);
   if (resolved !== root && !resolved.startsWith(root + sep)) {
     throw new Error(`Access denied: "${resolved}" is outside the project root "${root}"`);
   }

package/src/migrator.js

@@ -0,0 +1,124 @@
+/**
+ * migrator.js — one-time migration from flat JSON files to per-project directory structure.
+ *
+ * Old layout:
+ *   ~/.context-mcp/contexts.json      all entries flat
+ *   ~/.context-mcp/discussions.json   all discussions flat
+ *   ~/.context-mcp/graphs.json        all graph build records flat
+ *
+ * New layout:
+ *   ~/.context-mcp/projects/<slug>/context.json
+ *   ~/.context-mcp/projects/<slug>/graph.json     { build, entries[] }
+ *   ~/.context-mcp/projects/<slug>/summary.json
+ *   ~/.context-mcp/projects/<slug>/discussions.json
+ */
+
+import { readFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+
+function normPath(p) {
+  return p ? p.toLowerCase().replace(/\\/g, '/').replace(/\/$/, '') : '';
+}
+
+function treeFor(entry) {
+  if (entry.type === 'compaction') return 'summary';
+  return 'context';
+}
+
+function readArr(filePath, key) {
+  if (!existsSync(filePath)) return [];
+  try {
+    const d = JSON.parse(readFileSync(filePath, 'utf8'));
+    return Array.isArray(d[key]) ? d[key] : (Array.isArray(d) ? d : []);
+  } catch { return []; }
+}
+
+/**
+ * Run migration if legacy flat files are present.
+ * @param {object} opts
+ * @param {string}   opts.dataDir       - base data dir (~/.context-mcp)
+ * @param {string}   opts.projectsDir   - projects sub-dir
+ * @param {string}   opts.projectsPath  - path to projects.json
+ * @param {Function} opts.slugify       - name → filesystem slug
+ * @param {Function} opts.flushFile     - (filePath, content) atomic write
+ * @param {Array}    opts.projectsIndex - current projects.json array (mutated in place)
+ */
+export function runMigration({ dataDir, projectsDir, projectsPath, slugify, flushFile, projectsIndex }) {
+  const legacyContexts    = join(dataDir, 'contexts.json');
+  const legacyDiscussions = join(dataDir, 'discussions.json');
+  const legacyGraphs      = join(dataDir, 'graphs.json');
+
+  const hasLegacy = existsSync(legacyContexts)
+    || existsSync(legacyDiscussions)
+    || existsSync(legacyGraphs);
+
+  if (!hasLegacy) return false;
+
+  const oldContexts    = readArr(legacyContexts,    'contexts');
+  const oldDiscussions = readArr(legacyDiscussions,  'discussions');
+  const oldGraphs      = readArr(legacyGraphs,       'graphs');
+
+  // Remap legacy type names to current 4-type schema
+  const TYPE_MAP = { architecture: 'note', code: 'note', error: 'bug', summary: 'compaction' };
+  const remapType = entry => {
+    if (TYPE_MAP[entry.type]) entry.type = TYPE_MAP[entry.type];
+    return entry;
+  };
+
+  // Group everything by project name
+  const byProject = {};
+  const ensure = name => {
+    if (!byProject[name]) byProject[name] = {
+      context: [], graph: { build: null }, summary: [], discussions: [],
+    };
+    return byProject[name];
+  };
+
+  for (const entry of oldContexts) {
+    remapType(entry);
+    const p = entry.project || 'global';
+    const d = ensure(p);
+    if (treeFor(entry) === 'summary') d.summary.push(entry);
+    else d.context.push(entry);
+  }
+
+  for (const disc of oldDiscussions) {
+    ensure(disc.project || 'global').discussions.push(disc);
+  }
+
+  // Match graph build records to projects via rootPath
+  for (const graph of oldGraphs) {
+    const proj = projectsIndex.find(p => normPath(p.rootPath) === normPath(graph.path));
+    const name = proj ? proj.name : 'global';
+    const d = ensure(name);
+    d.graph.build = {
+      path: graph.path, nodes: graph.nodes, edges: graph.edges,
+      communities: graph.communities, cached: graph.cached || 0,
+      changed: graph.changed || 0, time_ms: graph.time_ms || 0,
+      summary: graph.summary || '', builtAt: graph.builtAt,
+    };
+  }
+
+  // Write per-project files
+  for (const [name, data] of Object.entries(byProject)) {
+    const dir = join(projectsDir, slugify(name));
+    mkdirSync(dir, { recursive: true });
+    flushFile(join(dir, 'context.json'),     { entries: data.context });
+    flushFile(join(dir, 'graph.json'),       data.graph);
+    flushFile(join(dir, 'summary.json'),     { entries: data.summary });
+    flushFile(join(dir, 'discussions.json'), { discussions: data.discussions });
+  }
+
+  // Stamp dataDir onto each project record
+  for (const proj of projectsIndex) {
+    if (!proj.dataDir) proj.dataDir = `projects/${slugify(proj.name)}`;
+  }
+  flushFile(projectsPath, { projects: projectsIndex });
+
+  // Remove legacy flat files
+  try { unlinkSync(legacyContexts);    } catch {}
+  try { unlinkSync(legacyDiscussions); } catch {}
+  try { unlinkSync(legacyGraphs);      } catch {}
+
+  return true;
+}

package/src/server.js

@@ -5,7 +5,7 @@ import { getConfig } from './config.js';
 
 import * as contextTool    from './tools/context.js';
 import * as searchTool     from './tools/search.js';
-import * as discussionTool from './tools/discussion.js';
+import * as planTool        from './tools/plan.js';
 import * as errorCheckTool from './tools/errorCheck.js';
 import * as fileTool       from './tools/fileTools.js';
 import * as gitTool        from './tools/gitTools.js';
@@ -17,8 +17,9 @@ const CODEGRAPH_TOOL_NAMES = codegraphTool.TOOL_NAMES;
 
 export function createServer({ enableFileTools = false, enableGitTools = getConfig().access_git === true } = {}) {
   const state = {
-    sessionProject: null,
-    discussionId:   null,
+    sessionProject:  null,
+    discussionId:    null,
+    projectRootPath: null,
   };
 
   const server = new Server(
@@ -30,7 +31,7 @@ export function createServer({ enableFileTools = false, enableGitTools = getConf
     const tools = [
       contextTool.definition,
       searchTool.definition,
-      discussionTool.definition,
+      planTool.definition,
       errorCheckTool.definition,
     ];
     if (enableFileTools) tools.push(...fileTool.definitions);
@@ -56,8 +57,8 @@ export function createServer({ enableFileTools = false, enableGitTools = getConf
         result = await contextTool.handle(args, state);
       } else if (name === searchTool.definition.name) {
         result = await searchTool.handle(args, state);
-      } else if (name === discussionTool.definition.name) {
-        result = await discussionTool.handle(args, state);
+      } else if (name === planTool.definition.name) {
+        result = await planTool.handle(args, state);
       } else if (name === errorCheckTool.definition.name) {
         result = await errorCheckTool.handle(args, state);
       } else if (FILE_TOOL_NAMES.has(name)) {

package/src/templates/AGENTS.md

@@ -11,7 +11,7 @@ Call the `context` MCP tool with `action: "resume"`, `project: "<project-name>"`
 
 Returns:
 - `recentEntries` — decisions, bugs, notes from previous conversations
-- `activeDiscussions` — ongoing topics
+- `activePlans` — active AI-created plans for this project
 - `codegraph` — `{ built: true/false, nodes, edges, communities }`
 
 Then:
@@ -24,7 +24,7 @@ Then:
 
 **After graph build or rebuild** — every time `codegraph_build` completes:
 ```
-context.save  type: "architecture"  title: "ContextGraph built — <project>"
+context.save  type: "note"  title: "ContextGraph built — <project>"
 content: "nodes: X | edges: Y | communities: Z"
 ```
 
@@ -35,18 +35,12 @@ content: "nodes: X | edges: Y | communities: Z"
 | What happened | Type |
 |--------------|------|
 | Approach / library / pattern decided | `decision` |
-| Bug found (root cause known) or fixed | `bug` |
-| System structure understood | `architecture` |
-| Gotcha, constraint, non-obvious behavior | `note` |
-| Config / env var / secret key discovered | `config` |
-| External API or service integration learned | `note` |
-| Performance insight (why something is slow/fast) | `note` |
-| How to run tests / test pattern discovered | `note` |
-| Deploy / release step discovered | `note` |
-| Milestone / feature / task completed | `note` |
+| Bug found, root cause known, or fixed | `bug` |
+| Gotcha, constraint, discovery, structure understood | `note` |
+| Config / env var / secret / deploy step | `config` |
 
 Do NOT save: routine reads, search results, temporary debugging dead-ends.
-Feature spans sessions → `discussion.save` status: `"active"`.
+**Making any kind of plan** → call `plan.save` immediately with the plan summary and `planDir` pointing to your platform's plans folder.
 Need past info → `search` before asking. Always pass `project`.
 
 ---
@@ -63,7 +57,6 @@ codegraph_build(path)  →  AST graph: functions, classes, imports, edges
 ### Step 2 — Query (free, instant)
 ```
 codegraph_query(path, question)   →  fetch any details about the codebase
-codegraph_explain(path, node)     →  single node: type, file, connections
 codegraph_path(path, from, to)    →  shortest path
 codegraph_nodes(path, type)       →  list nodes by type
 codegraph_report(path)            →  full graph analysis

package/src/templates/CLAUDE.md

@@ -24,7 +24,7 @@ Both fields are required: `project` names the memory bucket, `rootPath` enables
 
 Returns:
 - `recentEntries` — decisions, bugs, notes from previous conversations
-- `activeDiscussions` — ongoing topics (auto-linked if exactly one active)
+- `activePlans` — active AI-created plans for this project
 - `codegraph` — `{ built: true/false, nodes, edges, communities }`
 
 Then:
@@ -39,7 +39,7 @@ Then:
 
 **After graph build or rebuild** — every time `codegraph_build` completes:
 ```
-context.save  project: "<project>"  type: "architecture"  title: "ContextGraph built — <project>"
+context.save  project: "<project>"  type: "note"  title: "ContextGraph built — <project>"
 content: "nodes: X | edges: Y | communities: Z"
 ```
 
@@ -50,19 +50,13 @@ content: "nodes: X | edges: Y | communities: Z"
 | What happened | Type |
 |--------------|------|
 | Approach / library / pattern decided | `decision` |
-| Bug found (root cause known) or fixed | `bug` |
-| System structure understood | `architecture` |
-| Gotcha, constraint, non-obvious behavior | `note` |
-| Config / env var / secret key discovered | `config` |
-| External API or service integration learned | `note` |
-| Performance insight (why something is slow/fast) | `note` |
-| How to run tests / test pattern discovered | `note` |
-| Deploy / release step discovered | `note` |
-| Milestone / feature / task completed | `note` |
+| Bug found, root cause known, or fixed | `bug` |
+| Gotcha, constraint, discovery, structure understood | `note` |
+| Config / env var / secret / deploy step | `config` |
 
 Do NOT save: routine reads, search results, temporary debugging dead-ends.
 
-Feature spans multiple sessions → `discussion.create` or `discussion.update`.
+**Making any kind of plan** → call `plan.save` immediately with the plan summary and `planDir` pointing to your platform's plans folder.
 Need past info → `search` before asking user.
 Always pass `project`. Auto-compact fires at >20 entries.
 

package/src/templates/GEMINI.md

@@ -11,7 +11,7 @@ Call the `context` MCP tool with `action: "resume"`, `project: "<project-name>"`
 
 Returns:
 - `recentEntries` — decisions, bugs, notes from previous conversations
-- `activeDiscussions` — ongoing topics (auto-linked if exactly one active)
+- `activePlans` — active AI-created plans for this project
 - `codegraph` — `{ built: true/false, nodes, edges, communities }`
 
 Then:
@@ -24,7 +24,7 @@ Then:
 
 **After graph build or rebuild** — every time `codegraph_build` completes:
 ```
-context.save  type: "architecture"  title: "ContextGraph built — <project>"
+context.save  type: "note"  title: "ContextGraph built — <project>"
 content: "nodes: X | edges: Y | communities: Z"
 ```
 
@@ -35,18 +35,12 @@ content: "nodes: X | edges: Y | communities: Z"
 | What happened | Type |
 |--------------|------|
 | Approach / library / pattern decided | `decision` |
-| Bug found (root cause known) or fixed | `bug` |
-| System structure understood | `architecture` |
-| Gotcha, constraint, non-obvious behavior | `note` |
-| Config / env var / secret key discovered | `config` |
-| External API or service integration learned | `note` |
-| Performance insight (why something is slow/fast) | `note` |
-| How to run tests / test pattern discovered | `note` |
-| Deploy / release step discovered | `note` |
-| Milestone / feature / task completed | `note` |
+| Bug found, root cause known, or fixed | `bug` |
+| Gotcha, constraint, discovery, structure understood | `note` |
+| Config / env var / secret / deploy step | `config` |
 
 Do NOT save: routine reads, search results, temporary debugging dead-ends.
-Feature spans sessions → `discussion.save` then `discussion.update`.
+**Making any kind of plan** → call `plan.save` immediately with the plan summary and `planDir` pointing to your platform's plans folder.
 Need past info → `search` before asking. Always pass `project`.
 
 ---
@@ -63,7 +57,6 @@ codegraph_build(path)  →  AST graph: functions, classes, imports, edges
 ### Step 2 — Query (free, instant)
 ```
 codegraph_query(path, question)   →  fetch any details about the codebase
-codegraph_explain(path, node)     →  single node: type, file, connections
 codegraph_path(path, from, to)    →  shortest path
 codegraph_nodes(path, type)       →  list nodes by type
 codegraph_report(path)            →  full graph analysis

package/src/templates/commands/context-resume.md

@@ -4,7 +4,7 @@ Both `project` and `rootPath` are required: `project` names the memory bucket, `
 
 This loads:
 - Recent decisions, bugs, and notes from past sessions
-- Active discussions
+- Active plans
 - ContextGraph status (built or not)
 
 If `codegraph.built` is false in the response, immediately call `codegraph_build` on the project path before proceeding.

package/src/templates/commands/save-context.md

@@ -4,6 +4,6 @@ Parse `$ARGUMENTS` to determine:
 - `project`: infer from current working directory name if not specified
 - `title`: first sentence or phrase from the argument
 - `content`: full argument text
-- `type`: auto-detect — if mentions a bug/fix → `"bug"`, decision/chose/decided → `"decision"`, structure/architecture → `"architecture"`, otherwise `"note"`
+- `type`: auto-detect — if mentions a bug/fix → `"bug"`, decision/chose/decided → `"decision"`, config/env/secret/deploy → `"config"`, otherwise `"note"`
 
 Confirm to the user what was saved (title, type, project).

package/src/templates/cursor-rules.mdc

@@ -13,7 +13,7 @@ Every conversation starts with `context.resume`. Every structural question uses
 
 Call `context` tool, `action: "resume"`, `project: "<project-name>"` before anything else.
 
-Returns: `recentEntries`, `activeDiscussions`, `codegraph { built, nodes, edges }`.
+Returns: `recentEntries`, `activePlans`, `codegraph { built, nodes, edges }`.
 
 - `codegraph.built: true` → use `codegraph_query` before reading files
 - `codegraph.built: false` → run `codegraph_build(path)` first
@@ -24,8 +24,8 @@ Returns: `recentEntries`, `activeDiscussions`, `codegraph { built, nodes, edges
 |-----------|--------|
 | Decision made | `context.save` type: `"decision"` |
 | Bug found/fixed | `context.save` type: `"bug"` |
-| Architecture understood | `context.save` type: `"architecture"` |
-| Multi-session feature | `discussion.create` |
+| Discovery / structure understood | `context.save` type: `"note"` |
+| Making any plan | `plan.save` + `planDir` |
 
 ## 3. CodeGraph
 

package/src/templates/skills/SKILL.md

@@ -27,7 +27,7 @@ Both fields are required: `project` names the memory bucket, `rootPath` enables
 
 Returns:
 - `recentEntries` — decisions, bugs, notes from past sessions
-- `activeDiscussions` — ongoing topics (auto-linked if exactly one active)
+- `activePlans` — active AI-created plans for this project
 - `codegraph` — `{ built: true/false, nodes, edges, communities }`
 
 Then:
@@ -43,7 +43,7 @@ Then:
 **1. After graph build or rebuild**
 Every time `codegraph_build` completes successfully, immediately call:
 ```
-context.save  project: "<project>"  type: "architecture"  title: "ContextGraph built — <project>"
+context.save  project: "<project>"  type: "note"  title: "ContextGraph built — <project>"
 content: "nodes: X | edges: Y | communities: Z | built: <timestamp>"
 ```
 
@@ -63,17 +63,11 @@ Do NOT save for: routine file reads, search results, explanations of existing co
 | What happened | Type |
 |--------------|------|
 | Approach / library / pattern decided | `decision` |
-| Bug found (root cause known) or fixed | `bug` |
-| System structure understood | `architecture` |
-| Gotcha, constraint, non-obvious behavior | `note` |
-| Config / env var / secret key discovered | `config` |
-| External API or service integration learned | `note` |
-| Performance insight (why something is slow/fast) | `note` |
-| How to run tests / test pattern discovered | `note` |
-| Deploy / release step discovered | `note` |
-| Milestone / feature / task completed | `note` |
-
-Always pass `project`. Feature spans multiple sessions → `discussion.create` or `discussion.update`. Need past info → `search` before asking user. Auto-compact fires at >20 entries.
+| Bug found, root cause known, or fixed | `bug` |
+| Gotcha, constraint, discovery, structure understood | `note` |
+| Config / env var / secret / deploy step | `config` |
+
+Always pass `project`. **Making any plan** → `plan.save` immediately (planDir = your platform's plans folder). Need past info → `search` before asking user. Auto-compact fires at >20 entries.
 
 ---
 

package/src/templates/windsurf-rules.md

@@ -7,7 +7,7 @@ Every conversation starts with `context.resume`. Every structural question uses
 
 Call `context` tool, `action: "resume"`, `project: "<project-name>"` before anything else.
 
-Returns: `recentEntries`, `activeDiscussions`, `codegraph { built, nodes, edges }`.
+Returns: `recentEntries`, `activePlans`, `codegraph { built, nodes, edges }`.
 
 - `codegraph.built: true` → use `codegraph_query` before reading files
 - `codegraph.built: false` → run `codegraph_build(path)` first
@@ -18,8 +18,8 @@ Returns: `recentEntries`, `activeDiscussions`, `codegraph { built, nodes, edges
 |-----------|--------|
 | Decision made | `context.save` type: `"decision"` |
 | Bug found/fixed | `context.save` type: `"bug"` |
-| Architecture understood | `context.save` type: `"architecture"` |
-| Multi-session feature | `discussion.create` |
+| Discovery / structure understood | `context.save` type: `"note"` |
+| Making any plan | `plan.save` + `planDir` |
 
 ## 3. CodeGraph
 

package/src/tools/context.js

@@ -40,13 +40,12 @@ export const definition = {
       title:         { type: 'string' },
       project:       { type: 'string' },
       rootPath:      { type: 'string', description: 'Absolute path to the project root directory. Stored on first call and used to sandbox file/git tool access.' },
-      type:          { type: 'string', enum: ['decision', 'note', 'code', 'bug', 'architecture', 'config', 'summary', 'error'] },
+      type:          { type: 'string', enum: ['decision', 'bug', 'note', 'config'] },
       status:        { type: 'string', enum: ['active', 'archived'] },
       tags:          { type: 'array', items: { type: 'string' } },
       source:        { type: 'string', enum: ['user', 'ai-summary', 'file', 'web', 'cli', 'auto'] },
       files:         { type: 'array', items: { type: 'object' } },
       codeRefs:      { type: 'array', items: { type: 'object' } },
-      relations:     { type: 'array', items: { type: 'object' } },
       expiresAt:     { type: 'string' },
       limit:         { type: 'number' },
       includeArchived: { type: 'boolean' },
@@ -117,7 +116,7 @@ export async function handle(args, state) {
 
       return {
         recentEntries:      entries,
-        activeDiscussions:  discussions,
+        activePlans:        discussions,
         restoredDiscussion: discussions.length === 1 ? { id: discussions[0].id, name: discussions[0].name } : null,
         codegraph:          graphStatus,
         digest:             digest || undefined,
@@ -165,13 +164,12 @@ export async function handle(args, state) {
           type: args.type || dupe.type, status: args.status || dupe.status,
           expiresAt: args.expiresAt !== undefined ? args.expiresAt : dupe.expiresAt,
           files: args.files || dupe.files, codeRefs: args.codeRefs || dupe.codeRefs,
-          relations: args.relations || dupe.relations,
         });
         fireAutoLink(updated.id, state);
         return { success: true, id: updated.id, deduplicated: true,
           message: `Updated existing entry "${updated.title || updated.id}" (auto-dedup).` };
       }
-      const entry = saveContext({ ...args });
+      const entry = saveContext({ ...args, rootPath: state.projectRootPath || undefined });
       fireAutoLink(entry.id, state);
 
       // Auto-compact when too many entries accumulate

package/src/tools/gitTools.js

@@ -26,10 +26,8 @@ function autoDetectRoot(fromDir) {
 }
 
 function resolveCwd(args, state) {
-  // Auto-detect project root on first use if not already configured.
   if (!state.projectRootPath) {
-    const detected = autoDetectRoot(args.cwd ? pathResolve(args.cwd) : process.cwd());
-    state.projectRootPath = detected || process.cwd();
+    throw new Error('No project root configured. Call context.resume with rootPath before using git tools.');
   }
   const raw = args.cwd ? pathResolve(args.cwd) : state.projectRootPath;
   return guardPath(raw, state.projectRootPath);

package/src/tools/plan.js

@@ -0,0 +1,130 @@
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import {
+  saveDiscussion, getDiscussion, listDiscussions,
+  deleteDiscussion, updateDiscussion,
+} from '../db.js';
+
+function writePlanFile(planDir, name, content, title) {
+  if (!planDir) return null;
+  const dir = resolve(planDir);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  const filePath = join(dir, `${slug}.md`);
+  const md = `# ${title || name}\n\n${content || ''}\n`;
+  writeFileSync(filePath, md, 'utf8');
+  return filePath;
+}
+
+export const definition = {
+  name: 'plan',
+  description:
+    `AI plan storage — auto-call this tool whenever you create any kind of plan.\n` +
+    `Saves a summary of the plan to the project store and writes a .md file to planDir.\n` +
+    `• "save"   — Store a new plan or overwrite an existing one by name. Pass planDir to write a file.\n` +
+    `• "update" — Patch title/content/status on an existing plan.\n` +
+    `• "get"    — Retrieve a plan by name or id (full content).\n` +
+    `• "list"   — List all plans for the project.\n` +
+    `• "delete" — Remove a plan by name or id.`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action:  { type: 'string', enum: ['save', 'get', 'list', 'update', 'delete'] },
+      name:    { type: 'string', description: 'Short slug-style identifier for the plan, e.g. "auth-refactor"' },
+      id:      { type: 'string' },
+      project: { type: 'string' },
+      title:   { type: 'string', description: 'Human-readable plan title' },
+      content: { type: 'string', description: 'Full plan summary in markdown' },
+      status:  { type: 'string', enum: ['active', 'done'] },
+      tags:    { type: 'array', items: { type: 'string' } },
+      planDir: { type: 'string', description: 'Absolute path to the folder where .md plan files are written. Pass the path for your AI platform (e.g. ~/.claude/plans/ for Claude Code).' },
+    },
+    required: ['action'],
+  },
+  outputSchema: {
+    type: 'object',
+    properties: {
+      success:  { type: 'boolean' },
+      id:       { type: 'string' },
+      name:     { type: 'string' },
+      filePath: { type: 'string' },
+      plan:     { type: 'object' },
+      plans:    { type: 'array' },
+      message:  { type: 'string' },
+    },
+  },
+};
+
+export async function handle(args, state) {
+  if (!args.project && state.sessionProject) args = { ...args, project: state.sessionProject };
+
+  switch (args.action) {
+    case 'save': {
+      if (!args.name)    throw new Error('name is required for save');
+      if (!args.content) throw new Error('content is required for save');
+      const plan = saveDiscussion({
+        name:        args.name,
+        title:       args.title || args.name,
+        content:     args.content,
+        project:     args.project,
+        tags:        args.tags,
+        type:        'plan',
+        status:      args.status || 'active',
+        sessionId:   state.sessionId || null,
+      });
+      if (plan.status === 'active') state.discussionId = plan.id;
+      const filePath = writePlanFile(args.planDir, args.name, args.content, args.title);
+      return {
+        success: true, id: plan.id, name: plan.name,
+        filePath: filePath || undefined,
+        message: `Plan "${plan.name}" saved.${filePath ? ` Written to ${filePath}` : ''}`,
+      };
+    }
+
+    case 'update': {
+      if (!args.name && !args.id) throw new Error('name or id is required for update');
+      const updated = updateDiscussion({
+        name:    args.name,
+        id:      args.id,
+        title:   args.title,
+        content: args.content,
+        status:  args.status,
+        tags:    args.tags,
+      });
+      if (!updated) throw new Error(`No plan found for "${args.name || args.id}".`);
+      if (updated.status !== 'active' && state.discussionId === updated.id) state.discussionId = null;
+      if (updated.status === 'active') state.discussionId = updated.id;
+      const filePath = writePlanFile(args.planDir, updated.name, updated.content, updated.title);
+      return {
+        success: true, id: updated.id, name: updated.name, status: updated.status,
+        filePath: filePath || undefined,
+        message: `Plan "${updated.name}" updated (${updated.status}).`,
+      };
+    }
+
+    case 'get': {
+      if (!args.name && !args.id) throw new Error('name or id is required for get');
+      const plan = getDiscussion({ name: args.name, id: args.id, project: args.project });
+      return plan
+        ? { plan }
+        : { plan: null, message: `No plan found for "${args.name || args.id}".` };
+    }
+
+    case 'list': {
+      const plans = listDiscussions({ project: args.project, status: args.status });
+      return { plans };
+    }
+
+    case 'delete': {
+      if (!args.name && !args.id) throw new Error('name or id is required for delete');
+      const result = deleteDiscussion({ name: args.name, id: args.id });
+      if (state.discussionId && (args.id === state.discussionId || result.deleted > 0)) {
+        state.discussionId = null;
+      }
+      return { ...result, message: `Deleted ${result.deleted} plan(s).` };
+    }
+
+    default:
+      throw new Error(`Unknown plan action: ${args.action}`);
+  }
+}

package/uv.lock

@@ -168,7 +168,7 @@ wheels = [
 
 [[package]]
 name = "codegraph-mcp"
-version = "1.0.6"
+version = "1.0.8"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },