@evomap/evolver-mcp 2.0.0-beta.17 → 2.0.0-beta.19

package/dist/antigravityInstaller.d.ts

@@ -1,5 +1,5 @@
 import type { InjectionPlan, McpServerCmd, RuntimeId } from './injection.js';
-import { type InstallOptions, type InstallResult, type UninstallOptions } from './installer.js';
+import { type InstallOptions, type InstallResult, type UninstallOptions } from './installerShared.js';
 export declare const ANTIGRAVITY_NAMESPACES: readonly ["antigravity", "antigravity-ide"];
 export interface AntigravityConfigTarget {
     namespace: (typeof ANTIGRAVITY_NAMESPACES)[number];

package/dist/antigravityInstaller.js

@@ -1,9 +1,9 @@
-import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
-import { randomUUID } from 'node:crypto';
+import { lstatSync, mkdirSync, readFileSync, statSync, } from 'node:fs';
 import { homedir as osHomedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { util } from '@evomap/evolver-core';
-import { EmptySharedConfigError, SymlinkRefusedError, UnparseableConfigError, } from './installer.js';
+import { EmptySharedConfigError, SymlinkRefusedError, UnparseableConfigError, } from './installerShared.js';
+import { commitSharedFile, SharedFileConflictError } from './sharedFileCommit.js';
 const ENV_FILE_KEY = 'EVOLVER_ENV_FILE';
 const CONFIG_FILE = 'mcp_config.json';
 const CONFIG_WRITE_RETRIES = 5;
@@ -125,30 +125,6 @@ function existingFileMode(path) {
         throw error;
     }
 }
-function writeJsonAtomic(path, data) {
-    const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    const mode = existingFileMode(path) ?? NEW_CONFIG_MODE;
-    const restoreMode = process.platform === 'win32' && existsSync(path) ? existingFileMode(path) : undefined;
-    try {
-        writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, { encoding: 'utf8', flag: 'wx', mode });
-        chmodSync(tmp, mode);
-        if (process.platform === 'win32' && existsSync(path))
-            chmodSync(path, mode | 0o200);
-        renameSync(tmp, path);
-        chmodSync(path, mode);
-    }
-    catch (error) {
-        rmSync(tmp, { force: true });
-        if (restoreMode !== undefined) {
-            try {
-                if (existsSync(path))
-                    chmodSync(path, restoreMode);
-            }
-            catch { /* preserve the original error */ }
-        }
-        throw error;
-    }
-}
 function updateConfigWithRetry(path, update) {
     const lockPath = `${path}.evolver.lock`;
     util.acquireLock(lockPath);
@@ -160,8 +136,20 @@ function updateConfigWithRetry(path, update) {
                 return false;
             if (readRawIfExists(path) !== snapshot.raw)
                 continue;
-            writeJsonAtomic(path, next.data);
-            return true;
+            try {
+                commitSharedFile({
+                    path,
+                    expectedRaw: snapshot.raw ?? undefined,
+                    nextRaw: `${JSON.stringify(next.data, null, 2)}\n`,
+                    mode: existingFileMode(path) ?? NEW_CONFIG_MODE,
+                });
+                return true;
+            }
+            catch (error) {
+                if (error instanceof SharedFileConflictError)
+                    continue;
+                throw error;
+            }
         }
     }
     finally {

package/dist/codexInstaller.d.ts

@@ -1,7 +1,9 @@
 import type { RuntimeId, InjectionPlan } from './injection.js';
-import { type InstallResult, type InstallOptions } from './installer.js';
+import { type InstallResult, type InstallOptions } from './installerShared.js';
 /** The MCP server id evolver registers under [mcp_servers.evolver] / removes on uninstall. */
 export declare const CODEX_MCP_SERVER_ID = "evolver";
+type CodexConfigRaceHook = (path: string, attempt: number) => void;
+export declare function _setCodexConfigRaceHookForTest(hook?: CodexConfigRaceHook): void;
 /** The [mcp_servers.evolver] table from a plan's launch command. env omitted when empty (no `[..env]` table). */
 export declare function codexMcpServerEntry(server: {
     command: string;
@@ -10,13 +12,15 @@ export declare function codexMcpServerEntry(server: {
 }): Record<string, unknown>;
 /** A single [[hooks.SessionStart]] entry that runs `command` at session start. Shape matches codex's hooks schema. */
 export declare function codexSessionStartHook(command: string): Record<string, unknown>;
+/** UserPromptSubmit has no matcher in current Codex; five seconds keeps the prompt path fail-open and bounded. */
+export declare function codexUserPromptSubmitHook(command: string): Record<string, unknown>;
 /**
  * Merge evolver's codex config into the user's existing parsed TOML. Idempotent + non-destructive:
  *  - [mcp_servers] : set our `evolver` server, keep every other server the user registered.
  *  - [[hooks.SessionStart]] : drop any prior evolver-owned entry, keep all user entries, append ours fresh.
  * The user's unrelated tables (model, approval_policy, other hook events, …) pass through untouched.
  */
-export declare function mergeCodexConfig(existing: Record<string, unknown>, mcpServer: Record<string, unknown>, sessionStartHook: Record<string, unknown>): Record<string, unknown>;
+export declare function mergeCodexConfig(existing: Record<string, unknown>, mcpServer: Record<string, unknown>, sessionStartHook: Record<string, unknown>, userPromptSubmitHook?: Record<string, unknown>): Record<string, unknown>;
 /** Strip evolver's MCP server + SessionStart hook from parsed codex TOML (uninstall). Returns [changed, data]. */
 export declare function stripCodexManaged(data: Record<string, unknown>): {
     changed: boolean;
@@ -31,4 +35,5 @@ export declare function installCodex(plan: InjectionPlan, opts: InstallOptions):
 /** Remove evolver's MCP registration + SessionStart hook from a codex project config (leaves user content intact). */
 export declare function uninstallCodex(runtime: RuntimeId, opts: {
     configRoot: string;
-}): InstallResult;
+}): InstallResult;
+export {};

package/dist/codexInstaller.js

@@ -18,16 +18,18 @@
 // adapter-owned path, marker-managed so reinstall/uninstall only touch evolver's own entries, and a
 // hooks-UNION merge that preserves the user's existing hooks. TOML round-trips through smol-toml (spec
 // parser/serializer) so a user's hand-written config is preserved rather than clobbered.
-import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
-import { SymlinkRefusedError, DEFAULT_HOOK_COMMAND } from './installer.js';
+import { util } from '@evomap/evolver-core';
+import { commitSharedFile, SharedFileConflictError } from './sharedFileCommit.js';
+import { SymlinkRefusedError, DEFAULT_HOOK_COMMAND, DEFAULT_PROMPT_RECALL_HOOK_COMMAND, evolverManagedHookStatus, stripEvolverHookEntries, } from './installerShared.js';
 /** The MCP server id evolver registers under [mcp_servers.evolver] / removes on uninstall. */
 export const CODEX_MCP_SERVER_ID = 'evolver';
-/** A hook entry is evolver-owned if any command mentions this — used to replace-not-duplicate on reinstall. */
-const EVOLVER_HOOK_TAG = 'evolver';
 /** SessionStart matcher: codex fires `startup` on a fresh thread and `resume` on a resumed one — cover both. */
 const SESSION_START_MATCHER = 'startup|resume';
+const CONFIG_WRITE_RETRIES = 5;
+const CODEX_CONFIG_MODE = 0o600;
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
 // ── fs hardening (mirrors installer.ts) ──────────────────────────────────────
 function assertNotSymlink(path, label) {
@@ -43,21 +45,108 @@ function assertNotSymlink(path, label) {
     if (st.isSymbolicLink())
         throw new SymlinkRefusedError(label, path);
 }
-function readToml(path) {
+function readTomlSnapshot(path) {
+    let raw;
     try {
-        if (!existsSync(path))
-            return {};
-        const raw = readFileSync(path, 'utf8').trim();
-        return raw ? parseToml(raw) : {};
+        raw = readFileSync(path, 'utf8');
     }
-    catch {
-        return {}; // unparseable → start fresh (merge re-adds evolver entries; a broken file isn't silently kept)
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { data: {}, raw: null, mode: CODEX_CONFIG_MODE };
+        throw error;
+    }
+    if (!raw.trim()) {
+        throw new Error(`[setup-hooks] refusing to overwrite .codex/config.toml (${path}): the existing file is empty.`);
+    }
+    try {
+        return { data: parseToml(raw), raw, mode: (statSync(path).mode & 0o777) & 0o700 };
+    }
+    catch (error) {
+        throw new Error(`[setup-hooks] refusing to overwrite .codex/config.toml (${path}): the existing file is not valid TOML.`, { cause: error });
+    }
+}
+function readRawIfExists(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
     }
 }
-function writeTomlAtomic(path, data) {
-    const tmp = `${path}.tmp`;
-    writeFileSync(tmp, `${stringifyToml(data)}\n`, 'utf8');
-    renameSync(tmp, path);
+let codexConfigRaceHookForTest;
+export function _setCodexConfigRaceHookForTest(hook) {
+    codexConfigRaceHookForTest = hook;
+}
+function writeTomlWithRetry(path, update, assertSafe) {
+    const lockPath = `${path}.evolver.lock`;
+    assertSafe();
+    util.acquireLock(lockPath);
+    let operationResult = false;
+    let operationFailed = false;
+    let operationError;
+    try {
+        operationResult = (() => {
+            for (let attempt = 1; attempt <= CONFIG_WRITE_RETRIES; attempt += 1) {
+                assertSafe();
+                const snapshot = readTomlSnapshot(path);
+                const next = update(snapshot.data);
+                if (!next.changed)
+                    return false;
+                codexConfigRaceHookForTest?.(path, attempt);
+                assertSafe();
+                if (readRawIfExists(path) !== snapshot.raw)
+                    continue;
+                assertSafe();
+                try {
+                    commitSharedFile({
+                        path,
+                        expectedRaw: snapshot.raw ?? undefined,
+                        nextRaw: next.remove ? undefined : `${stringifyToml(next.data)}\n`,
+                        mode: snapshot.mode,
+                    });
+                    return true;
+                }
+                catch (error) {
+                    if (error instanceof SharedFileConflictError)
+                        continue;
+                    throw error;
+                }
+            }
+            throw new Error(`[setup-hooks] refusing to overwrite .codex/config.toml (${path}): the file changed repeatedly while evolver was merging it.`);
+        })();
+    }
+    catch (error) {
+        operationFailed = true;
+        operationError = error;
+    }
+    let releaseError;
+    try {
+        const released = util.releaseLock(lockPath);
+        if (!released.released)
+            releaseError = new util.LockReleaseError(released.reason);
+    }
+    catch (error) {
+        releaseError = error;
+    }
+    if (operationFailed) {
+        if (operationError instanceof Error && releaseError !== undefined) {
+            operationError.lockReleaseError = releaseError;
+        }
+        throw operationError;
+    }
+    if (releaseError !== undefined)
+        throw releaseError;
+    return operationResult;
+}
+function codexPathGuard(configRoot, codexDir, configPath) {
+    return () => {
+        assertNotSymlink(configRoot, 'config root');
+        assertNotSymlink(codexDir, '.codex');
+        assertNotSymlink(configPath, '.codex/config.toml');
+        assertNotSymlink(`${configPath}.evolver.lock`, '.codex/config.toml lock');
+    };
 }
 // ── pure merge (exported for tests) ──────────────────────────────────────────
 /** The [mcp_servers.evolver] table from a plan's launch command. env omitted when empty (no `[..env]` table). */
@@ -70,30 +159,66 @@ export function codexMcpServerEntry(server) {
 }
 /** A single [[hooks.SessionStart]] entry that runs `command` at session start. Shape matches codex's hooks schema. */
 export function codexSessionStartHook(command) {
-    return { matcher: SESSION_START_MATCHER, hooks: [{ type: 'command', command }] };
+    return { matcher: SESSION_START_MATCHER, hooks: [{
+                type: 'command', command, statusMessage: evolverManagedHookStatus(command),
+            }] };
 }
-const hookIsEvolverOwned = (entry) => {
-    if (!isObj(entry))
-        return false;
-    const inner = entry['hooks'];
-    if (!Array.isArray(inner))
+/** UserPromptSubmit has no matcher in current Codex; five seconds keeps the prompt path fail-open and bounded. */
+export function codexUserPromptSubmitHook(command) {
+    return { hooks: [{
+                type: 'command', command, timeout: 5, statusMessage: evolverManagedHookStatus(command),
+            }] };
+}
+function hookHasExactCommand(entry, command) {
+    if (!isObj(entry) || !Array.isArray(entry['hooks']))
         return false;
-    return inner.some((h) => isObj(h) && typeof h['command'] === 'string' && h['command'].includes(EVOLVER_HOOK_TAG));
-};
+    return entry['hooks'].some((handler) => isObj(handler) && handler['command'] === command);
+}
+function hookCommands(entries) {
+    const commands = new Set();
+    for (const entry of entries) {
+        if (!isObj(entry) || !Array.isArray(entry['hooks']))
+            continue;
+        for (const handler of entry['hooks']) {
+            if (isObj(handler) && typeof handler['command'] === 'string')
+                commands.add(handler['command']);
+        }
+    }
+    return commands;
+}
 /**
  * Merge evolver's codex config into the user's existing parsed TOML. Idempotent + non-destructive:
  *  - [mcp_servers] : set our `evolver` server, keep every other server the user registered.
  *  - [[hooks.SessionStart]] : drop any prior evolver-owned entry, keep all user entries, append ours fresh.
  * The user's unrelated tables (model, approval_policy, other hook events, …) pass through untouched.
  */
-export function mergeCodexConfig(existing, mcpServer, sessionStartHook) {
+export function mergeCodexConfig(existing, mcpServer, sessionStartHook, userPromptSubmitHook) {
     const out = { ...existing };
     const mcpServers = isObj(out['mcp_servers']) ? { ...out['mcp_servers'] } : {};
+    const trustManagedStatus = CODEX_MCP_SERVER_ID in mcpServers;
+    const managedCommands = hookCommands(userPromptSubmitHook ? [sessionStartHook, userPromptSubmitHook] : [sessionStartHook]);
     mcpServers[CODEX_MCP_SERVER_ID] = mcpServer;
     out['mcp_servers'] = mcpServers;
     const hooks = isObj(out['hooks']) ? { ...out['hooks'] } : {};
+    for (const event of Object.keys(hooks)) {
+        const value = hooks[event];
+        if (!Array.isArray(value))
+            continue;
+        const kept = stripEvolverHookEntries(value, trustManagedStatus, managedCommands).entries;
+        if (kept.length > 0)
+            hooks[event] = kept;
+        else
+            delete hooks[event];
+    }
     const prior = Array.isArray(hooks['SessionStart']) ? hooks['SessionStart'] : [];
-    hooks['SessionStart'] = [...prior.filter((e) => !hookIsEvolverOwned(e)), sessionStartHook];
+    hooks['SessionStart'] = [...prior, sessionStartHook];
+    if (userPromptSubmitHook) {
+        const priorPrompt = Array.isArray(hooks['UserPromptSubmit']) ? hooks['UserPromptSubmit'] : [];
+        hooks['UserPromptSubmit'] = [
+            ...priorPrompt,
+            userPromptSubmitHook,
+        ];
+    }
     out['hooks'] = hooks;
     return out;
 }
@@ -101,6 +226,8 @@ export function mergeCodexConfig(existing, mcpServer, sessionStartHook) {
 export function stripCodexManaged(data) {
     let changed = false;
     const out = { ...data };
+    const trustManagedStatus = isObj(out['mcp_servers'])
+        && CODEX_MCP_SERVER_ID in out['mcp_servers'];
     if (isObj(out['mcp_servers']) && CODEX_MCP_SERVER_ID in out['mcp_servers']) {
         const next = { ...out['mcp_servers'] };
         delete next[CODEX_MCP_SERVER_ID];
@@ -112,15 +239,18 @@ export function stripCodexManaged(data) {
     }
     if (isObj(out['hooks'])) {
         const hooks = { ...out['hooks'] };
-        if (Array.isArray(hooks['SessionStart'])) {
-            const arr = hooks['SessionStart'];
-            const kept = arr.filter((e) => !hookIsEvolverOwned(e));
-            if (kept.length !== arr.length)
+        for (const event of Object.keys(hooks)) {
+            const value = hooks[event];
+            if (!Array.isArray(value))
+                continue;
+            const stripped = stripEvolverHookEntries(value, trustManagedStatus);
+            const kept = stripped.entries;
+            if (stripped.changed)
                 changed = true;
             if (kept.length > 0)
-                hooks['SessionStart'] = kept;
+                hooks[event] = kept;
             else
-                delete hooks['SessionStart'];
+                delete hooks[event];
         }
         if (Object.keys(hooks).length > 0)
             out['hooks'] = hooks;
@@ -130,8 +260,16 @@ export function stripCodexManaged(data) {
     return { changed, data: out };
 }
 /** True if evolver's MCP server is already registered in this parsed config (structural install marker). */
-function codexAlreadyInstalled(cfg) {
-    return isObj(cfg['mcp_servers']) && CODEX_MCP_SERVER_ID in cfg['mcp_servers'];
+function codexAlreadyInstalled(cfg, sessionStartCommand, promptRecallCommand) {
+    if (!isObj(cfg['mcp_servers']) || !(CODEX_MCP_SERVER_ID in cfg['mcp_servers']))
+        return false;
+    const hooks = cfg['hooks'];
+    if (!isObj(hooks))
+        return false;
+    const sessionStart = Array.isArray(hooks['SessionStart']) ? hooks['SessionStart'] : [];
+    const promptSubmit = Array.isArray(hooks['UserPromptSubmit']) ? hooks['UserPromptSubmit'] : [];
+    return sessionStart.some((entry) => hookHasExactCommand(entry, sessionStartCommand))
+        && promptSubmit.some((entry) => hookHasExactCommand(entry, promptRecallCommand));
 }
 // ── install / uninstall ───────────────────────────────────────────────────────
 /**
@@ -141,31 +279,46 @@ function codexAlreadyInstalled(cfg) {
  */
 export function installCodex(plan, opts) {
     const hookCommand = opts.hookCommand ?? DEFAULT_HOOK_COMMAND;
+    const promptRecallHookCommand = opts.promptRecallHookCommand ?? DEFAULT_PROMPT_RECALL_HOOK_COMMAND;
     const codexDir = join(opts.configRoot, '.codex');
     const configPath = join(codexDir, 'config.toml');
-    assertNotSymlink(opts.configRoot, 'config root');
-    assertNotSymlink(codexDir, '.codex');
-    assertNotSymlink(configPath, '.codex/config.toml');
-    const existing = readToml(configPath);
-    if (!opts.force && codexAlreadyInstalled(existing)) {
-        return { ok: true, runtime: plan.runtime, mode: plan.mode, files: [], alreadyInstalled: true };
-    }
+    const assertSafe = codexPathGuard(opts.configRoot, codexDir, configPath);
+    assertSafe();
     const mcpServer = codexMcpServerEntry(opts.server);
     const sessionStartHook = codexSessionStartHook(hookCommand);
-    const merged = mergeCodexConfig(existing, mcpServer, sessionStartHook);
+    const userPromptSubmitHook = codexUserPromptSubmitHook(promptRecallHookCommand);
     mkdirSync(codexDir, { recursive: true });
-    writeTomlAtomic(configPath, merged);
-    return { ok: true, runtime: plan.runtime, mode: plan.mode, files: [configPath] };
+    const changed = writeTomlWithRetry(configPath, (current) => {
+        if (!opts.force && codexAlreadyInstalled(current, hookCommand, promptRecallHookCommand)) {
+            return { changed: false, data: current };
+        }
+        return {
+            changed: true,
+            data: mergeCodexConfig(current, mcpServer, sessionStartHook, userPromptSubmitHook),
+        };
+    }, assertSafe);
+    return {
+        ok: true,
+        runtime: plan.runtime,
+        mode: plan.mode,
+        files: changed ? [configPath] : [],
+        ...(!changed ? { alreadyInstalled: true } : {}),
+    };
 }
 /** Remove evolver's MCP registration + SessionStart hook from a codex project config (leaves user content intact). */
 export function uninstallCodex(runtime, opts) {
-    const configPath = join(opts.configRoot, '.codex', 'config.toml');
-    assertNotSymlink(configPath, '.codex/config.toml');
+    const codexDir = join(opts.configRoot, '.codex');
+    const configPath = join(codexDir, 'config.toml');
+    const assertSafe = codexPathGuard(opts.configRoot, codexDir, configPath);
+    assertSafe();
     if (!existsSync(configPath))
         return { ok: true, runtime, mode: 'uninstall', files: [] };
-    const { changed, data } = stripCodexManaged(readToml(configPath));
-    if (!changed)
-        return { ok: true, runtime, mode: 'uninstall', files: [] };
-    writeTomlAtomic(configPath, data);
-    return { ok: true, runtime, mode: 'uninstall', files: [configPath] };
+    const changed = writeTomlWithRetry(configPath, (current) => {
+        const stripped = stripCodexManaged(current);
+        return {
+            ...stripped,
+            remove: stripped.changed && Object.keys(stripped.data).length === 0,
+        };
+    }, assertSafe);
+    return { ok: true, runtime, mode: 'uninstall', files: changed ? [configPath] : [] };
 }

package/dist/cursorRulesInstaller.d.ts

@@ -1,4 +1,4 @@
-import { type InstallResult } from './installer.js';
+import { type InstallResult } from './installerShared.js';
 /** Project-relative location cursor loads project rules from. */
 export declare const CURSOR_RULES_DIR: string;
 /** The single evolver-owned rules file. Other `.cursor/rules/*.mdc` (user-authored) are never touched. */

package/dist/cursorRulesInstaller.js

@@ -15,9 +15,10 @@
 // with an unchanged gene set is a byte-for-byte no-op) and we never clobber rules a user hand-wrote in the same
 // file. Hardened exactly like the other installers: atomic writes (tmp+rename) and refusal to follow a symlink
 // at any adapter-owned path (a hostile workspace could redirect writes/unlinks outside the project).
+import { randomUUID } from 'node:crypto';
 import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { SymlinkRefusedError } from './installer.js';
+import { basename, dirname, join } from 'node:path';
+import { SymlinkRefusedError } from './installerShared.js';
 /** Project-relative location cursor loads project rules from. */
 export const CURSOR_RULES_DIR = join('.cursor', 'rules');
 /** The single evolver-owned rules file. Other `.cursor/rules/*.mdc` (user-authored) are never touched. */
@@ -47,10 +48,60 @@ function assertNotSymlink(path, label) {
     if (st.isSymbolicLink())
         throw new SymlinkRefusedError(label, path);
 }
-function writeTextAtomic(path, text) {
-    const tmp = `${path}.tmp`;
-    writeFileSync(tmp, text, 'utf8');
-    renameSync(tmp, path);
+function cursorRulePaths(configRoot) {
+    return {
+        cursorDir: join(configRoot, '.cursor'),
+        rulesDir: join(configRoot, CURSOR_RULES_DIR),
+        filePath: cursorRulesPath(configRoot),
+    };
+}
+function assertCursorRulePathsNotSymlink(configRoot, paths) {
+    assertNotSymlink(configRoot, 'config root');
+    assertNotSymlink(paths.cursorDir, '.cursor');
+    assertNotSymlink(paths.rulesDir, '.cursor/rules');
+    assertNotSymlink(paths.filePath, '.cursor/rules/evolver.mdc');
+}
+function cleanupAtomicTemp(filePath) {
+    try {
+        const stat = lstatSync(filePath);
+        if (!stat.isFile() && !stat.isSymbolicLink()) {
+            return new Error(`Refusing to clean non-file atomic temp path: ${filePath}`);
+        }
+        unlinkSync(filePath);
+        return undefined;
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? undefined : error;
+    }
+}
+function writeTextAtomic(filePath, text, beforeCommit) {
+    const tmp = join(dirname(filePath), `${basename(filePath)}.${randomUUID()}.tmp`);
+    let writeCompleted = false;
+    let renameCompleted = false;
+    let operationFailed = false;
+    let operationError;
+    let cleanupError;
+    try {
+        writeFileSync(tmp, text, { encoding: 'utf8', flag: 'wx' });
+        writeCompleted = true;
+        beforeCommit?.();
+        assertNotSymlink(filePath, '.cursor/rules/evolver.mdc');
+        renameSync(tmp, filePath);
+        renameCompleted = true;
+    }
+    catch (error) {
+        operationFailed = true;
+        operationError = error;
+    }
+    finally {
+        const collidedBeforeWrite = !writeCompleted && operationError?.code === 'EEXIST';
+        if (!renameCompleted && !collidedBeforeWrite)
+            cleanupError = cleanupAtomicTemp(tmp);
+    }
+    if (operationFailed)
+        throw operationError;
+    if (cleanupError !== undefined)
+        throw cleanupError;
 }
 // ── pure rendering (exported for tests) ───────────────────────────────────────
 /** One compact line for a gene in the rules body. Deterministic; defensively caps the hint length. */
@@ -135,14 +186,10 @@ export function cursorRulesPath(configRoot) {
  * Symlink-hardened on every adapter-owned path; other `.cursor/rules/*.mdc` files are never read or written.
  */
 export function installCursorRules(opts) {
-    const rulesDir = join(opts.configRoot, CURSOR_RULES_DIR);
-    const cursorDir = join(opts.configRoot, '.cursor');
-    const filePath = cursorRulesPath(opts.configRoot);
+    const paths = cursorRulePaths(opts.configRoot);
+    const { rulesDir, filePath } = paths;
     const maxGenes = opts.maxGenes ?? DEFAULT_CURSOR_MAX_GENES;
-    assertNotSymlink(opts.configRoot, 'config root');
-    assertNotSymlink(cursorDir, '.cursor');
-    assertNotSymlink(rulesDir, '.cursor/rules');
-    assertNotSymlink(filePath, '.cursor/rules/evolver.mdc');
+    assertCursorRulePathsNotSymlink(opts.configRoot, paths);
     const block = renderManagedBlock(opts.genes, maxGenes);
     const existing = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
     const next = existing ? spliceManagedBlock(existing, block) : renderCursorRulesFile(opts.genes, maxGenes);
@@ -151,7 +198,7 @@ export function installCursorRules(opts) {
         return { ok: true, runtime: 'cursor', mode: 'cursor-rules', files: [], rewritten: false };
     }
     mkdirSync(rulesDir, { recursive: true });
-    writeTextAtomic(filePath, next);
+    writeTextAtomic(filePath, next, () => assertCursorRulePathsNotSymlink(opts.configRoot, paths));
     return { ok: true, runtime: 'cursor', mode: 'cursor-rules', files: [filePath], rewritten: true };
 }
 /**
@@ -159,19 +206,21 @@ export function installCursorRules(opts) {
  * file; otherwise strip just the managed block and keep the user's content. Other rules files are untouched.
  */
 export function uninstallCursorRules(opts) {
-    const filePath = cursorRulesPath(opts.configRoot);
-    assertNotSymlink(filePath, '.cursor/rules/evolver.mdc');
+    const paths = cursorRulePaths(opts.configRoot);
+    const { filePath } = paths;
+    assertCursorRulePathsNotSymlink(opts.configRoot, paths);
     if (!existsSync(filePath))
         return { ok: true, runtime: 'cursor', mode: 'uninstall', files: [] };
     const text = readFileSync(filePath, 'utf8');
     if (isEvolverOnly(text)) {
+        assertCursorRulePathsNotSymlink(opts.configRoot, paths);
         unlinkSync(filePath);
         return { ok: true, runtime: 'cursor', mode: 'uninstall', files: [filePath] };
     }
     const { changed, text: stripped } = stripManagedBlock(text);
     if (!changed)
         return { ok: true, runtime: 'cursor', mode: 'uninstall', files: [] };
-    writeTextAtomic(filePath, stripped.endsWith('\n') ? stripped : `${stripped}\n`);
+    writeTextAtomic(filePath, stripped.endsWith('\n') ? stripped : `${stripped}\n`, () => assertCursorRulePathsNotSymlink(opts.configRoot, paths));
     return { ok: true, runtime: 'cursor', mode: 'uninstall', files: [filePath] };
 }
 /** Convenience for the daemon rewrite trigger: rewrite the rules file to reflect the current top genes. Returns

package/dist/installer.d.ts

@@ -1,11 +1,16 @@
 import { type RuntimeId, type McpServerCmd, type InjectionPlan } from './injection.js';
 import { type CursorGene } from './cursorRulesInstaller.js';
+export { EmptySharedConfigError, SymlinkRefusedError, UnparseableConfigError, } from './installerShared.js';
 /** Marks a config file as containing evolver-managed entries, so uninstall only removes what we added. */
 export declare const MANAGED_MARKER = "_evolver_managed";
+/** Official command-handler metadata, also gives custom commands an ownership marker for reinstall/uninstall. */
+export declare const EVOLVER_HOOK_STATUS = "Loading Evolver memory";
 /** Default command the SessionStart hook runs to render + print the memory injection. The `--hook-stdin` flag opts
  *  the entrypoint into reading the runtime's SessionStart JSON from stdin (to capture session_id, #205); only the
  *  installed hook sets it, so a manual `evolver inject session-start` never reads stdin. */
 export declare const DEFAULT_HOOK_COMMAND = "evolver inject session-start --hook-stdin";
+/** Local-only prompt recall. The handler is default-off and reads stdin only when EVOLVER_RECALL_MODE opts in. */
+export declare const DEFAULT_PROMPT_RECALL_HOOK_COMMAND = "evolver inject prompt-recall --hook-stdin";
 /**
  * Where a claude-code install registers the evolver MCP server. This is the fix for "global install doesn't
  * actually globalize" (#290): Claude Code's MCP scopes are local / user / project, and a `.mcp.json` is the
@@ -30,6 +35,8 @@ export interface InstallOptions {
     server: McpServerCmd;
     /** Command the SessionStart hook runs to inject memory. Default 'evolver inject session-start'. */
     hookCommand?: string;
+    /** Command the UserPromptSubmit hook runs. Default is local-only, default-off prompt recall. */
+    promptRecallHookCommand?: string;
     /** Reinstall even if an evolver install is already present. */
     force?: boolean;
     /** Plan and validate without writing config or backup files. */
@@ -93,31 +100,16 @@ export interface InstallResult {
     backups?: string[];
     error?: string;
 }
-export declare class SymlinkRefusedError extends Error {
-    constructor(label: string, path: string);
-}
-/**
- * Thrown when a SHARED user config (~/.claude.json or ~/.claude/settings.json) exists but does not parse as JSON.
- * These files are Claude Code's own state (projects/oauthAccount/userID/history/settings),
- * and user-scope install merges into them via a full-file atomic replace. The lenient readJson() returns {} on
- * a parse failure, which would make the merge emit ONLY evolver's entry and silently WIPE the whole file — a
- * realistic data-loss path because Claude Code writes these files non-atomically (a concurrent session can leave
- * one truncated). For the shared-config read we therefore refuse instead of clobbering. Project-scoped
- * .mcp.json/.claude/settings.json are evolver-owned, so their lenient fresh-start behavior stays unchanged.
- */
-export declare class UnparseableConfigError extends Error {
-    constructor(label: string, path: string, owner?: string);
-}
-/**
- * Thrown when a SHARED user config exists but is empty or whitespace-only. Claude Code writes these files with a
- * truncating write, so present-empty can be a concurrent-write window rather than a fresh config.
- */
-export declare class EmptySharedConfigError extends Error {
-    constructor(label: string, path: string, owner?: string);
-}
 type SharedConfigRaceHook = (path: string, attempt: number) => void;
 export declare function _setSharedConfigRaceHookForTest(hook?: SharedConfigRaceHook): void;
 export declare function deepMerge(target: Record<string, unknown>, source: Record<string, unknown>): Record<string, unknown>;
+/** Bind custom-command ownership to that exact command without adding undocumented hook-schema fields. */
+export declare function evolverManagedHookStatus(command: string): string;
+/** Remove only Evolver-owned handlers, retaining user handlers that share the same matcher group. */
+export declare function stripEvolverHookEntries(entries: readonly unknown[], trustManagedStatus?: boolean, managedCommands?: ReadonlySet<string>): {
+    changed: boolean;
+    entries: unknown[];
+};
 /**
  * deepMerge, but for `hooks.<event>` arrays keep the user's existing entries and only replace evolver-owned
  * ones — so reinstalling refreshes evolver's hook without clobbering a user's own SessionStart/Stop hooks.
@@ -147,5 +139,4 @@ export declare function installInjection(plan: InjectionPlan, opts: InstallOptio
  *  the mcpServers.evolver entry (and any evolver-owned hooks/marker), so it is safe on the shared ~/.claude.json. */
 export declare function uninstallInjection(runtime: RuntimeId, opts: UninstallOptions): InstallResult;
 /** Convenience: plan + install in one call for a runtime. */
-export declare function setupRuntime(runtime: RuntimeId, opts: InstallOptions): InstallResult;
-export {};
+export declare function setupRuntime(runtime: RuntimeId, opts: InstallOptions): InstallResult;