context-mcp-server 1.0.8 → 1.1.1

package/src/templates/codex/prompts/save-context.md

@@ -0,0 +1,24 @@
+---
+description: "Save a note/decision/bug to context-mcp project memory"
+argument-hint: [what to remember]
+---
+
+Call the `context` MCP tool with `action: "save"` to store a note for the
+current project.
+
+Parse the following to determine the fields: $ARGUMENTS
+
+- `project`: infer from current working directory name if not specified.
+- `title`: first sentence or phrase, up to 120 chars.
+- `why`: why it mattered, what problem it solved, or what constraint it revealed.
+- `outcome`: what changed, what was verified, what shipped, and which files were affected.
+- `files`: list of files changed, required for task/bug types.
+- `content`: full argument text.
+- `type`: auto-detect:
+  - bug/fix/error -> `"bug"`
+  - task/done/complete/shipped/implemented -> `"task"`
+  - decision/chose/decided/approach -> `"decision"`
+  - config/env/secret/deploy -> `"config"`
+  - otherwise -> `"note"`
+
+Confirm to the user: title, type, why, outcome, and project.

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

@@ -0,0 +1,7 @@
+# context-resume
+
+Resume project memory and ContextGraph from context-mcp before starting any work.
+
+Call the `context` MCP tool with `action: "resume"`, infer `project` from the current working directory name, and pass `rootPath` as the absolute path to the git repo root.
+
+This loads recent decisions, bugs, notes, active plans, and ContextGraph status. If `codegraph.built` is false, immediately call `codegraph_build` on the project path.

package/src/templates/cursor/commands/graph-build.md

@@ -0,0 +1,7 @@
+# graph-build
+
+Build the ContextGraph (AST knowledge graph) for the current project.
+
+Call `codegraph_build` with the current working directory as the path (or a path provided by the user).
+
+After the build completes, report total nodes, edges, and communities. Once built, use `codegraph_query` to answer structural questions about the codebase instead of reading files directly.

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

@@ -0,0 +1,12 @@
+# save-context
+
+Save a note, decision, bug, or task to context-mcp project memory.
+
+Call the `context` MCP tool with `action: "save"`. Infer `project` from the current working directory name. Auto-detect `type` from the user's description:
+- bug/fix/error → `"bug"`
+- task/done/complete/shipped → `"task"`
+- decision/chose/decided → `"decision"`
+- config/env/deploy → `"config"`
+- otherwise → `"note"`
+
+Fill in `title` (up to 120 chars), `why`, `outcome`, and `files`. Confirm back to the user what was saved.

package/src/templates/{cursor-rules.mdc → cursor/cursor-rules.mdc}

@@ -29,13 +29,23 @@ Returns: `recentEntries`, `activePlans`, `codegraph { built, nodes, edges }`.
 
 ## 3. CodeGraph
 
-Build once: `codegraph_build(path)` — then query forever.
-Use `codegraph_query` for structural questions. Read files for bugs/logic.
+Build once: `codegraph_build(path)` — auto-generates visualizations, then query forever.
+
+```
+codegraph_arch(path)                   → module map (files, exports, imports)
+codegraph_query(path, question?, node?) → find symbol or answer structural question
+codegraph_nodes(path, type)            → list all nodes of a type
+codegraph_report(path)                 → god nodes, clusters, structural analysis
+codegraph_affected(path, node, depth?) → blast radius — what breaks if X changes?
+codegraph_html(path, formats?)         → regenerate visualizations on demand
+```
+
+Use `codegraph_arch` for structural questions. Read files for bugs/logic.
 
 ## Rules
 
 1. `context.resume` first — every conversation
 2. Always pass `project`
 3. `search` before asking the user about past work
-4. `codegraph_query` before reading files
+4. `codegraph_arch` before reading files
 5. Files only for bugs and logic

