@contextstream/mcp-server 0.4.65 → 0.4.67

package/dist/index.js

@@ -1563,10 +1563,12 @@ var init_files = __esm({
 // src/hooks-config.ts
 var hooks_config_exports = {};
 __export(hooks_config_exports, {
+  CLAUDE_ENFORCEMENT_CRITICAL_HOOKS: () => CLAUDE_ENFORCEMENT_CRITICAL_HOOKS,
   CLINE_POSTTOOLUSE_HOOK_SCRIPT: () => CLINE_POSTTOOLUSE_HOOK_SCRIPT,
   CLINE_PRETOOLUSE_HOOK_SCRIPT: () => CLINE_PRETOOLUSE_HOOK_SCRIPT,
   CLINE_USER_PROMPT_HOOK_SCRIPT: () => CLINE_USER_PROMPT_HOOK_SCRIPT,
   CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT: () => CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT,
+  CURSOR_ENFORCEMENT_CRITICAL_HOOKS: () => CURSOR_ENFORCEMENT_CRITICAL_HOOKS,
   CURSOR_PRETOOLUSE_HOOK_SCRIPT: () => CURSOR_PRETOOLUSE_HOOK_SCRIPT,
   MEDIA_AWARE_HOOK_SCRIPT: () => MEDIA_AWARE_HOOK_SCRIPT,
   PRECOMPACT_HOOK_SCRIPT: () => PRECOMPACT_HOOK_SCRIPT,
@@ -1585,6 +1587,7 @@ __export(hooks_config_exports, {
   getIndexStatusPath: () => getIndexStatusPath,
   getKiloCodeHooksDir: () => getKiloCodeHooksDir,
   getRooCodeHooksDir: () => getRooCodeHooksDir,
+  getWindsurfHooksConfigPath: () => getWindsurfHooksConfigPath,
   installAllEditorHooks: () => installAllEditorHooks,
   installClaudeCodeHooks: () => installClaudeCodeHooks,
   installClineHookScripts: () => installClineHookScripts,
@@ -1593,15 +1596,18 @@ __export(hooks_config_exports, {
   installHookScripts: () => installHookScripts,
   installKiloCodeHookScripts: () => installKiloCodeHookScripts,
   installRooCodeHookScripts: () => installRooCodeHookScripts,
+  installWindsurfHookScripts: () => installWindsurfHookScripts,
   markProjectIndexed: () => markProjectIndexed,
   mergeHooksIntoSettings: () => mergeHooksIntoSettings,
   readClaudeSettings: () => readClaudeSettings,
   readCursorHooksConfig: () => readCursorHooksConfig,
   readIndexStatus: () => readIndexStatus,
+  readWindsurfHooksConfig: () => readWindsurfHooksConfig,
   unmarkProjectIndexed: () => unmarkProjectIndexed,
   writeClaudeSettings: () => writeClaudeSettings,
   writeCursorHooksConfig: () => writeCursorHooksConfig,
-  writeIndexStatus: () => writeIndexStatus
+  writeIndexStatus: () => writeIndexStatus,
+  writeWindsurfHooksConfig: () => writeWindsurfHooksConfig
 });
 import * as fs4 from "node:fs/promises";
 import * as fsSync from "node:fs";
@@ -1711,6 +1717,18 @@ function buildHooksConfig(options) {
         ]
       }
     ];
+    config.PostCompact = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("post-compact"),
+            timeout: 15
+          }
+        ]
+      }
+    ];
   }
   if (options?.includeSessionInit !== false) {
     config.SessionStart = [
@@ -1725,6 +1743,102 @@ function buildHooksConfig(options) {
         ]
       }
     ];
