@contextstream/mcp-server 0.4.65 → 0.4.67

package/dist/hooks/auto-rules.js

@@ -1159,10 +1159,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,
@@ -1181,6 +1183,7 @@ __export(hooks_config_exports, {
   getIndexStatusPath: () => getIndexStatusPath,
   getKiloCodeHooksDir: () => getKiloCodeHooksDir,
   getRooCodeHooksDir: () => getRooCodeHooksDir,
+  getWindsurfHooksConfigPath: () => getWindsurfHooksConfigPath,
   installAllEditorHooks: () => installAllEditorHooks,
   installClaudeCodeHooks: () => installClaudeCodeHooks,
   installClineHookScripts: () => installClineHookScripts,
@@ -1189,15 +1192,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 fs3 from "node:fs/promises";
 import * as fsSync from "node:fs";
@@ -1307,6 +1313,18 @@ function buildHooksConfig(options) {
         ]
       }
     ];
+    config.PostCompact = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("post-compact"),
+            timeout: 15
+          }
+        ]
+      }
+    ];
   }
   if (options?.includeSessionInit !== false) {
     config.SessionStart = [
@@ -1321,6 +1339,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 = [
@@ -1347,6 +1461,18 @@ function buildHooksConfig(options) {
         ]
       }
     ];
+    config.StopFailure = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("stop-failure"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
   }
   const postToolUseHooks = [];
   if (options?.includePostWrite !== false) {
@@ -1442,6 +1568,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: "*",
@@ -1522,11 +1654,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"),
@@ -1534,6 +1676,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"));
@@ -1828,6 +1971,15 @@ function getCursorHooksDir(scope, projectPath) {
   }
   return path3.join(projectPath, ".cursor", "hooks");
 }
+function getWindsurfHooksConfigPath(scope, projectPath) {
+  if (scope === "global") {
+    return path3.join(homedir2(), ".codeium", "windsurf", "hooks.json");
+  }
+  if (!projectPath) {
+    throw new Error("projectPath required for project scope");
+  }
+  return path3.join(projectPath, ".windsurf", "hooks.json");
+}
 async function readCursorHooksConfig(scope, projectPath) {
   const configPath = getCursorHooksConfigPath(scope, projectPath);
   try {
@@ -1854,17 +2006,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",
@@ -1872,7 +2038,7 @@ async function installCursorHookScripts(options) {
         }
       ],
       beforeSubmitPrompt: [
-        ...filteredBeforeSubmit,
+        ...cleanedHooks.beforeSubmitPrompt || [],
         {
           command: userPromptCommand,
           type: "command",
@@ -1883,6 +2049,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 }
       ]
     }
   };
@@ -1894,6 +2124,83 @@ async function installCursorHookScripts(options) {
     config: configPath
   };
 }
+async function readWindsurfHooksConfig(scope, projectPath) {
+  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
+  try {
+    const content = await fs3.readFile(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return { hooks: {} };
+  }
+}
+async function writeWindsurfHooksConfig(config, scope, projectPath) {
+  const configPath = getWindsurfHooksConfigPath(scope, projectPath);
+  const dir = path3.dirname(configPath);
+  await fs3.mkdir(dir, { recursive: true });
+  await fs3.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) {
@@ -1953,12 +2260,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: path3.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 {
@@ -1986,8 +2301,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 |
@@ -1998,9 +2314,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
@@ -2030,7 +2356,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
 
@@ -2039,7 +2365,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";
@@ -2520,6 +2846,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

package/dist/hooks/runner.js

@@ -2410,6 +2410,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;
   }
@@ -2421,7 +2424,7 @@ ${options.workspaceId ? `# Workspace ID: ${options.workspaceId}` : ""}
     content: content.trim() + "\n"
   };
 }
-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";
@@ -3353,13 +3356,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: {
@@ -3367,6 +3389,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: {
@@ -4952,8 +4985,17 @@ var hooks = {
   notification: async () => (await Promise.resolve().then(() => (init_notification(), notification_exports))).runNotificationHook(),
   "permission-request": async () => (await Promise.resolve().then(() => (init_permission_request(), permission_request_exports))).runPermissionRequestHook(),
   "post-tool-use-failure": async () => (await Promise.resolve().then(() => (init_post_tool_use_failure(), post_tool_use_failure_exports))).runPostToolUseFailureHook(),
+  "instructions-loaded": async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
+  "config-change": async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
+  "cwd-changed": async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
+  "file-changed": async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
+  "worktree-create": async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
+  "worktree-remove": async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
+  elicitation: async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
+  "elicitation-result": async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
   "subagent-start": async () => (await Promise.resolve().then(() => (init_subagent_start(), subagent_start_exports))).runSubagentStartHook(),
   "subagent-stop": async () => (await Promise.resolve().then(() => (init_subagent_stop(), subagent_stop_exports))).runSubagentStopHook(),
+  "task-created": async () => (await Promise.resolve().then(() => (init_noop(), noop_exports))).runNoopHook(),
   "task-completed": async () => (await Promise.resolve().then(() => (init_task_completed(), task_completed_exports))).runTaskCompletedHook(),
   "teammate-idle": async () => (await Promise.resolve().then(() => (init_teammate_idle(), teammate_idle_exports))).runTeammateIdleHook(),
   "on-save-intent": async () => (await Promise.resolve().then(() => (init_on_save_intent(), on_save_intent_exports))).runOnSaveIntentHook()

package/dist/hooks/session-init.js

@@ -1264,13 +1264,32 @@ After updating, user should restart their AI tool.
 
 ---
 `;
-var NO_HOOKS_EDITORS = ["codex", "aider", "antigravity"];
+var 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
+`;
+var NO_HOOKS_EDITORS = ["copilot", "codex", "opencode", "aider", "antigravity"];
 var 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: {
@@ -1278,6 +1297,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: {
@@ -1369,6 +1399,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;
   }