package/src/templates/cursor/hooks/context-mcp-post-tool-use.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+/**
+ * Cursor postToolUse hook for context-mcp.
+ *
+ * Input (stdin JSON): { hook_event_name: "postToolUse", tool_name,
+ *   tool_input: { command }, tool_response: { exit_code, stdout, stderr }, cwd }
+ *
+ * Saves failed shell commands to context-mcp so the next session can see
+ * what broke. Exits silently when the command succeeded or exit code is unknown.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  let event = {};
+  try {
+    event = input.trim() ? JSON.parse(input) : {};
+  } catch {
+    return;
+  }
+
+  const toolInput = event.tool_input || {};
+  const toolResult = typeof event.tool_response === 'object' && event.tool_response !== null
+    ? event.tool_response
+    : {};
+  const command = toolInput.command || toolInput.cmd || '';
+  const exitCode = toolResult.exit_code ?? toolResult.exitCode ?? toolResult.code
+    ?? event.exit_code ?? event.exitCode;
+
+  if (!command || exitCode === undefined || Number(exitCode) === 0) return;
+
+  const output = String(
+    toolResult.stderr || toolResult.stdout || toolResult.output || event.tool_output || '',
+  ).trim();
+
+  const content = [
+    `Command: ${command}`,
+    `Exit code: ${exitCode}`,
+    output ? `Output:\n${output.slice(0, 4000)}` : null,
+  ].filter(Boolean).join('\n\n');
+
+  spawnSync('ctx', [
+    'save',
+    '--project', (event.cwd || process.cwd()).split(/[\\/]/).pop() || 'default',
+    '--type', 'bug',
+    '--title', `Failed shell command: ${command.slice(0, 80)}`,
+    '--content', content,
+  ], { encoding: 'utf8', shell: true, stdio: 'ignore' });
+});

package/src/templates/gemini/GEMINI.md

@@ -0,0 +1,92 @@
+# Context-MCP — Gemini CLI Usage Guide
+
+Persistent memory + codebase knowledge graph.
+`context.resume` starts every session. `codegraph_arch` shows module structure. `codegraph_query` finds specific symbols. Files only for bugs/logic.
+
+---
+
+## 1. Start of Every Conversation (MANDATORY)
+
+Call `context` MCP tool: `action:"resume"`, `project:"<project>"` before anything else.
+
+Returns: `recentEntries`, `activePlans`, `codegraph`, `stats.totalEntries`.
+
+- `codegraph.built: true` → use graph tools before reading files
+- `codegraph.built: false` → call `codegraph_build(path)` first
+- `stats.totalEntries ≥ 20` → write compaction summary FIRST (see Rule 4)
+- `activePlans` non-empty → read them before starting new work
+
+---
+
+## 2. Save Triggers (MANDATORY)
+
+Call `context.save` with `type: "note"` after finishing anything worth keeping:
+
+| Trigger | Required fields |
+|---|---|
+| Task / fix / feature complete | title, why, outcome, files[] |
+| Decision made | title, why, outcome |
+| Discovery / constraint / gotcha | title, content |
+| Config / env / deploy info | title, content |
+| Graph build complete | title, content (nodes/edges count) |
+| User says "save this" | title, content |
+| "compact now" / "compress memory" | `type:"compaction"`, full session summary |
+
+**Do NOT save:** routine reads, search results, explanations of existing code.
+
+---
+
+## 3. Plans (MANDATORY for multi-file work)
+
+**Create a plan when:** editing 2+ files, multi-step implementation, refactor, multi-file bug fix.
+
+1. Call `plan.save` with name, content, project before starting
+2. Call `plan.update status:"done"` when complete — deletes the plan
+
+Check `activePlans` on resume — don't create duplicates.
+
+---
+
+## 4. Auto-Summary at ≥ 20 Entries (MANDATORY)
+
+When `totalEntries ≥ 20`, call `context.save` BEFORE the user's task:
+
+```
+type: "compaction"  title: "Session summary — <YYYY-MM-DD>"
+content: "<what was built, decided, broke, current state>"
+project: "<project>"
+```
+
+---
+
+## 5. Search Before Asking
+
+Call `search` before asking user to re-explain past work.
+
+---
+
+## 6. ContextGraph Tools
+
+```
+codegraph_build(path)                    → build AST graph + auto-generate all visualizations
+codegraph_arch(path, limit?)             → module map: files, exports, imports
+codegraph_query(path, question?, node?)  → find symbol or answer structural question
+codegraph_nodes(path, type)              → list all nodes of a type
+codegraph_report(path)                   → structural analysis
+codegraph_affected(path, node, depth?)   → blast radius BFS — what breaks if X changes?
+codegraph_html(path, formats?)           → regenerate visualizations on demand
+```
+
+Use `codegraph_arch` first. Never read files for structure questions.
+
+---
+
+## 7. Rules
+
+1. `context.resume` first — before any tool or response
+2. Always pass `project`
+3. Save on task complete — `why` + `outcome` + `files`
+4. Compaction at ≥ 20 entries — before starting task
+5. Plan before multi-file work — `status:"done"` deletes it
+6. Search before asking about past work
+7. Graph tools before files

package/src/templates/gemini/commands/context-resume.toml

@@ -0,0 +1,15 @@
+# Invoked via: /context-resume [project]
+description = "Resume project memory + ContextGraph from context-mcp"
+
+prompt = """
+Call the `context` MCP tool with `action: "resume"`, `project: "{{args}}"` (if no argument given, infer the project name from the current working directory name), and `rootPath: "<absolute path to the project root / git repo root>"`.
+
+Both `project` and `rootPath` are required: `project` names the memory bucket, `rootPath` enables exact graph lookup and file sandboxing.
+
+This loads:
+- Recent decisions, bugs, and notes from past sessions
+- 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/gemini/commands/graph-build.toml

@@ -0,0 +1,14 @@
+# Invoked via: /graph-build [path]
+description = "Build the ContextGraph (AST knowledge graph) for a project"
+
+prompt = """
+Call `codegraph_build` with the path `{{args}}`.
+
+If no argument is given, use the current working directory.
+
+This builds the ContextGraph for the project by parsing source files into an AST
+knowledge graph. Once built, use `codegraph_query` to answer structural questions
+about the codebase before reading files directly.
+
+After the build completes, report total nodes, edges, and communities.
+"""

package/src/templates/gemini/commands/save-context.toml

@@ -0,0 +1,24 @@
+# Invoked via: /save-context <what to remember>
+description = "Save a note/decision/bug to context-mcp project memory"
+
+prompt = """
+Call the `context` MCP tool with `action: "save"` to store a note for the
+current project.
+
+Parse the following arguments to determine the fields: {{args}}
+
+- `project`: infer from current working directory name if not specified.
+- `title`: first sentence or phrase, up to 120 chars.
+- `why`: why it mattered, what problem it solved, or what constraint it revealed.
+- `outcome`: what changed, what was verified, what shipped, and which files were affected.
+- `files`: list of files changed, required for task/bug types.
+- `content`: full argument text.
+- `type`: auto-detect:
+  - bug/fix/error -> `"bug"`
+  - task/done/complete/shipped/implemented -> `"task"`
+  - decision/chose/decided/approach -> `"decision"`
+  - config/env/secret/deploy -> `"config"`
+  - otherwise -> `"note"`
+
+Confirm to the user: title, type, why, outcome, and project.
+"""

package/src/templates/gemini/hooks/context-mcp-after-tool.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+/**
+ * Gemini CLI AfterTool hook for context-mcp.
+ *
+ * Input (stdin JSON): { session_id, cwd, hook_event_name: "AfterTool",
+ *   tool_name, tool_input: { command }, tool_response }
+ *
+ * Saves failed run_shell_command invocations to context-mcp so the next
+ * session can see what broke. Exits silently when the command succeeded
+ * or the exit code cannot be determined.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  let event = {};
+  try {
+    event = input.trim() ? JSON.parse(input) : {};
+  } catch {
+    return;
+  }
+
+  const toolInput = event.tool_input || {};
+  const toolResult = typeof event.tool_response === 'object' && event.tool_response !== null
+    ? event.tool_response
+    : {};
+  const command = toolInput.command || '';
+  const exitCode = toolResult.exit_code ?? toolResult.exitCode ?? toolResult.code;
+
+  if (!command || exitCode === undefined || Number(exitCode) === 0) return;
+
+  const output = String(
+    toolResult.stderr || toolResult.stdout || toolResult.output || '',
+  ).trim();
+
+  const content = [
+    `Command: ${command}`,
+    `Exit code: ${exitCode}`,
+    output ? `Output:\n${output.slice(0, 4000)}` : null,
+  ].filter(Boolean).join('\n\n');
+
+  spawnSync('ctx', [
+    'save',
+    '--project', (event.cwd || process.cwd()).split(/[\\/]/).pop() || 'default',
+    '--type', 'bug',
+    '--title', `Failed shell command: ${command.slice(0, 80)}`,
+    '--content', content,
+  ], {
+    encoding: 'utf8',
+    shell: true,
+    stdio: 'ignore',
+  });
+});

package/src/templates/gemini/hooks/context-mcp-before-tool.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+/**
+ * Gemini CLI BeforeTool hook for context-mcp.
+ *
+ * Input (stdin JSON): { session_id, cwd, hook_event_name: "BeforeTool",
+ *   tool_name, tool_input }
+ *
+ * This hook is intentionally conservative. It validates the hook pipeline
+ * runs before run_shell_command but never blocks (exit 0 with no decision =
+ * allow). Keep policy decisions in GEMINI.md or a dedicated security hook
+ * if your team needs blocking (print {"decision":"deny","reason":"..."}).
+ */
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    if (input.trim()) JSON.parse(input);
+  } catch {
+    // Do not interrupt the user's command because hook input changed.
+  }
+});

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