+    config.InstructionsLoaded = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("instructions-loaded"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+    config.ConfigChange = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("config-change"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+    config.CwdChanged = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("cwd-changed"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+    config.FileChanged = [
+      {
+        matcher: ".*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("file-changed"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+    config.WorktreeCreate = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("worktree-create"),
+            timeout: 15
+          }
+        ]
+      }
+    ];
+    config.WorktreeRemove = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("worktree-remove"),
+            timeout: 15
+          }
+        ]
+      }
+    ];
+    config.Elicitation = [
+      {
+        matcher: ".*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("elicitation"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+    config.ElicitationResult = [
+      {
+        matcher: ".*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("elicitation-result"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
   }
   if (options?.includeSessionEnd !== false) {
     config.Stop = [
@@ -1751,6 +1865,18 @@ function buildHooksConfig(options) {
         ]
       }
     ];
+    config.StopFailure = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("stop-failure"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
   }
   const postToolUseHooks = [];
   if (options?.includePostWrite !== false) {
@@ -1846,6 +1972,12 @@ function buildHooksConfig(options) {
       hooks: [{ type: "command", command: getHookCommand("subagent-stop"), timeout: 15 }]
     }
   ];
+  config.TaskCreated = [
+    {
+      matcher: "*",
+      hooks: [{ type: "command", command: getHookCommand("task-created"), timeout: 10 }]
+    }
+  ];
   config.TaskCompleted = [
     {
       matcher: "*",
@@ -1926,11 +2058,21 @@ async function installClaudeCodeHooks(options) {
     getHookCommand("user-prompt-submit"),
     getHookCommand("on-save-intent"),
     getHookCommand("session-start"),
+    getHookCommand("instructions-loaded"),
+    getHookCommand("config-change"),
+    getHookCommand("cwd-changed"),
+    getHookCommand("file-changed"),
+    getHookCommand("worktree-create"),
+    getHookCommand("worktree-remove"),
+    getHookCommand("elicitation"),
+    getHookCommand("elicitation-result"),
     getHookCommand("stop"),
+    getHookCommand("stop-failure"),
     getHookCommand("session-end"),
     getHookCommand("post-tool-use-failure"),
     getHookCommand("subagent-start"),
     getHookCommand("subagent-stop"),
+    getHookCommand("task-created"),
     getHookCommand("task-completed"),
     getHookCommand("teammate-idle"),
     getHookCommand("notification"),
@@ -1938,6 +2080,7 @@ async function installClaudeCodeHooks(options) {
   );
   if (options.includePreCompact !== false) {
     result.scripts.push(getHookCommand("pre-compact"));
+    result.scripts.push(getHookCommand("post-compact"));
   }
   if (options.includeMediaAware === true) {
     result.scripts.push(getHookCommand("media-aware"));
@@ -2232,6 +2375,15 @@ function getCursorHooksDir(scope, projectPath) {
   }
   return path4.join(projectPath, ".cursor", "hooks");
 }
+function getWindsurfHooksConfigPath(scope, projectPath) {
+  if (scope === "global") {
+    return path4.join(homedir3(), ".codeium", "windsurf", "hooks.json");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path4.join(projectPath, ".windsurf", "hooks.json");
+}
 async function readCursorHooksConfig(scope, projectPath) {
   const configPath = getCursorHooksConfigPath(scope, projectPath);
   try {
@@ -2258,17 +2410,31 @@ async function installCursorHookScripts(options) {
       return !hook.command?.includes("contextstream");
     });
   };
-  const filteredPreToolUse = filterContextStreamHooks(existingConfig.hooks.preToolUse);
-  const filteredBeforeSubmit = filterContextStreamHooks(existingConfig.hooks.beforeSubmitPrompt);
+  const cleanedHooks = {};
+  for (const [eventName, entries] of Object.entries(existingConfig.hooks || {})) {
+    cleanedHooks[eventName] = filterContextStreamHooks(entries);
+  }
   const preToolUseCommand = getHookCommand("pre-tool-use");
   const userPromptCommand = getHookCommand("user-prompt-submit");
   const saveIntentCommand = getHookCommand("on-save-intent");
+  const postToolUseCommand = getHookCommand("post-tool-use");
+  const postToolUseFailureCommand = getHookCommand("post-tool-use-failure");
+  const preCompactCommand = getHookCommand("pre-compact");
+  const sessionStartCommand = getHookCommand("session-start");
+  const sessionEndCommand = getHookCommand("session-end");
+  const stopCommand = getHookCommand("stop");
+  const notificationCommand = getHookCommand("notification");
+  const permissionRequestCommand = getHookCommand("permission-request");
+  const subagentStartCommand = getHookCommand("subagent-start");
+  const subagentStopCommand = getHookCommand("subagent-stop");
+  const taskCompletedCommand = getHookCommand("task-completed");
+  const teammateIdleCommand = getHookCommand("teammate-idle");
   const config = {
     version: 1,
     hooks: {
-      ...existingConfig.hooks,
+      ...cleanedHooks,
       preToolUse: [
-        ...filteredPreToolUse,
+        ...cleanedHooks.preToolUse || [],
         {
           command: preToolUseCommand,
           type: "command",
@@ -2276,7 +2442,7 @@ async function installCursorHookScripts(options) {
         }
       ],
       beforeSubmitPrompt: [
-        ...filteredBeforeSubmit,
+        ...cleanedHooks.beforeSubmitPrompt || [],
         {
           command: userPromptCommand,
           type: "command",
@@ -2287,6 +2453,70 @@ async function installCursorHookScripts(options) {
           type: "command",
           timeout: 5
         }
+      ],
+      beforeMCPExecution: [
+        ...cleanedHooks.beforeMCPExecution || [],
+        { command: preToolUseCommand, type: "command", timeout: 5 }
+      ],
+      afterMCPExecution: [
+        ...cleanedHooks.afterMCPExecution || [],
+        { command: postToolUseCommand, type: "command", timeout: 10 }
+      ],
+      beforeShellExecution: [
+        ...cleanedHooks.beforeShellExecution || [],
+        { command: preToolUseCommand, type: "command", timeout: 5 }
+      ],
+      afterShellExecution: [
+        ...cleanedHooks.afterShellExecution || [],
+        { command: postToolUseFailureCommand, type: "command", timeout: 10 }
+      ],
+      beforeReadFile: [
+        ...cleanedHooks.beforeReadFile || [],
+        { command: preToolUseCommand, type: "command", timeout: 5 }
+      ],
+      afterFileEdit: [
+        ...cleanedHooks.afterFileEdit || [],
+        { command: postToolUseCommand, type: "command", timeout: 10 }
+      ],
+      preCompact: [
+        ...cleanedHooks.preCompact || [],
+        { command: preCompactCommand, type: "command", timeout: 15 }
+      ],
+      sessionStart: [
+        ...cleanedHooks.sessionStart || [],
+        { command: sessionStartCommand, type: "command", timeout: 15 }
+      ],
+      sessionEnd: [
+        ...cleanedHooks.sessionEnd || [],
+        { command: sessionEndCommand, type: "command", timeout: 10 }
+      ],
+      stop: [
+        ...cleanedHooks.stop || [],
+        { command: stopCommand, type: "command", timeout: 15 }
+      ],
+      subagentStart: [
+        ...cleanedHooks.subagentStart || [],
+        { command: subagentStartCommand, type: "command", timeout: 10 }
+      ],
+      subagentStop: [
+        ...cleanedHooks.subagentStop || [],
+        { command: subagentStopCommand, type: "command", timeout: 10 }
+      ],
+      taskCompleted: [
+        ...cleanedHooks.taskCompleted || [],
+        { command: taskCompletedCommand, type: "command", timeout: 10 }
+      ],
+      teammateIdle: [
+        ...cleanedHooks.teammateIdle || [],
+        { command: teammateIdleCommand, type: "command", timeout: 10 }
+      ],
+      notification: [
+        ...cleanedHooks.notification || [],
+        { command: notificationCommand, type: "command", timeout: 10 }
+      ],
+      permissionRequest: [
+        ...cleanedHooks.permissionRequest || [],
+        { command: permissionRequestCommand, type: "command", timeout: 10 }
       ]
     }
   };
@@ -2298,6 +2528,83 @@ async function installCursorHookScripts(options) {
     config: configPath
   };
 }
+async function readWindsurfHooksConfig(scope, projectPath) {
+  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
+  try {
+    const content = await fs4.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { hooks: {} };
+  }
+}
+async function writeWindsurfHooksConfig(config, scope, projectPath) {
+  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
+  const dir = path4.dirname(configPath);
+  await fs4.mkdir(dir, { recursive: true });
+  await fs4.writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function installWindsurfHookScripts(options) {
+  const existingConfig = await readWindsurfHooksConfig(options.scope, options.projectPath);
+  const filterContextStreamHooks = (hooks) => {
+    if (!hooks) return [];
+    return hooks.filter((h) => {
+      const hook = h;
+      return !hook.command?.toLowerCase().includes("contextstream");
+    });
+  };
+  const cleanedHooks = {};
+  for (const [eventName, entries] of Object.entries(existingConfig.hooks || {})) {
+    cleanedHooks[eventName] = filterContextStreamHooks(entries);
+  }
+  const preToolUseCommand = getHookCommand("pre-tool-use");
+  const userPromptCommand = getHookCommand("user-prompt-submit");
+  const postToolUseCommand = getHookCommand("post-tool-use");
+  const sessionEndCommand = getHookCommand("session-end");
+  const config = {
+    hooks: {
+      ...cleanedHooks,
+      pre_mcp_tool_use: [
+        ...cleanedHooks.pre_mcp_tool_use || [],
+        { command: preToolUseCommand, show_output: true }
+      ],
+      pre_user_prompt: [
+        ...cleanedHooks.pre_user_prompt || [],
+        { command: userPromptCommand }
+      ],
+      pre_read_code: [
+        ...cleanedHooks.pre_read_code || [],
+        { command: preToolUseCommand, show_output: true }
+      ],
+      pre_write_code: [
+        ...cleanedHooks.pre_write_code || [],
+        { command: preToolUseCommand, show_output: true }
+      ],
+      pre_run_command: [
+        ...cleanedHooks.pre_run_command || [],
+        { command: preToolUseCommand, show_output: true }
+      ],
+      post_write_code: [
+        ...cleanedHooks.post_write_code || [],
+        { command: postToolUseCommand, show_output: false }
+      ],
+      post_mcp_tool_use: [
+        ...cleanedHooks.post_mcp_tool_use || [],
+        { command: postToolUseCommand, show_output: false }
+      ],
+      post_cascade_response_with_transcript: [
+        ...cleanedHooks.post_cascade_response_with_transcript || [],
+        { command: sessionEndCommand }
+      ]
+    }
+  };
+  await writeWindsurfHooksConfig(config, options.scope, options.projectPath);
+  const configPath = getWindsurfHooksConfigPath(options.scope, options.projectPath);
+  return {
+    preMcpToolUse: preToolUseCommand,
+    preUserPrompt: userPromptCommand,
+    config: configPath
+  };
+}
 async function installEditorHooks(options) {
   const { editor, scope, projectPath, includePreCompact, includePostWrite } = options;
   switch (editor) {
@@ -2357,12 +2664,20 @@ async function installEditorHooks(options) {
         hooksDir: getCursorHooksDir(scope, projectPath)
       };
     }
+    case "windsurf": {
+      const scripts = await installWindsurfHookScripts({ scope, projectPath });
+      return {
+        editor: "windsurf",
+        installed: [scripts.preMcpToolUse, scripts.preUserPrompt, scripts.config],
+        hooksDir: path4.dirname(scripts.config)
+      };
+    }
     default:
       throw new Error(`Unsupported editor: ${editor}`);
   }
 }
 async function installAllEditorHooks(options) {
-  const editors = options.editors || ["claude", "cline", "roo", "kilo", "cursor"];
+  const editors = options.editors || ["claude", "cline", "roo", "kilo", "cursor", "windsurf"];
   const results = [];
   for (const editor of editors) {
     try {
@@ -2390,8 +2705,9 @@ ContextStream can install hooks for multiple AI code editors to enforce ContextS
 
 | Editor | Hooks Location | Hook Types |
 |--------|---------------|------------|
-| **Claude Code** | \`~/.claude/hooks/\` | PreToolUse, UserPromptSubmit, PreCompact |
-| **Cursor** | \`~/.cursor/hooks/\` | preToolUse, beforeSubmit |
+| **Claude Code** | \`~/.claude/hooks/\` | PreToolUse, UserPromptSubmit, SessionStart, Pre/PostCompact, PostToolUse |
+| **Cursor** | \`~/.cursor/hooks/\` | preToolUse, beforeSubmitPrompt, before/after MCP+Shell, beforeReadFile, afterFileEdit |
+| **Windsurf** | \`~/.codeium/windsurf/hooks.json\` | pre_mcp_tool_use, pre_user_prompt, pre/post code + command hooks |
 | **Cline** | \`~/Documents/Cline/Rules/Hooks/\` | PreToolUse, UserPromptSubmit |
 | **Roo Code** | \`~/.roo/hooks/\` | PreToolUse, UserPromptSubmit |
 | **Kilo Code** | \`~/.kilocode/hooks/\` | PreToolUse, UserPromptSubmit |
@@ -2402,9 +2718,19 @@ ${generateHooksDocumentation()}
 
 ### Cursor Hooks
 
-Cursor uses a \`hooks.json\` configuration file:
-- **preToolUse**: Blocks discovery tools before execution
-- **beforeSubmitPrompt**: Injects ContextStream rules reminder
+Cursor uses a \`hooks.json\` configuration file with enforcement + lifecycle hooks:
+- **preToolUse / beforeMCPExecution / beforeShellExecution / beforeReadFile**: blocks or redirects non-ContextStream-first flows
+- **beforeSubmitPrompt**: injects ContextStream rules reminder + save-intent capture
+- **afterMCPExecution / afterShellExecution / afterFileEdit**: post-action bookkeeping/index updates
+- **sessionStart / preCompact / stop / sessionEnd**: lifecycle persistence and reliability
+
+### Windsurf Hooks
+
+Windsurf uses a \`hooks.json\` configuration file:
+- **pre_mcp_tool_use / pre_read_code / pre_write_code / pre_run_command**: pre-action gating and enforcement
+- **pre_user_prompt**: injects ContextStream-first guidance each prompt
+- **post_write_code / post_mcp_tool_use**: post-action indexing bookkeeping
+- **post_cascade_response_with_transcript**: end-of-response/session capture
 
 #### Output Format
 \`\`\`json
@@ -2434,7 +2760,7 @@ Hooks are executable scripts named after the hook type (no extension).
 
 ### Installation
 
-Use \`generate_rules(install_hooks=true, editors=["claude", "cursor", "cline", "roo", "kilo"])\` to install hooks for specific editors, or omit \`editors\` to install for all.
+Use \`generate_rules(install_hooks=true, editors=["claude", "cursor", "windsurf", "cline", "roo", "kilo"])\` to install hooks for specific editors, or omit \`editors\` to install for all.
 
 ### Disabling Hooks
 
@@ -2443,7 +2769,7 @@ Set environment variables:
 - \`CONTEXTSTREAM_REMINDER_ENABLED=false\` - Disable UserPromptSubmit reminders
 `.trim();
 }
-var PRETOOLUSE_HOOK_SCRIPT, USER_PROMPT_HOOK_SCRIPT, MEDIA_AWARE_HOOK_SCRIPT, PRECOMPACT_HOOK_SCRIPT, CLINE_PRETOOLUSE_HOOK_SCRIPT, CLINE_USER_PROMPT_HOOK_SCRIPT, CLINE_POSTTOOLUSE_HOOK_SCRIPT, CURSOR_PRETOOLUSE_HOOK_SCRIPT, CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT;
+var PRETOOLUSE_HOOK_SCRIPT, USER_PROMPT_HOOK_SCRIPT, MEDIA_AWARE_HOOK_SCRIPT, PRECOMPACT_HOOK_SCRIPT, CLAUDE_ENFORCEMENT_CRITICAL_HOOKS, CURSOR_ENFORCEMENT_CRITICAL_HOOKS, CLINE_PRETOOLUSE_HOOK_SCRIPT, CLINE_USER_PROMPT_HOOK_SCRIPT, CLINE_POSTTOOLUSE_HOOK_SCRIPT, CURSOR_PRETOOLUSE_HOOK_SCRIPT, CURSOR_BEFORE_SUBMIT_HOOK_SCRIPT;
 var init_hooks_config = __esm({
   "src/hooks-config.ts"() {
     "use strict";
@@ -2924,6 +3250,23 @@ After compaction, call session_init(is_post_compact=true) to restore context.
 if __name__ == "__main__":
     main()
 `;
+    CLAUDE_ENFORCEMENT_CRITICAL_HOOKS = [
+      "PreToolUse",
+      "UserPromptSubmit",
+      "SessionStart",
+      "PreCompact",
+      "PostToolUse"
+    ];
+    CURSOR_ENFORCEMENT_CRITICAL_HOOKS = [
+      "preToolUse",
+      "beforeSubmitPrompt",
+      "beforeMCPExecution",
+      "beforeShellExecution",
+      "beforeReadFile",
+      "afterFileEdit",
+      "sessionStart",
+      "preCompact"
+    ];
     CLINE_PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
 """
 ContextStream PreToolUse Hook for Cline
@@ -3427,6 +3770,7 @@ memory(
 | Persistent plan | \`session(action="capture_plan")\` |
 | Task status | \`memory(action="update_task")\` |
 | Decision capture | \`session(action="capture", event_type="decision")\` |
+| Update skill by name | \`skill(action="update", name="...", instruction_body="...", change_summary="...")\` |
 | Past context | \`session(action="recall", query="...")\` |
 | Lessons | \`session(action="get_lessons", query="...")\` |
 
@@ -3462,6 +3806,9 @@ ${options.workspaceId ? `# Workspace ID: ${options.workspaceId}` : ""}
   if (NO_HOOKS_EDITORS.includes(editor.toLowerCase())) {
     content += NO_HOOKS_SUPPLEMENT;
   }
+  if (editor.toLowerCase() === "antigravity") {
+    content += ANTIGRAVITY_SUPPLEMENT;
+  }
   if (options?.additionalRules) {
     content += "\n\n## Project-Specific Rules\n\n" + options.additionalRules;
   }
@@ -3497,7 +3844,7 @@ function generateAllRuleFiles(options) {
     }))
   ).filter((r) => r !== null);
 }
-var DEFAULT_CLAUDE_MCP_SERVER_NAME, RULES_VERSION, CONTEXTSTREAM_TOOL_NAMES, CONTEXTSTREAM_RULES_BOOTSTRAP, CONTEXTSTREAM_RULES_DYNAMIC, CONTEXTSTREAM_RULES_FULL, CONTEXTSTREAM_RULES_MINIMAL, NO_HOOKS_SUPPLEMENT, NO_HOOKS_EDITORS, TEMPLATES;
+var DEFAULT_CLAUDE_MCP_SERVER_NAME, RULES_VERSION, CONTEXTSTREAM_TOOL_NAMES, CONTEXTSTREAM_RULES_BOOTSTRAP, CONTEXTSTREAM_RULES_DYNAMIC, CONTEXTSTREAM_RULES_FULL, CONTEXTSTREAM_RULES_MINIMAL, NO_HOOKS_SUPPLEMENT, ANTIGRAVITY_SUPPLEMENT, NO_HOOKS_EDITORS, TEMPLATES;
 var init_rules_templates = __esm({
   "src/rules-templates.ts"() {
     "use strict";
@@ -4429,13 +4776,32 @@ After updating, user should restart their AI tool.
 
 ---
 `;
-    NO_HOOKS_EDITORS = ["codex", "aider", "antigravity"];
+    ANTIGRAVITY_SUPPLEMENT = `
+---
+## Antigravity-Specific Reliability Notes
+
+- Antigravity currently has no documented lifecycle hooks for ContextStream enforcement.
+- Treat ContextStream-first behavior as mandatory policy: run \`context(...)\` first, then \`search(mode="auto", ...)\` before local discovery.
+- Keep \`mcp_config.json\` valid and minimal: preserve non-ContextStream servers and only update the \`contextstream\` server block.
+- If ContextStream appears skipped, verify:
+  1. MCP server status is healthy in Antigravity settings
+  2. Project is indexed and \`search(mode="auto", ...)\` is retried before local fallbacks
+  3. Instructions file contains the current ContextStream managed block
+`;
+    NO_HOOKS_EDITORS = ["copilot", "codex", "opencode", "aider", "antigravity"];
     TEMPLATES = {
       codex: {
         filename: "AGENTS.md",
         description: "Codex CLI agent instructions",
         build: (rules) => `# Codex CLI Instructions
 ${rules}
+`
+      },
+      opencode: {
+        filename: "AGENTS.md",
+        description: "OpenCode CLI agent instructions",
+        build: (rules) => `# OpenCode CLI Instructions
+${rules}
 `
       },
       cursor: {
@@ -4443,6 +4809,17 @@ ${rules}
         description: "Cursor AI rules",
         build: (rules) => `# Cursor Rules
 ${rules}
+`
+      },
+      windsurf: {
+        filename: ".windsurf/rules/contextstream.md",
+        description: "Windsurf AI rules",
+        build: (rules) => `---
+trigger: always_on
+---
+
+# Windsurf Rules
+${rules}
 `
       },
       cline: {
@@ -12919,6 +13296,37 @@ function normalizeTags(tags) {
   );
   return normalized.length > 0 ? normalized : void 0;
 }
+function extractEventTags(item) {
+  const tags = [];
+  if (Array.isArray(item.tags)) {
+    tags.push(...item.tags.filter((t) => typeof t === "string"));
+  }
+  const metaTags = item.metadata?.tags;
+  if (Array.isArray(metaTags)) {
+    tags.push(...metaTags.filter((t) => typeof t === "string"));
+  }
+  return tags;
+}
+function extractEffectiveEventType(item) {
+  for (const field of ["event_type", "node_type", "type"]) {
+    const val = item[field];
+    if (typeof val === "string" && val.trim()) return val.trim();
+  }
+  for (const field of ["original_type", "node_type", "event_type", "type"]) {
+    const val = item.metadata?.[field];
+    if (typeof val === "string" && val.trim()) return val.trim();
+  }
+  return "unknown";
+}
+function isLessonResult(item) {
+  const effectiveType = extractEffectiveEventType(item);
+  if (effectiveType === "lesson") return true;
+  const tags = extractEventTags(item);
+  if (tags.some((t) => t === "lesson" || t === "lesson_system")) return true;
+  const content = typeof item.content === "string" ? item.content : "";
+  if (content.includes("### Prevention") && content.includes("### Trigger")) return true;
+  return false;
+}
 function pickString(value) {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
@@ -13472,6 +13880,8 @@ var ContextStreamClient = class _ContextStreamClient {
     const query = new URLSearchParams();
     if (params?.limit) query.set("limit", String(params.limit));
     if (withDefaults.project_id) query.set("project_id", withDefaults.project_id);
+    if (params?.event_type) query.set("event_type", params.event_type);
+    if (params?.tags && params.tags.length > 0) query.set("tags", params.tags.join(","));
     const suffix = query.toString() ? `?${query.toString()}` : "";
     return request(this.config, `/memory/events/workspace/${withDefaults.workspace_id}${suffix}`, {
       method: "GET"
@@ -15835,14 +16245,13 @@ ${context}`;
       });
       if (!searchResult?.results) return [];
       const lessons = searchResult.results.filter((item) => {
-        const tags = item.metadata?.tags || [];
-        const isLesson = tags.includes("lesson") || tags.includes("lesson_system");
-        if (!isLesson) return false;
+        if (!isLessonResult(item)) return false;
+        const tags = extractEventTags(item);
         const severityTag = tags.find((t) => t.startsWith("severity:"));
         const severity = severityTag?.split(":")[1] || item.metadata?.importance || "medium";
         return severity === "critical" || severity === "high";
       }).slice(0, limit).map((item) => {
-        const tags = item.metadata?.tags || [];
+        const tags = extractEventTags(item);
         const severityTag = tags.find((t) => t.startsWith("severity:"));
         const severity = severityTag?.split(":")[1] || item.metadata?.importance || "medium";
         const category = tags.find(
@@ -15856,7 +16265,7 @@ ${context}`;
         ) || "unknown";
         const content = item.content || "";
         const preventionMatch = content.match(/### Prevention\n([\s\S]*?)(?:\n\n|\n\*\*|$)/);
-        const prevention = preventionMatch?.[1]?.trim() || content.slice(0, 200);
+        const prevention = preventionMatch?.[1]?.trim() || content.slice(0, 1e3);
         return {
           title: item.title || "Lesson",
           severity,
@@ -17111,6 +17520,55 @@ ${context}`;
     return request(this.config, `/docs/${params.doc_id}`, { method: "DELETE" });
   }
   // -------------------------------------------------------------------------
+  // Skill methods (portable instruction + action bundles)
+  // -------------------------------------------------------------------------
+  async listSkills(params) {
+    const withDefaults = this.withDefaults(params || {});
+    const query = new URLSearchParams();
+    if (withDefaults.workspace_id) query.set("workspace_id", withDefaults.workspace_id);
+    if (params?.project_id) query.set("project_id", params.project_id);
+    if (params?.scope) query.set("scope", params.scope);
+    if (params?.status) query.set("status", params.status);
+    if (params?.category) query.set("category", params.category);
+    if (params?.query) query.set("query", params.query);
+    if (params?.is_personal !== void 0) query.set("is_personal", String(params.is_personal));
+    if (params?.limit) query.set("limit", String(params.limit));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/skills${suffix}`, { method: "GET" });
+  }
+  async getSkill(skillId) {
+    return request(this.config, `/skills/${skillId}`, { method: "GET" });
+  }
+  async createSkill(params) {
+    return request(this.config, "/skills", { body: this.withDefaults(params) });
+  }
+  async updateSkill(skillId, params) {
+    return request(this.config, `/skills/${skillId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  async runSkill(skillId, params) {
+    return request(this.config, `/skills/${skillId}/run`, {
+      body: params || {}
+    });
+  }
+  async deleteSkill(skillId) {
+    return request(this.config, `/skills/${skillId}`, { method: "DELETE" });
+  }
+  async importSkills(params) {
+    return request(this.config, "/skills/import", { body: this.withDefaults(params) });
+  }
+  async exportSkills(params) {
+    const withDefaults = this.withDefaults(params || {});
+    return request(this.config, "/skills/export", { body: withDefaults });
+  }
+  async shareSkill(skillId, scope) {
+    return request(this.config, `/skills/${skillId}/share`, {
+      body: { scope }
+    });
+  }
+  // -------------------------------------------------------------------------
   // Transcript methods (conversation session storage)
   // -------------------------------------------------------------------------
   /**
@@ -17202,14 +17660,14 @@ ${context}`;
 };
 
 // src/tools.ts
-init_files();
-init_rules_templates();
-init_version();
 import * as fs5 from "node:fs";
 import * as path6 from "node:path";
 import { execFile } from "node:child_process";
 import { homedir as homedir4 } from "node:os";
 import { promisify as promisify2 } from "node:util";
+init_files();
+init_rules_templates();
+init_version();
 
 // src/tool-catalog.ts
 var TOOL_CATALOG = [
@@ -19313,6 +19771,8 @@ var CONSOLIDATED_TOOLS = /* @__PURE__ */ new Set([
   // Consolidates slack_*, github_*, notion_*, integrations_*
   "media",
   // Consolidates media indexing, search, and clip retrieval for Remotion/FFmpeg
+  "skill",
+  // Skill management: list, get, create, update, run, delete, import, export, share
   "help"
   // Consolidates session_tools, auth_me, mcp_server_version, etc.
 ]);
@@ -19332,6 +19792,7 @@ function mapToolToConsolidatedDomain(toolName) {
     return "integration";
   }
   if (toolName.startsWith("media_")) return "media";
+  if (toolName.startsWith("skill_")) return "skill";
   if (toolName === "session_tools" || toolName === "auth_me" || toolName === "mcp_server_version" || toolName === "tools_enable_bundle") {
     return "help";
   }
@@ -19427,6 +19888,93 @@ function toStructured(data) {
   }
   return void 0;
 }
+function formatSkillDetail(skill) {
+  const lines = [
+    `**${skill.title || skill.name || "?"}** (${skill.name || "?"})`,
+    `- ID: ${skill.id || "?"}`,
+    `- Scope: ${skill.scope || "personal"} | Status: ${skill.status || "active"}`
+  ];
+  if (skill.description) lines.push(`- Description: ${skill.description}`);
+  if (skill.trigger_patterns?.length) lines.push(`- Triggers: ${skill.trigger_patterns.join(", ")}`);
+  if (skill.categories?.length) lines.push(`- Categories: ${skill.categories.join(", ")}`);
+  if (skill.priority != null) lines.push(`- Priority: ${skill.priority}`);
+  if (skill.version) lines.push(`- Version: ${skill.version}`);
+  if (skill.instruction_body) {
+    const body = String(skill.instruction_body);
+    lines.push(`
+### Instruction
+${body.length > 2e3 ? body.slice(0, 2e3) + "\u2026" : body}`);
+  }
+  return lines.join("\n");
+}
+function formatRunResult(result) {
+  if (result.instruction) return result.instruction;
+  if (result.output) return `Skill output:
+${result.output}`;
+  return JSON.stringify(result, null, 2);
+}
+function computeSkillMatchScore(query, name, title) {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) return null;
+  const normalizedName = String(name || "").trim().toLowerCase();
+  const normalizedTitle = String(title || "").trim().toLowerCase();
+  if (normalizedName === normalizedQuery) return 0;
+  if (normalizedTitle === normalizedQuery) return 1;
+  if (normalizedName.includes(normalizedQuery)) return 2;
+  if (normalizedTitle.includes(normalizedQuery)) return 3;
+  return null;
+}
+function rankSkillCandidates(query, items) {
+  return items.map((item) => {
+    const id = String(item?.id || "");
+    const name = String(item?.name || "?");
+    const title = String(item?.title || name);
+    const score = computeSkillMatchScore(query, name, title);
+    if (!id || score == null) return null;
+    return {
+      id,
+      name,
+      title,
+      scope: String(item?.scope || "?"),
+      status: String(item?.status || "?"),
+      score
+    };
+  }).filter((item) => item !== null).sort((a, b) => {
+    if (a.score !== b.score) return a.score - b.score;
+    if (a.name !== b.name) return a.name.localeCompare(b.name);
+    if (a.title !== b.title) return a.title.localeCompare(b.title);
+    return a.id.localeCompare(b.id);
+  });
+}
+async function resolveSkillIdForAction(client, input, action) {
+  if (input.skill_id) return input.skill_id;
+  const name = typeof input.name === "string" ? input.name.trim() : "";
+  if (!name) {
+    throw new Error(`Either skill_id or name is required for '${action}'`);
+  }
+  const result = await client.listSkills({
+    workspace_id: input.workspace_id,
+    project_id: input.project_id,
+    query: name,
+    limit: 25
+  });
+  const ranked = rankSkillCandidates(name, result.items || []);
+  if (ranked.length === 0) {
+    throw new Error(`Skill '${name}' not found. Provide a different name or skill_id.`);
+  }
+  const bestScore = ranked[0].score;
+  const bestCandidates = ranked.filter((candidate) => candidate.score === bestScore);
+  if (bestCandidates.length > 1) {
+    const candidates = bestCandidates.slice(0, 5).map(
+      (candidate) => `- ${candidate.title} (${candidate.name}) [${candidate.scope}|${candidate.status}] id=${candidate.id}`
+    ).join("\n");
+    throw new Error(
+      `Skill name '${name}' is ambiguous. Provide skill_id or use a more specific name. Candidates:
+${candidates}`
+    );
+  }
+  return ranked[0].id;
+}
 function readStatNumber(payload, key) {
   if (!payload || typeof payload !== "object") return void 0;
   const direct = payload[key];
@@ -21750,6 +22298,178 @@ Access: Free`,
       };
     }
   );
+  registerTool(
+    "skill",
+    {
+      title: "Manage reusable skills",
+      description: `Manage and execute reusable skills (instruction + action bundles). Skills are portable across projects, sessions, and tools.
+
+Actions:
+- list: Browse skills (filter by scope, status, category)
+- get: Get skill details by ID or name
+- create: Define a new skill with name, instruction, and triggers
+- update: Modify an existing skill
+- run: Execute a skill (by ID or name)
+- delete: Remove a skill
+- import: Import skills from file or content (supports markdown, JSON, cursorrules, claude_md)
+- export: Export skills in various formats
+- share: Change skill visibility scope`,
+      inputSchema: external_exports.object({
+        action: external_exports.enum(["list", "get", "create", "update", "run", "delete", "import", "export", "share"]).describe("The action to perform"),
+        skill_id: external_exports.string().optional().describe("Skill ID (UUID)"),
+        name: external_exports.string().optional().describe("Skill name (slug, e.g. 'deploy-checker')"),
+        title: external_exports.string().optional().describe("Skill display title"),
+        description: external_exports.string().optional().describe("Skill description"),
+        instruction_body: external_exports.string().optional().describe("Markdown instruction text (the prompt)"),
+        trigger_patterns: external_exports.array(external_exports.string()).optional().describe("Keywords/phrases for auto-activation"),
+        trigger_regex: external_exports.string().optional().describe("Optional regex for advanced trigger matching"),
+        categories: external_exports.array(external_exports.string()).optional().describe("Tags for discovery/filtering"),
+        actions: external_exports.any().optional().describe("Action steps array [{type, tool, params, ...}]"),
+        params: external_exports.any().optional().describe("Parameters passed to skill execution"),
+        dry_run: external_exports.boolean().optional().describe("Preview execution without running"),
+        scope: external_exports.enum(["personal", "team", "public", "all"]).optional().describe("Visibility scope"),
+        status: external_exports.enum(["active", "draft", "archived"]).optional().describe("Skill status"),
+        is_personal: external_exports.boolean().optional().describe("Whether skill is personal"),
+        priority: external_exports.number().optional().describe("Skill priority 0-100 (higher = matched first)"),
+        content: external_exports.string().optional().describe("Content string for import"),
+        file_path: external_exports.string().optional().describe("Local file path for import"),
+        format: external_exports.enum(["auto", "json", "markdown", "skills_md", "cursorrules", "claude_md", "aider", "zip"]).optional().describe("Import/export format"),
+        source_tool: external_exports.string().optional().describe("Source tool name (for import provenance)"),
+        source_file: external_exports.string().optional().describe("Source filename (for import provenance)"),
+        skill_ids: external_exports.array(external_exports.string()).optional().describe("Skill IDs for export"),
+        change_summary: external_exports.string().optional().describe("Summary of changes (for version history)"),
+        workspace_id: external_exports.string().optional().describe("Workspace ID (UUID)"),
+        project_id: external_exports.string().optional().describe("Project ID (UUID)"),
+        query: external_exports.string().optional().describe("Search query"),
+        category: external_exports.string().optional().describe("Filter by category tag"),
+        limit: external_exports.number().optional().describe("Max results to return")
+      })
+    },
+    async (input) => {
+      const action = input.action;
+      switch (action) {
+        case "list": {
+          const result = await client.listSkills({
+            workspace_id: input.workspace_id,
+            project_id: input.project_id,
+            scope: input.scope,
+            status: input.status,
+            category: input.category,
+            query: input.query,
+            is_personal: input.is_personal,
+            limit: input.limit
+          });
+          const items = result.items || [];
+          let text = `Found ${items.length} skill(s).
+`;
+          for (const item of items) {
+            const name = item.name || "?";
+            const title = item.title || "?";
+            const scope = item.scope || "?";
+            const status = item.status || "?";
+            const id = item.id || "?";
+            text += `- ${title} (${name}) [${scope}|${status}] id=${id}
+`;
+          }
+          return { content: [{ type: "text", text }] };
+        }
+        case "get": {
+          const resolvedId = await resolveSkillIdForAction(client, input, "get");
+          const skillData = await client.getSkill(resolvedId);
+          const detail = formatSkillDetail(skillData);
+          return { content: [{ type: "text", text: detail }] };
+        }
+        case "create": {
+          if (!input.name) throw new Error("'name' is required for create");
+          if (!input.instruction_body) throw new Error("'instruction_body' is required for create");
+          const result = await client.createSkill({
+            name: input.name,
+            title: input.title || input.name,
+            instruction_body: input.instruction_body,
+            description: input.description,
+            trigger_patterns: input.trigger_patterns,
+            trigger_regex: input.trigger_regex,
+            categories: input.categories,
+            actions: input.actions,
+            scope: input.scope,
+            is_personal: input.is_personal,
+            priority: input.priority,
+            workspace_id: input.scope === "team" ? input.workspace_id : void 0,
+            project_id: void 0,
+            // Skills are account-level by default
+            source_tool: input.source_tool,
+            source_file: input.source_file
+          });
+          return { content: [{ type: "text", text: `Skill '${input.name}' created (id=${result.id || "?"}).` }] };
+        }
+        case "update": {
+          const resolvedId = await resolveSkillIdForAction(client, input, "update");
+          const result = await client.updateSkill(resolvedId, {
+            title: input.title,
+            description: input.description,
+            instruction_body: input.instruction_body,
+            trigger_patterns: input.trigger_patterns,
+            trigger_regex: input.trigger_regex,
+            categories: input.categories,
+            actions: input.actions,
+            scope: input.scope,
+            status: input.status,
+            is_personal: input.is_personal,
+            priority: input.priority,
+            change_summary: input.change_summary
+          });
+          return { content: [{ type: "text", text: `Skill ${resolvedId} updated (version=${result.version || 0}).` }] };
+        }
+        case "run": {
+          const resolvedId = await resolveSkillIdForAction(client, input, "run");
+          const result = await client.runSkill(resolvedId, {
+            params: input.params,
+            dry_run: input.dry_run
+          });
+          return { content: [{ type: "text", text: formatRunResult(result) }] };
+        }
+        case "delete": {
+          const resolvedId = await resolveSkillIdForAction(client, input, "delete");
+          await client.deleteSkill(resolvedId);
+          return { content: [{ type: "text", text: `Skill ${resolvedId} deleted.` }] };
+        }
+        case "import": {
+          let importContent = input.content;
+          if (!importContent && input.file_path) {
+            const { readFile: readFile4 } = await import("fs/promises");
+            importContent = await readFile4(input.file_path, "utf-8");
+          }
+          if (!importContent) throw new Error("Either 'content' or 'file_path' is required for import");
+          const result = await client.importSkills({
+            content: importContent,
+            format: input.format,
+            source_tool: input.source_tool,
+            source_file: input.source_file || input.file_path,
+            scope: input.scope,
+            workspace_id: input.workspace_id
+          });
+          return { content: [{ type: "text", text: `Import complete: ${result.imported || 0} imported, ${result.skipped || 0} skipped (duplicates).` }] };
+        }
+        case "export": {
+          const result = await client.exportSkills({
+            skill_ids: input.skill_ids,
+            format: input.format,
+            scope: input.scope,
+            workspace_id: input.workspace_id
+          });
+          return { content: [{ type: "text", text: result.content || JSON.stringify(result, null, 2) }] };
+        }
+        case "share": {
+          if (!input.scope) throw new Error("'scope' is required for share");
+          const resolvedId = await resolveSkillIdForAction(client, input, "share");
+          const result = await client.shareSkill(resolvedId, input.scope);
+          return { content: [{ type: "text", text: `Skill ${resolvedId} shared with scope=${result.scope || input.scope}.` }] };
+        }
+        default:
+          throw new Error(`Invalid skill action: '${action}'. Valid: list, get, create, update, run, delete, import, export, share`);
+      }
+    }
+  );
   registerTool(
     "memory_bulk_ingest",
     {
@@ -21772,15 +22492,24 @@ Access: Free`,
     "memory_list_events",
     {
       title: "List memory events",
-      description: "List memory events (optionally scoped)",
+      description: "List memory events (optionally scoped). Supports tag-based and event_type filtering for precise provenance tracking.",
       inputSchema: external_exports.object({
         workspace_id: external_exports.string().uuid().optional(),
         project_id: external_exports.string().uuid().optional(),
-        limit: external_exports.number().optional()
+        limit: external_exports.number().optional(),
+        tags: external_exports.array(external_exports.string()).optional().describe("Filter events that contain ALL of these tags"),
+        event_type: external_exports.string().optional().describe("Filter by event type (e.g. decision, lesson, manual_note)")
       })
     },
     async (input) => {
       const result = await client.listMemoryEvents(input);
+      if (input.tags && input.tags.length > 0 && result.items) {
+        const requiredTags = input.tags;
+        result.items = result.items.filter((item) => {
+          const itemTags = extractEventTags(item);
+          return requiredTags.every((tag) => itemTags.includes(tag));
+        });
+      }
       return {
         content: [{ type: "text", text: formatContent(result) }]
       };
@@ -21834,16 +22563,24 @@ Access: Free`,
     "memory_search",
     {
       title: "Memory-aware search",
-      description: "Search memory events/notes",
+      description: "Search memory events/notes. Supports optional tag-based pre-filtering.",
       inputSchema: external_exports.object({
         query: external_exports.string(),
         workspace_id: external_exports.string().uuid().optional(),
         project_id: external_exports.string().uuid().optional(),
-        limit: external_exports.number().optional()
+        limit: external_exports.number().optional(),
+        tags: external_exports.array(external_exports.string()).optional().describe("Filter results that contain ALL of these tags")
       })
     },
     async (input) => {
       const result = await client.memorySearch(input);
+      if (input.tags && input.tags.length > 0 && result.results) {
+        const requiredTags = input.tags;
+        result.results = result.results.filter((item) => {
+          const itemTags = extractEventTags(item);
+          return requiredTags.every((tag) => itemTags.includes(tag));
+        });
+      }
       return {
         content: [{ type: "text", text: formatContent(result) }]
       };
@@ -23631,9 +24368,8 @@ Returns lessons filtered by:
         // Fetch more to filter
       });
       const lessons = (searchResult.results || []).filter((item) => {
-        const tags = item.metadata?.tags || [];
-        const isLesson = tags.includes("lesson");
-        if (!isLesson) return false;
+        if (!isLessonResult(item)) return false;
+        const tags = extractEventTags(item);
         if (input.category && !tags.includes(input.category)) {
           return false;
         }
@@ -23652,7 +24388,7 @@ Returns lessons filtered by:
         };
       }
       const formattedLessons = lessons.map((lesson, i) => {
-        const tags = lesson.metadata?.tags || [];
+        const tags = extractEventTags(lesson);
         const severity = tags.find((t) => t.startsWith("severity:"))?.split(":")[1] || "medium";
         const category = tags.find(
           (t) => [
@@ -23671,7 +24407,7 @@ Returns lessons filtered by:
         }[severity] || "\u26AA";
         return `${i + 1}. ${severityEmoji} **${lesson.title}**
    Category: ${category} | Severity: ${severity}
-   ${lesson.content?.slice(0, 200)}...`;
+   ${lesson.content?.slice(0, 500)}...`;
       }).join("\n\n");
       return {
         content: [
@@ -23903,6 +24639,7 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
       ).length;
       const skippedCount = results.filter((r) => r.status.startsWith("skipped")).length;
       const baseMessage = input.dry_run ? "Dry run complete. Use dry_run: false to write files." : skippedCount > 0 ? `Generated ${createdCount} rule files. ${skippedCount} skipped (existing files). Re-run with overwrite_existing: true to replace ContextStream blocks.` : `Generated ${createdCount} rule files.`;
+      const copilotSetupNote = editors.includes("copilot") ? "Select Copilot in setup; setup handles both ~/.copilot/mcp-config.json and project .vscode/mcp.json automatically." : void 0;
       const globalPrompt = input.apply_global ? "Global rule update complete." : globalTargets.length > 0 ? "Apply rules globally too? Re-run with apply_global: true." : "No global rule locations are known for these editors.";
       let hooksResults;
       let hooksPrompt;
@@ -23911,7 +24648,8 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
         cline: "cline",
         roo: "roo",
         kilo: "kilo",
-        cursor: "cursor"
+        cursor: "cursor",
+        windsurf: "windsurf"
       };
       const hookSupportedEditors = editors.filter((e) => e in editorHookMap);
       const shouldInstallHooks = hookSupportedEditors.length > 0 && input.install_hooks !== false;
@@ -23950,6 +24688,10 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
                   { editor, file: "~/.cursor/hooks/contextstream-beforesubmit.py", status: "dry run - would create" },
                   { editor, file: "~/.cursor/hooks.json", status: "dry run - would update" }
                 );
+              } else if (editor === "windsurf") {
+                hooksResults.push(
+                  { editor, file: "~/.codeium/windsurf/hooks.json", status: "dry run - would update" }
+                );
               }
             }
           } else {
@@ -23978,6 +24720,7 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
         ...globalTargets.length > 0 ? { global_targets: globalTargets } : {},
         ...hooksResults ? { hooks_results: hooksResults } : {},
         message: baseMessage,
+        ...copilotSetupNote ? { copilot_setup_note: copilotSetupNote } : {},
         global_prompt: globalPrompt,
         ...hooksPrompt ? { hooks_prompt: hooksPrompt } : {}
       };
@@ -24068,7 +24811,10 @@ Supported editors: ${getAvailableEditors().join(", ")}`,
       const summary = {
         folder: folderPath,
         results,
-        message: input.dry_run ? "Dry run complete. Use dry_run: false to write files." : skippedCount > 0 ? `Generated ${createdCount} rule files. ${skippedCount} skipped (existing files). Re-run with overwrite_existing: true to replace ContextStream blocks.` : `Generated ${createdCount} rule files.`
+        message: input.dry_run ? "Dry run complete. Use dry_run: false to write files." : skippedCount > 0 ? `Generated ${createdCount} rule files. ${skippedCount} skipped (existing files). Re-run with overwrite_existing: true to replace ContextStream blocks.` : `Generated ${createdCount} rule files.`,
+        ...editors.includes("copilot") ? {
+          copilot_setup_note: "Select Copilot in setup; setup handles both ~/.copilot/mcp-config.json and project .vscode/mcp.json automatically."
+        } : {}
       };
       return {
         content: [{ type: "text", text: formatContent(summary) }]
@@ -30226,6 +30972,7 @@ This will:
 - Start a 5-day Pro trial
 - Auto-configure your editor's MCP settings
 - Write rules files for better AI assistance
+- If you select Copilot, setup automatically writes both ~/.copilot/mcp-config.json and project .vscode/mcp.json
 
 Preview first:
   npx --prefer-online -y @contextstream/mcp-server@latest setup --dry-run
@@ -32067,9 +32814,11 @@ init_hooks_config();
 init_files();
 var EDITOR_LABELS = {
   codex: "Codex CLI",
+  copilot: "GitHub Copilot (VS Code)",
   opencode: "OpenCode",
   claude: "Claude Code",
   cursor: "Cursor / VS Code",
+  windsurf: "Windsurf",
   cline: "Cline",
   kilo: "Kilo Code",
   roo: "Roo Code",
@@ -32077,7 +32826,7 @@ var EDITOR_LABELS = {
   antigravity: "Antigravity (Google)"
 };
 function supportsProjectMcpConfig(editor) {
-  return editor === "opencode" || editor === "cursor" || editor === "claude" || editor === "kilo" || editor === "roo" || editor === "antigravity";
+  return editor === "opencode" || editor === "copilot" || editor === "cursor" || editor === "claude" || editor === "kilo" || editor === "roo";
 }
 function normalizeInput(value) {
   return value.trim();
@@ -32148,6 +32897,7 @@ var CONTEXTSTREAM_PREAMBLE_PATTERNS2 = [
   /^#\s+codex cli instructions$/i,
   /^#\s+claude code instructions$/i,
   /^#\s+cursor rules$/i,
+  /^#\s+windsurf rules$/i,
   /^#\s+cline rules$/i,
   /^#\s+kilo code rules$/i,
   /^#\s+roo code rules$/i,
@@ -32288,6 +33038,10 @@ function globalRulesPathForEditor(editor) {
   switch (editor) {
     case "codex":
       return path8.join(home, ".codex", "AGENTS.md");
+    case "copilot":
+      return null;
+    case "opencode":
+      return path8.join(home, ".opencode", "AGENTS.md");
     case "claude":
       return path8.join(home, ".claude", "CLAUDE.md");
     case "cline":
@@ -32302,6 +33056,8 @@ function globalRulesPathForEditor(editor) {
       return path8.join(home, ".gemini", "GEMINI.md");
     case "cursor":
       return null;
+    case "windsurf":
+      return path8.join(home, ".codeium", "windsurf", "memories", "global_rules.md");
     default:
       return null;
   }
@@ -32367,6 +33123,16 @@ async function isClineInstalled() {
   ];
   return anyPathExists(candidates);
 }
+async function isCopilotInstalled() {
+  const home = homedir6();
+  const candidates = [
+    path8.join(home, ".copilot"),
+    path8.join(home, ".config", "github-copilot"),
+    path8.join(home, ".vscode", "extensions", "github.copilot-chat"),
+    path8.join(home, ".vscode", "extensions", "github.copilot")
+  ];
+  return anyPathExists(candidates);
+}
 async function isKiloInstalled() {
   const home = homedir6();
   const candidates = [path8.join(home, ".kilocode"), path8.join(home, ".config", "kilocode")];
@@ -32405,6 +33171,29 @@ async function isCursorInstalled() {
   }
   return anyPathExists(candidates);
 }
+async function isWindsurfInstalled() {
+  const home = homedir6();
+  const candidates = [path8.join(home, ".codeium", "windsurf")];
+  if (process.platform === "darwin") {
+    candidates.push("/Applications/Windsurf.app");
+    candidates.push(path8.join(home, "Applications", "Windsurf.app"));
+    candidates.push(path8.join(home, "Library", "Application Support", "Windsurf"));
+  } else if (process.platform === "win32") {
+    const localApp = process.env.LOCALAPPDATA;
+    const programFiles = process.env.ProgramFiles;
+    const programFilesX86 = process.env["ProgramFiles(x86)"];
+    if (localApp) candidates.push(path8.join(localApp, "Programs", "Windsurf", "Windsurf.exe"));
+    if (localApp) candidates.push(path8.join(localApp, "Windsurf", "Windsurf.exe"));
+    if (programFiles) candidates.push(path8.join(programFiles, "Windsurf", "Windsurf.exe"));
+    if (programFilesX86) candidates.push(path8.join(programFilesX86, "Windsurf", "Windsurf.exe"));
+  } else {
+    candidates.push("/usr/bin/windsurf");
+    candidates.push("/usr/local/bin/windsurf");
+    candidates.push("/opt/Windsurf");
+    candidates.push("/opt/windsurf");
+  }
+  return anyPathExists(candidates);
+}
 async function isAntigravityInstalled() {
   const home = homedir6();
   const candidates = [path8.join(home, ".gemini")];
@@ -32434,12 +33223,16 @@ async function isEditorInstalled(editor) {
   switch (editor) {
     case "codex":
       return isCodexInstalled();
+    case "copilot":
+      return isCopilotInstalled();
     case "opencode":
       return isOpenCodeInstalled();
     case "claude":
       return isClaudeInstalled();
     case "cursor":
       return isCursorInstalled();
+    case "windsurf":
+      return isWindsurfInstalled();
     case "cline":
       return isClineInstalled();
     case "kilo":
@@ -33239,7 +34032,7 @@ Code: ${device.user_code}`);
         );
       }
     }
-    const NO_HOOKS_EDITORS2 = ["codex", "opencode", "aider", "antigravity"];
+    const NO_HOOKS_EDITORS2 = ["codex", "copilot", "opencode", "aider", "antigravity"];
     const getModeForEditor = (editor) => NO_HOOKS_EDITORS2.includes(editor) ? "full" : "bootstrap";
     const detectedPlanName = await client.getPlanName();
     const detectedGraphTier = await client.getGraphTier();
@@ -33266,9 +34059,11 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     }
     const editors = [
       "codex",
+      "copilot",
       "opencode",
       "claude",
       "cursor",
+      "windsurf",
       "cline",
       "kilo",
       "roo",
@@ -33338,6 +34133,28 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
       )
     ) || mcpChoiceDefault;
     const mcpScope = mcpChoice === "2" && hasCodex && !hasProjectMcpEditors ? "skip" : mcpChoice === "4" ? "skip" : mcpChoice === "1" ? "global" : mcpChoice === "2" ? "project" : "both";
+    const copilotSelected = configuredEditors.includes("copilot");
+    let enforceCopilotCanonicalPair = copilotSelected && mcpScope !== "skip";
+    if (enforceCopilotCanonicalPair) {
+      const confirmCopilotPair = normalizeInput(
+        await rl.question(
+          "Configure Copilot canonical MCP files (~/.copilot/mcp-config.json + .vscode/mcp.json)? [Y/n]: "
+        )
+      ).toLowerCase();
+      enforceCopilotCanonicalPair = confirmCopilotPair !== "n" && confirmCopilotPair !== "no";
+    }
+    if (enforceCopilotCanonicalPair) {
+      console.log(
+        "\nCopilot automation enabled: setup will write both ~/.copilot/mcp-config.json and project .vscode/mcp.json (no separate Copilot command needed)."
+      );
+      console.log(
+        "If you installed the Rust runtime, replace the generated command with `contextstream-mcp` in both files."
+      );
+    } else if (copilotSelected && mcpScope !== "skip") {
+      console.log(
+        "\nCopilot canonical pair disabled for this run. You can rerun setup anytime to generate both files together."
+      );
+    }
     const mcpServer = buildContextStreamMcpServer({ apiUrl, apiKey, contextPackEnabled });
     const mcpServerClaude = buildContextStreamMcpServer({ apiUrl, apiKey, contextPackEnabled });
     const mcpServerOpenCode = buildContextStreamOpenCodeLocalServer({
@@ -33354,7 +34171,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
         "  OpenCode reads CONTEXTSTREAM_API_KEY from your environment. Export it before launching OpenCode."
       );
     };
-    const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex;
+    const needsGlobalMcpConfig = mcpScope === "global" || mcpScope === "both" || mcpScope === "project" && hasCodex || enforceCopilotCanonicalPair;
     if (needsGlobalMcpConfig) {
       console.log("\nInstalling global MCP config...");
       for (const editor of configuredEditors) {
@@ -33376,6 +34193,18 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
             continue;
           }
+          if (editor === "copilot") {
+            const filePath = path8.join(homedir6(), ".copilot", "mcp-config.json");
+            if (dryRun) {
+              writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
+              console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
+              continue;
+            }
+            const status = await upsertJsonMcpConfig(filePath, mcpServer);
+            writeActions.push({ kind: "mcp-config", target: filePath, status });
+            console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
+            continue;
+          }
           if (editor === "claude") {
             const desktopPath = claudeDesktopConfigPath();
             if (desktopPath) {
@@ -33431,6 +34260,18 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
             continue;
           }
+          if (editor === "windsurf") {
+            const filePath = path8.join(homedir6(), ".codeium", "windsurf", "mcp_config.json");
+            if (dryRun) {
+              writeActions.push({ kind: "mcp-config", target: filePath, status: "dry-run" });
+              console.log(`- ${EDITOR_LABELS[editor]}: would update ${filePath}`);
+              continue;
+            }
+            const status = await upsertJsonMcpConfig(filePath, mcpServer);
+            writeActions.push({ kind: "mcp-config", target: filePath, status });
+            console.log(`- ${EDITOR_LABELS[editor]}: ${status} ${filePath}`);
+            continue;
+          }
           if (editor === "cline") {
             console.log(
               `- ${EDITOR_LABELS[editor]}: MCP config is managed via the extension UI (skipping global).`
@@ -33456,11 +34297,14 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     const HOOKS_SUPPORTED_EDITORS = {
       claude: "claude",
       cursor: "cursor",
+      windsurf: "windsurf",
       cline: "cline",
       roo: "roo",
       kilo: "kilo",
       codex: null,
       // No hooks API
+      copilot: null,
+      // No hooks API
       opencode: null,
       // No hooks API
       aider: null,
@@ -33489,6 +34333,16 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
             writeActions.push({ kind: "hooks", target: script, status: "created" });
             console.log(`- ${EDITOR_LABELS[editor]}: installed ${path8.basename(script)}`);
           }
+          if (editor === "cursor") {
+            console.log(
+              "  Cursor hooks enabled: preToolUse, beforeSubmitPrompt, before/after MCP+shell, beforeReadFile, afterFileEdit, session lifecycle"
+            );
+          }
+          if (editor === "windsurf") {
+            console.log(
+              "  Windsurf hooks enabled: pre_mcp_tool_use, pre_user_prompt, pre/post code+command hooks, post_cascade_response_with_transcript"
+            );
+          }
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           console.log(`- ${EDITOR_LABELS[editor]}: failed to install hooks: ${message}`);
@@ -33496,6 +34350,19 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
       }
       console.log("  Disable hooks anytime with CONTEXTSTREAM_HOOK_ENABLED=false");
     }
+    const noHookEditors = configuredEditors.filter((e) => HOOKS_SUPPORTED_EDITORS[e] === null);
+    if (noHookEditors.length > 0) {
+      console.log("\nEditors without lifecycle hooks (rules-only enforcement):");
+      for (const editor of noHookEditors) {
+        if (editor === "antigravity") {
+          console.log(
+            `- ${EDITOR_LABELS[editor]}: no hooks API available; relying on strict ContextStream rules + index/search discipline.`
+          );
+        } else {
+          console.log(`- ${EDITOR_LABELS[editor]}: no hooks API available; using rules-only enforcement.`);
+        }
+      }
+    }
     console.log("\nCode Privacy:");
     console.log("  \u2713 Encrypted in transit (TLS 1.3) and at rest (AES-256)");
     console.log("  \u2713 Isolated per workspace \u2014 no cross-tenant access");
@@ -33503,12 +34370,6 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     if (scope === "global" || scope === "both") {
       console.log("\nInstalling global rules...");
       for (const editor of configuredEditors) {
-        if (editor === "opencode") {
-          console.log(
-            `- ${EDITOR_LABELS[editor]}: rules are not auto-generated yet (MCP config only).`
-          );
-          continue;
-        }
         const filePath = globalRulesPathForEditor(editor);
         if (!filePath) {
           console.log(
@@ -33539,7 +34400,7 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
       }
     }
     const projectPaths = /* @__PURE__ */ new Set();
-    const needsProjects = scope === "project" || scope === "both" || (mcpScope === "project" || mcpScope === "both") && hasProjectMcpEditors;
+    const needsProjects = scope === "project" || scope === "both" || (mcpScope === "project" || mcpScope === "both") && hasProjectMcpEditors || enforceCopilotCanonicalPair;
     if (needsProjects) {
       console.log("\nProject setup...");
       const addCwd = normalizeInput(
@@ -33622,8 +34483,10 @@ Applying to ${projects.length} project(s)...`);
           status: "dry-run"
         });
       }
-      if (mcpScope === "project" || mcpScope === "both") {
+      if (mcpScope === "project" || mcpScope === "both" || enforceCopilotCanonicalPair) {
         for (const editor of configuredEditors) {
+          const shouldWriteProjectMcp = mcpScope === "project" || mcpScope === "both" || enforceCopilotCanonicalPair && editor === "copilot";
+          if (!shouldWriteProjectMcp) continue;
           try {
             if (editor === "cursor") {
               const cursorPath = path8.join(projectPath, ".cursor", "mcp.json");
@@ -33639,6 +34502,12 @@ Applying to ${projects.length} project(s)...`);
               }
               continue;
             }
+            if (editor === "windsurf") {
+              console.log(
+                `- ${EDITOR_LABELS[editor]}: uses global MCP config only (${path8.join(homedir6(), ".codeium", "windsurf", "mcp_config.json")}).`
+              );
+              continue;
+            }
             if (editor === "claude") {
               const mcpPath = path8.join(projectPath, ".mcp.json");
               if (dryRun) {
@@ -33664,6 +34533,16 @@ Applying to ${projects.length} project(s)...`);
               printOpenCodeEnvNote();
               continue;
             }
+            if (editor === "copilot") {
+              const vsCodePath = path8.join(projectPath, ".vscode", "mcp.json");
+              if (dryRun) {
+                writeActions.push({ kind: "mcp-config", target: vsCodePath, status: "dry-run" });
+              } else {
+                const status = await upsertJsonVsCodeMcpConfig(vsCodePath, vsCodeServer);
+                writeActions.push({ kind: "mcp-config", target: vsCodePath, status });
+              }
+              continue;
+            }
             if (editor === "kilo") {
               const kiloPath = path8.join(projectPath, ".kilocode", "mcp.json");
               if (dryRun) {
@@ -33695,7 +34574,6 @@ Applying to ${projects.length} project(s)...`);
       for (const editor of selectedEditors) {
         if (scope !== "project" && scope !== "both") continue;
         if (!configuredEditors.includes(editor)) continue;
-        if (editor === "opencode") continue;
         const rule = generateRuleContent(editor, {
           workspaceName,
           workspaceId: workspaceId && workspaceId !== "dry-run" ? workspaceId : void 0,
@@ -33819,6 +34697,16 @@ Applying to ${projects.length} project(s)...`);
     console.log(
       "- For UI-based MCP setup (Cline/Kilo/Roo global), see https://contextstream.io/docs/mcp"
     );
+    if (copilotSelected) {
+      const nodeCommand = IS_WINDOWS ? "cmd /c npx --prefer-online -y @contextstream/mcp-server@latest" : "npx --prefer-online -y @contextstream/mcp-server@latest";
+      console.log("\nGitHub Copilot + VS Code checklist:");
+      console.log("- Confirm ~/.copilot/mcp-config.json has a contextstream server entry.");
+      console.log("- Confirm .vscode/mcp.json has a contextstream server entry.");
+      console.log(`- Node runtime command: ${nodeCommand}`);
+      console.log(
+        "- If Rust MCP is installed, replace the command in both files with `contextstream-mcp` and set args to []."
+      );
+    }
     console.log("");
     console.log(
       "You're all set! ContextStream gives your AI persistent memory, semantic code search, and cross-session context."