context-mode 1.0.57 → 1.0.59

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.59"
   },
   "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.59",
       "author": {
         "name": "Mert Koseoğlu"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "context-mode",
-  "version": "1.0.57",
+  "version": "1.0.59",
   "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.59",
   "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.59",
   "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,21 @@ Full documentation: [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md)
    command = "context-mode"
    ```
 
-3. Copy routing instructions (Codex CLI has no hook support):
+3. Add hooks for routing enforcement and session tracking. Create `~/.codex/hooks.json`:
+
+   ```json
+   {
+     "hooks": {
+       "PreToolUse": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex pretooluse" }] }],
+       "PostToolUse": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex posttooluse" }] }],
+       "SessionStart": [{ "hooks": [{ "type": "command", "command": "context-mode hook codex sessionstart" }] }]
+     }
+   }
+   ```
+
+   `PreToolUse` enforces sandbox routing (blocks dangerous commands, redirects to MCP tools). `PostToolUse` captures session events. `SessionStart` restores state after compaction.
+
+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 +434,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:** Hooks enforce routing programmatically via PreToolUse. PostToolUse tracks session events. SessionStart restores state. The optional AGENTS.md file provides routing instructions for model awareness. 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 +600,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.
@@ -718,13 +739,14 @@ Session continuity requires 4 hooks working together:
 
 | Hook | Role | Claude Code | Gemini CLI | VS Code Copilot | Cursor | OpenCode | KiloCode | OpenClaw | Codex CLI | Antigravity | Kiro | Zed | Pi |
 |---|---|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|
-| **PostToolUse** | Captures events after each tool call | Yes | Yes | Yes | Yes | Plugin | Plugin | Plugin | -- | -- | Yes | -- | ✓ (via tool_result event) |
+| **PreToolUse** | Enforces sandbox routing before tool execution | Yes | -- | -- | Yes | -- | -- | -- | Yes | -- | Yes | -- | ✓ (via tool_call event) |
+| **PostToolUse** | Captures events after each tool call | Yes | Yes | Yes | Yes | Plugin | Plugin | Plugin | Yes | -- | Yes | -- | ✓ (via tool_result event) |
 | **UserPromptSubmit** | Captures user decisions and corrections | Yes | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- | -- |
 | **PreCompact** | Builds snapshot before compaction | Yes | Yes | Yes | -- | Plugin | Plugin | Plugin | -- | -- | -- | -- | ✓ (via session_before_compact) |
-| **SessionStart** | Restores state after compaction or resume | Yes | Yes | Yes | -- | -- | -- | Plugin | -- | -- | -- | -- | ✓ (via session_start event) |
-| | **Session completeness** | **Full** | **High** | **High** | **Partial** | **High** | **High** | **High** | **--** | **--** | **Partial** | **--** | **High** |
+| **SessionStart** | Restores state after compaction or resume | Yes | Yes | Yes | -- | -- | -- | Plugin | Yes | -- | -- | -- | ✓ (via session_start event) |
+| | **Session completeness** | **Full** | **High** | **High** | **Partial** | **High** | **High** | **High** | **Partial** | **--** | **Partial** | **--** | **High** |
 
-> **Note:** Full session continuity (capture + snapshot + restore) works on **Claude Code**, **Gemini CLI**, and **VS Code Copilot**. **OpenCode** provides **high** session continuity: it captures tool events and injects compaction snapshots via the plugin, but SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), so startup/resume restore is not supported. **KiloCode** shares the same plugin architecture as OpenCode via the OpenCodeAdapter, so its continuity level depends on KiloCode's SessionStart support. **Cursor** captures tool events via `preToolUse`/`postToolUse`, but `sessionStart` is currently rejected by Cursor's validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)), so session restore after compaction is not available yet. **OpenClaw** uses native gateway plugin hooks (`api.on()`) for full session continuity. **Pi Coding Agent** provides high session continuity via extension hooks (`tool_call`, `tool_result`, `session_start`, `session_before_compact`). **Codex CLI**, **Antigravity**, **Kiro**, and **Zed** have no hook support in the current release, so session tracking is not available.
+> **Note:** Full session continuity (capture + snapshot + restore) works on **Claude Code**, **Gemini CLI**, and **VS Code Copilot**. **OpenCode** provides **high** session continuity: it captures tool events and injects compaction snapshots via the plugin, but SessionStart is not yet available ([#14808](https://github.com/sst/opencode/issues/14808)), so startup/resume restore is not supported. **KiloCode** shares the same plugin architecture as OpenCode via the OpenCodeAdapter, so its continuity level depends on KiloCode's SessionStart support. **Cursor** captures tool events via `preToolUse`/`postToolUse`, but `sessionStart` is currently rejected by Cursor's validator ([forum report](https://forum.cursor.com/t/unknown-hook-type-sessionstart/149566)), so session restore after compaction is not available yet. **OpenClaw** uses native gateway plugin hooks (`api.on()`) for full session continuity. **Pi Coding Agent** provides high session continuity via extension hooks (`tool_call`, `tool_result`, `session_start`, `session_before_compact`). **Codex CLI** provides hook-based session tracking via PreToolUse/PostToolUse/SessionStart, using the same JSON stdin/stdout protocol as Claude Code. **Antigravity**, **Kiro**, and **Zed** have no hook support in the current release, so session tracking is not available.
 
 <details>
 <summary><strong>What gets captured</strong></summary>
@@ -807,7 +829,7 @@ Detailed event data is also indexed into FTS5 for on-demand retrieval via `searc
 
 **OpenClaw / Pi Agent** — High coverage. All tool lifecycle hooks (`after_tool_call`, `before_compaction`, `session_start`) fire via the native gateway plugin. User decisions aren't captured but file edits, git ops, errors, and tasks are fully tracked. Falls back to DB snapshot reconstruction if compaction hooks fail on older gateway versions. See [`docs/adapters/openclaw.md`](docs/adapters/openclaw.md).
 
-**Codex CLI** — No session support. No hooks means no event capture. Each compaction or new session starts fresh. Requires manually copying `AGENTS.md` to your project root.
+**Codex CLI** — Hook-based session tracking. PreToolUse enforces routing, PostToolUse captures events, SessionStart restores state after compaction. Same wire protocol as Claude Code. PreCompact and UserPromptSubmit are not yet available, so compaction snapshots rely on DB reconstruction.
 
 **Antigravity** — No session support. Same as Codex CLI — no hooks, no event capture. Requires manually copying `GEMINI.md` to your project root. Auto-detected via MCP protocol handshake (`clientInfo.name`).
 

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.