context-mode 1.0.57 → 1.0.58

package/.claude-plugin/marketplace.json

@@ -6,14 +6,14 @@
   },
   "metadata": {
     "description": "Claude Code plugins by Mert Koseoğlu",
-    "version": "1.0.57"
+    "version": "1.0.58"
   },
   "plugins": [
     {
       "name": "context-mode",
       "source": "./",
       "description": "Claude Code MCP plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-      "version": "1.0.57",
+      "version": "1.0.58",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.57",
+  "version": "1.0.58",
   "description": "MCP server that saves 98% of your context window with session continuity. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and automatic state restore across compactions.",
   "author": {
     "name": "Mert Koseoğlu",

package/.openclaw-plugin/openclaw.plugin.json

@@ -3,7 +3,7 @@
   "name": "Context Mode",
   "kind": "tool",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
-  "version": "1.0.57",
+  "version": "1.0.58",
   "sandbox": {
     "mode": "permissive",
     "filesystem_access": "full",

package/.openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.57",
+  "version": "1.0.58",
   "description": "OpenClaw plugin that saves 98% of your context window. Sandboxed code execution in 11 languages, FTS5 knowledge base with BM25 ranking, and intent-driven search.",
   "author": {
     "name": "Mert Koseoğlu",

package/README.md

@@ -188,7 +188,7 @@ Full hook config including PreCompact: [`configs/vscode-copilot/hooks.json`](con
 </details>
 
 <details>
-<summary><strong>Cursor</strong> — hooks without SessionStart</summary>
+<summary><strong>Cursor</strong> — hooks with stop support</summary>
 
 **Prerequisites:** Node.js 18+, Cursor with agent mode.
 
@@ -228,12 +228,17 @@ Full hook config including PreCompact: [`configs/vscode-copilot/hooks.json`](con
          {
            "command": "context-mode hook cursor posttooluse"
          }
+       ],
+       "stop": [
+         {
+           "command": "context-mode hook cursor stop"
+         }
        ]
      }
    }
    ```
 
-   The `preToolUse` matcher is optional — without it, the hook fires on all tools.
+   The `preToolUse` matcher is optional — without it, the hook fires on all tools. The `stop` hook fires when the agent turn ends and can send a followup message to continue the loop. `afterAgentResponse` is also available (fire-and-forget, receives full response text).
 
 4. Copy the routing rules file. Cursor lacks a SessionStart hook, so the model needs a rules file for routing awareness:
 
@@ -246,7 +251,7 @@ Full hook config including PreCompact: [`configs/vscode-copilot/hooks.json`](con
 
 **Verify:** Open Cursor Settings > MCP and confirm "context-mode" shows as connected. In agent chat, type `ctx stats`.
 
-**Routing:** Hooks enforce routing programmatically via `preToolUse`/`postToolUse`. The `.cursor/rules/context-mode.mdc` file provides routing instructions at session start since Cursor's `sessionStart` hook is currently rejected by their validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)). Project `.cursor/hooks.json` overrides `~/.cursor/hooks.json`.
+**Routing:** Hooks enforce routing programmatically via `preToolUse`/`postToolUse`/`stop`. The `.cursor/rules/context-mode.mdc` file provides routing instructions at session start since Cursor's `sessionStart` hook is currently rejected by their validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)). Project `.cursor/hooks.json` overrides `~/.cursor/hooks.json`.
 
 Full configs: [`configs/cursor/hooks.json`](configs/cursor/hooks.json) | [`configs/cursor/mcp.json`](configs/cursor/mcp.json) | [`configs/cursor/context-mode.mdc`](configs/cursor/context-mode.mdc)
 
@@ -388,7 +393,7 @@ Full documentation: [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md)
 </details>
 
 <details>
-<summary><strong>Codex CLI</strong> — MCP-only, no hooks</summary>
+<summary><strong>Codex CLI</strong> — hooks + MCP</summary>
 
 **Prerequisites:** Node.js 18+, Codex CLI installed.
 
@@ -407,7 +412,20 @@ Full documentation: [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md)
    command = "context-mode"
    ```
 
-3. Copy routing instructions (Codex CLI has no hook support):
+3. *(Optional)* Add hooks for session tracking. Create `~/.codex/hooks.json`:
+
+   ```json
+   {
+     "hooks": {
+       "PostToolUse": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex posttooluse" }] }],
+       "SessionStart": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex sessionstart" }] }]
+     }
+   }
+   ```
+
+   Hooks enable session continuity and event tracking. Without hooks, only MCP tools are available.
+
+4. Copy routing instructions (recommended even with hooks for full routing awareness):
 
    ```bash
    cp node_modules/context-mode/configs/codex/AGENTS.md ./AGENTS.md
@@ -415,11 +433,11 @@ Full documentation: [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md)
 
    For global use: `cp node_modules/context-mode/configs/codex/AGENTS.md ~/.codex/AGENTS.md`. Global applies to all projects. If both exist, Codex CLI merges them.
 
-4. Restart Codex CLI.
+5. Restart Codex CLI.
 
 **Verify:** Start a session and type `ctx stats`. Context-mode tools should appear and respond.
 
-**Routing:** Manual. The `AGENTS.md` file is the only enforcement method (~60% compliance). There is no programmatic interception — the model can run raw `curl`, read large files, or bypass sandbox tools at any time. Hook support PRs [#2904](https://github.com/openai/codex/pull/2904) and [#9796](https://github.com/openai/codex/pull/9796) were closed without merge.
+**Routing:** With hooks, SessionStart injects routing instructions and PostToolUse tracks events. Without hooks, the `AGENTS.md` file is the only enforcement method (~60% compliance). Codex CLI's hook system uses the same JSON stdin/stdout wire protocol as Claude Code but does not support arg or output modification.
 
 </details>
 
@@ -581,19 +599,21 @@ Full configs: [`configs/kiro/mcp.json`](configs/kiro/mcp.json) | [`configs/kiro/
    npm run build
    ```
 
-2. Add to `~/.pi/settings/mcp.json` (or `.pi/settings/mcp.json` for project-level):
+2. Add to `~/.pi/agent/mcp.json` (or `.pi/mcp.json` for project-level):
 
    ```json
    {
      "mcpServers": {
        "context-mode": {
          "command": "node",
-         "args": ["~/.pi/extensions/context-mode/node_modules/context-mode/start.mjs"]
+         "args": ["/home/youruser/.pi/extensions/context-mode/node_modules/context-mode/start.mjs"]
        }
      }
    }
    ```
 
+   > **Note:** JSON does not expand `~`. Replace `/home/youruser` with your actual home directory (run `echo $HOME` to find it).
+
 3. Restart Pi.
 
 **Verify:** In a Pi session, type `ctx stats`. Context-mode tools should appear and respond.

package/build/adapters/codex/index.d.ts

@@ -1,14 +1,19 @@
 /**
- * adapters/codex — Codex CLI platform adapter.
+ * adapters/codex — Codex CLI (codex-rs) platform adapter.
  *
- * Implements HookAdapter for Codex CLI's MCP-only paradigm.
+ * Implements HookAdapter for Codex CLI's JSON stdin/stdout hook paradigm.
  *
  * Codex CLI hook specifics:
- *   - NO hook support (PRs #2904, #9796 were closed without merge)
- *   - Only "hook": notify config for agent-turn-complete (very limited)
- *   - Config: ~/.codex/config.toml (TOML format, not JSON)
+ *   - I/O: JSON on stdin, JSON on stdout (same wire protocol as Claude Code)
+ *   - 5 hook events: PreToolUse, PostToolUse, SessionStart, PreCompact, Stop
+ *   - Arg modification: NOT supported (no updatedInput field)
+ *   - Output modification: NOT supported (no updatedMCPToolOutput field)
+ *   - Blocking: `hookSpecificOutput.permissionDecision: "deny"` in response
+ *   - Context injection: `hookSpecificOutput.additionalContext` in response
+ *   - Session ID: session_id field from hook input
+ *   - Project dir: cwd field from hook input
+ *   - Config: ~/.codex/config.toml (TOML format)
  *   - MCP: full support via [mcp_servers] in config.toml
- *   - All capabilities are false — MCP is the only integration path
  *   - Session dir: ~/.codex/context-mode/sessions/
  */
 import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration } from "../types.js";
@@ -16,19 +21,19 @@ export declare class CodexAdapter implements HookAdapter {
     readonly name = "Codex CLI";
     readonly paradigm: HookParadigm;
     readonly capabilities: PlatformCapabilities;
-    parsePreToolUseInput(_raw: unknown): PreToolUseEvent;
-    parsePostToolUseInput(_raw: unknown): PostToolUseEvent;
-    parsePreCompactInput(_raw: unknown): PreCompactEvent;
-    parseSessionStartInput(_raw: unknown): SessionStartEvent;
-    formatPreToolUseResponse(_response: PreToolUseResponse): unknown;
-    formatPostToolUseResponse(_response: PostToolUseResponse): unknown;
-    formatPreCompactResponse(_response: PreCompactResponse): unknown;
-    formatSessionStartResponse(_response: SessionStartResponse): unknown;
+    parsePreToolUseInput(raw: unknown): PreToolUseEvent;
+    parsePostToolUseInput(raw: unknown): PostToolUseEvent;
+    parsePreCompactInput(raw: unknown): PreCompactEvent;
+    parseSessionStartInput(raw: unknown): SessionStartEvent;
+    formatPreToolUseResponse(response: PreToolUseResponse): unknown;
+    formatPostToolUseResponse(response: PostToolUseResponse): unknown;
+    formatPreCompactResponse(response: PreCompactResponse): unknown;
+    formatSessionStartResponse(response: SessionStartResponse): unknown;
     getSettingsPath(): string;
     getSessionDir(): string;
     getSessionDBPath(projectDir: string): string;
     getSessionEventsPath(projectDir: string): string;
-    generateHookConfig(_pluginRoot: string): HookRegistration;
+    generateHookConfig(pluginRoot: string): HookRegistration;
     readSettings(): Record<string, unknown> | null;
     writeSettings(_settings: Record<string, unknown>): void;
     validateHooks(_pluginRoot: string): DiagnosticResult[];
@@ -39,4 +44,9 @@ export declare class CodexAdapter implements HookAdapter {
     setHookPermissions(_pluginRoot: string): string[];
     updatePluginRegistry(_pluginRoot: string, _version: string): void;
     getRoutingInstructions(): string;
+    /**
+     * Extract session ID from Codex CLI hook input.
+     * Priority: session_id field > fallback to ppid.
+     */
+    private extractSessionId;
 }

package/build/adapters/codex/index.js

@@ -1,14 +1,19 @@
 /**
- * adapters/codex — Codex CLI platform adapter.
+ * adapters/codex — Codex CLI (codex-rs) platform adapter.
  *
- * Implements HookAdapter for Codex CLI's MCP-only paradigm.
+ * Implements HookAdapter for Codex CLI's JSON stdin/stdout hook paradigm.
  *
  * Codex CLI hook specifics:
- *   - NO hook support (PRs #2904, #9796 were closed without merge)
- *   - Only "hook": notify config for agent-turn-complete (very limited)
- *   - Config: ~/.codex/config.toml (TOML format, not JSON)
+ *   - I/O: JSON on stdin, JSON on stdout (same wire protocol as Claude Code)
+ *   - 5 hook events: PreToolUse, PostToolUse, SessionStart, PreCompact, Stop
+ *   - Arg modification: NOT supported (no updatedInput field)
+ *   - Output modification: NOT supported (no updatedMCPToolOutput field)
+ *   - Blocking: `hookSpecificOutput.permissionDecision: "deny"` in response
+ *   - Context injection: `hookSpecificOutput.additionalContext` in response
+ *   - Session ID: session_id field from hook input
+ *   - Project dir: cwd field from hook input
+ *   - Config: ~/.codex/config.toml (TOML format)
  *   - MCP: full support via [mcp_servers] in config.toml
- *   - All capabilities are false — MCP is the only integration path
  *   - Session dir: ~/.codex/context-mode/sessions/
  */
 import { createHash } from "node:crypto";
@@ -21,44 +26,121 @@ import { homedir } from "node:os";
 // ─────────────────────────────────────────────────────────
 export class CodexAdapter {
     name = "Codex CLI";
-    paradigm = "mcp-only";
+    paradigm = "json-stdio";
     capabilities = {
-        preToolUse: false,
-        postToolUse: false,
+        preToolUse: true,
+        postToolUse: true,
         preCompact: false,
-        sessionStart: false,
+        sessionStart: true,
         canModifyArgs: false,
         canModifyOutput: false,
-        canInjectSessionContext: false,
+        canInjectSessionContext: true,
     };
     // ── Input parsing ──────────────────────────────────────
-    // Codex CLI does not support hooks. These methods exist to satisfy the
-    // interface contract but will throw if called.
-    parsePreToolUseInput(_raw) {
-        throw new Error("Codex CLI does not support hooks");
+    parsePreToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            sessionId: this.extractSessionId(input),
+            projectDir: input.cwd,
+            raw,
+        };
     }
-    parsePostToolUseInput(_raw) {
-        throw new Error("Codex CLI does not support hooks");
+    parsePostToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            toolOutput: input.tool_response,
+            sessionId: this.extractSessionId(input),
+            projectDir: input.cwd,
+            raw,
+        };
     }
-    parsePreCompactInput(_raw) {
-        throw new Error("Codex CLI does not support hooks");
+    parsePreCompactInput(raw) {
+        const input = raw;
+        return {
+            sessionId: this.extractSessionId(input),
+            projectDir: input.cwd,
+            raw,
+        };
     }
-    parseSessionStartInput(_raw) {
-        throw new Error("Codex CLI does not support hooks");
+    parseSessionStartInput(raw) {
+        const input = raw;
+        const rawSource = input.source ?? "startup";
+        let source;
+        switch (rawSource) {
+            case "compact":
+                source = "compact";
+                break;
+            case "resume":
+                source = "resume";
+                break;
+            case "clear":
+                source = "clear";
+                break;
+            default:
+                source = "startup";
+        }
+        return {
+            sessionId: this.extractSessionId(input),
+            source,
+            projectDir: input.cwd,
+            raw,
+        };
     }
     // ── Response formatting ────────────────────────────────
-    // Codex CLI does not support hooks. Return undefined for all responses.
-    formatPreToolUseResponse(_response) {
-        return undefined;
+    // Codex CLI uses hookSpecificOutput wrapper for all hook responses.
+    // Unlike Claude Code, Codex does NOT support updatedInput or updatedMCPToolOutput.
+    formatPreToolUseResponse(response) {
+        if (response.decision === "deny") {
+            return {
+                hookSpecificOutput: {
+                    permissionDecision: "deny",
+                    permissionDecisionReason: response.reason ?? "Blocked by context-mode hook",
+                },
+            };
+        }
+        if (response.decision === "context" && response.additionalContext) {
+            return {
+                hookSpecificOutput: {
+                    additionalContext: response.additionalContext,
+                },
+            };
+        }
+        // "allow" — return empty object for passthrough
+        return {};
     }
-    formatPostToolUseResponse(_response) {
-        return undefined;
+    formatPostToolUseResponse(response) {
+        if (response.additionalContext) {
+            return {
+                hookSpecificOutput: {
+                    additionalContext: response.additionalContext,
+                },
+            };
+        }
+        return {};
     }
-    formatPreCompactResponse(_response) {
-        return undefined;
+    formatPreCompactResponse(response) {
+        if (response.context) {
+            return {
+                hookSpecificOutput: {
+                    additionalContext: response.context,
+                },
+            };
+        }
+        return {};
     }
-    formatSessionStartResponse(_response) {
-        return undefined;
+    formatSessionStartResponse(response) {
+        if (response.context) {
+            return {
+                hookSpecificOutput: {
+                    additionalContext: response.context,
+                },
+            };
+        }
+        return {};
     }
     // ── Configuration ──────────────────────────────────────
     getSettingsPath() {
@@ -83,9 +165,42 @@ export class CodexAdapter {
             .slice(0, 16);
         return join(this.getSessionDir(), `${hash}-events.md`);
     }
-    generateHookConfig(_pluginRoot) {
-        // Codex CLI does not support hooks — return empty registration
-        return {};
+    generateHookConfig(pluginRoot) {
+        return {
+            PreToolUse: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node ${pluginRoot}/hooks/pretooluse.mjs`,
+                        },
+                    ],
+                },
+            ],
+            PostToolUse: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node ${pluginRoot}/hooks/posttooluse.mjs`,
+                        },
+                    ],
+                },
+            ],
+            SessionStart: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `node ${pluginRoot}/hooks/sessionstart.mjs`,
+                        },
+                    ],
+                },
+            ],
+        };
     }
     readSettings() {
         // Codex CLI uses TOML format. Full TOML parsing is complex;
@@ -110,9 +225,8 @@ export class CodexAdapter {
         return [
             {
                 check: "Hook support",
-                status: "warn",
-                message: "Codex CLI does not support hooks (PRs #2904, #9796 closed without merge). " +
-                    "Only MCP integration is available.",
+                status: "pass",
+                message: "Codex CLI supports hooks (PreToolUse, PostToolUse, SessionStart) via JSON stdin/stdout.",
             },
         ];
     }
@@ -158,7 +272,7 @@ export class CodexAdapter {
     }
     // ── Upgrade ────────────────────────────────────────────
     configureAllHooks(_pluginRoot) {
-        // Codex CLI does not support hooks — nothing to configure
+        // Codex CLI hook configuration is done via hooks.json, not config.toml
         return [];
     }
     backupSettings() {
@@ -174,7 +288,7 @@ export class CodexAdapter {
         }
     }
     setHookPermissions(_pluginRoot) {
-        // No hook scripts for Codex CLI
+        // Hook permissions are set during plugin install
         return [];
     }
     updatePluginRegistry(_pluginRoot, _version) {
@@ -190,4 +304,14 @@ export class CodexAdapter {
             return "# context-mode\n\nUse context-mode MCP tools (execute, execute_file, batch_execute, fetch_and_index, search) instead of bash/cat/curl for data-heavy operations.";
         }
     }
+    // ── Internal helpers ───────────────────────────────────
+    /**
+     * Extract session ID from Codex CLI hook input.
+     * Priority: session_id field > fallback to ppid.
+     */
+    extractSessionId(input) {
+        if (input.session_id)
+            return input.session_id;
+        return `pid-${process.ppid}`;
+    }
 }

package/build/adapters/cursor/hooks.d.ts

@@ -10,6 +10,8 @@ export declare const HOOK_TYPES: {
     readonly PRE_TOOL_USE: "preToolUse";
     readonly POST_TOOL_USE: "postToolUse";
     readonly SESSION_START: "sessionStart";
+    readonly STOP: "stop";
+    readonly AFTER_AGENT_RESPONSE: "afterAgentResponse";
 };
 export type HookType = (typeof HOOK_TYPES)[keyof typeof HOOK_TYPES];
 /** Map of hook types to their script file names. */

package/build/adapters/cursor/hooks.js

@@ -10,12 +10,16 @@ export const HOOK_TYPES = {
     PRE_TOOL_USE: "preToolUse",
     POST_TOOL_USE: "postToolUse",
     SESSION_START: "sessionStart",
+    STOP: "stop",
+    AFTER_AGENT_RESPONSE: "afterAgentResponse",
 };
 /** Map of hook types to their script file names. */
 export const HOOK_SCRIPTS = {
     [HOOK_TYPES.PRE_TOOL_USE]: "pretooluse.mjs",
     [HOOK_TYPES.POST_TOOL_USE]: "posttooluse.mjs",
     [HOOK_TYPES.SESSION_START]: "sessionstart.mjs",
+    [HOOK_TYPES.STOP]: "stop.mjs",
+    [HOOK_TYPES.AFTER_AGENT_RESPONSE]: "afteragentresponse.mjs",
 };
 /** Canonical Cursor-native matchers for tools context-mode routes proactively. */
 export const PRE_TOOL_USE_MATCHERS = [

package/build/adapters/cursor/index.d.ts

@@ -5,6 +5,13 @@
  * `.cursor/hooks.json` / `~/.cursor/hooks.json`.
  */
 import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, SessionStartResponse, HookRegistration } from "../types.js";
+interface StopEvent {
+    sessionId: string;
+    status: string;
+    loopCount: number;
+    generationId?: string;
+    transcriptPath?: string;
+}
 export declare class CursorAdapter implements HookAdapter {
     readonly name = "Cursor";
     readonly paradigm: HookParadigm;
@@ -15,6 +22,13 @@ export declare class CursorAdapter implements HookAdapter {
     formatPreToolUseResponse(response: PreToolUseResponse): unknown;
     formatPostToolUseResponse(response: PostToolUseResponse): unknown;
     formatSessionStartResponse(response: SessionStartResponse): unknown;
+    parseStopInput(raw: unknown): StopEvent;
+    formatStopResponse(response: {
+        followupMessage?: string;
+    }): Record<string, unknown>;
+    parseAfterAgentResponseInput(raw: unknown): {
+        text: string;
+    };
     getSettingsPath(): string;
     getSessionDir(): string;
     getSessionDBPath(projectDir: string): string;
@@ -36,3 +50,4 @@ export declare class CursorAdapter implements HookAdapter {
     private hasClaudeCompatibilityHooks;
     private upsertHookEntry;
 }
+export {};

package/build/adapters/cursor/index.js

@@ -102,6 +102,26 @@ export class CursorAdapter {
         // the payload is effectively a no-op.
         return { additional_context: response.context ?? "" };
     }
+    parseStopInput(raw) {
+        const input = raw;
+        return {
+            sessionId: input.conversation_id ?? `pid-${process.ppid}`,
+            status: input.status ?? "completed",
+            loopCount: input.loop_count ?? 0,
+            generationId: input.generation_id,
+            transcriptPath: input.transcript_path ?? undefined,
+        };
+    }
+    formatStopResponse(response) {
+        if (response.followupMessage) {
+            return { followup_message: response.followupMessage };
+        }
+        return {};
+    }
+    parseAfterAgentResponseInput(raw) {
+        const input = raw;
+        return { text: input.text ?? "" };
+    }
     getSettingsPath() {
         return resolve(".cursor", "hooks.json");
     }
@@ -151,6 +171,22 @@ export class CursorAdapter {
                     failClosed: false,
                 },
             ],
+            [CURSOR_HOOK_NAMES.STOP]: [
+                {
+                    type: "command",
+                    command: buildHookCommand(CURSOR_HOOK_NAMES.STOP),
+                    loop_limit: null,
+                    failClosed: false,
+                },
+            ],
+            [CURSOR_HOOK_NAMES.AFTER_AGENT_RESPONSE]: [
+                {
+                    type: "command",
+                    command: buildHookCommand(CURSOR_HOOK_NAMES.AFTER_AGENT_RESPONSE),
+                    loop_limit: null,
+                    failClosed: false,
+                },
+            ],
         };
         return hooks;
     }
@@ -301,6 +337,18 @@ export class CursorAdapter {
             loop_limit: null,
             failClosed: false,
         }, changes);
+        this.upsertHookEntry(hooks, CURSOR_HOOK_NAMES.STOP, {
+            type: "command",
+            command: buildHookCommand(CURSOR_HOOK_NAMES.STOP),
+            loop_limit: null,
+            failClosed: false,
+        }, changes);
+        this.upsertHookEntry(hooks, CURSOR_HOOK_NAMES.AFTER_AGENT_RESPONSE, {
+            type: "command",
+            command: buildHookCommand(CURSOR_HOOK_NAMES.AFTER_AGENT_RESPONSE),
+            loop_limit: null,
+            failClosed: false,
+        }, changes);
         settings.version = 1;
         settings.hooks = hooks;
         this.writeSettings(settings);

package/build/adapters/opencode/index.d.ts

@@ -47,6 +47,10 @@ export declare class OpenCodeAdapter implements HookAdapter {
     backupSettings(): string | null;
     setHookPermissions(_pluginRoot: string): string[];
     updatePluginRegistry(_pluginRoot: string, _version: string): void;
+    /**
+     * Check whether a settings object has the context-mode plugin registered.
+     */
+    private hasContextModePlugin;
     /**
      * Extract session ID from OpenCode hook input.
      * OpenCode uses camelCase sessionID.