@contextstream/mcp-server 0.4.66 → 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: {
@@ -19536,6 +19913,68 @@ function formatRunResult(result) {
 ${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];
@@ -21935,20 +22374,8 @@ Actions:
           return { content: [{ type: "text", text }] };
         }
         case "get": {
-          let skillData;
-          if (input.skill_id) {
-            skillData = await client.getSkill(input.skill_id);
-          } else if (input.name) {
-            const result = await client.listSkills({
-              workspace_id: input.workspace_id,
-              query: input.name,
-              limit: 1
-            });
-            skillData = result.items?.find((s) => s.name === input.name) || result.items?.[0];
-            if (!skillData) throw new Error(`Skill '${input.name}' not found`);
-          } else {
-            throw new Error("Either skill_id or name is required for 'get'");
-          }
+          const resolvedId = await resolveSkillIdForAction(client, input, "get");
+          const skillData = await client.getSkill(resolvedId);
           const detail = formatSkillDetail(skillData);
           return { content: [{ type: "text", text: detail }] };
         }
@@ -21976,8 +22403,8 @@ Actions:
           return { content: [{ type: "text", text: `Skill '${input.name}' created (id=${result.id || "?"}).` }] };
         }
         case "update": {
-          if (!input.skill_id) throw new Error("'skill_id' is required for update");
-          const result = await client.updateSkill(input.skill_id, {
+          const resolvedId = await resolveSkillIdForAction(client, input, "update");
+          const result = await client.updateSkill(resolvedId, {
             title: input.title,
             description: input.description,
             instruction_body: input.instruction_body,
@@ -21991,21 +22418,10 @@ Actions:
             priority: input.priority,
             change_summary: input.change_summary
           });
-          return { content: [{ type: "text", text: `Skill ${input.skill_id} updated (version=${result.version || 0}).` }] };
+          return { content: [{ type: "text", text: `Skill ${resolvedId} updated (version=${result.version || 0}).` }] };
         }
         case "run": {
-          let resolvedId = input.skill_id;
-          if (!resolvedId && input.name) {
-            const result2 = await client.listSkills({
-              workspace_id: input.workspace_id,
-              query: input.name,
-              limit: 1
-            });
-            const found = result2.items?.find((s) => s.name === input.name) || result2.items?.[0];
-            if (!found?.id) throw new Error(`Skill '${input.name}' not found`);
-            resolvedId = found.id;
-          }
-          if (!resolvedId) throw new Error("Either skill_id or name is required for 'run'");
+          const resolvedId = await resolveSkillIdForAction(client, input, "run");
           const result = await client.runSkill(resolvedId, {
             params: input.params,
             dry_run: input.dry_run
@@ -22013,9 +22429,9 @@ Actions:
           return { content: [{ type: "text", text: formatRunResult(result) }] };
         }
         case "delete": {
-          if (!input.skill_id) throw new Error("'skill_id' is required for delete");
-          await client.deleteSkill(input.skill_id);
-          return { content: [{ type: "text", text: `Skill ${input.skill_id} deleted.` }] };
+          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;
@@ -22044,10 +22460,10 @@ Actions:
           return { content: [{ type: "text", text: result.content || JSON.stringify(result, null, 2) }] };
         }
         case "share": {
-          if (!input.skill_id) throw new Error("'skill_id' is required for share");
           if (!input.scope) throw new Error("'scope' is required for share");
-          const result = await client.shareSkill(input.skill_id, input.scope);
-          return { content: [{ type: "text", text: `Skill ${input.skill_id} shared with scope=${result.scope || input.scope}.` }] };
+          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`);
@@ -24223,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;
@@ -24231,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;
@@ -24270,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 {
@@ -24298,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 } : {}
       };
@@ -24388,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) }]
@@ -30546,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
@@ -32387,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",
@@ -32397,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();
@@ -32468,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,
@@ -32608,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":
@@ -32622,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;
   }
@@ -32687,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")];
@@ -32725,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")];
@@ -32754,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":
@@ -33559,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();
@@ -33586,9 +34059,11 @@ Detected plan: ${planLabel} (graph: ${graphTierLabel})`);
     }
     const editors = [
       "codex",
+      "copilot",
       "opencode",
       "claude",
       "cursor",
+      "windsurf",
       "cline",
       "kilo",
       "roo",
@@ -33658,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({
@@ -33674,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) {
@@ -33696,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) {
@@ -33751,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).`
@@ -33776,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,
@@ -33809,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}`);
@@ -33816,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");
@@ -33823,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(
@@ -33859,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(
@@ -33942,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");
@@ -33959,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) {
@@ -33984,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) {
@@ -34015,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,
@@ -34139,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."