context-mode 0.9.21 → 1.0.0

package/build/adapters/vscode-copilot/hooks.js

@@ -0,0 +1,76 @@
+/**
+ * adapters/vscode-copilot/hooks — VS Code Copilot hook definitions and matchers.
+ *
+ * Defines the hook types, matchers, and registration format specific to
+ * VS Code Copilot's hook system. This module is used by:
+ *   - CLI setup/upgrade commands (to configure hooks)
+ *   - Doctor command (to validate hook configuration)
+ *   - Hook config generation
+ *
+ * VS Code Copilot hook system reference:
+ *   - Hooks are registered in .github/hooks/*.json
+ *   - Hook names: PreToolUse, PostToolUse, PreCompact, SessionStart (PascalCase)
+ *   - Additional hooks: Stop, SubagentStart, SubagentStop (unique to VS Code)
+ *   - CRITICAL: matchers are parsed but IGNORED (all hooks fire on all tools)
+ *   - Input: JSON on stdin
+ *   - Output: JSON on stdout (or empty for passthrough)
+ *   - Preview status — API may change
+ */
+// ─────────────────────────────────────────────────────────
+// Hook type constants
+// ─────────────────────────────────────────────────────────
+/** VS Code Copilot hook types. */
+export const HOOK_TYPES = {
+    PRE_TOOL_USE: "PreToolUse",
+    POST_TOOL_USE: "PostToolUse",
+    PRE_COMPACT: "PreCompact",
+    SESSION_START: "SessionStart",
+    // Additional hooks unique to VS Code Copilot
+    STOP: "Stop",
+    SUBAGENT_START: "SubagentStart",
+    SUBAGENT_STOP: "SubagentStop",
+};
+// ─────────────────────────────────────────────────────────
+// Hook script file names
+// ─────────────────────────────────────────────────────────
+/** 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.PRE_COMPACT]: "precompact.mjs",
+    [HOOK_TYPES.SESSION_START]: "sessionstart.mjs",
+};
+// ─────────────────────────────────────────────────────────
+// Hook validation
+// ─────────────────────────────────────────────────────────
+/** Required hooks that must be configured for context-mode to function. */
+export const REQUIRED_HOOKS = [
+    HOOK_TYPES.PRE_TOOL_USE,
+    HOOK_TYPES.SESSION_START,
+];
+/** Optional hooks that enhance functionality but aren't critical. */
+export const OPTIONAL_HOOKS = [
+    HOOK_TYPES.POST_TOOL_USE,
+    HOOK_TYPES.PRE_COMPACT,
+];
+/**
+ * Check if a hook entry points to a context-mode hook script.
+ */
+export function isContextModeHook(entry, hookType) {
+    const scriptName = HOOK_SCRIPTS[hookType];
+    if (!scriptName)
+        return false;
+    return (entry.hooks?.some((h) => h.command?.includes(scriptName)) ?? false);
+}
+/**
+ * Build the hook command string for a given hook type.
+ * Uses the CLI dispatcher: `context-mode hook vscode-copilot <event>`
+ * Requires global install: `npm install -g context-mode`
+ */
+export function buildHookCommand(hookType) {
+    const scriptName = HOOK_SCRIPTS[hookType];
+    if (!scriptName) {
+        throw new Error(`No script defined for hook type: ${hookType}`);
+    }
+    return `context-mode hook vscode-copilot ${hookType.toLowerCase()}`;
+}

