prism-mcp-server 20.1.0 → 20.2.0

package/README.md

@@ -18,6 +18,16 @@ A paid subscription adds cloud sync, higher model tiers, and team features throu
 
 ---
 
+## What's New in v20.2.0
+
+### One Command Connects Every Supported Host
+Install Prism globally and run `prism connect`. It detects Claude Code, Claude
+Desktop on macOS, Windows, and Linux (beta), Cursor, Gemini CLI, and Codex, then safely registers the
+server from the installed package. Existing custom entries are untouched;
+`--dry-run` previews changes and `--refresh` updates only Prism-managed entries.
+
+---
+
 ## What's New in v20.1.0
 
 ### Every Inference Outcome Is Now Observable
@@ -97,20 +107,31 @@ External contributions now require signing the [Individual CLA](./CLA.md). The C
 
 ## Quickstart
 
-The free tier needs no account, no API key, and no cloud. Add the server to your MCP client:
-
-```json
-{
-  "mcpServers": {
-    "prism": {
-      "command": "npx",
-      "args": ["-y", "prism-mcp-server"]
-    }
-  }
-}
+The free tier needs no account, no API key, and no cloud. Install Prism, then
+register it with every supported MCP host already installed on your machine:
+
+```bash
+npm install --global prism-mcp-server
+prism connect
 ```
 
-Open Claude Desktop or Cursor and your agent now has memory backed by a local SQLite database (`~/.prism-mcp/data.db`).
+`prism connect` detects Claude Code, Claude Desktop (macOS/Windows/Linux), Cursor,
+Gemini CLI, and Codex.
+Use `prism connect --all` to target all five, `--host <name>` for one host, or
+`--dry-run` to preview the files that would change. Existing `prism` and
+`prism-mcp` entries are never overwritten by default. `--refresh` updates only
+an entry previously created by Prism; custom entries remain untouched.
+Close the target MCP hosts before a non-dry-run registration so they cannot
+edit their configuration at the same time.
+
+Codex registration preserves `~/.codex/config.toml` and appends only a marked
+Prism-managed block. `CODEX_HOME` is respected when set and must already exist,
+matching Codex's own contract. Restart Codex CLI, the
+IDE extension, or the ChatGPT desktop app after connecting.
+
+Restart the connected host and your agent now has memory backed by a local
+SQLite database (`~/.prism-mcp/data.db`). See [IDE setup](docs/IDE_SETUP.md)
+for manual configuration and host-specific paths.
 
 **Optional — local model fleet** for offline tool-routing. Pull whichever fits your hardware:
 

package/dist/cli.js

@@ -8,11 +8,73 @@ import { getSetting } from './storage/configStorage.js';
 import { PRISM_USER_ID, SERVER_CONFIG } from './config.js';
 import { getCurrentGitState } from './utils/git.js';
 import { sessionLoadContextHandler, sessionSaveLedgerHandler, sessionSaveHandoffHandler } from './tools/ledgerHandlers.js';
+import { connectHosts, normalizeHostName } from './connect.js';
 const program = new Command();
 program
     .name('prism')
     .description('Prism — The Mind Palace for AI Agents')
     .version(SERVER_CONFIG.version);
+// ─── prism connect ────────────────────────────────────────────
+// Registers this installed package with supported MCP hosts. The
+// merge is additive: an existing `prism` or `prism-mcp` entry is
+// reported and left byte-for-byte untouched.
+program
+    .command('connect')
+    .description('Register Prism with installed MCP hosts (close hosts before writing)')
+    .option('--host <name>', 'Target one host: claude-code, claude-desktop, cursor, gemini, or codex')
+    .option('--all', 'Target all supported hosts instead of auto-detecting installed hosts')
+    .option('--dry-run', 'Preview configuration changes without writing files')
+    .option('--refresh', 'Refresh only entries previously created by Prism; custom entries stay untouched')
+    .action((options) => {
+    try {
+        if (!options.dryRun) {
+            console.log('Close target MCP hosts before registration so they cannot edit configuration concurrently.');
+        }
+        const hosts = options.host ? [normalizeHostName(options.host)] : undefined;
+        const summary = connectHosts({
+            all: !!options.all,
+            dryRun: !!options.dryRun,
+            refresh: !!options.refresh,
+            hosts,
+        });
+        if (summary.results.length === 0) {
+            console.error('No supported MCP hosts detected. Use --host <name> or --all to target one explicitly.');
+            process.exitCode = 1;
+            return;
+        }
+        for (const result of summary.results) {
+            if (result.status === 'registered') {
+                console.log(`✓ ${result.label}: registered (${result.path})`);
+            }
+            else if (result.status === 'would-register') {
+                console.log(`• ${result.label}: would register (${result.path})`);
+            }
+            else if (result.status === 'refreshed') {
+                console.log(`✓ ${result.label}: Prism-managed entry refreshed (${result.path})`);
+            }
+            else if (result.status === 'would-refresh') {
+                console.log(`• ${result.label}: would refresh Prism-managed entry (${result.path})`);
+            }
+            else if (result.status === 'existing') {
+                console.log(`− ${result.label}: already registered — untouched (${result.path})`);
+            }
+            else {
+                console.error(`✗ ${result.label}: ${result.message || 'registration failed'} (${result.path})`);
+                process.exitCode = 1;
+            }
+        }
+        if (options.dryRun) {
+            console.log('\nDry run complete — no files changed.');
+        }
+        if (!summary.usedApiKey) {
+            console.log('PRISM_SYNALUX_API_KEY is not set; new registrations use local/free mode.');
+        }
+    }
+    catch (err) {
+        console.error(`Connect failed: ${err instanceof Error ? err.message : String(err)}`);
+        process.exitCode = 1;
+    }
+});
 // ─── prism load <project> ─────────────────────────────────────
 // Loads session context using the same storage layer as the MCP
 // session_load_context tool. Works with both SQLite and Supabase.

package/dist/connect.js

@@ -0,0 +1,560 @@
+import { accessSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+export const CONNECT_HOSTS = [
+    "claude-code",
+    "claude-desktop",
+    "cursor",
+    "gemini",
+    "codex",
+];
+const HOST_ALIASES = {
+    "claude-code": "claude-code",
+    claude: "claude-code",
+    code: "claude-code",
+    "claude-desktop": "claude-desktop",
+    desktop: "claude-desktop",
+    cursor: "cursor",
+    gemini: "gemini",
+    "gemini-cli": "gemini",
+    codex: "codex",
+    "codex-cli": "codex",
+};
+const CODEX_MANAGED_START = "# >>> prism connect managed: prism-mcp";
+const CODEX_MANAGED_END = "# <<< prism connect managed: prism-mcp";
+export function normalizeHostName(value) {
+    const normalized = value.trim().toLowerCase();
+    const host = HOST_ALIASES[normalized];
+    if (!host) {
+        throw new Error(`Unsupported host "${value}". Choose one of: ${CONNECT_HOSTS.join(", ")}`);
+    }
+    return host;
+}
+export function resolveInstalledServerPath(moduleUrl = import.meta.url) {
+    const manifestPath = fileURLToPath(new URL("../package.json", moduleUrl));
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Cannot read Prism package manifest at ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isJsonObject(manifest) || typeof manifest.main !== "string" || !manifest.main.trim()) {
+        throw new Error(`Prism package manifest has no valid "main" entry: ${manifestPath}`);
+    }
+    const serverPath = resolve(dirname(manifestPath), manifest.main);
+    if (!existsSync(serverPath)) {
+        throw new Error(`Prism server entrypoint was not found: ${serverPath}. Run npm run build first.`);
+    }
+    return realpathSync(serverPath);
+}
+export function connectHosts(options = {}) {
+    if (options.all && options.hosts?.length) {
+        throw new Error("Use either --all or --host, not both.");
+    }
+    const homeDir = options.homeDir ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const serverPath = options.serverPath ?? resolveInstalledServerPath();
+    const nodePath = options.nodePath ?? process.execPath;
+    const definitions = getHostDefinitions(homeDir, platform, env, options.homeDir === undefined);
+    const pathEnv = options.pathEnv ?? env.PATH ?? "";
+    let selected;
+    if (options.hosts?.length) {
+        const requested = new Set(options.hosts);
+        selected = definitions.filter((definition) => requested.has(definition.name));
+        const unavailable = options.hosts.filter((host) => !selected.some((definition) => definition.name === host));
+        if (unavailable.length > 0) {
+            throw new Error(`${unavailable.join(", ")} is not supported on ${platform}`);
+        }
+    }
+    else if (options.all) {
+        selected = definitions;
+    }
+    else {
+        selected = definitions.filter((definition) => isHostDetected(definition, platform, pathEnv));
+    }
+    const entry = buildMcpEntry(nodePath, serverPath, env);
+    const results = selected.map((definition) => registerHost(definition, entry, !!options.dryRun, !!options.refresh, options.beforeCommit));
+    return {
+        results,
+        usedApiKey: typeof env.PRISM_SYNALUX_API_KEY === "string" && env.PRISM_SYNALUX_API_KEY.length > 0,
+        serverPath,
+    };
+}
+function getHostDefinitions(homeDir, platform, env, includeSystemPaths) {
+    const claudeDesktop = claudeDesktopPath(homeDir, platform, env);
+    const cursorDetectionPaths = [join(homeDir, ".cursor")];
+    const desktopDetectionPaths = claudeDesktop ? [dirname(claudeDesktop)] : [];
+    const configuredCodexHome = includeSystemPaths && env.CODEX_HOME?.trim()
+        ? resolve(env.CODEX_HOME.trim())
+        : undefined;
+    const codexHome = configuredCodexHome ?? join(homeDir, ".codex");
+    const codexDetectionPaths = [codexHome];
+    let codexConfigurationError;
+    if (configuredCodexHome) {
+        try {
+            if (!statSync(configuredCodexHome).isDirectory()) {
+                codexConfigurationError = `CODEX_HOME must be an existing directory: ${configuredCodexHome}`;
+            }
+        }
+        catch (error) {
+            codexConfigurationError = `CODEX_HOME must be an existing directory: ${configuredCodexHome} (${error instanceof Error ? error.message : String(error)})`;
+        }
+    }
+    if (platform === "darwin") {
+        desktopDetectionPaths.push(join(homeDir, "Applications", "Claude.app"));
+        cursorDetectionPaths.push(join(homeDir, "Applications", "Cursor.app"));
+        codexDetectionPaths.push(join(homeDir, "Applications", "ChatGPT.app"));
+        if (includeSystemPaths) {
+            desktopDetectionPaths.push("/Applications/Claude.app");
+            cursorDetectionPaths.push("/Applications/Cursor.app");
+            codexDetectionPaths.push("/Applications/ChatGPT.app");
+        }
+    }
+    else if (platform === "win32") {
+        const localAppData = env.LOCALAPPDATA || join(homeDir, "AppData", "Local");
+        desktopDetectionPaths.push(join(localAppData, "Programs", "Claude", "Claude.exe"), join(localAppData, "AnthropicClaude", "Claude.exe"));
+        cursorDetectionPaths.push(join(localAppData, "Programs", "cursor", "Cursor.exe"), join(localAppData, "Cursor", "Cursor.exe"));
+        codexDetectionPaths.push(join(localAppData, "Programs", "OpenAI", "Codex", "bin", "codex.exe"), join(localAppData, "Microsoft", "WindowsApps", "ChatGPT.exe"));
+    }
+    const definitions = [
+        {
+            name: "claude-code",
+            label: "Claude Code",
+            format: "json",
+            configPath: join(homeDir, ".claude.json"),
+            detectionPaths: [join(homeDir, ".claude.json"), join(homeDir, ".claude")],
+            executables: ["claude"],
+        },
+    ];
+    if (claudeDesktop) {
+        definitions.push({
+            name: "claude-desktop",
+            label: "Claude Desktop",
+            format: "json",
+            configPath: claudeDesktop,
+            detectionPaths: desktopDetectionPaths,
+            executables: ["claude-desktop"],
+        });
+    }
+    definitions.push({
+        name: "cursor",
+        label: "Cursor",
+        format: "json",
+        configPath: join(homeDir, ".cursor", "mcp.json"),
+        detectionPaths: cursorDetectionPaths,
+        executables: ["cursor"],
+    }, {
+        name: "gemini",
+        label: "Gemini CLI",
+        format: "json",
+        configPath: join(homeDir, ".gemini", "settings.json"),
+        detectionPaths: [join(homeDir, ".gemini")],
+        executables: ["gemini"],
+    }, {
+        name: "codex",
+        label: "Codex",
+        format: "codex-toml",
+        configPath: join(codexHome, "config.toml"),
+        detectionPaths: codexDetectionPaths,
+        executables: ["codex"],
+        configurationError: codexConfigurationError,
+    });
+    return definitions;
+}
+function claudeDesktopPath(homeDir, platform, env) {
+    if (platform === "darwin") {
+        return join(homeDir, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (platform === "win32") {
+        const appData = env.APPDATA || join(homeDir, "AppData", "Roaming");
+        return join(appData, "Claude", "claude_desktop_config.json");
+    }
+    if (platform === "linux") {
+        const configHome = env.XDG_CONFIG_HOME || join(homeDir, ".config");
+        return join(configHome, "Claude", "claude_desktop_config.json");
+    }
+    return undefined;
+}
+function isHostDetected(definition, platform, pathEnv) {
+    return definition.configurationError !== undefined
+        || definition.detectionPaths.some(existsSync)
+        || definition.executables.some((executable) => executableExists(executable, platform, pathEnv));
+}
+function executableExists(name, platform, pathEnv) {
+    if (!pathEnv)
+        return false;
+    const separator = platform === "win32" ? ";" : ":";
+    const extensions = platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+    for (const directory of pathEnv.split(separator).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = join(directory, `${name}${extension}`);
+            try {
+                if (!statSync(candidate).isFile())
+                    continue;
+                if (platform !== "win32")
+                    accessSync(candidate, constants.X_OK);
+                return true;
+            }
+            catch {
+                // Keep searching PATH entries when a candidate is absent or not executable.
+            }
+        }
+    }
+    return false;
+}
+function buildMcpEntry(nodePath, serverPath, env) {
+    const serverEnv = {
+        PRISM_INSTANCE: "prism-mcp",
+        PRISM_SYNALUX_BASE_URL: env.PRISM_SYNALUX_BASE_URL || "https://synalux.ai",
+        PRISM_STORAGE: "auto",
+    };
+    if (env.PRISM_SYNALUX_API_KEY) {
+        serverEnv.PRISM_SYNALUX_API_KEY = env.PRISM_SYNALUX_API_KEY;
+    }
+    return {
+        command: nodePath,
+        args: [serverPath],
+        env: serverEnv,
+    };
+}
+function registerHost(definition, entry, dryRun, refresh, beforeCommit) {
+    if (definition.configurationError) {
+        return result(definition, "error", definition.configurationError);
+    }
+    if (definition.format === "codex-toml") {
+        return registerCodexTomlHost(definition, entry, dryRun, refresh, beforeCommit);
+    }
+    return registerJsonHost(definition, entry, dryRun, refresh, beforeCommit);
+}
+function registerJsonHost(definition, entry, dryRun, refresh, beforeCommit) {
+    const { configPath } = definition;
+    let config = {};
+    let originalText;
+    let writePath = configPath;
+    let symlinkPath;
+    try {
+        const pathInfo = lstatSync(configPath);
+        if (pathInfo.isSymbolicLink()) {
+            try {
+                writePath = realpathSync(configPath);
+                symlinkPath = configPath;
+            }
+            catch (error) {
+                return result(definition, "error", `config symlink target is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        try {
+            originalText = readFileSync(writePath, "utf8");
+            const parsed = JSON.parse(originalText);
+            if (!isJsonObject(parsed)) {
+                throw new Error("top-level JSON value must be an object");
+            }
+            config = parsed;
+        }
+        catch (error) {
+            return result(definition, "error", `could not parse config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT")) {
+            return result(definition, "error", `could not inspect config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const currentServers = config.mcpServers;
+    if (currentServers !== undefined && !isJsonObject(currentServers)) {
+        return result(definition, "error", '"mcpServers" must be a JSON object');
+    }
+    const mcpServers = (currentServers ?? {});
+    const existingKey = Object.prototype.hasOwnProperty.call(mcpServers, "prism-mcp")
+        ? "prism-mcp"
+        : Object.prototype.hasOwnProperty.call(mcpServers, "prism")
+            ? "prism"
+            : undefined;
+    if (existingKey) {
+        const existingEntry = mcpServers[existingKey];
+        if (!refresh || existingKey !== "prism-mcp" || !isManagedPrismEntry(existingEntry)) {
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+        }
+        const refreshedEntry = refreshManagedEntry(existingEntry, entry);
+        if (JSON.stringify(refreshedEntry) === JSON.stringify(existingEntry)) {
+            return result(definition, "existing", "Prism-managed entry is already current");
+        }
+        if (dryRun) {
+            return result(definition, "would-refresh");
+        }
+        mcpServers[existingKey] = refreshedEntry;
+        config.mcpServers = mcpServers;
+        try {
+            writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
+            return result(definition, "refreshed");
+        }
+        catch (error) {
+            return result(definition, "error", error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (dryRun) {
+        return result(definition, "would-register");
+    }
+    mcpServers["prism-mcp"] = entry;
+    config.mcpServers = mcpServers;
+    try {
+        writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
+        return result(definition, "registered");
+    }
+    catch (error) {
+        return result(definition, "error", error instanceof Error ? error.message : String(error));
+    }
+}
+function registerCodexTomlHost(definition, entry, dryRun, refresh, beforeCommit) {
+    const { configPath } = definition;
+    let config = {};
+    let originalText;
+    let writePath = configPath;
+    let symlinkPath;
+    try {
+        const pathInfo = lstatSync(configPath);
+        if (pathInfo.isSymbolicLink()) {
+            try {
+                writePath = realpathSync(configPath);
+                symlinkPath = configPath;
+                if (!statSync(writePath).isFile()) {
+                    throw new Error("config symlink target is not a regular file");
+                }
+            }
+            catch (error) {
+                return result(definition, "error", `config symlink target is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        try {
+            originalText = readFileSync(writePath, "utf8");
+            const parsed = parseToml(originalText);
+            if (!isJsonObject(parsed)) {
+                throw new Error("top-level TOML value must be a table");
+            }
+            config = parsed;
+        }
+        catch (error) {
+            return result(definition, "error", `could not parse config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT")) {
+            return result(definition, "error", `could not inspect config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    let managedBlock;
+    try {
+        managedBlock = locateCodexManagedBlock(originalText ?? "");
+    }
+    catch (error) {
+        return result(definition, "error", error instanceof Error ? error.message : String(error));
+    }
+    const currentServers = config.mcp_servers;
+    if (currentServers !== undefined && !isJsonObject(currentServers)) {
+        return result(definition, "error", '"mcp_servers" must be a TOML table');
+    }
+    const mcpServers = (currentServers ?? {});
+    const hasCanonical = Object.prototype.hasOwnProperty.call(mcpServers, "prism-mcp");
+    const hasLegacy = Object.prototype.hasOwnProperty.call(mcpServers, "prism");
+    if (hasCanonical && hasLegacy) {
+        return result(definition, "error", "Codex config contains both prism and prism-mcp entries; resolve the duplicate before retrying");
+    }
+    if (hasCanonical || hasLegacy) {
+        const existingKey = hasCanonical ? "prism-mcp" : "prism";
+        const existingEntry = mcpServers[existingKey];
+        if (!refresh || existingKey !== "prism-mcp") {
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+        }
+        if (!managedBlock) {
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+        }
+        if (!isManagedPrismEntry(existingEntry)) {
+            return result(definition, "error", "Prism-managed Codex block has an invalid ownership marker");
+        }
+        const refreshedEntry = refreshManagedEntry(existingEntry, entry);
+        if (isDeepStrictEqual(refreshedEntry, existingEntry)) {
+            return result(definition, "existing", "Prism-managed entry is already current");
+        }
+        let nextText;
+        try {
+            nextText = `${originalText.slice(0, managedBlock.start)}${serializeCodexManagedBlock(refreshedEntry, originalText)}${originalText.slice(managedBlock.end)}`;
+            validateCodexCandidate(nextText);
+        }
+        catch (error) {
+            return result(definition, "error", `could not build valid Codex config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (dryRun) {
+            return result(definition, "would-refresh");
+        }
+        try {
+            writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+            return result(definition, "refreshed");
+        }
+        catch (error) {
+            return result(definition, "error", error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (managedBlock) {
+        return result(definition, "error", "Codex config contains a Prism-managed marker without its MCP entry");
+    }
+    let nextText;
+    try {
+        const currentText = originalText ?? "";
+        const newline = currentText.includes("\r\n") ? "\r\n" : "\n";
+        const separator = currentText.length === 0
+            ? ""
+            : currentText.endsWith("\n") || currentText.endsWith("\r")
+                ? newline
+                : `${newline}${newline}`;
+        nextText = `${currentText}${separator}${serializeCodexManagedBlock(entry, currentText)}`;
+        validateCodexCandidate(nextText);
+    }
+    catch (error) {
+        return result(definition, "error", `could not safely extend Codex config without rewriting existing TOML: ${error instanceof Error ? error.message : String(error)}. Convert an inline mcp_servers value to standard TOML tables, then retry`);
+    }
+    if (dryRun) {
+        return result(definition, "would-register");
+    }
+    try {
+        writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+        return result(definition, "registered");
+    }
+    catch (error) {
+        return result(definition, "error", error instanceof Error ? error.message : String(error));
+    }
+}
+function serializeCodexManagedBlock(entry, existingText) {
+    const newline = existingText.includes("\r\n") ? "\r\n" : "\n";
+    const serialized = stringifyToml({ mcp_servers: { "prism-mcp": entry } }).trimEnd();
+    return `${CODEX_MANAGED_START}\n${serialized}\n${CODEX_MANAGED_END}\n`.replaceAll("\n", newline);
+}
+function validateCodexCandidate(text) {
+    const parsed = parseToml(text);
+    if (!isJsonObject(parsed) || !isJsonObject(parsed.mcp_servers)) {
+        throw new Error("generated mcp_servers table is unavailable");
+    }
+    const entry = parsed.mcp_servers["prism-mcp"];
+    if (!isManagedPrismEntry(entry)) {
+        throw new Error("generated prism-mcp entry failed ownership validation");
+    }
+}
+function locateCodexManagedBlock(text) {
+    const starts = findExactLineRanges(text, CODEX_MANAGED_START);
+    const ends = findExactLineRanges(text, CODEX_MANAGED_END);
+    if (starts.length === 0 && ends.length === 0)
+        return undefined;
+    if (starts.length !== 1 || ends.length !== 1 || starts[0].start >= ends[0].start) {
+        throw new Error("Codex config has malformed or duplicate Prism-managed markers; no changes made");
+    }
+    return { start: starts[0].start, end: ends[0].end };
+}
+function findExactLineRanges(text, expected) {
+    const ranges = [];
+    let start = 0;
+    while (start <= text.length) {
+        const newline = text.indexOf("\n", start);
+        const lineEnd = newline === -1 ? text.length : newline;
+        const contentEnd = lineEnd > start && text[lineEnd - 1] === "\r" ? lineEnd - 1 : lineEnd;
+        if (text.slice(start, contentEnd) === expected) {
+            ranges.push({ start, end: newline === -1 ? text.length : newline + 1 });
+        }
+        if (newline === -1)
+            break;
+        start = newline + 1;
+    }
+    return ranges;
+}
+function writeTextAtomically(filePath, contents, expectedText, beforeCommit, symlinkPath) {
+    const directory = dirname(filePath);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const mode = existsSync(filePath) ? statSync(filePath).mode & 0o777 : 0o600;
+    const tempPath = join(directory, `.${basename(filePath)}.prism-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`);
+    try {
+        writeFileSync(tempPath, contents, {
+            encoding: "utf8",
+            flag: "wx",
+            mode,
+        });
+        beforeCommit?.(filePath);
+        if (symlinkPath) {
+            let currentTarget;
+            try {
+                currentTarget = realpathSync(symlinkPath);
+                if (currentTarget !== filePath || !statSync(currentTarget).isFile()) {
+                    throw new Error("target changed");
+                }
+            }
+            catch (error) {
+                throw new Error(`Config symlink changed while Prism was preparing the update; retry: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (expectedText === undefined) {
+            if (existsSync(filePath)) {
+                throw new Error(`Config changed while Prism was preparing the update; retry: ${filePath}`);
+            }
+        }
+        else {
+            let currentText;
+            try {
+                currentText = readFileSync(filePath, "utf8");
+            }
+            catch (error) {
+                throw new Error(`Config changed while Prism was preparing the update; retry: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (currentText !== expectedText) {
+                throw new Error(`Config changed while Prism was preparing the update; retry: ${filePath}`);
+            }
+        }
+        // This compare-before-rename catches observable host edits and the rename
+        // itself is atomic. No portable filesystem API can make the comparison and
+        // replacement one operation against an uncooperative host, which is why the
+        // CLI also tells users to close target hosts before writing.
+        renameSync(tempPath, filePath);
+    }
+    finally {
+        if (existsSync(tempPath))
+            unlinkSync(tempPath);
+    }
+}
+function result(definition, status, message) {
+    return {
+        host: definition.name,
+        label: definition.label,
+        path: definition.configPath,
+        status,
+        message,
+    };
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isManagedPrismEntry(value) {
+    return isJsonObject(value)
+        && isJsonObject(value.env)
+        && value.env.PRISM_INSTANCE === "prism-mcp";
+}
+function refreshManagedEntry(existing, desired) {
+    const existingEnv = isJsonObject(existing.env) ? existing.env : {};
+    const desiredEnv = isJsonObject(desired.env) ? desired.env : {};
+    const mergedEnv = {
+        ...existingEnv,
+        ...desiredEnv,
+    };
+    if (!Object.prototype.hasOwnProperty.call(desiredEnv, "PRISM_SYNALUX_API_KEY")) {
+        delete mergedEnv.PRISM_SYNALUX_API_KEY;
+    }
+    return {
+        ...existing,
+        command: desired.command,
+        args: desired.args,
+        env: mergedEnv,
+    };
+}
+function isErrno(error, code) {
+    return error instanceof Error && error.code === code;
+}

package/dist/onboarding/wizard.js

@@ -94,41 +94,18 @@ session_save_ledger({
     };
 }
 function getIDEConfigContent(client = "claude_desktop") {
-    const configs = {
-        claude_desktop: `{
-  "mcpServers": {
-    "prism-mcp": {
-      "command": "npx",
-      "args": ["-y", "prism-mcp@latest"],
-      "env": {
-        "BRAVE_API_KEY": "your-brave-key"
-      }
-    }
-  }
-}`,
-        cursor: `{
-  "mcpServers": {
-    "prism-mcp": {
-      "command": "npx",
-      "args": ["-y", "prism-mcp@latest"],
-      "env": {
-        "BRAVE_API_KEY": "your-brave-key"
-      }
-    }
-  }
-}`,
-    };
+    const host = client === "cursor" ? "cursor" : "claude-desktop";
     return {
         step: "ide_config",
         title: "⚙️ Configure Your IDE",
-        description: "Add Prism as an MCP server in your AI coding tool's configuration.",
+        description: "Register Prism as an MCP server in your AI coding tool.",
         instructions: [
-            "Copy the config below into your IDE's MCP configuration file",
-            "For Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json",
-            "For Cursor: .cursor/mcp.json in your workspace",
+            "Run the command below in a terminal",
+            "Prism adds only a missing registration and never overwrites custom entries",
+            "Use --dry-run first if you want to preview the target file",
             "Restart your IDE to pick up the new MCP server",
         ],
-        codeSnippet: configs[client] || configs.claude_desktop,
+        codeSnippet: `prism connect --host ${host}`,
         nextStep: "first_save",
         progress: 43,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.1.0",
+  "version": "20.2.0",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local-first storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",
@@ -65,6 +65,7 @@
     "rag",
     "embeddings",
     "cursor",
+    "codex",
     "windsurf",
     "cline",
     "persistent-memory",
@@ -144,6 +145,7 @@
     "p-limit": "^7.3.0",
     "postcss": "8.5.12",
     "quickjs-emscripten": "^0.32.0",
+    "smol-toml": "^1.7.0",
     "stream-json": "^2.0.0",
     "turndown": "^7.2.2",
     "zod": "^4.3.6"

package/dist/utils/groundingVerifier.js

@@ -1,203 +0,0 @@
-/**
- * groundingVerifier — runtime accountability for prism_infer
- * ============================================================
- *
- * When a caller passes `evidence` + `verify: true` to prism_infer, this
- * module checks that every factual claim in the model's draft is
- * entailed by one of the evidence snippets. Sibling of synalux-portal's
- * chat-verifier — same architecture, lighter footprint (no DB audit,
- * stateless MCP), pointed at free-form generation instead of tool-call
- * responses.
- *
- * Cascade role: qwen3.5:4b is the default verifier (fast, 2.5GB).
- * 14b drafts; 4b verifies. Different model = Patronus rule satisfied.
- * Falls back to 2b on devices with <4GB free RAM.
- *
- * Failure modes:
- *   - Verifier model unreachable / timeout → fail-closed refusal
- *   - Verifier returns malformed JSON → fail-closed refusal
- *   - NEUTRAL or CONTRADICTED claim → fail-closed refusal that names
- *     the failed claim
- *
- * The refusal text always names which claim couldn't be grounded so
- * the calling agent can decide whether to retry with more evidence or
- * fall back to cloud.
- */
-import { PRISM_LOCAL_LLM_URL } from "../config.js";
-// ─── Pre-checks ─────────────────────────────────────────────────────────
-const ASSERTIVE_RX = /\b(?:\d{1,5}|[A-Z]\d{2}\.\d|ICD-?10|CPT|\$\d|\d{4}-\d{2}-\d{2}|[A-Z][a-z]{2,}\s+[A-Z][a-z]{2,})\b/;
-/**
- * Returns true when the draft makes at least one assertion that could be
- * fabricated — numbers, dates, ICD/CPT codes, two-word names, dollar
- * amounts. Conversational replies skip the verifier entirely.
- */
-export function draftHasAssertiveClaims(draft) {
-    if (!draft)
-        return false;
-    return ASSERTIVE_RX.test(draft);
-}
-// ─── Verifier prompt (grammar-constrained JSON) ─────────────────────────
-const VERIFIER_SYSTEM_PROMPT = `You are a strict factual-grounding verifier. Your job is to REJECT ungrounded claims.
-Given EVIDENCE (one or more text snippets) and DRAFT_ANSWER, find every
-factual claim (counts, names, dates, codes, dollar amounts) and assign:
-
-  ENTAILED     — the EXACT value appears verbatim in EVIDENCE text, or is an
-                 arithmetic identity (e.g. "3" and "three"). STRICT: if you
-                 must infer, estimate, or extrapolate, it is NOT ENTAILED.
-  CONTRADICTED — the claim states a DIFFERENT value than what EVIDENCE says
-                 for the same fact.
-  NEUTRAL      — the claim is not addressed in EVIDENCE at all.
-
-CRITICAL DEFAULT RULE: when in doubt, use NEUTRAL — never guess ENTAILED.
-Prefer false negatives over false positives. If the evidence does not
-explicitly state the value, it is NEUTRAL.
-
-Do NOT report opinions, refusals, or hedges as claims. Conversational
-phrasing ("Hello", "I can help") is not a claim.
-
-Output JSON only — no prose, no apology.`;
-const VERIFIER_JSON_SCHEMA = {
-    type: "object",
-    properties: {
-        claims: {
-            type: "array",
-            items: {
-                type: "object",
-                properties: {
-                    text: { type: "string" },
-                    verdict: { type: "string", enum: ["ENTAILED", "NEUTRAL", "CONTRADICTED"] },
-                    evidence_span: { type: ["string", "null"] },
-                },
-                required: ["text", "verdict", "evidence_span"],
-                additionalProperties: false,
-            },
-        },
-    },
-    required: ["claims"],
-    additionalProperties: false,
-};
-// ─── Refusal text ───────────────────────────────────────────────────────
-function refusalText(action, failedClaim) {
-    switch (action) {
-        case "refused_fabricated":
-            return `I can't ground "${failedClaim}" in the evidence provided. ` +
-                "If this claim is correct, supply the supporting source as evidence and retry.";
-        case "refused_no_evidence":
-            return `I can't ground "${failedClaim}" — no evidence was provided this turn. ` +
-                "Provide evidence snippets via the `evidence` argument and retry.";
-        case "refused_timeout":
-            return `I couldn't verify "${failedClaim}" within the allowed time. ` +
-                "The verifier model may be cold-loading; try again in a moment.";
-        case "served":
-            return ""; // unreachable
-    }
-}
-export async function verifyGrounding(opts) {
-    const verifierModel = opts.verifierModel ?? "qwen3.5:4b";
-    const timeoutMs = opts.timeoutMs ?? 2000;
-    const ollamaUrl = opts.ollamaUrl ?? PRISM_LOCAL_LLM_URL;
-    const fetchImpl = opts.fetchImpl ?? fetch;
-    const verifierChain = [];
-    // Tier 0 — conversational drafts skip the verifier entirely.
-    if (!draftHasAssertiveClaims(opts.draft)) {
-        return {
-            action: "served",
-            finalText: opts.draft,
-            claims: [],
-            verifierChain,
-        };
-    }
-    // Tier 0a — assertive draft with NO evidence is fail-closed:
-    // the model is making claims it cannot back up.
-    if (opts.evidence.length === 0) {
-        const claim = firstAssertiveSpan(opts.draft);
-        return {
-            action: "refused_no_evidence",
-            finalText: refusalText("refused_no_evidence", claim),
-            claims: [{ claim, verdict: "NEUTRAL", evidence_span: null }],
-            verifierChain,
-            refusalClaim: claim,
-        };
-    }
-    // Tier 2 — NLI verifier call.
-    const t0 = Date.now();
-    const evidenceText = opts.evidence
-        .map((e, i) => `[${i}] ${e.source}\n${e.content}`)
-        .join("\n\n");
-    const payload = {
-        model: verifierModel,
-        messages: [
-            { role: "system", content: VERIFIER_SYSTEM_PROMPT },
-            { role: "user", content: `EVIDENCE:\n${evidenceText}\n\nDRAFT_ANSWER:\n${opts.draft}` },
-        ],
-        stream: false,
-        response_format: {
-            type: "json_schema",
-            json_schema: { name: "verifier", schema: VERIFIER_JSON_SCHEMA, strict: true },
-        },
-        temperature: 0,
-    };
-    let parsedClaims = null;
-    try {
-        const res = await fetchImpl(`${ollamaUrl}/v1/chat/completions`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(payload),
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status}`);
-        const data = (await res.json());
-        const content = data?.choices?.[0]?.message?.content;
-        if (typeof content !== "string")
-            throw new Error("no content");
-        const parsed = JSON.parse(content);
-        if (!parsed || !Array.isArray(parsed.claims))
-            throw new Error("malformed");
-        parsedClaims = parsed.claims.map((c) => ({
-            claim: String(c.text ?? ""),
-            verdict: ["ENTAILED", "NEUTRAL", "CONTRADICTED"].includes(c.verdict)
-                ? c.verdict
-                : "NEUTRAL",
-            evidence_span: typeof c.evidence_span === "string" ? c.evidence_span : null,
-        }));
-    }
-    catch {
-        const latencyMs = Date.now() - t0;
-        verifierChain.push({ model: verifierModel, verdict: "NEUTRAL", latencyMs });
-        const claim = firstAssertiveSpan(opts.draft);
-        return {
-            action: "refused_timeout",
-            finalText: refusalText("refused_timeout", claim),
-            claims: [{ claim, verdict: "NEUTRAL", evidence_span: null }],
-            verifierChain,
-            refusalClaim: claim,
-        };
-    }
-    const latencyMs = Date.now() - t0;
-    const failing = parsedClaims.find(c => c.verdict !== "ENTAILED");
-    const rollup = failing ? failing.verdict : "ENTAILED";
-    verifierChain.push({ model: verifierModel, verdict: rollup, latencyMs });
-    if (failing) {
-        return {
-            action: "refused_fabricated",
-            finalText: refusalText("refused_fabricated", failing.claim),
-            claims: parsedClaims,
-            verifierChain,
-            refusalClaim: failing.claim,
-        };
-    }
-    return {
-        action: "served",
-        finalText: opts.draft,
-        claims: parsedClaims,
-        verifierChain,
-    };
-}
-// ─── helpers ────────────────────────────────────────────────────────────
-function firstAssertiveSpan(draft) {
-    const m = draft.match(ASSERTIVE_RX);
-    if (m)
-        return m[0];
-    return draft.slice(0, 80);
-}