@@ -0,0 +1,15 @@
+---
+mode: agent
+description: "Resume project memory + ContextGraph from context-mcp"
+---
+
+Call the `context` MCP tool with `action: "resume"`, infer `project` from the current working directory name, and pass `rootPath` as the absolute path to the git repo root.
+
+Both `project` and `rootPath` are required: `project` names the memory bucket, `rootPath` enables exact graph lookup and file sandboxing.
+
+This loads:
+- Recent decisions, bugs, and notes from past sessions
+- 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/vscode/commands/graph-build.prompt.md

@@ -0,0 +1,10 @@
+---
+mode: agent
+description: "Build the ContextGraph (AST knowledge graph) for the current project"
+---
+
+Call `codegraph_build` with the current working directory as the path (or a path provided by the user).
+
+This builds the ContextGraph for the project by parsing source files into an AST knowledge graph. Once built, use `codegraph_query` to answer structural questions about the codebase before reading files directly.
+
+After the build completes, report total nodes, edges, and communities.

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

@@ -0,0 +1,16 @@
+---
+mode: agent
+description: "Save a note/decision/bug to context-mcp project memory"
+argument-hint: "What to remember (e.g. 'fixed auth bug in src/auth.js')"
+---
+
+Call the `context` MCP tool with `action: "save"` to store a note for the current project.
+
+Infer `project` from the current working directory name. Auto-detect `type`:
+- bug/fix/error → `"bug"`
+- task/done/complete/shipped/implemented → `"task"`
+- decision/chose/decided/approach → `"decision"`
+- config/env/secret/deploy → `"config"`
+- otherwise → `"note"`
+
+Fill in `title` (up to 120 chars), `why`, `outcome`, and `files`. Confirm back to the user: title, type, why, outcome, and project.

