myagentmemory 0.4.16 → 0.5.1

package/dist/hooks.d.ts

@@ -1,3 +1,4 @@
+import { type HookMode } from "./core.js";
 /** Override the detected home directory in deterministic tests. */
 export declare function _setHookHomeDirForTest(directory: string | null): void;
 export type HookAgentKey = "claude" | "codex" | "cursor" | "opencode" | "pi";
@@ -14,6 +15,24 @@ export interface DetectedHookTarget extends HookTargetInfo {
     detected: boolean;
     detectReason?: string;
 }
+/**
+ * Read-only check whether the SessionStart hook for `key` is already present in
+ * the user's config. Mirrors each installer's "already installed" detection so
+ * the CLI can avoid prompting for hooks that don't need to be installed.
+ */
+export declare function isHookInstalled(homeDir: string, key: HookAgentKey): boolean;
+/**
+ * Read-only check whether the per-turn UserPromptSubmit hook is present.
+ * Only Claude Code and Codex support a per-prompt hook; cursor/opencode
+ * always return false (static rules only).
+ */
+export declare function isUserPromptSubmitInstalled(homeDir: string, key: HookAgentKey): boolean;
+/**
+ * Read-only check whether the periodic Stop-hook memory-write nudge is present.
+ * Claude Code only — Codex/Cursor/opencode don't have a confirmed equivalent
+ * block/reason protocol for this event yet.
+ */
+export declare function isStopHookInstalled(homeDir: string, key: HookAgentKey): boolean;
 export declare function detectHookAgents(): {
     homeDir: string | null;
     targets: DetectedHookTarget[];
@@ -25,6 +44,7 @@ export interface HookInstallResult {
     path?: string;
     backup?: string;
     reason?: string;
+    mode?: HookMode;
 }
 export interface InstallHooksReport {
     ok: boolean;
@@ -32,7 +52,7 @@ export interface InstallHooksReport {
     results: HookInstallResult[];
     error?: string;
 }
-export declare function installHooks(agents: Set<HookAgentKey>): InstallHooksReport;
+export declare function installHooks(agents: Set<HookAgentKey>, mode?: HookMode): InstallHooksReport;
 export interface UninstallHooksReport {
     ok: boolean;
     homeDir?: string;

package/dist/hooks.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { writeHookMode } from "./core.js";
 let homeDirOverride = null;
 /** Override the detected home directory in deterministic tests. */
 export function _setHookHomeDirForTest(directory) {
@@ -35,6 +36,12 @@ const HOOK_MARKER_END = "# END agent-memory hook";
 function sessionStartHookCommand(agent) {
     return `agent-memory hook session-start --agent ${agent}`;
 }
+function userPromptSubmitHookCommand(agent) {
+    return `agent-memory hook user-prompt-submit --agent ${agent}`;
+}
+function stopHookCommand(agent) {
+    return `agent-memory hook stop --agent ${agent}`;
+}
 function hookTargets(homeDir) {
     return [
         {
@@ -82,6 +89,101 @@ function hookTargets(homeDir) {
         },
     ];
 }
+function hasClaudeHookGroup(homeDir, eventKey, command) {
+    const settingsPath = path.join(homeDir, ".claude", "settings.json");
+    if (!fs.existsSync(settingsPath))
+        return false;
+    const settings = readJsonConfig(settingsPath);
+    const hooks = settings.hooks ?? {};
+    const groups = Array.isArray(hooks[eventKey]) ? hooks[eventKey] : [];
+    for (const group of groups) {
+        if (!group || typeof group !== "object")
+            continue;
+        const g = group;
+        const list = Array.isArray(g.hooks) ? g.hooks : [];
+        for (const hook of list) {
+            if (!hook || typeof hook !== "object")
+                continue;
+            const h = hook;
+            if (h[HOOK_MARKER_JSON] === true && h.command === command)
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Read-only check whether the SessionStart hook for `key` is already present in
+ * the user's config. Mirrors each installer's "already installed" detection so
+ * the CLI can avoid prompting for hooks that don't need to be installed.
+ */
+export function isHookInstalled(homeDir, key) {
+    try {
+        if (key === "claude")
+            return hasClaudeHookGroup(homeDir, "SessionStart", sessionStartHookCommand("claude"));
+        if (key === "codex") {
+            const configPath = path.join(homeDir, ".codex", "config.toml");
+            if (!fs.existsSync(configPath))
+                return false;
+            const existing = fs.readFileSync(configPath, "utf-8");
+            if (!existing.includes(HOOK_MARKER_BEGIN))
+                return false;
+            const command = sessionStartHookCommand("codex");
+            return existing.includes(`command = "${command}"`);
+        }
+        if (key === "cursor") {
+            return isCursorSessionStartHookRegistered(homeDir);
+        }
+        if (key === "opencode") {
+            const configPath = path.join(homeDir, ".config", "opencode", "opencode.json");
+            if (!fs.existsSync(configPath))
+                return false;
+            const config = readJsonConfig(configPath);
+            const raw = config.instructions;
+            const list = Array.isArray(raw) ? raw : [];
+            const instructionsPath = path.join(homeDir, ".agent-memory", "hooks", "opencode.md");
+            return list.includes(instructionsPath);
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
+/**
+ * Read-only check whether the per-turn UserPromptSubmit hook is present.
+ * Only Claude Code and Codex support a per-prompt hook; cursor/opencode
+ * always return false (static rules only).
+ */
+export function isUserPromptSubmitInstalled(homeDir, key) {
+    try {
+        if (key === "claude")
+            return hasClaudeHookGroup(homeDir, "UserPromptSubmit", userPromptSubmitHookCommand("claude"));
+        if (key === "codex") {
+            const configPath = path.join(homeDir, ".codex", "config.toml");
+            if (!fs.existsSync(configPath))
+                return false;
+            const existing = fs.readFileSync(configPath, "utf-8");
+            if (!existing.includes(HOOK_MARKER_BEGIN))
+                return false;
+            return existing.includes(`command = "${userPromptSubmitHookCommand("codex")}"`);
+        }
+    }
+    catch { }
+    return false;
+}
+/**
+ * Read-only check whether the periodic Stop-hook memory-write nudge is present.
+ * Claude Code only — Codex/Cursor/opencode don't have a confirmed equivalent
+ * block/reason protocol for this event yet.
+ */
+export function isStopHookInstalled(homeDir, key) {
+    try {
+        if (key === "claude")
+            return hasClaudeHookGroup(homeDir, "Stop", stopHookCommand("claude"));
+    }
+    catch { }
+    return false;
+}
 export function detectHookAgents() {
     const homeDir = resolveHomeDir();
     if (!homeDir)
@@ -130,17 +232,17 @@ function writeJson(filePath, data) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
 }
-function installClaudeCodeHook(homeDir) {
-    const settingsPath = path.join(homeDir, ".claude", "settings.json");
-    const backup = backupOnce(settingsPath);
-    const settings = readJsonConfig(settingsPath);
-    const hooks = settings.hooks ?? {};
-    const sessionStart = Array.isArray(hooks.SessionStart) ? [...hooks.SessionStart] : [];
-    // Idempotency: look for any existing entry tagged with our marker.
-    const command = sessionStartHookCommand("claude");
-    let managed = 0;
-    let updated = 0;
-    for (const group of sessionStart) {
+/**
+ * Idempotently upsert the agent-memory-managed hook group for `eventKey`
+ * (SessionStart or UserPromptSubmit) with `command`. Returns `{ changed,
+ * hadManaged }` so the caller can decide between "installed" / "updated" /
+ * "already installed" reasons.
+ */
+function upsertClaudeHookGroup(hooks, eventKey, command) {
+    const groups = Array.isArray(hooks[eventKey]) ? [...hooks[eventKey]] : [];
+    const managedIndexes = [];
+    for (let i = 0; i < groups.length; i++) {
+        const group = groups[i];
         if (!group || typeof group !== "object")
             continue;
         const g = group;
@@ -148,64 +250,165 @@ function installClaudeCodeHook(homeDir) {
         for (const hook of list) {
             if (!hook || typeof hook !== "object")
                 continue;
-            const managedHook = hook;
-            if (managedHook[HOOK_MARKER_JSON] !== true)
-                continue;
-            managed++;
-            if (managedHook.command !== command) {
-                managedHook.command = command;
-                updated++;
+            const h = hook;
+            if (h[HOOK_MARKER_JSON] === true) {
+                managedIndexes.push(i);
+                break;
             }
         }
     }
-    if (managed && !updated) {
-        return { key: "claude", label: "Claude Code", installed: false, path: settingsPath, reason: "already installed" };
-    }
-    if (updated) {
-        hooks.SessionStart = sessionStart;
-        settings.hooks = hooks;
-        writeJson(settingsPath, settings);
-        return { key: "claude", label: "Claude Code", installed: true, path: settingsPath, backup, reason: "updated" };
+    if (managedIndexes.length > 0) {
+        const keep = managedIndexes[0];
+        const dupes = managedIndexes.slice(1);
+        for (const idx of dupes.reverse())
+            groups.splice(idx, 1);
+        const group = groups[keep];
+        let changed = dupes.length > 0;
+        if ("matcher" in group) {
+            delete group.matcher;
+            changed = true;
+        }
+        const list = group.hooks;
+        for (const h of list) {
+            if (h[HOOK_MARKER_JSON] === true && h.command !== command) {
+                h.command = command;
+                changed = true;
+            }
+        }
+        hooks[eventKey] = groups;
+        return { changed, hadManaged: true };
     }
-    sessionStart.push({
-        matcher: "startup|resume",
-        hooks: [{ type: "command", command, [HOOK_MARKER_JSON]: true }],
+    // No existing managed group — add a fresh one without a matcher so it fires on all harnesses.
+    groups.push({ hooks: [{ type: "command", command, [HOOK_MARKER_JSON]: true }] });
+    hooks[eventKey] = groups;
+    return { changed: true, hadManaged: false };
+}
+/**
+ * Remove all agent-memory-managed hook entries for `eventKey`. Used when
+ * downgrading from per-turn back to stable (drops UserPromptSubmit).
+ * Returns true if anything was removed.
+ */
+function removeClaudeHookGroup(hooks, eventKey) {
+    const groups = Array.isArray(hooks[eventKey]) ? hooks[eventKey] : [];
+    if (groups.length === 0)
+        return false;
+    let removed = 0;
+    const filtered = groups
+        .map((group) => {
+        if (!group || typeof group !== "object")
+            return group;
+        const g = { ...group };
+        const list = Array.isArray(g.hooks) ? g.hooks : [];
+        const kept = list.filter((h) => {
+            const isOurs = h && typeof h === "object" && h[HOOK_MARKER_JSON] === true;
+            if (isOurs)
+                removed++;
+            return !isOurs;
+        });
+        g.hooks = kept;
+        return g;
+    })
+        .filter((group) => {
+        if (!group || typeof group !== "object")
+            return true;
+        const g = group;
+        return Array.isArray(g.hooks) && g.hooks.length > 0;
     });
-    hooks.SessionStart = sessionStart;
+    if (removed === 0)
+        return false;
+    if (filtered.length === 0)
+        delete hooks[eventKey];
+    else
+        hooks[eventKey] = filtered;
+    return true;
+}
+function installClaudeCodeHook(homeDir, mode = "per-turn") {
+    const settingsPath = path.join(homeDir, ".claude", "settings.json");
+    const backup = backupOnce(settingsPath);
+    const settings = readJsonConfig(settingsPath);
+    const hooks = settings.hooks ?? {};
+    const session = upsertClaudeHookGroup(hooks, "SessionStart", sessionStartHookCommand("claude"));
+    let promptChanged = false;
+    let promptHadManaged = false;
+    if (mode === "per-turn") {
+        const prompt = upsertClaudeHookGroup(hooks, "UserPromptSubmit", userPromptSubmitHookCommand("claude"));
+        promptChanged = prompt.changed;
+        promptHadManaged = prompt.hadManaged;
+    }
+    else {
+        promptChanged = removeClaudeHookGroup(hooks, "UserPromptSubmit");
+    }
+    // Stop backs the write side of memory with a periodic nudge. It is orthogonal
+    // to stable/per-turn context injection, so it is installed unconditionally.
+    const stop = upsertClaudeHookGroup(hooks, "Stop", stopHookCommand("claude"));
+    // Remove the ineffective PreCompact reminder from pre-release 0.5.0 installs.
+    // Claude Code does not inject plain hook stdout for that event.
+    const legacyPreCompactRemoved = removeClaudeHookGroup(hooks, "PreCompact");
+    if (!session.changed && !promptChanged && !stop.changed && !legacyPreCompactRemoved) {
+        return {
+            key: "claude",
+            label: "Claude Code",
+            installed: false,
+            path: settingsPath,
+            reason: "already installed",
+            mode,
+        };
+    }
     settings.hooks = hooks;
     writeJson(settingsPath, settings);
-    return { key: "claude", label: "Claude Code", installed: true, path: settingsPath, backup };
+    const reason = session.hadManaged || promptHadManaged || stop.hadManaged || legacyPreCompactRemoved ? "updated" : undefined;
+    return { key: "claude", label: "Claude Code", installed: true, path: settingsPath, backup, mode, reason };
 }
-function installCodexHook(homeDir) {
+function installCodexHook(homeDir, mode = "per-turn") {
     const configPath = path.join(homeDir, ".codex", "config.toml");
     const backup = backupOnce(configPath);
     const existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, "utf-8") : "";
-    const command = sessionStartHookCommand("codex");
-    const block = [
+    const sessionCommand = sessionStartHookCommand("codex");
+    const promptCommand = userPromptSubmitHookCommand("codex");
+    const lines = [
         HOOK_MARKER_BEGIN,
         "[[hooks.SessionStart]]",
         'matcher = "startup|resume"',
         "",
         "[[hooks.SessionStart.hooks]]",
         'type = "command"',
-        `command = "${command}"`,
-        HOOK_MARKER_END,
-    ].join("\n");
+        `command = "${sessionCommand}"`,
+    ];
+    if (mode === "per-turn") {
+        lines.push("", "[[hooks.UserPromptSubmit]]", "", "[[hooks.UserPromptSubmit.hooks]]", 'type = "command"', `command = "${promptCommand}"`);
+    }
+    lines.push(HOOK_MARKER_END);
+    const block = lines.join("\n");
     if (existing.includes(HOOK_MARKER_BEGIN)) {
         const escapeRe = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
         const pattern = new RegExp(`${escapeRe(HOOK_MARKER_BEGIN)}[\\s\\S]*?${escapeRe(HOOK_MARKER_END)}`);
         const current = existing.match(pattern)?.[0] ?? "";
-        if (current.includes(`command = "${command}"`)) {
-            return { key: "codex", label: "Codex", installed: false, path: configPath, reason: "already installed" };
+        if (current === block) {
+            return {
+                key: "codex",
+                label: "Codex",
+                installed: false,
+                path: configPath,
+                reason: "already installed",
+                mode,
+            };
         }
         fs.writeFileSync(configPath, existing.replace(pattern, block), "utf-8");
-        return { key: "codex", label: "Codex", installed: true, path: configPath, backup, reason: "updated" };
+        return {
+            key: "codex",
+            label: "Codex",
+            installed: true,
+            path: configPath,
+            backup,
+            reason: "updated",
+            mode,
+        };
     }
     const separator = existing === "" || existing.endsWith("\n") ? "" : "\n";
     const next = `${existing}${separator}${block}\n`;
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
     fs.writeFileSync(configPath, next, "utf-8");
-    return { key: "codex", label: "Codex", installed: true, path: configPath, backup };
+    return { key: "codex", label: "Codex", installed: true, path: configPath, backup, mode };
 }
 const CURSOR_RULE_BODY = `---
 description: Load persistent memory context from agent-memory
@@ -223,12 +426,76 @@ scratchpad items, and long-term memory. Prefer it over guessing.
 function installCursorRule(homeDir) {
     const rulesDir = path.join(homeDir, ".cursor", "rules");
     const rulePath = path.join(rulesDir, "agent-memory.mdc");
-    if (fs.existsSync(rulePath)) {
-        return { key: "cursor", label: "Cursor", installed: false, path: rulePath, reason: "already installed" };
-    }
+    if (fs.existsSync(rulePath))
+        return;
     fs.mkdirSync(rulesDir, { recursive: true });
     fs.writeFileSync(rulePath, CURSOR_RULE_BODY, "utf-8");
-    return { key: "cursor", label: "Cursor", installed: true, path: rulePath };
+}
+// Cursor's `sessionStart` hook (https://cursor.com/docs/agent/hooks) fires automatically when a
+// new conversation is created and can inject `additional_context` without the model choosing to
+// run anything — unlike the static .mdc rule above, this is a real, code-level guarantee.
+const CURSOR_HOOK_SCRIPT_RELATIVE = path.join("hooks", "agent-memory-session-start.js");
+const CURSOR_HOOK_SCRIPT_BODY = `#!/usr/bin/env node
+const { execSync } = require("node:child_process");
+let context = "";
+try {
+	context = execSync("agent-memory context --no-search", { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+} catch {
+	// agent-memory not on PATH, or the memory dir isn't initialized yet — fail open with no context.
+}
+process.stdout.write(JSON.stringify({ additional_context: context }));
+`;
+function isCursorSessionStartHookRegistered(homeDir) {
+    const hooksJsonPath = path.join(homeDir, ".cursor", "hooks.json");
+    if (!fs.existsSync(hooksJsonPath))
+        return false;
+    try {
+        const config = readJsonConfig(hooksJsonPath);
+        const hooks = config.hooks ?? {};
+        const sessionStart = Array.isArray(hooks.sessionStart) ? hooks.sessionStart : [];
+        return sessionStart.some((entry) => entry &&
+            typeof entry === "object" &&
+            entry.command === CURSOR_HOOK_SCRIPT_RELATIVE);
+    }
+    catch {
+        return false;
+    }
+}
+function installCursorHook(homeDir) {
+    const cursorDir = path.join(homeDir, ".cursor");
+    const scriptPath = path.join(cursorDir, CURSOR_HOOK_SCRIPT_RELATIVE);
+    const hooksJsonPath = path.join(cursorDir, "hooks.json");
+    // Cheap, harmless fallback for Cursor installs where hooks are disabled or unavailable.
+    installCursorRule(homeDir);
+    fs.mkdirSync(path.dirname(scriptPath), { recursive: true });
+    const scriptChanged = !fs.existsSync(scriptPath) || fs.readFileSync(scriptPath, "utf-8") !== CURSOR_HOOK_SCRIPT_BODY;
+    if (scriptChanged) {
+        fs.writeFileSync(scriptPath, CURSOR_HOOK_SCRIPT_BODY, "utf-8");
+        fs.chmodSync(scriptPath, 0o755);
+    }
+    const alreadyRegistered = isCursorSessionStartHookRegistered(homeDir);
+    if (alreadyRegistered && !scriptChanged) {
+        return { key: "cursor", label: "Cursor", installed: false, path: hooksJsonPath, reason: "already installed" };
+    }
+    const backup = backupOnce(hooksJsonPath);
+    const config = readJsonConfig(hooksJsonPath);
+    if (typeof config.version !== "number")
+        config.version = 1;
+    const hooks = config.hooks ?? {};
+    const sessionStart = Array.isArray(hooks.sessionStart) ? [...hooks.sessionStart] : [];
+    if (!alreadyRegistered)
+        sessionStart.push({ command: CURSOR_HOOK_SCRIPT_RELATIVE });
+    hooks.sessionStart = sessionStart;
+    config.hooks = hooks;
+    writeJson(hooksJsonPath, config);
+    return {
+        key: "cursor",
+        label: "Cursor",
+        installed: true,
+        path: hooksJsonPath,
+        backup,
+        reason: alreadyRegistered ? "updated" : undefined,
+    };
 }
 const OPENCODE_INSTRUCTIONS_BODY = `# agent-memory
 
@@ -257,7 +524,7 @@ function installOpencodeInstructions(homeDir) {
     writeJson(configPath, config);
     return { key: "opencode", label: "opencode", installed: true, path: configPath, backup };
 }
-export function installHooks(agents) {
+export function installHooks(agents, mode = "per-turn") {
     const { homeDir, targets } = detectHookAgents();
     if (!homeDir) {
         return {
@@ -267,6 +534,7 @@ export function installHooks(agents) {
         };
     }
     const results = [];
+    let anyInstalled = false;
     for (const target of targets) {
         if (!agents.has(target.key))
             continue;
@@ -289,14 +557,20 @@ export function installHooks(agents) {
             continue;
         }
         try {
+            let result;
             if (target.key === "claude")
-                results.push(installClaudeCodeHook(homeDir));
+                result = installClaudeCodeHook(homeDir, mode);
             else if (target.key === "codex")
-                results.push(installCodexHook(homeDir));
+                result = installCodexHook(homeDir, mode);
             else if (target.key === "cursor")
-                results.push(installCursorRule(homeDir));
+                result = installCursorHook(homeDir);
             else if (target.key === "opencode")
-                results.push(installOpencodeInstructions(homeDir));
+                result = installOpencodeInstructions(homeDir);
+            else
+                continue;
+            results.push(result);
+            if (result.installed)
+                anyInstalled = true;
         }
         catch (err) {
             results.push({
@@ -307,6 +581,14 @@ export function installHooks(agents) {
             });
         }
     }
+    if (anyInstalled) {
+        try {
+            writeHookMode(mode);
+        }
+        catch {
+            // Persisting the mode is best-effort — install output is authoritative.
+        }
+    }
     return { ok: true, homeDir, results };
 }
 function uninstallClaudeCodeHook(homeDir) {
@@ -316,35 +598,13 @@ function uninstallClaudeCodeHook(homeDir) {
     }
     const settings = readJsonConfig(settingsPath);
     const hooks = settings.hooks ?? {};
-    const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
-    let removed = 0;
-    const filtered = sessionStart
-        .map((group) => {
-        if (!group || typeof group !== "object")
-            return group;
-        const g = { ...group };
-        const list = Array.isArray(g.hooks) ? g.hooks : [];
-        const kept = list.filter((h) => {
-            const isOurs = h && typeof h === "object" && h[HOOK_MARKER_JSON] === true;
-            if (isOurs)
-                removed++;
-            return !isOurs;
-        });
-        g.hooks = kept;
-        return g;
-    })
-        .filter((group) => {
-        if (!group || typeof group !== "object")
-            return true;
-        const g = group;
-        return Array.isArray(g.hooks) && g.hooks.length > 0;
-    });
-    if (removed === 0) {
+    const sessionRemoved = removeClaudeHookGroup(hooks, "SessionStart");
+    const promptRemoved = removeClaudeHookGroup(hooks, "UserPromptSubmit");
+    const stopRemoved = removeClaudeHookGroup(hooks, "Stop");
+    const legacyPreCompactRemoved = removeClaudeHookGroup(hooks, "PreCompact");
+    if (!sessionRemoved && !promptRemoved && !stopRemoved && !legacyPreCompactRemoved) {
         return { key: "claude", label: "Claude Code", installed: false, reason: "not installed" };
     }
-    hooks.SessionStart = filtered;
-    if (filtered.length === 0)
-        delete hooks.SessionStart;
     if (Object.keys(hooks).length === 0)
         delete settings.hooks;
     else
@@ -367,19 +627,54 @@ function uninstallCodexHook(homeDir) {
     fs.writeFileSync(configPath, next, "utf-8");
     return { key: "codex", label: "Codex", installed: true, path: configPath };
 }
-function uninstallCursorRule(homeDir) {
+function uninstallCursorHook(homeDir) {
     const rulePath = path.join(homeDir, ".cursor", "rules", "agent-memory.mdc");
-    if (!fs.existsSync(rulePath)) {
-        return { key: "cursor", label: "Cursor", installed: false, reason: "not installed" };
+    const scriptPath = path.join(homeDir, ".cursor", CURSOR_HOOK_SCRIPT_RELATIVE);
+    const hooksJsonPath = path.join(homeDir, ".cursor", "hooks.json");
+    let touched = false;
+    if (fs.existsSync(rulePath)) {
+        fs.unlinkSync(rulePath);
+        try {
+            fs.rmdirSync(path.dirname(rulePath));
+        }
+        catch {
+            // non-empty; fine
+        }
+        touched = true;
     }
-    fs.unlinkSync(rulePath);
-    try {
-        fs.rmdirSync(path.dirname(rulePath));
+    if (fs.existsSync(hooksJsonPath)) {
+        try {
+            const config = readJsonConfig(hooksJsonPath);
+            const hooks = config.hooks ?? {};
+            const sessionStart = Array.isArray(hooks.sessionStart) ? hooks.sessionStart : [];
+            const filtered = sessionStart.filter((entry) => !(entry &&
+                typeof entry === "object" &&
+                entry.command === CURSOR_HOOK_SCRIPT_RELATIVE));
+            if (filtered.length !== sessionStart.length) {
+                if (filtered.length === 0)
+                    delete hooks.sessionStart;
+                else
+                    hooks.sessionStart = filtered;
+                if (Object.keys(hooks).length === 0)
+                    delete config.hooks;
+                else
+                    config.hooks = hooks;
+                writeJson(hooksJsonPath, config);
+                touched = true;
+            }
+        }
+        catch {
+            // invalid hooks.json — leave it for the user to fix rather than guessing.
+        }
     }
-    catch {
-        // non-empty; fine
+    if (fs.existsSync(scriptPath)) {
+        fs.unlinkSync(scriptPath);
+        touched = true;
+    }
+    if (!touched) {
+        return { key: "cursor", label: "Cursor", installed: false, reason: "not installed" };
     }
-    return { key: "cursor", label: "Cursor", installed: true, path: rulePath };
+    return { key: "cursor", label: "Cursor", installed: true, path: hooksJsonPath };
 }
 function uninstallOpencodeInstructions(homeDir) {
     const configPath = path.join(homeDir, ".config", "opencode", "opencode.json");
@@ -427,7 +722,7 @@ export function uninstallHooks(agents) {
             else if (key === "codex")
                 results.push(uninstallCodexHook(homeDir));
             else if (key === "cursor")
-                results.push(uninstallCursorRule(homeDir));
+                results.push(uninstallCursorHook(homeDir));
             else if (key === "opencode")
                 results.push(uninstallOpencodeInstructions(homeDir));
         }

package/dist/mcp-server.d.ts

@@ -0,0 +1,27 @@
+export interface McpToolInputSchema {
+    type: "object";
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+    }>;
+    required?: string[];
+}
+export interface McpToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: McpToolInputSchema;
+}
+export type McpToolHandler = (input: Record<string, unknown>) => unknown | Promise<unknown>;
+export declare class StdioMcpServer {
+    private readonly version;
+    private readonly tools;
+    private readonly startupHooks;
+    constructor(version?: string);
+    addTool(definition: McpToolDefinition, handler: McpToolHandler): void;
+    addStartupHook(fn: () => void | Promise<void>): void;
+    start(): Promise<void>;
+    private handleMessage;
+    private respond;
+    private respondError;
+}