prism-mcp-server 20.2.0 → 20.2.2

package/dist/connect.js

@@ -1,9 +1,10 @@
 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 { basename, dirname, isAbsolute, join, relative, resolve, sep, win32 as win32Path } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { LOCAL_FIRST_POLICY_ID, LOCAL_FIRST_POLICY_LINES } from "./localFirstPolicy.js";
 export const CONNECT_HOSTS = [
     "claude-code",
     "claude-desktop",
@@ -25,6 +26,49 @@ const HOST_ALIASES = {
 };
 const CODEX_MANAGED_START = "# >>> prism connect managed: prism-mcp";
 const CODEX_MANAGED_END = "# <<< prism connect managed: prism-mcp";
+const CLAUDE_STARTUP_MANAGED_START = "<!-- >>> prism connect managed: native startup -->";
+const CLAUDE_STARTUP_MANAGED_END = "<!-- <<< prism connect managed: native startup -->";
+const GEMINI_STARTUP_MANAGED_START = "<!-- >>> prism connect managed: native startup -->";
+const GEMINI_STARTUP_MANAGED_END = "<!-- <<< prism connect managed: native startup -->";
+const CODEX_STARTUP_MANAGED_START = "<!-- >>> prism connect managed: codex native startup -->";
+const CODEX_STARTUP_MANAGED_END = "<!-- <<< prism connect managed: codex native startup -->";
+const CODEX_STARTUP_BODY = [
+    "## Prism session startup",
+    "On the first user turn of every conversation, including a greeting, your first action must be",
+    "`session_bootstrap({})`, exactly once. Emit no preamble. Print the complete tool result verbatim as the",
+    "entire first-turn startup display, before any optional answer. Do not summarize, paraphrase, rename headings,",
+    "reformat, or omit any returned section. Preserve its order and line content. For a greeting-only prompt, stop",
+    "after the verbatim startup display. If `session_bootstrap` is deferred, use native tool discovery to load that",
+    "exact tool, then invoke it. Do not use shell commands, file reads, subagents, or unrelated tool inspection as",
+    "a substitute. Do not call `session_load_context`. If discovery or invocation fails, report",
+    "`Prism startup failure` and stop. Reuse the `conversation_id` returned in structuredContent for every",
+    "session_save_ledger, session_save_handoff, and session_detect_drift call in this conversation. This hook-free",
+    "block is managed by `prism connect`; do not edit it manually.",
+    "",
+    ...LOCAL_FIRST_POLICY_LINES,
+];
+const CONNECT_STORAGE_BACKENDS = ["auto", "local", "synalux", "supabase"];
+const LEGACY_CLAUDE_PROJECT_PRISM_ENTRY = {
+    command: "npx",
+    args: ["-y", "prism-mcp-server"],
+};
+const INSTALLATION_RECEIPT_SCHEMA_VERSION = 1;
+const INSTALLATION_RECEIPT_OWNER = "prism-connect";
+const CLAUDE_FALLBACK_SUBAGENT_MODEL = "sonnet";
+const CODEX_LOCAL_FIRST_POLICY = {
+    features: {
+        multi_agent: false,
+    },
+    agents: {
+        max_threads: 2,
+        max_depth: 1,
+        default_subagent_model: "gpt-5.6-terra",
+        default_subagent_reasoning_effort: "low",
+        job_max_runtime_seconds: 900,
+    },
+};
+const CODEX_POLICY_MARKER_PREFIX = "# >>> prism connect managed: local-first";
+const CODEX_POLICY_MARKER_SUFFIX = "# <<< prism connect managed: local-first";
 export function normalizeHostName(value) {
     const normalized = value.trim().toLowerCase();
     const host = HOST_ALIASES[normalized];
@@ -51,6 +95,19 @@ export function resolveInstalledServerPath(moduleUrl = import.meta.url) {
     }
     return realpathSync(serverPath);
 }
+function resolveInstalledPackageVersion(moduleUrl = import.meta.url) {
+    const manifestPath = fileURLToPath(new URL("../package.json", moduleUrl));
+    try {
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+        if (isJsonObject(manifest) && typeof manifest.version === "string" && manifest.version.trim()) {
+            return manifest.version;
+        }
+    }
+    catch (error) {
+        throw new Error(`Cannot read Prism package version at ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    throw new Error(`Prism package manifest has no valid "version" entry: ${manifestPath}`);
+}
 export function connectHosts(options = {}) {
     if (options.all && options.hosts?.length) {
         throw new Error("Use either --all or --host, not both.");
@@ -79,12 +136,775 @@ export function connectHosts(options = {}) {
     }
     const entry = buildMcpEntry(nodePath, serverPath, env);
     const results = selected.map((definition) => registerHost(definition, entry, !!options.dryRun, !!options.refresh, options.beforeCommit));
+    let installationReceiptPath;
+    if (!options.dryRun && results.some((item) => item.status !== "error" && item.startupCompatible)) {
+        const pathApi = platform === "win32" ? win32Path : { dirname, join, isAbsolute, resolve };
+        const absoluteNodePath = pathApi.isAbsolute(nodePath) ? nodePath : pathApi.resolve(nodePath);
+        const absoluteServerPath = pathApi.isAbsolute(serverPath) ? serverPath : pathApi.resolve(serverPath);
+        const rawCliPath = options.cliPath ?? pathApi.join(pathApi.dirname(absoluteServerPath), "cli.js");
+        const absoluteCliPath = pathApi.isAbsolute(rawCliPath) ? rawCliPath : pathApi.resolve(rawCliPath);
+        installationReceiptPath = writeInstallationReceipt(homeDir, {
+            schema_version: INSTALLATION_RECEIPT_SCHEMA_VERSION,
+            owner: INSTALLATION_RECEIPT_OWNER,
+            node_path: absoluteNodePath,
+            cli_path: absoluteCliPath,
+            server_path: absoluteServerPath,
+            package_version: options.packageVersion ?? resolveInstalledPackageVersion(),
+        }, options.beforeReceiptCommit);
+    }
     return {
         results,
         usedApiKey: typeof env.PRISM_SYNALUX_API_KEY === "string" && env.PRISM_SYNALUX_API_KEY.length > 0,
         serverPath,
+        installationReceiptPath,
     };
 }
+/** Write the Prism-owned GUI discovery receipt without following symlinks. */
+export function writeInstallationReceipt(homeDir, receipt, beforeCommit) {
+    if (!isAbsolute(resolve(homeDir)))
+        throw new Error("Prism installation receipt home must resolve absolutely");
+    for (const [key, value] of Object.entries(receipt)) {
+        if (key.endsWith("_path") && (typeof value !== "string" || (!isAbsolute(value) && !win32Path.isAbsolute(value)))) {
+            throw new Error(`Prism installation receipt ${key} must be absolute`);
+        }
+    }
+    const directory = join(resolve(homeDir), ".prism-mcp");
+    const receiptPath = join(directory, "installation.json");
+    try {
+        const directoryInfo = lstatSync(directory);
+        if (directoryInfo.isSymbolicLink() || !directoryInfo.isDirectory()) {
+            throw new Error("receipt directory must be a real directory");
+        }
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT")) {
+            throw new Error(`Could not secure Prism installation receipt directory: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        const directoryInfo = lstatSync(directory);
+        if (directoryInfo.isSymbolicLink() || !directoryInfo.isDirectory()) {
+            throw new Error("Could not secure Prism installation receipt directory");
+        }
+    }
+    let originalText;
+    try {
+        const receiptInfo = lstatSync(receiptPath);
+        if (receiptInfo.isSymbolicLink() || !receiptInfo.isFile()) {
+            throw new Error("receipt must be a regular Prism-owned file");
+        }
+        originalText = readFileSync(receiptPath, "utf8");
+        const current = JSON.parse(originalText);
+        if (!isJsonObject(current)
+            || current.schema_version !== INSTALLATION_RECEIPT_SCHEMA_VERSION
+            || current.owner !== INSTALLATION_RECEIPT_OWNER) {
+            throw new Error("existing receipt is not owned by prism-connect");
+        }
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT")) {
+            throw new Error(`Could not inspect Prism installation receipt: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    writeTextAtomically(receiptPath, `${JSON.stringify(receipt, null, 2)}\n`, originalText, beforeCommit);
+    return receiptPath;
+}
+/**
+ * Remove the exact project-scoped registration written by Prism's former
+ * `npx -y prism-mcp-server` setup. Claude Code resolves the nearest ancestor
+ * `.mcp.json`, so a stale entry there can shadow the native user registration.
+ * Custom Prism commands, arguments, environment, and unrelated servers remain
+ * untouched.
+ */
+export function migrateLegacyClaudeProjectMcp(homeDir = homedir(), cwd = process.cwd(), dryRun = false, beforeCommit) {
+    let resolvedHome;
+    let resolvedCwd;
+    try {
+        resolvedHome = realpathSync(resolve(homeDir));
+        resolvedCwd = realpathSync(resolve(cwd));
+    }
+    catch (error) {
+        throw new Error(`Could not resolve Claude project MCP search path: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const fallbackPath = join(resolvedHome, ".mcp.json");
+    if (!isPathWithin(resolvedCwd, resolvedHome)) {
+        return { path: fallbackPath, status: "unchanged", removed: 0 };
+    }
+    let configPath;
+    for (let directory = resolvedCwd;; directory = dirname(directory)) {
+        const candidate = join(directory, ".mcp.json");
+        try {
+            lstatSync(candidate);
+            configPath = candidate;
+            break;
+        }
+        catch (error) {
+            if (!isErrno(error, "ENOENT")) {
+                throw new Error(`Could not inspect Claude project MCP config: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (directory === resolvedHome)
+            break;
+    }
+    if (!configPath)
+        return { path: fallbackPath, status: "unchanged", removed: 0 };
+    let writePath = configPath;
+    let symlinkPath;
+    let originalText;
+    try {
+        const pathInfo = lstatSync(configPath);
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(configPath);
+            symlinkPath = configPath;
+        }
+        if (!statSync(writePath).isFile())
+            throw new Error("config is not a regular file");
+        originalText = readFileSync(writePath, "utf8");
+    }
+    catch (error) {
+        throw new Error(`Could not inspect Claude project MCP config: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let config;
+    try {
+        const parsed = JSON.parse(originalText);
+        if (!isJsonObject(parsed))
+            throw new Error("top-level JSON value must be an object");
+        config = parsed;
+    }
+    catch (error) {
+        throw new Error(`Could not parse Claude project MCP config: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const currentServers = config.mcpServers;
+    if (currentServers === undefined) {
+        return { path: configPath, status: "unchanged", removed: 0 };
+    }
+    if (!isJsonObject(currentServers)) {
+        throw new Error('Could not inspect Claude project MCP config: "mcpServers" must be a JSON object');
+    }
+    if (!Object.prototype.hasOwnProperty.call(currentServers, "prism-mcp")
+        || !isDeepStrictEqual(currentServers["prism-mcp"], LEGACY_CLAUDE_PROJECT_PRISM_ENTRY)) {
+        return { path: configPath, status: "unchanged", removed: 0 };
+    }
+    delete currentServers["prism-mcp"];
+    if (dryRun)
+        return { path: configPath, status: "would-remove", removed: 1 };
+    writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
+    return { path: configPath, status: "removed", removed: 1 };
+}
+function legacyClaudeHookTuples(homeDir) {
+    const hooksDir = join(homeDir, ".claude", "hooks");
+    const syncSkills = `${join(homeDir, "prism", "scripts", "sync-skills.sh")} > /dev/null 2>&1`;
+    const loadMatcher = "session_load_context|mcp__prism-mcp__session_load_context";
+    const driftMatcher = "session_detect_drift|mcp__prism-mcp__session_detect_drift|session_save_ledger|mcp__prism-mcp__session_save_ledger";
+    const stop = "python3 -c \"import json; print(json.dumps({'continue': True, 'suppressOutput': True, 'systemMessage': 'MANDATORY END WORKFLOW: 1) Call mcp__prism-mcp__session_save_ledger with project and summary. 2) Call mcp__prism-mcp__session_save_handoff with expected_version set to the loaded version.'}))\"";
+    const tuple = (event, matcher, command) => JSON.stringify([event, matcher, "command", command]);
+    return new Set([
+        tuple("SessionStart", "*", `python3 ${join(hooksDir, "prism-startup", "init.py")}`),
+        tuple("SessionStart", "*", syncSkills),
+        tuple("UserPromptSubmit", "*", `python3 ${join(hooksDir, "prism-startup", "guard_on_submit.py")}`),
+        tuple("UserPromptSubmit", "*", join(hooksDir, "prism-startup", "maybe_sync_skills.sh")),
+        tuple("PostToolUse", loadMatcher, `python3 ${join(hooksDir, "prism-startup", "mark_loaded.py")}`),
+        tuple("PostToolUse", driftMatcher, `python3 ${join(hooksDir, "drift-detection", "reset_timer.py")}`),
+        tuple("PostToolUseFailure", loadMatcher, `python3 ${join(hooksDir, "prism-startup", "record_retry.py")}`),
+        tuple("SessionEnd", "*", `python3 ${join(hooksDir, "prism-startup", "cleanup.py")}`),
+        tuple("SessionEnd", "*", syncSkills),
+        tuple("Stop", "*", stop),
+    ]);
+}
+/**
+ * Remove only the exact Claude lifecycle hooks installed by Prism's legacy
+ * bootstrap script. Native skills and server-side drift reminders now own the
+ * same behavior; unrelated and near-match user hooks must remain untouched.
+ */
+export function migrateLegacyClaudeHooks(homeDir = homedir(), dryRun = false, beforeCommit) {
+    const configPath = join(homeDir, ".claude", "settings.json");
+    let writePath = configPath;
+    let symlinkPath;
+    let originalText;
+    try {
+        const pathInfo = lstatSync(configPath);
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(configPath);
+            symlinkPath = configPath;
+            if (!statSync(writePath).isFile())
+                throw new Error("target is not a regular file");
+        }
+        originalText = readFileSync(writePath, "utf8");
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT"))
+            return { path: configPath, status: "unchanged", removed: 0 };
+        throw new Error(`Could not inspect Claude hook settings: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let config;
+    try {
+        const parsed = JSON.parse(originalText);
+        if (!isJsonObject(parsed))
+            throw new Error("top-level JSON value must be an object");
+        config = parsed;
+    }
+    catch (error) {
+        throw new Error(`Could not parse Claude hook settings: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isJsonObject(config.hooks))
+        return { path: configPath, status: "unchanged", removed: 0 };
+    const legacyTuples = legacyClaudeHookTuples(homeDir);
+    const nextEvents = {};
+    let removed = 0;
+    for (const [event, groups] of Object.entries(config.hooks)) {
+        if (!Array.isArray(groups)) {
+            nextEvents[event] = groups;
+            continue;
+        }
+        const nextGroups = [];
+        for (const group of groups) {
+            if (!isJsonObject(group) || !Array.isArray(group.hooks)) {
+                nextGroups.push(group);
+                continue;
+            }
+            let removedFromGroup = 0;
+            const nextHooks = group.hooks.filter((hook) => {
+                const owned = isJsonObject(hook)
+                    && hook.type === "command"
+                    && typeof hook.command === "string"
+                    && legacyTuples.has(JSON.stringify([event, group.matcher, hook.type, hook.command]));
+                if (owned)
+                    removedFromGroup += 1;
+                return !owned;
+            });
+            removed += removedFromGroup;
+            if (removedFromGroup === 0)
+                nextGroups.push(group);
+            else if (nextHooks.length > 0)
+                nextGroups.push({ ...group, hooks: nextHooks });
+        }
+        if (nextGroups.length > 0)
+            nextEvents[event] = nextGroups;
+    }
+    if (removed === 0)
+        return { path: configPath, status: "unchanged", removed: 0 };
+    if (Object.keys(nextEvents).length > 0)
+        config.hooks = nextEvents;
+    else
+        delete config.hooks;
+    if (dryRun)
+        return { path: configPath, status: "would-remove", removed };
+    writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
+    return { path: configPath, status: "removed", removed };
+}
+/**
+ * Remove the legacy Prism-only startup sections from ~/CLAUDE.md. The rest of
+ * the developer's global instructions remain byte-for-byte unchanged. Native
+ * skill and MCP metadata now own first-turn bootstrap selection.
+ */
+export function migrateLegacyClaudeInstructions(homeDir = homedir(), dryRun = false, beforeCommit) {
+    const instructionPath = join(homeDir, "CLAUDE.md");
+    let writePath = instructionPath;
+    let symlinkPath;
+    let originalText;
+    let instructionEntryExists = false;
+    try {
+        const pathInfo = lstatSync(instructionPath);
+        instructionEntryExists = true;
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(instructionPath);
+            symlinkPath = instructionPath;
+            if (!statSync(writePath).isFile())
+                throw new Error("target is not a regular file");
+        }
+        originalText = readFileSync(writePath, "utf8");
+    }
+    catch (error) {
+        if (!instructionEntryExists && isErrno(error, "ENOENT")) {
+            return { path: instructionPath, status: "unchanged", removed: 0 };
+        }
+        throw new Error(`Could not inspect Claude instructions: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const stepOne = findExactLineRanges(originalText, "## STEP 1: Auto-Load Prism Memory (MUST BE YOUR FIRST ACTION — NO EXCEPTIONS)");
+    const hardGates = findExactLineRanges(originalText, "## HARD BEHAVIORAL GATES — SUPERSEDE ALL OTHER INSTRUCTIONS");
+    if (stepOne.length !== 1 || hardGates.length !== 1 || hardGates[0].start <= stepOne[0].start) {
+        return { path: instructionPath, status: "unchanged", removed: 0 };
+    }
+    const legacyBlock = originalText.slice(stepOne[0].start, hardGates[0].start);
+    const signatures = [
+        'mcp__prism-mcp__session_load_context(project="prism-mcp")',
+        "## STEP 2: Display Startup Block (ONLY AFTER STEP 1 COMPLETES)",
+        "Use the `[📜 SKILL: ...]` blocks returned by session_load_context to build the display:",
+    ];
+    if (!signatures.every((signature) => legacyBlock.includes(signature))) {
+        return { path: instructionPath, status: "unchanged", removed: 0 };
+    }
+    const nextText = originalText.slice(0, stepOne[0].start) + originalText.slice(hardGates[0].start);
+    if (dryRun)
+        return { path: instructionPath, status: "would-remove", removed: 2 };
+    writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+    return { path: instructionPath, status: "removed", removed: 2 };
+}
+/** Remove only Prism's marked startup block from the former ~/CLAUDE.md path. */
+export function migrateLegacyClaudeManagedStartup(homeDir = homedir(), dryRun = false, beforeCommit) {
+    const instructionPath = join(homeDir, "CLAUDE.md");
+    let writePath = instructionPath;
+    let symlinkPath;
+    let originalText;
+    let instructionEntryExists = false;
+    try {
+        const pathInfo = lstatSync(instructionPath);
+        instructionEntryExists = true;
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(instructionPath);
+            symlinkPath = instructionPath;
+            if (!statSync(writePath).isFile())
+                throw new Error("target is not a regular file");
+        }
+        originalText = readFileSync(writePath, "utf8");
+    }
+    catch (error) {
+        if (!instructionEntryExists && isErrno(error, "ENOENT")) {
+            return { path: instructionPath, status: "unchanged", removed: 0 };
+        }
+        throw new Error(`Could not inspect legacy Claude instructions: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const startRanges = findExactLineRanges(originalText, CLAUDE_STARTUP_MANAGED_START);
+    const endRanges = findExactLineRanges(originalText, CLAUDE_STARTUP_MANAGED_END);
+    if (startRanges.length !== endRanges.length || startRanges.length > 1) {
+        throw new Error(`Legacy Claude instructions contain ambiguous Prism startup ownership markers: ${instructionPath}`);
+    }
+    if (startRanges.length === 0)
+        return { path: instructionPath, status: "unchanged", removed: 0 };
+    if (endRanges[0].start <= startRanges[0].start) {
+        throw new Error(`Legacy Claude instructions contain out-of-order Prism startup ownership markers: ${instructionPath}`);
+    }
+    const nextText = originalText.slice(0, startRanges[0].start) + originalText.slice(endRanges[0].end);
+    if (dryRun)
+        return { path: instructionPath, status: "would-remove", removed: 1 };
+    writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+    return { path: instructionPath, status: "removed", removed: 1 };
+}
+function serializeClaudeStartupBlock(newline) {
+    return [
+        CLAUDE_STARTUP_MANAGED_START,
+        "## Prism session startup",
+        "On the first user turn of every conversation, including a greeting, your first action must be to call",
+        "`mcp__prism-mcp__session_bootstrap` exactly once with an empty object (`{}`). Emit no preamble. Print the",
+        "complete tool result verbatim as the entire first-turn startup display, before any optional answer. Do not",
+        "summarize, paraphrase, rename headings, reformat, or omit any returned section. Preserve its order and line",
+        "content. For a greeting-only prompt, stop after the verbatim startup display. If `session_bootstrap` is",
+        "deferred, use native tool discovery/ToolSearch to load that",
+        "exact tool, then invoke it. Do not use shell commands, file reads, subagents, or unrelated tool inspection",
+        "as a substitute. Do not call `session_load_context`. If discovery or invocation fails, report",
+        "`Prism startup failure` and stop. Reuse the `conversation_id` returned in structuredContent for every",
+        "session_save_ledger, session_save_handoff, and session_detect_drift call in this conversation. This block is",
+        "managed by `prism connect`; do not edit it manually.",
+        "",
+        ...LOCAL_FIRST_POLICY_LINES,
+        CLAUDE_STARTUP_MANAGED_END,
+        "",
+    ].join(newline);
+}
+/** Install or refresh Claude Code's native, hook-free first-turn instruction. */
+export function configureClaudeNativeStartup(homeDir = homedir(), dryRun = false, beforeCommit) {
+    const instructionPath = join(homeDir, ".claude", "CLAUDE.md");
+    let writePath = instructionPath;
+    let symlinkPath;
+    let originalText;
+    let instructionEntryExists = false;
+    try {
+        const pathInfo = lstatSync(instructionPath);
+        instructionEntryExists = true;
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(instructionPath);
+            symlinkPath = instructionPath;
+            if (!statSync(writePath).isFile())
+                throw new Error("target is not a regular file");
+        }
+        originalText = readFileSync(writePath, "utf8");
+    }
+    catch (error) {
+        if (instructionEntryExists || !isErrno(error, "ENOENT")) {
+            throw new Error(`Could not inspect Claude instructions: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const currentText = originalText ?? "";
+    const newline = currentText.includes("\r\n") ? "\r\n" : "\n";
+    const startRanges = findExactLineRanges(currentText, CLAUDE_STARTUP_MANAGED_START);
+    const endRanges = findExactLineRanges(currentText, CLAUDE_STARTUP_MANAGED_END);
+    if (startRanges.length !== endRanges.length || startRanges.length > 1) {
+        throw new Error(`Claude instructions contain ambiguous Prism startup ownership markers: ${instructionPath}`);
+    }
+    const managedBlock = serializeClaudeStartupBlock(newline);
+    let nextText;
+    let action;
+    if (startRanges.length === 1) {
+        if (endRanges[0].start <= startRanges[0].start) {
+            throw new Error(`Claude instructions contain out-of-order Prism startup ownership markers: ${instructionPath}`);
+        }
+        const managedEnd = endRanges[0].end;
+        if (currentText.slice(startRanges[0].start, managedEnd) === managedBlock) {
+            return { path: instructionPath, status: "unchanged" };
+        }
+        nextText = currentText.slice(0, startRanges[0].start) + managedBlock + currentText.slice(managedEnd);
+        action = "refresh";
+    }
+    else {
+        const separator = currentText.length === 0
+            ? ""
+            : currentText.endsWith("\n") || currentText.endsWith("\r")
+                ? newline
+                : `${newline}${newline}`;
+        nextText = currentText + separator + managedBlock;
+        action = "install";
+    }
+    if (dryRun) {
+        return { path: instructionPath, status: action === "install" ? "would-install" : "would-refresh" };
+    }
+    writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+    return { path: instructionPath, status: action === "install" ? "installed" : "refreshed" };
+}
+function serializeGeminiStartupBlock(newline) {
+    return [
+        GEMINI_STARTUP_MANAGED_START,
+        "## Prism session startup",
+        "On the first user turn of every conversation, including a greeting, your first action must be",
+        "`session_bootstrap({})`, exactly once. Emit no preamble. Print the complete tool result verbatim as the",
+        "entire first-turn startup display, before any optional answer. Do not summarize, paraphrase, rename headings,",
+        "reformat, or omit any returned section. Preserve its order and line content. For a greeting-only prompt, stop",
+        "after the verbatim startup display. If `session_bootstrap` is deferred, use native tool discovery/ToolSearch",
+        "to load that exact tool, then invoke it.",
+        "Do not use shell commands, file reads, subagents, or unrelated tool inspection as a substitute. Do not call",
+        "`session_load_context`. If discovery or invocation fails, report `Prism startup failure` and stop. Reuse the",
+        "`conversation_id` returned in structuredContent for session_save_ledger, session_save_handoff, and",
+        "session_detect_drift calls. This block is managed by `prism connect`; do not edit it manually.",
+        "",
+        ...LOCAL_FIRST_POLICY_LINES,
+        GEMINI_STARTUP_MANAGED_END,
+        "",
+    ].join(newline);
+}
+/** The exact Gemini startup section provisioned before native bootstrap support. */
+function legacyGeminiStartupBlock(newline) {
+    return [
+        "# Startup — MANDATORY",
+        "",
+        "Your first action in every conversation is loading Prism session context. Zero text before the tool call.",
+        "",
+        "**Dual-path detection:** Check your available toolset.",
+        "- **If `mcp_prism-mcp_session_load_context` exists:** Call it with `project: \"prism-mcp\"`, `level: \"deep\"`.",
+        "- **If no MCP tools are available (Antigravity):** Run `bash ~/.gemini/antigravity/scratch/prism_session_loader.sh prism-mcp` via `run_command`. This uses the `prism load` CLI under the hood, sharing the same storage layer (SQLite or Supabase) as the MCP tool.",
+        "",
+        "After success: echo agent identity, last summary, open TODOs, session version.",
+        "If any call fails: say \"Prism load failed — retrying\" and retry ONE more time.",
+        "",
+        "",
+    ].join(newline);
+}
+/** Install or refresh Gemini CLI's native, hook-free first-turn instruction. */
+export function configureGeminiNativeStartup(homeDir = homedir(), dryRun = false, beforeCommit) {
+    const instructionPath = join(homeDir, ".gemini", "GEMINI.md");
+    let writePath = instructionPath;
+    let symlinkPath;
+    let originalText;
+    let instructionEntryExists = false;
+    try {
+        const pathInfo = lstatSync(instructionPath);
+        instructionEntryExists = true;
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(instructionPath);
+            symlinkPath = instructionPath;
+            if (!statSync(writePath).isFile())
+                throw new Error("target is not a regular file");
+        }
+        originalText = readFileSync(writePath, "utf8");
+    }
+    catch (error) {
+        if (instructionEntryExists || !isErrno(error, "ENOENT")) {
+            throw new Error(`Could not inspect Gemini instructions: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const currentText = originalText ?? "";
+    const newline = currentText.includes("\r\n") ? "\r\n" : "\n";
+    const startRanges = findExactLineRanges(currentText, GEMINI_STARTUP_MANAGED_START);
+    const endRanges = findExactLineRanges(currentText, GEMINI_STARTUP_MANAGED_END);
+    if (startRanges.length !== endRanges.length || startRanges.length > 1) {
+        throw new Error(`Gemini instructions contain ambiguous Prism startup ownership markers: ${instructionPath}`);
+    }
+    const managedBlock = serializeGeminiStartupBlock(newline);
+    let nextText;
+    let action;
+    if (startRanges.length === 1) {
+        if (endRanges[0].start <= startRanges[0].start) {
+            throw new Error(`Gemini instructions contain out-of-order Prism startup ownership markers: ${instructionPath}`);
+        }
+        const managedEnd = endRanges[0].end;
+        if (currentText.slice(startRanges[0].start, managedEnd) === managedBlock) {
+            return { path: instructionPath, status: "unchanged" };
+        }
+        nextText = currentText.slice(0, startRanges[0].start) + managedBlock + currentText.slice(managedEnd);
+        action = "refresh";
+    }
+    else {
+        const legacyBlock = legacyGeminiStartupBlock(newline);
+        if (currentText.startsWith(legacyBlock)) {
+            nextText = managedBlock + newline + currentText.slice(legacyBlock.length);
+        }
+        else {
+            const separator = currentText.length === 0
+                ? ""
+                : currentText.endsWith("\n") || currentText.endsWith("\r")
+                    ? newline
+                    : `${newline}${newline}`;
+            nextText = currentText + separator + managedBlock;
+        }
+        action = "install";
+    }
+    if (dryRun) {
+        return { path: instructionPath, status: action === "install" ? "would-install" : "would-refresh" };
+    }
+    writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+    return { path: instructionPath, status: action === "install" ? "installed" : "refreshed" };
+}
+function serializeCodexStartupBlock(newline) {
+    return [
+        CODEX_STARTUP_MANAGED_START,
+        ...CODEX_STARTUP_BODY,
+        CODEX_STARTUP_MANAGED_END,
+        "",
+    ].join(newline);
+}
+/** Install or refresh Codex's official global, hook-free first-turn instruction. */
+export function configureCodexNativeStartup(homeDir, dryRun = false, beforeCommit, env = homeDir === undefined ? process.env : {}) {
+    const userHome = homeDir ?? homedir();
+    const configuredCodexHome = env.CODEX_HOME?.trim();
+    const codexHome = configuredCodexHome ? resolve(configuredCodexHome) : join(userHome, ".codex");
+    const instructionPath = join(codexHome, "AGENTS.md");
+    let writePath = instructionPath;
+    let symlinkPath;
+    let originalText;
+    let instructionEntryExists = false;
+    try {
+        const pathInfo = lstatSync(instructionPath);
+        instructionEntryExists = true;
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(instructionPath);
+            symlinkPath = instructionPath;
+            if (!statSync(writePath).isFile())
+                throw new Error("target is not a regular file");
+        }
+        originalText = readFileSync(writePath, "utf8");
+    }
+    catch (error) {
+        if (instructionEntryExists || !isErrno(error, "ENOENT")) {
+            throw new Error(`Could not inspect Codex instructions: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const currentText = originalText ?? "";
+    const newline = currentText.includes("\r\n") ? "\r\n" : "\n";
+    const startRanges = findExactLineRanges(currentText, CODEX_STARTUP_MANAGED_START);
+    const endRanges = findExactLineRanges(currentText, CODEX_STARTUP_MANAGED_END);
+    if (startRanges.length !== endRanges.length || startRanges.length > 1) {
+        throw new Error(`Codex instructions contain ambiguous Prism startup ownership markers: ${instructionPath}`);
+    }
+    const managedBlock = serializeCodexStartupBlock(newline);
+    let nextText;
+    let action;
+    if (startRanges.length === 1) {
+        if (endRanges[0].start <= startRanges[0].start) {
+            throw new Error(`Codex instructions contain out-of-order Prism startup ownership markers: ${instructionPath}`);
+        }
+        const managedEnd = endRanges[0].end;
+        if (currentText.slice(startRanges[0].start, managedEnd) === managedBlock) {
+            return { path: instructionPath, status: "unchanged" };
+        }
+        nextText = currentText.slice(0, startRanges[0].start) + managedBlock + currentText.slice(managedEnd);
+        action = "refresh";
+    }
+    else {
+        const separator = currentText.length === 0
+            ? ""
+            : currentText.endsWith("\n") || currentText.endsWith("\r")
+                ? newline
+                : `${newline}${newline}`;
+        nextText = currentText + separator + managedBlock;
+        action = "install";
+    }
+    if (dryRun) {
+        return { path: instructionPath, status: action === "install" ? "would-install" : "would-refresh" };
+    }
+    writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+    return { path: instructionPath, status: action === "install" ? "installed" : "refreshed" };
+}
+function configureJsonAgentPolicy(configPath, label, mutate, dryRun, beforeCommit) {
+    let writePath = configPath;
+    let symlinkPath;
+    let originalText;
+    let config = {};
+    try {
+        const pathInfo = lstatSync(configPath);
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(configPath);
+            symlinkPath = configPath;
+            if (!statSync(writePath).isFile())
+                throw new Error("target is not a regular file");
+        }
+        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) {
+        if (!isErrno(error, "ENOENT")) {
+            throw new Error(`Could not inspect ${label}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const changed = mutate(config);
+    if (!changed)
+        return { path: configPath, status: "unchanged" };
+    const action = originalText === undefined ? "install" : "refresh";
+    if (dryRun) {
+        return { path: configPath, status: action === "install" ? "would-install" : "would-refresh" };
+    }
+    writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
+    return { path: configPath, status: action === "install" ? "installed" : "refreshed" };
+}
+/** Configure Claude Code's economy fallback model; policy text prevents routine fan-out. */
+export function configureClaudeAgentPolicy(homeDir = homedir(), dryRun = false, beforeCommit) {
+    const configPath = join(homeDir, ".claude", "settings.json");
+    return configureJsonAgentPolicy(configPath, "Claude agent settings", (config) => {
+        const currentEnv = config.env;
+        if (currentEnv !== undefined && !isJsonObject(currentEnv)) {
+            throw new Error('"env" must be a JSON object');
+        }
+        const env = (currentEnv ?? {});
+        if (env.CLAUDE_CODE_SUBAGENT_MODEL === CLAUDE_FALLBACK_SUBAGENT_MODEL)
+            return false;
+        env.CLAUDE_CODE_SUBAGENT_MODEL = CLAUDE_FALLBACK_SUBAGENT_MODEL;
+        config.env = env;
+        return true;
+    }, dryRun, beforeCommit);
+}
+/** Disable Gemini's native/remote subagents; Prism local workers remain available over MCP. */
+export function configureGeminiAgentPolicy(homeDir = homedir(), dryRun = false, beforeCommit) {
+    const configPath = join(homeDir, ".gemini", "settings.json");
+    return configureJsonAgentPolicy(configPath, "Gemini agent settings", (config) => {
+        const currentExperimental = config.experimental;
+        if (currentExperimental !== undefined && !isJsonObject(currentExperimental)) {
+            throw new Error('"experimental" must be a JSON object');
+        }
+        const experimental = (currentExperimental ?? {});
+        if (experimental.enableAgents === false)
+            return false;
+        experimental.enableAgents = false;
+        config.experimental = experimental;
+        return true;
+    }, dryRun, beforeCommit);
+}
+function tomlValue(value) {
+    return typeof value === "string" ? JSON.stringify(value) : String(value);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function applyTomlTablePolicy(source, table, desired) {
+    const newline = source.includes("\r\n") ? "\r\n" : "\n";
+    const hadFinalNewline = source.endsWith("\n");
+    const lines = source.length === 0 ? [] : source.split(/\r?\n/);
+    if (hadFinalNewline)
+        lines.pop();
+    const tablePattern = new RegExp(`^\\s*\\[${escapeRegExp(table)}\\]\\s*(?:#.*)?$`);
+    const tableIndexes = lines
+        .map((line, index) => tablePattern.test(line) ? index : -1)
+        .filter((index) => index >= 0);
+    if (tableIndexes.length > 1)
+        throw new Error(`duplicate [${table}] tables`);
+    let tableStart = tableIndexes[0];
+    if (tableStart === undefined) {
+        if (lines.length > 0 && lines[lines.length - 1] !== "")
+            lines.push("");
+        lines.push(`[${table}]`);
+        tableStart = lines.length - 1;
+    }
+    let tableEnd = lines.findIndex((line, index) => index > tableStart && /^\s*\[{1,2}[^\]]+\]{1,2}\s*(?:#.*)?$/.test(line));
+    if (tableEnd < 0)
+        tableEnd = lines.length;
+    const missing = [];
+    for (const [key, value] of Object.entries(desired)) {
+        const keyPattern = new RegExp(`^(\\s*${escapeRegExp(key)}\\s*=\\s*)(.*?)(\\s+#.*)?$`);
+        const matches = [];
+        for (let index = tableStart + 1; index < tableEnd; index++) {
+            if (keyPattern.test(lines[index]))
+                matches.push(index);
+        }
+        if (matches.length > 1)
+            throw new Error(`duplicate ${table}.${key} assignments`);
+        if (matches.length === 0) {
+            missing.push([key, value]);
+            continue;
+        }
+        lines[matches[0]] = lines[matches[0]].replace(keyPattern, (_match, prefix, _oldValue, comment) => `${prefix}${tomlValue(value)}${comment ?? ""}`);
+    }
+    if (missing.length > 0) {
+        const marker = `${CODEX_POLICY_MARKER_PREFIX} ${table}`;
+        const markerEnd = `${CODEX_POLICY_MARKER_SUFFIX} ${table}`;
+        lines.splice(tableEnd, 0, marker, ...missing.map(([key, value]) => `${key} = ${tomlValue(value)}`), markerEnd);
+    }
+    return `${lines.join(newline)}${hadFinalNewline || lines.length > 0 ? newline : ""}`;
+}
+/** Hard-disable Codex fan-out while retaining a bounded economy fallback profile. */
+export function configureCodexAgentPolicy(homeDir, dryRun = false, beforeCommit, env = homeDir === undefined ? process.env : {}) {
+    const userHome = homeDir ?? homedir();
+    const configuredCodexHome = env.CODEX_HOME?.trim();
+    const codexHome = configuredCodexHome ? resolve(configuredCodexHome) : join(userHome, ".codex");
+    const configPath = join(codexHome, "config.toml");
+    let writePath = configPath;
+    let symlinkPath;
+    let originalText;
+    try {
+        const pathInfo = lstatSync(configPath);
+        if (pathInfo.isSymbolicLink()) {
+            writePath = realpathSync(configPath);
+            symlinkPath = configPath;
+            if (!statSync(writePath).isFile())
+                throw new Error("target is not a regular file");
+        }
+        originalText = readFileSync(writePath, "utf8");
+        parseToml(originalText);
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT")) {
+            throw new Error(`Could not inspect Codex agent settings: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    let nextText = originalText ?? "";
+    nextText = applyTomlTablePolicy(nextText, "features", CODEX_LOCAL_FIRST_POLICY.features);
+    nextText = applyTomlTablePolicy(nextText, "agents", CODEX_LOCAL_FIRST_POLICY.agents);
+    let parsed;
+    try {
+        parsed = parseToml(nextText);
+    }
+    catch (error) {
+        throw new Error(`Could not build valid Codex local-first policy: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const parsedFeatures = isJsonObject(parsed) && isJsonObject(parsed.features)
+        ? parsed.features
+        : undefined;
+    const parsedAgents = isJsonObject(parsed) && isJsonObject(parsed.agents)
+        ? parsed.agents
+        : undefined;
+    if (!parsedFeatures
+        || !parsedAgents
+        || !isDeepStrictEqual(parsedFeatures.multi_agent, false)
+        || !Object.entries(CODEX_LOCAL_FIRST_POLICY.agents)
+            .every(([key, value]) => isDeepStrictEqual(parsedAgents[key], value))) {
+        throw new Error("Generated Codex local-first policy failed validation");
+    }
+    if (nextText === originalText)
+        return { path: configPath, status: "unchanged" };
+    const action = originalText === undefined ? "install" : "refresh";
+    if (dryRun) {
+        return { path: configPath, status: action === "install" ? "would-install" : "would-refresh" };
+    }
+    writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+    return { path: configPath, status: action === "install" ? "installed" : "refreshed" };
+}
 function getHostDefinitions(homeDir, platform, env, includeSystemPaths) {
     const claudeDesktop = claudeDesktopPath(homeDir, platform, env);
     const cursorDetectionPaths = [join(homeDir, ".cursor")];
@@ -208,10 +1028,15 @@ function executableExists(name, platform, pathEnv) {
     return false;
 }
 function buildMcpEntry(nodePath, serverPath, env) {
+    const storage = env.PRISM_STORAGE ?? "auto";
+    if (!CONNECT_STORAGE_BACKENDS.includes(storage)) {
+        throw new Error(`Invalid PRISM_STORAGE "${storage}". Choose one of: ${CONNECT_STORAGE_BACKENDS.join(", ")}`);
+    }
     const serverEnv = {
         PRISM_INSTANCE: "prism-mcp",
+        PRISM_AGENT_POLICY: LOCAL_FIRST_POLICY_ID,
         PRISM_SYNALUX_BASE_URL: env.PRISM_SYNALUX_BASE_URL || "https://synalux.ai",
-        PRISM_STORAGE: "auto",
+        PRISM_STORAGE: storage,
     };
     if (env.PRISM_SYNALUX_API_KEY) {
         serverEnv.PRISM_SYNALUX_API_KEY = env.PRISM_SYNALUX_API_KEY;
@@ -277,34 +1102,37 @@ function registerJsonHost(definition, entry, dryRun, refresh, beforeCommit) {
             : undefined;
     if (existingKey) {
         const existingEntry = mcpServers[existingKey];
+        const startupCompatible = existingKey === "prism-mcp"
+            && isManagedPrismEntry(existingEntry)
+            && isDeepStrictEqual(refreshManagedEntry(existingEntry, entry), existingEntry);
         if (!refresh || existingKey !== "prism-mcp" || !isManagedPrismEntry(existingEntry)) {
-            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched", startupCompatible);
         }
         const refreshedEntry = refreshManagedEntry(existingEntry, entry);
         if (JSON.stringify(refreshedEntry) === JSON.stringify(existingEntry)) {
-            return result(definition, "existing", "Prism-managed entry is already current");
+            return result(definition, "existing", "Prism-managed entry is already current", true);
         }
         if (dryRun) {
-            return result(definition, "would-refresh");
+            return result(definition, "would-refresh", undefined, true);
         }
         mcpServers[existingKey] = refreshedEntry;
         config.mcpServers = mcpServers;
         try {
             writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
-            return result(definition, "refreshed");
+            return result(definition, "refreshed", undefined, true);
         }
         catch (error) {
             return result(definition, "error", error instanceof Error ? error.message : String(error));
         }
     }
     if (dryRun) {
-        return result(definition, "would-register");
+        return result(definition, "would-register", undefined, true);
     }
     mcpServers["prism-mcp"] = entry;
     config.mcpServers = mcpServers;
     try {
         writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
-        return result(definition, "registered");
+        return result(definition, "registered", undefined, true);
     }
     catch (error) {
         return result(definition, "error", error instanceof Error ? error.message : String(error));
@@ -367,18 +1195,22 @@ function registerCodexTomlHost(definition, entry, dryRun, refresh, beforeCommit)
     if (hasCanonical || hasLegacy) {
         const existingKey = hasCanonical ? "prism-mcp" : "prism";
         const existingEntry = mcpServers[existingKey];
+        const startupCompatible = existingKey === "prism-mcp"
+            && managedBlock !== undefined
+            && isManagedPrismEntry(existingEntry)
+            && isDeepStrictEqual(refreshManagedEntry(existingEntry, entry), existingEntry);
         if (!refresh || existingKey !== "prism-mcp") {
-            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched", startupCompatible);
         }
         if (!managedBlock) {
-            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched", false);
         }
         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");
+            return result(definition, "existing", "Prism-managed entry is already current", true);
         }
         let nextText;
         try {
@@ -389,11 +1221,11 @@ function registerCodexTomlHost(definition, entry, dryRun, refresh, beforeCommit)
             return result(definition, "error", `could not build valid Codex config: ${error instanceof Error ? error.message : String(error)}`);
         }
         if (dryRun) {
-            return result(definition, "would-refresh");
+            return result(definition, "would-refresh", undefined, true);
         }
         try {
             writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
-            return result(definition, "refreshed");
+            return result(definition, "refreshed", undefined, true);
         }
         catch (error) {
             return result(definition, "error", error instanceof Error ? error.message : String(error));
@@ -418,11 +1250,11 @@ function registerCodexTomlHost(definition, entry, dryRun, refresh, beforeCommit)
         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");
+        return result(definition, "would-register", undefined, true);
     }
     try {
         writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
-        return result(definition, "registered");
+        return result(definition, "registered", undefined, true);
     }
     catch (error) {
         return result(definition, "error", error instanceof Error ? error.message : String(error));
@@ -521,18 +1353,24 @@ function writeTextAtomically(filePath, contents, expectedText, beforeCommit, sym
             unlinkSync(tempPath);
     }
 }
-function result(definition, status, message) {
+function result(definition, status, message, startupCompatible = false) {
     return {
         host: definition.name,
         label: definition.label,
         path: definition.configPath,
         status,
+        startupCompatible,
         message,
     };
 }
 function isJsonObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isPathWithin(candidate, parent) {
+    const relativePath = relative(parent, candidate);
+    return relativePath === ""
+        || (!isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep}`));
+}
 function isManagedPrismEntry(value) {
     return isJsonObject(value)
         && isJsonObject(value.env)