package/src/templates/vscode/hooks/context-mcp-post-tool-use.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * VS Code Copilot PostToolUse hook for context-mcp.
+ *
+ * Input (stdin JSON): { hook_event_name: "PostToolUse", tool_name,
+ *   tool_input: { command }, tool_output: { exit_code, stdout, stderr }, cwd }
+ *
+ * Saves failed shell commands to context-mcp so the next session can see
+ * what broke. Exits silently when the command succeeded or exit code is unknown.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  let event = {};
+  try {
+    event = input.trim() ? JSON.parse(input) : {};
+  } catch {
+    return;
+  }
+
+  const toolInput = event.tool_input || {};
+  // VS Code uses tool_output (not tool_response) for the result object
+  const toolResult = typeof event.tool_output === 'object' && event.tool_output !== null
+    ? event.tool_output
+    : typeof event.tool_response === 'object' && event.tool_response !== null
+      ? event.tool_response
+      : {};
+  const command = toolInput.command || toolInput.cmd || '';
+  const exitCode = toolResult.exit_code ?? toolResult.exitCode ?? toolResult.code
+    ?? event.exit_code ?? event.exitCode;
+
+  if (!command || exitCode === undefined || Number(exitCode) === 0) return;
+
+  const output = String(
+    toolResult.stderr || toolResult.stdout || toolResult.output || '',
+  ).trim();
+
+  const content = [
+    `Command: ${command}`,
+    `Exit code: ${exitCode}`,
+    output ? `Output:\n${output.slice(0, 4000)}` : null,
+  ].filter(Boolean).join('\n\n');
+
+  spawnSync('ctx', [
+    'save',
+    '--project', (event.cwd || process.cwd()).split(/[\\/]/).pop() || 'default',
+    '--type', 'bug',
+    '--title', `Failed shell command: ${command.slice(0, 80)}`,
+    '--content', content,
+  ], { encoding: 'utf8', shell: true, stdio: 'ignore' });
+});