package/build/adapters/vscode-copilot/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * adapters/vscode-copilot — VS Code Copilot platform adapter.
+ *
+ * Implements HookAdapter for VS Code Copilot's JSON stdin/stdout hook paradigm.
+ *
+ * VS Code Copilot hook specifics:
+ *   - I/O: JSON on stdin, JSON on stdout (same paradigm as Claude Code)
+ *   - Hook names: PreToolUse, PostToolUse, PreCompact, SessionStart (PascalCase)
+ *   - Additional hooks: Stop, SubagentStart, SubagentStop (unique to VS Code)
+ *   - Arg modification: `updatedInput` in hookSpecificOutput wrapper (NOT flat)
+ *   - Blocking: `permissionDecision: "deny"` (same as Claude Code)
+ *   - Output modification: `additionalContext` in hookSpecificOutput,
+ *     `decision: "block"` + reason
+ *   - Tool input fields: tool_name, tool_input (snake_case, same as Claude Code)
+ *   - But tool input PROPERTY names are camelCase (filePath not file_path)
+ *   - Session ID: sessionId (camelCase, NOT session_id)
+ *   - MCP tool prefix: f1e_ (not mcp__server__tool)
+ *   - CRITICAL: matchers are parsed but IGNORED (all hooks fire on all tools)
+ *   - Config: .github/hooks/*.json (primary), also reads .claude/settings.json
+ *   - Env detection: VSCODE_PID, TERM_PROGRAM=vscode
+ *   - Session dir: ~/.vscode/context-mode/sessions/ (fallback)
+ *   - Preview status — API may change
+ */
+import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration, RoutingInstructionsConfig } from "../types.js";
+export declare class VSCodeCopilotAdapter implements HookAdapter {
+    readonly name = "VS Code Copilot";
+    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;
+    getSettingsPath(): string;
+    getSessionDir(): string;
+    getSessionDBPath(projectDir: string): string;
+    getSessionEventsPath(projectDir: string): string;
+    generateHookConfig(_pluginRoot: string): HookRegistration;
+    readSettings(): Record<string, unknown> | null;
+    writeSettings(settings: Record<string, unknown>): void;
+    validateHooks(pluginRoot: string): DiagnosticResult[];
+    checkPluginRegistration(): DiagnosticResult;
+    getInstalledVersion(): string;
+    configureAllHooks(_pluginRoot: string): string[];
+    backupSettings(): string | null;
+    setHookPermissions(pluginRoot: string): string[];
+    updatePluginRegistry(_pluginRoot: string, _version: string): void;
+    getRoutingInstructionsConfig(): RoutingInstructionsConfig;
+    writeRoutingInstructions(projectDir: string, pluginRoot: string): string | null;
+    /**
+     * Extract session ID from VS Code Copilot hook input.
+     * VS Code Copilot uses camelCase sessionId (NOT session_id).
+     */
+    private extractSessionId;
+}

package/build/adapters/vscode-copilot/index.js