package/src/templates/windsurf/hooks/context-mcp-post-run-command.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+/**
+ * Windsurf post_run_command hook for context-mcp.
+ *
+ * Input (stdin JSON): { hook_event_name: "post_run_command", tool_name,
+ *   tool_input: { command }, tool_response: { exit_code, stdout, stderr }, cwd }
+ *
+ * Saves failed shell commands to context-mcp so the next session can see
+ * what broke. Exits silently when the command succeeded or exit code is unknown.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  let event = {};
+  try {
+    event = input.trim() ? JSON.parse(input) : {};
+  } catch {
+    return;
+  }
+
+  const toolInput = event.tool_input || {};
+  const toolResult = typeof event.tool_response === 'object' && event.tool_response !== null
+    ? event.tool_response
+    : typeof event.tool_output === 'object' && event.tool_output !== null
+      ? event.tool_output
+      : {};
+  const command = toolInput.command || toolInput.cmd || event.command || '';
+  const exitCode = toolResult.exit_code ?? toolResult.exitCode ?? toolResult.code
+    ?? event.exit_code ?? event.exitCode;
+
+  if (!command || exitCode === undefined || Number(exitCode) === 0) return;
+
+  const output = String(
+    toolResult.stderr || toolResult.stdout || toolResult.output || '',
+  ).trim();
+
+  const content = [
+    `Command: ${command}`,
+    `Exit code: ${exitCode}`,
+    output ? `Output:\n${output.slice(0, 4000)}` : null,
+  ].filter(Boolean).join('\n\n');
+
+  spawnSync('ctx', [
+    'save',
+    '--project', (event.cwd || process.cwd()).split(/[\\/]/).pop() || 'default',
+    '--type', 'bug',
+    '--title', `Failed shell command: ${command.slice(0, 80)}`,
+    '--content', content,
+  ], { encoding: 'utf8', shell: true, stdio: 'ignore' });
+});

package/src/templates/windsurf/windsurf-rules.md

@@ -0,0 +1,86 @@
+# Context-MCP — Windsurf Usage Guide
+
+Persistent memory + codebase knowledge graph.
+`context.resume` starts every session. `codegraph_arch` shows module structure. `codegraph_query` finds specific symbols. Files only for bugs/logic.
+
+---
+
+## 1. Start of Every Conversation (MANDATORY)
+
+Call `context` tool: `action:"resume"`, `project:"<name>"` before anything else.
+
+Returns: `recentEntries`, `activePlans`, `codegraph`, `stats.totalEntries`.
+
+- `codegraph.built: false` → run `codegraph_build(path)` first
+- `stats.totalEntries ≥ 20` → write compaction summary first (see Rule 4)
+- `activePlans` non-empty → read before starting new work
+
+---
+
+## 2. Save Triggers (MANDATORY)
+
+Call `context.save` with `type: "note"` after finishing anything worth keeping:
+
+| Trigger | Required fields |
+|---|---|
+| Task / fix / feature complete | title, why, outcome, files[] |
+| Decision made | title, why, outcome |
+| Discovery / constraint / gotcha | title, content |
+| Config / env / deploy info | title, content |
+| Graph build complete | title, content (nodes/edges count) |
+| User says "save this" | title, content |
+| "compact now" / "compress memory" | `type:"compaction"`, full session summary |
+
+**Do NOT save:** routine reads, search results, explanations of existing code.
+
+---
+
+## 3. Plans
+
+Call `plan.save` before any work touching 2+ files or multiple steps.
+Call `plan.update status:"done"` when complete — deletes the plan.
+Check `activePlans` on resume — don't duplicate.
+
+---
+
+## 4. Auto-Summary at ≥ 20 Entries (MANDATORY)
+
+When `totalEntries ≥ 20`, call `context.save` BEFORE the user's task:
+
+```
+type: "compaction"  title: "Session summary — <date>"
+content: "<what was built, decided, broke, current state>"
+project: "<project>"
+```
+
+---
+
+## 5. Search Before Asking
+
+Call `search` before asking user to re-explain past work.
+
+---
+
+## 6. ContextGraph Tools
+
+```
+codegraph_arch(path)                   → module map (files, exports, imports)
+codegraph_query(path, ...)             → find specific function/class/file
+codegraph_nodes(path, type)            → list all nodes of a type
+codegraph_report(path)                 → structural analysis
+codegraph_affected(path, node, depth?) → blast radius — what breaks if X changes?
+codegraph_html(path, formats?)         → regenerate visualizations (auto on every build)
+```
+
+Use `codegraph_arch` first. Never read files for structure questions.
+
+---
+
+## 7. Rules
+
+1. `context.resume` first — every conversation
+2. Save on task complete — `why` + `outcome` + `files`
+3. Compaction at ≥ 20 entries — before starting task
+4. Plan for 2+ file changes — `status:"done"` deletes it
+5. Search before asking about past work
+6. Graph tools before files

package/src/templates/windsurf/workflows/context-resume.md

@@ -0,0 +1,11 @@
+# context-resume
+
+Resume project memory and ContextGraph from context-mcp before starting any work.
+
+1. Call the `context` MCP tool with `action: "resume"`, infer `project` from the current working directory name, and pass `rootPath` as the absolute path to the git repo root.
+
+2. Read the returned `recentEntries` (last 15 entries), `activePlans`, and `codegraph` status.
+
+3. If `codegraph.built` is false, call `codegraph_build` on the project path immediately before proceeding.
+
+4. If `stats.totalEntries` is 20 or more, save a compaction summary before starting any new work.

package/src/templates/windsurf/workflows/graph-build.md

@@ -0,0 +1,11 @@
+# graph-build
+
+Build the ContextGraph (AST knowledge graph) for the current project.
+
+1. Call `codegraph_build` with the current working directory as the path (or a path provided by the user).
+
+2. Wait for the build to complete.
+
+3. Report total nodes, edges, and communities found.
+
+4. Once built, use `codegraph_query` to answer structural questions about the codebase instead of reading files directly.

package/src/templates/windsurf/workflows/save-context.md

@@ -0,0 +1,18 @@
+# save-context
+
+Save a note, decision, bug, or task to context-mcp project memory.
+
+1. Call the `context` MCP tool with `action: "save"`.
+
+2. Infer `project` from the current working directory name.
+
+3. Auto-detect `type` from the user's description:
+   - bug/fix/error → `"bug"`
+   - task/done/complete/shipped/implemented → `"task"`
+   - decision/chose/decided/approach → `"decision"`
+   - config/env/secret/deploy → `"config"`
+   - otherwise → `"note"`
+
+4. Fill in `title` (up to 120 chars), `why`, `outcome`, and `files`.
+
+5. Confirm back to the user: title, type, why, outcome, and project name.