@@ -0,0 +1,512 @@
+/**
+ * adapters/vscode-copilot — VS Code Copilot platform adapter.
+ *
+ * Implements HookAdapter for VS Code Copilot's JSON stdin/stdout hook paradigm.
+ *
+ * VS Code Copilot hook specifics:
+ *   - I/O: JSON on stdin, JSON on stdout (same paradigm as Claude Code)
+ *   - Hook names: PreToolUse, PostToolUse, PreCompact, SessionStart (PascalCase)
+ *   - Additional hooks: Stop, SubagentStart, SubagentStop (unique to VS Code)
+ *   - Arg modification: `updatedInput` in hookSpecificOutput wrapper (NOT flat)
+ *   - Blocking: `permissionDecision: "deny"` (same as Claude Code)
+ *   - Output modification: `additionalContext` in hookSpecificOutput,
+ *     `decision: "block"` + reason
+ *   - Tool input fields: tool_name, tool_input (snake_case, same as Claude Code)
+ *   - But tool input PROPERTY names are camelCase (filePath not file_path)
+ *   - Session ID: sessionId (camelCase, NOT session_id)
+ *   - MCP tool prefix: f1e_ (not mcp__server__tool)
+ *   - CRITICAL: matchers are parsed but IGNORED (all hooks fire on all tools)
+ *   - Config: .github/hooks/*.json (primary), also reads .claude/settings.json
+ *   - Env detection: VSCODE_PID, TERM_PROGRAM=vscode
+ *   - Session dir: ~/.vscode/context-mode/sessions/ (fallback)
+ *   - Preview status — API may change
+ */
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync, mkdirSync, copyFileSync, accessSync, existsSync, chmodSync, constants, } from "node:fs";
+import { resolve, join } from "node:path";
+import { homedir } from "node:os";
+// ─────────────────────────────────────────────────────────
+// Hook constants (re-exported from hooks.ts)
+// ─────────────────────────────────────────────────────────
+import { HOOK_TYPES as VSCODE_HOOK_NAMES, HOOK_SCRIPTS as VSCODE_HOOK_SCRIPTS, } from "./hooks.js";
+// ─────────────────────────────────────────────────────────
+// Adapter implementation
+// ─────────────────────────────────────────────────────────
+export class VSCodeCopilotAdapter {
+    name = "VS Code Copilot";
+    paradigm = "json-stdio";
+    capabilities = {
+        preToolUse: true,
+        postToolUse: true,
+        preCompact: true,
+        sessionStart: true,
+        canModifyArgs: true,
+        canModifyOutput: true,
+        canInjectSessionContext: true,
+    };
+    // ── Input parsing ──────────────────────────────────────
+    parsePreToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            sessionId: this.extractSessionId(input),
+            projectDir: process.env.CLAUDE_PROJECT_DIR || process.cwd(),
+            raw,
+        };
+    }
+    parsePostToolUseInput(raw) {
+        const input = raw;
+        return {
+            toolName: input.tool_name ?? "",
+            toolInput: input.tool_input ?? {},
+            toolOutput: input.tool_output,
+            isError: input.is_error,
+            sessionId: this.extractSessionId(input),
+            projectDir: process.env.CLAUDE_PROJECT_DIR || process.cwd(),
+            raw,
+        };
+    }
+    parsePreCompactInput(raw) {
+        const input = raw;
+        return {
+            sessionId: this.extractSessionId(input),
+            projectDir: process.env.CLAUDE_PROJECT_DIR || process.cwd(),
+            raw,
+        };
+    }
+    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: process.env.CLAUDE_PROJECT_DIR || process.cwd(),
+            raw,
+        };
+    }
+    // ── Response formatting ────────────────────────────────
+    formatPreToolUseResponse(response) {
+        if (response.decision === "deny") {
+            return {
+                permissionDecision: "deny",
+                reason: response.reason ?? "Blocked by context-mode hook",
+            };
+        }
+        if (response.decision === "modify" && response.updatedInput) {
+            // VS Code Copilot: updatedInput is wrapped in hookSpecificOutput
+            return {
+                hookSpecificOutput: {
+                    hookEventName: VSCODE_HOOK_NAMES.PRE_TOOL_USE,
+                    updatedInput: response.updatedInput,
+                },
+            };
+        }
+        if (response.decision === "context" && response.additionalContext) {
+            // VS Code Copilot: inject additionalContext via hookSpecificOutput
+            return {
+                hookSpecificOutput: {
+                    hookEventName: VSCODE_HOOK_NAMES.PRE_TOOL_USE,
+                    additionalContext: response.additionalContext,
+                },
+            };
+        }
+        if (response.decision === "ask") {
+            // VS Code Copilot: use deny to force user attention (no native "ask")
+            return {
+                permissionDecision: "deny",
+                reason: response.reason ?? "Action requires user confirmation (security policy)",
+            };
+        }
+        // "allow" — return undefined for passthrough
+        return undefined;
+    }
+    formatPostToolUseResponse(response) {
+        if (response.updatedOutput) {
+            // VS Code Copilot: decision "block" + reason for output replacement
+            return {
+                hookSpecificOutput: {
+                    hookEventName: VSCODE_HOOK_NAMES.POST_TOOL_USE,
+                    decision: "block",
+                    reason: response.updatedOutput,
+                },
+            };
+        }
+        if (response.additionalContext) {
+            return {
+                hookSpecificOutput: {
+                    hookEventName: VSCODE_HOOK_NAMES.POST_TOOL_USE,
+                    additionalContext: response.additionalContext,
+                },
+            };
+        }
+        return undefined;
+    }
+    formatPreCompactResponse(response) {
+        // VS Code Copilot: stdout content on exit 0 is injected as context
+        return response.context ?? "";
+    }
+    formatSessionStartResponse(response) {
+        // VS Code Copilot: stdout content is injected as additional context
+        return response.context ?? "";
+    }
+    // ── Configuration ──────────────────────────────────────
+    getSettingsPath() {
+        // VS Code Copilot primarily uses .github/hooks/*.json
+        // but also reads .claude/settings.json
+        return resolve(".github", "hooks", "context-mode.json");
+    }
+    getSessionDir() {
+        // Prefer .github/context-mode/sessions/ if .github exists,
+        // otherwise fall back to ~/.vscode/context-mode/sessions/
+        const githubDir = resolve(".github", "context-mode", "sessions");
+        const fallbackDir = join(homedir(), ".vscode", "context-mode", "sessions");
+        const dir = existsSync(resolve(".github")) ? githubDir : fallbackDir;
+        mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    getSessionDBPath(projectDir) {
+        const hash = createHash("sha256")
+            .update(projectDir)
+            .digest("hex")
+            .slice(0, 16);
+        return join(this.getSessionDir(), `${hash}.db`);
+    }
+    getSessionEventsPath(projectDir) {
+        const hash = createHash("sha256")
+            .update(projectDir)
+            .digest("hex")
+            .slice(0, 16);
+        return join(this.getSessionDir(), `${hash}-events.md`);
+    }
+    generateHookConfig(_pluginRoot) {
+        return {
+            [VSCODE_HOOK_NAMES.PRE_TOOL_USE]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `context-mode hook vscode-copilot ${VSCODE_HOOK_NAMES.PRE_TOOL_USE.toLowerCase()}`,
+                        },
+                    ],
+                },
+            ],
+            [VSCODE_HOOK_NAMES.POST_TOOL_USE]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `context-mode hook vscode-copilot ${VSCODE_HOOK_NAMES.POST_TOOL_USE.toLowerCase()}`,
+                        },
+                    ],
+                },
+            ],
+            [VSCODE_HOOK_NAMES.PRE_COMPACT]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `context-mode hook vscode-copilot ${VSCODE_HOOK_NAMES.PRE_COMPACT.toLowerCase()}`,
+                        },
+                    ],
+                },
+            ],
+            [VSCODE_HOOK_NAMES.SESSION_START]: [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `context-mode hook vscode-copilot ${VSCODE_HOOK_NAMES.SESSION_START.toLowerCase()}`,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    readSettings() {
+        // Try .github/hooks/context-mode.json first, then .claude/settings.json
+        const paths = [
+            this.getSettingsPath(),
+            resolve(".claude", "settings.json"),
+        ];
+        for (const configPath of paths) {
+            try {
+                const raw = readFileSync(configPath, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    writeSettings(settings) {
+        const configPath = this.getSettingsPath();
+        const dir = resolve(".github", "hooks");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(configPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+    }
+    // ── Diagnostics (doctor) ─────────────────────────────────
+    validateHooks(pluginRoot) {
+        const results = [];
+        // Check .github/hooks/ directory for hook JSON files
+        const hooksDir = resolve(".github", "hooks");
+        try {
+            accessSync(hooksDir, constants.R_OK);
+        }
+        catch {
+            results.push({
+                check: "Hooks directory",
+                status: "fail",
+                message: ".github/hooks/ directory not found",
+                fix: "context-mode upgrade",
+            });
+            return results;
+        }
+        // Check for context-mode hook config
+        const hookConfigPath = resolve(hooksDir, "context-mode.json");
+        try {
+            const raw = readFileSync(hookConfigPath, "utf-8");
+            const config = JSON.parse(raw);
+            const hooks = config.hooks;
+            // Check PreToolUse
+            if (hooks?.[VSCODE_HOOK_NAMES.PRE_TOOL_USE]) {
+                results.push({
+                    check: "PreToolUse hook",
+                    status: "pass",
+                    message: "PreToolUse hook configured in context-mode.json",
+                });
+            }
+            else {
+                results.push({
+                    check: "PreToolUse hook",
+                    status: "fail",
+                    message: "PreToolUse not found in context-mode.json",
+                    fix: "context-mode upgrade",
+                });
+            }
+            // Check SessionStart
+            if (hooks?.[VSCODE_HOOK_NAMES.SESSION_START]) {
+                results.push({
+                    check: "SessionStart hook",
+                    status: "pass",
+                    message: "SessionStart hook configured in context-mode.json",
+                });
+            }
+            else {
+                results.push({
+                    check: "SessionStart hook",
+                    status: "fail",
+                    message: "SessionStart not found in context-mode.json",
+                    fix: "context-mode upgrade",
+                });
+            }
+        }
+        catch {
+            results.push({
+                check: "Hook configuration",
+                status: "fail",
+                message: "Could not read .github/hooks/context-mode.json",
+                fix: "context-mode upgrade",
+            });
+        }
+        // Warn about preview status
+        results.push({
+            check: "API stability",
+            status: "warn",
+            message: "VS Code Copilot hooks are in preview — API may change without notice",
+        });
+        // Warn about matcher behavior
+        results.push({
+            check: "Matcher support",
+            status: "warn",
+            message: "Matchers are parsed but IGNORED — all hooks fire on all tools",
+        });
+        return results;
+    }
+    checkPluginRegistration() {
+        // Check MCP config in .vscode/mcp.json
+        try {
+            const mcpConfigPath = resolve(".vscode", "mcp.json");
+            const raw = readFileSync(mcpConfigPath, "utf-8");
+            const config = JSON.parse(raw);
+            const servers = config.servers;
+            if (servers) {
+                const hasPlugin = Object.keys(servers).some((k) => k.includes("context-mode"));
+                if (hasPlugin) {
+                    return {
+                        check: "MCP registration",
+                        status: "pass",
+                        message: "context-mode found in .vscode/mcp.json",
+                    };
+                }
+            }
+            return {
+                check: "MCP registration",
+                status: "fail",
+                message: "context-mode not found in .vscode/mcp.json",
+                fix: "Add context-mode server to .vscode/mcp.json",
+            };
+        }
+        catch {
+            return {
+                check: "MCP registration",
+                status: "warn",
+                message: "Could not read .vscode/mcp.json",
+            };
+        }
+    }
+    getInstalledVersion() {
+        // Check VS Code extensions for context-mode
+        const extensionDirs = [
+            join(homedir(), ".vscode", "extensions"),
+            join(homedir(), ".vscode-insiders", "extensions"),
+        ];
+        for (const extDir of extensionDirs) {
+            try {
+                const entries = readFileSync(join(extDir, "extensions.json"), "utf-8");
+                const exts = JSON.parse(entries);
+                const contextMode = exts.find((e) => typeof e.identifier === "object" &&
+                    e.identifier !== null &&
+                    e.identifier.id?.toString().includes("context-mode"));
+                if (contextMode && typeof contextMode.version === "string") {
+                    return contextMode.version;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return "not installed";
+    }
+    // ── Upgrade ────────────────────────────────────────────
+    configureAllHooks(_pluginRoot) {
+        const changes = [];
+        const hookConfig = { hooks: {} };
+        const hooks = hookConfig.hooks;
+        const hookTypes = [
+            VSCODE_HOOK_NAMES.PRE_TOOL_USE,
+            VSCODE_HOOK_NAMES.POST_TOOL_USE,
+            VSCODE_HOOK_NAMES.PRE_COMPACT,
+            VSCODE_HOOK_NAMES.SESSION_START,
+        ];
+        for (const hookType of hookTypes) {
+            const script = VSCODE_HOOK_SCRIPTS[hookType];
+            if (!script)
+                continue;
+            hooks[hookType] = [
+                {
+                    matcher: "",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `context-mode hook vscode-copilot ${hookType.toLowerCase()}`,
+                        },
+                    ],
+                },
+            ];
+            changes.push(`Configured ${hookType} hook`);
+        }
+        // Write to .github/hooks/context-mode.json
+        const outputDir = resolve(".github", "hooks");
+        mkdirSync(outputDir, { recursive: true });
+        const outputPath = resolve(outputDir, "context-mode.json");
+        writeFileSync(outputPath, JSON.stringify(hookConfig, null, 2) + "\n", "utf-8");
+        changes.push(`Wrote hook config to ${outputPath}`);
+        return changes;
+    }
+    backupSettings() {
+        const settingsPath = this.getSettingsPath();
+        try {
+            accessSync(settingsPath, constants.R_OK);
+            const backupPath = settingsPath + ".bak";
+            copyFileSync(settingsPath, backupPath);
+            return backupPath;
+        }
+        catch {
+            return null;
+        }
+    }
+    setHookPermissions(pluginRoot) {
+        const set = [];
+        const hooksDir = join(pluginRoot, "hooks", "vscode-copilot");
+        for (const scriptName of Object.values(VSCODE_HOOK_SCRIPTS)) {
+            const scriptPath = resolve(hooksDir, scriptName);
+            try {
+                accessSync(scriptPath, constants.R_OK);
+                chmodSync(scriptPath, 0o755);
+                set.push(scriptPath);
+            }
+            catch {
+                /* skip missing scripts */
+            }
+        }
+        return set;
+    }
+    updatePluginRegistry(_pluginRoot, _version) {
+        // VS Code manages extensions through its own marketplace/extension system.
+        // No manual registry update needed.
+    }
+    // ── Routing Instructions (soft enforcement) ────────────
+    getRoutingInstructionsConfig() {
+        return {
+            fileName: "copilot-instructions.md",
+            globalPath: "", // VS Code Copilot uses org-level, not global file
+            projectRelativePath: join(".github", "copilot-instructions.md"),
+        };
+    }
+    writeRoutingInstructions(projectDir, pluginRoot) {
+        const config = this.getRoutingInstructionsConfig();
+        const targetPath = resolve(projectDir, config.projectRelativePath);
+        const sourcePath = resolve(pluginRoot, "configs", "vscode-copilot", config.fileName);
+        try {
+            const content = readFileSync(sourcePath, "utf-8");
+            // Ensure .github directory exists
+            mkdirSync(resolve(projectDir, ".github"), { recursive: true });
+            try {
+                const existing = readFileSync(targetPath, "utf-8");
+                if (existing.includes("context-mode"))
+                    return null;
+                writeFileSync(targetPath, existing.trimEnd() + "\n\n" + content, "utf-8");
+                return targetPath;
+            }
+            catch {
+                writeFileSync(targetPath, content, "utf-8");
+                return targetPath;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    // ── Internal helpers ───────────────────────────────────
+    /**
+     * Extract session ID from VS Code Copilot hook input.
+     * VS Code Copilot uses camelCase sessionId (NOT session_id).
+     */
+    extractSessionId(input) {
+        if (input.sessionId)
+            return input.sessionId;
+        if (process.env.VSCODE_PID)
+            return `vscode-${process.env.VSCODE_PID}`;
+        return `pid-${process.ppid}`;
+    }
+}

package/build/cli.d.ts

@@ -3,10 +3,13 @@
  * context-mode CLI
  *
  * Usage:
- *   context-mode          → Start MCP server (stdio)
- *   context-mode setup    → Interactive setup (detect runtimes, install Bun)
- *   context-mode doctor   → Diagnose runtime issues, hooks, FTS5, version
- *   context-mode upgrade  → Fix hooks, permissions, and settings
- *   context-mode stats    → (skill only — /context-mode:stats)
+ *   context-mode                              → Start MCP server (stdio)
+ *   context-mode doctor                       → Diagnose runtime issues, hooks, FTS5, version
+ *   context-mode upgrade                      → Fix hooks, permissions, and settings
+ *   context-mode hook <platform> <event>      → Dispatch a hook script (used by platform hook configs)
+ *
+ * Platform auto-detection: CLI detects which platform is running
+ * (Claude Code, Gemini CLI, OpenCode, etc.) and uses the appropriate adapter.
  */
-export {};
+/** Normalize Windows backslash paths to forward slashes for Bash (MSYS2) compatibility. */
+export declare function toUnixPath(p: string): string;