@evomap/evolver-mcp 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/antigravityInstaller.d.ts

@@ -0,0 +1,32 @@
+import type { InjectionPlan, McpServerCmd, RuntimeId } from './injection.js';
+import { type InstallOptions, type InstallResult, type UninstallOptions } from './installer.js';
+export declare const ANTIGRAVITY_NAMESPACES: readonly ["antigravity", "antigravity-ide"];
+export interface AntigravityConfigTarget {
+    namespace: (typeof ANTIGRAVITY_NAMESPACES)[number];
+    root: string;
+    configPath: string;
+}
+export declare class AntigravityConfigShapeError extends Error {
+    constructor(path: string, detail: string);
+}
+export declare class AntigravityPathTypeError extends Error {
+    constructor(label: string, path: string);
+}
+export declare class AntigravitySecretRefusedError extends Error {
+    constructor(detail: string);
+}
+/**
+ * Resolve Antigravity's user-level config targets. Every existing runtime root is targeted. If neither namespace
+ * exists, installation falls back to the canonical ~/.gemini/antigravity root. This function never creates paths.
+ */
+export declare function resolveAntigravityConfigTargets(homeDir?: string): AntigravityConfigTarget[];
+export declare function antigravityMcpServerEntry(server: McpServerCmd): Record<string, unknown>;
+export declare function mergeAntigravityConfig(current: Record<string, unknown>, serverEntry: Record<string, unknown>): Record<string, unknown>;
+export declare function stripAntigravityManaged(current: Record<string, unknown>): {
+    changed: boolean;
+    data: Record<string, unknown>;
+};
+/** Install MCP tool discovery only. Antigravity has no verified SessionStart hook contract. */
+export declare function installAntigravity(plan: InjectionPlan, opts: InstallOptions): InstallResult;
+/** Remove only mcpServers.evolver. The shared config file and all unrelated user content always remain. */
+export declare function uninstallAntigravity(runtime: RuntimeId, opts: UninstallOptions): InstallResult;

package/dist/antigravityInstaller.js

@@ -0,0 +1,271 @@
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { homedir as osHomedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { util } from '@evomap/evolver-core';
+import { EmptySharedConfigError, SymlinkRefusedError, UnparseableConfigError, } from './installer.js';
+const ENV_FILE_KEY = 'EVOLVER_ENV_FILE';
+const CONFIG_FILE = 'mcp_config.json';
+const CONFIG_WRITE_RETRIES = 5;
+const NEW_CONFIG_MODE = 0o600;
+const NEW_DIR_MODE = 0o700;
+export const ANTIGRAVITY_NAMESPACES = ['antigravity', 'antigravity-ide'];
+export class AntigravityConfigShapeError extends Error {
+    constructor(path, detail) {
+        super(`[setup-hooks] refusing to overwrite Antigravity MCP config (${path}): ${detail}. Fix the shared config, then rerun.`);
+        this.name = 'AntigravityConfigShapeError';
+    }
+}
+export class AntigravityPathTypeError extends Error {
+    constructor(label, path) {
+        super(`[setup-hooks] refusing to operate: ${label} (${path}) exists but is not a directory.`);
+        this.name = 'AntigravityPathTypeError';
+    }
+}
+export class AntigravitySecretRefusedError extends Error {
+    constructor(detail) {
+        super(`[setup-hooks] refusing to write Antigravity MCP config: ${detail}; use only an ${ENV_FILE_KEY} pointer to a credential file.`);
+        this.name = 'AntigravitySecretRefusedError';
+    }
+}
+const isObj = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function lstatIfExists(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function assertDirectoryOrMissing(path, label) {
+    const stat = lstatIfExists(path);
+    if (stat === undefined)
+        return false;
+    if (stat.isSymbolicLink())
+        throw new SymlinkRefusedError(label, path);
+    if (!stat.isDirectory())
+        throw new AntigravityPathTypeError(label, path);
+    return true;
+}
+function assertFileNotSymlink(path, label) {
+    const stat = lstatIfExists(path);
+    if (stat?.isSymbolicLink())
+        throw new SymlinkRefusedError(label, path);
+}
+/**
+ * Resolve Antigravity's user-level config targets. Every existing runtime root is targeted. If neither namespace
+ * exists, installation falls back to the canonical ~/.gemini/antigravity root. This function never creates paths.
+ */
+export function resolveAntigravityConfigTargets(homeDir = osHomedir()) {
+    assertDirectoryOrMissing(homeDir, 'home directory');
+    const geminiRoot = join(homeDir, '.gemini');
+    assertDirectoryOrMissing(geminiRoot, '~/.gemini');
+    const candidates = ANTIGRAVITY_NAMESPACES.map((namespace) => {
+        const root = join(geminiRoot, namespace);
+        return { namespace, root, configPath: join(root, CONFIG_FILE) };
+    });
+    const existing = candidates.filter((target) => assertDirectoryOrMissing(target.root, `~/.gemini/${target.namespace}`));
+    const targets = existing.length > 0 ? existing : [candidates[0]];
+    for (const target of targets) {
+        assertFileNotSymlink(target.configPath, `~/.gemini/${target.namespace}/${CONFIG_FILE}`);
+    }
+    return targets;
+}
+function validateConfigShape(data, path) {
+    const mcpServers = data['mcpServers'];
+    if (mcpServers !== undefined && !isObj(mcpServers)) {
+        throw new AntigravityConfigShapeError(path, 'mcpServers must be a JSON object');
+    }
+}
+function readStrictSnapshot(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { data: {}, raw: null };
+        throw error;
+    }
+    const trimmed = raw.trim();
+    if (!trimmed)
+        throw new EmptySharedConfigError('Antigravity MCP config', path, 'Antigravity');
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        throw new UnparseableConfigError('Antigravity MCP config', path, 'Antigravity');
+    }
+    if (!isObj(parsed)) {
+        throw new AntigravityConfigShapeError(path, 'the top-level JSON value must be an object');
+    }
+    validateConfigShape(parsed, path);
+    return { data: parsed, raw };
+}
+function readRawIfExists(path) {
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+function existingFileMode(path) {
+    try {
+        return statSync(path).mode & 0o777;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}
+function writeJsonAtomic(path, data) {
+    const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    const mode = existingFileMode(path) ?? NEW_CONFIG_MODE;
+    const restoreMode = process.platform === 'win32' && existsSync(path) ? existingFileMode(path) : undefined;
+    try {
+        writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, { encoding: 'utf8', flag: 'wx', mode });
+        chmodSync(tmp, mode);
+        if (process.platform === 'win32' && existsSync(path))
+            chmodSync(path, mode | 0o200);
+        renameSync(tmp, path);
+        chmodSync(path, mode);
+    }
+    catch (error) {
+        rmSync(tmp, { force: true });
+        if (restoreMode !== undefined) {
+            try {
+                if (existsSync(path))
+                    chmodSync(path, restoreMode);
+            }
+            catch { /* preserve the original error */ }
+        }
+        throw error;
+    }
+}
+function updateConfigWithRetry(path, update) {
+    const lockPath = `${path}.evolver.lock`;
+    util.acquireLock(lockPath);
+    try {
+        for (let attempt = 0; attempt < CONFIG_WRITE_RETRIES; attempt++) {
+            const snapshot = readStrictSnapshot(path);
+            const next = update(snapshot.data);
+            if (!next.changed)
+                return false;
+            if (readRawIfExists(path) !== snapshot.raw)
+                continue;
+            writeJsonAtomic(path, next.data);
+            return true;
+        }
+    }
+    finally {
+        util.releaseLock(lockPath);
+    }
+    throw new Error(`[setup-hooks] refusing to overwrite Antigravity MCP config (${path}): the file changed repeatedly while evolver was merging it. Retry after Antigravity finishes writing it.`);
+}
+const SECRET_FLAG_RE = /(?:^|\s)--?(?:api[-_]?key|password|passwd|secret|token)(?:=|\s+)/i;
+const SECRET_ASSIGNMENT_RE = /\b(?:A2A_NODE_SECRET|EVOMAP_ENTERPRISE_TOKEN|EVOMAP_PRIVATE_HUB_TOKEN|EVOMAP_NODE_SECRET|EVOLVER_IPC_TOKEN|EVOLVER_LLM_TOKEN|PHUB_ENTERPRISE_TOKEN|PRIVATE_HUB_ENTERPRISE_TOKEN)\b\s*=/;
+const BEARER_RE = /\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/i;
+function looksLikeEnvFilePointer(value) {
+    return /[\\/]/.test(value)
+        || /^[.~$%]/.test(value)
+        || /\.(?:env|dotenv)(?:$|[._-])/i.test(value);
+}
+function validateServer(server) {
+    const commandLine = [server.command, ...(server.args ?? [])].join(' ');
+    if (SECRET_FLAG_RE.test(commandLine) || SECRET_ASSIGNMENT_RE.test(commandLine) || BEARER_RE.test(commandLine)) {
+        throw new AntigravitySecretRefusedError('the MCP command or args contain an inline secret-looking value');
+    }
+    if (server.env === undefined || Object.keys(server.env).length === 0)
+        return;
+    const keys = Object.keys(server.env);
+    if (keys.some((key) => key !== ENV_FILE_KEY)) {
+        throw new AntigravitySecretRefusedError(`env may contain only ${ENV_FILE_KEY}`);
+    }
+    const pointer = server.env[ENV_FILE_KEY]?.trim();
+    if (!pointer || !looksLikeEnvFilePointer(pointer)) {
+        throw new AntigravitySecretRefusedError(`${ENV_FILE_KEY} must contain a file path, not a credential value`);
+    }
+}
+export function antigravityMcpServerEntry(server) {
+    validateServer(server);
+    const pointer = server.env?.[ENV_FILE_KEY]?.trim();
+    return {
+        command: server.command,
+        args: server.args ?? [],
+        ...(pointer ? { env: { [ENV_FILE_KEY]: pointer } } : {}),
+    };
+}
+export function mergeAntigravityConfig(current, serverEntry) {
+    const prior = current['mcpServers'];
+    const mcpServers = isObj(prior) ? { ...prior } : {};
+    mcpServers['evolver'] = serverEntry;
+    return { ...current, mcpServers };
+}
+export function stripAntigravityManaged(current) {
+    const prior = current['mcpServers'];
+    if (!isObj(prior) || !('evolver' in prior))
+        return { changed: false, data: current };
+    const mcpServers = { ...prior };
+    delete mcpServers['evolver'];
+    const data = { ...current };
+    if (Object.keys(mcpServers).length > 0)
+        data['mcpServers'] = mcpServers;
+    else
+        delete data['mcpServers'];
+    return { changed: true, data };
+}
+function hasEvolver(current) {
+    const mcpServers = current['mcpServers'];
+    return isObj(mcpServers) && 'evolver' in mcpServers;
+}
+function ensureTargetRoot(target) {
+    const geminiRoot = dirname(target.root);
+    assertDirectoryOrMissing(geminiRoot, '~/.gemini');
+    mkdirSync(dirname(target.configPath), { recursive: true, mode: NEW_DIR_MODE });
+    assertDirectoryOrMissing(geminiRoot, '~/.gemini');
+    assertDirectoryOrMissing(target.root, `~/.gemini/${target.namespace}`);
+    assertFileNotSymlink(target.configPath, `~/.gemini/${target.namespace}/${CONFIG_FILE}`);
+}
+/** Install MCP tool discovery only. Antigravity has no verified SessionStart hook contract. */
+export function installAntigravity(plan, opts) {
+    const serverEntry = antigravityMcpServerEntry(opts.server);
+    const targets = resolveAntigravityConfigTargets(opts.homeDir);
+    // Validate every shared config before the first mutation so one corrupt namespace cannot leave a partial install.
+    const snapshots = targets.map((target) => ({ target, snapshot: readStrictSnapshot(target.configPath) }));
+    if (!opts.force && snapshots.every(({ snapshot }) => hasEvolver(snapshot.data))) {
+        return { ok: true, runtime: plan.runtime, mode: plan.mode, files: [], alreadyInstalled: true };
+    }
+    const files = [];
+    for (const { target } of snapshots) {
+        ensureTargetRoot(target);
+        const changed = updateConfigWithRetry(target.configPath, (current) => {
+            if (!opts.force && hasEvolver(current))
+                return { changed: false, data: current };
+            return { changed: true, data: mergeAntigravityConfig(current, serverEntry) };
+        });
+        if (changed)
+            files.push(target.configPath);
+    }
+    return { ok: true, runtime: plan.runtime, mode: plan.mode, files };
+}
+/** Remove only mcpServers.evolver. The shared config file and all unrelated user content always remain. */
+export function uninstallAntigravity(runtime, opts) {
+    const targets = resolveAntigravityConfigTargets(opts.homeDir);
+    const snapshots = targets.map((target) => ({ target, snapshot: readStrictSnapshot(target.configPath) }));
+    const files = [];
+    for (const { target, snapshot } of snapshots) {
+        if (!hasEvolver(snapshot.data))
+            continue;
+        const changed = updateConfigWithRetry(target.configPath, stripAntigravityManaged);
+        if (changed)
+            files.push(target.configPath);
+    }
+    return { ok: true, runtime, mode: 'uninstall', files };
+}

package/dist/index.d.ts

@@ -9,4 +9,8 @@ export * from './manualWiring.js';
 export * from './serviceGuidance.js';
 export * from './codexInstaller.js';
 export * from './cursorRulesInstaller.js';
+export * from './antigravityInstaller.js';
+export * from './jsonMcpInstaller.js';
+export * from './opencodeInstaller.js';
+export * from './kiroInstaller.js';
 export * from './envFile.js';

package/dist/index.js

@@ -9,4 +9,8 @@ export * from './manualWiring.js';
 export * from './serviceGuidance.js';
 export * from './codexInstaller.js';
 export * from './cursorRulesInstaller.js';
+export * from './antigravityInstaller.js';
+export * from './jsonMcpInstaller.js';
+export * from './opencodeInstaller.js';
+export * from './kiroInstaller.js';
 export * from './envFile.js';

package/dist/injection.d.ts

@@ -1,10 +1,11 @@
-export type RuntimeId = 'claude-code' | 'codex' | 'cursor' | 'kiro' | 'opencode';
-export type InjectionMode = 'mcp-hooks' | 'mcp-plugin' | 'cursor-rules' | 'passive';
+export type RuntimeId = 'claude-code' | 'codex' | 'cursor' | 'antigravity' | 'kiro' | 'opencode';
+export type InjectionMode = 'mcp-hooks' | 'mcp-plugin' | 'mcp-config' | 'cursor-rules' | 'passive';
 /**
  * Setup support contract (#217). A bootstrapper that delegates runtime onboarding to evolver v2 needs a
  * DETERMINISTIC answer for every runtime it might ask about — not just the ones v2 can write config for.
  * The three outcomes are the whole contract:
- *  - `installed`   v2 can write the runtime config/hooks and verify it (claude-code, codex, cursor today).
+ *  - `installed`   v2 can write the runtime config/hooks and verify it (claude-code, codex, cursor, antigravity,
+ *                  opencode, kiro).
  *  - `manual`      v2 cannot mutate this runtime's config, but the path is real: it prints precise MCP/HTTP
  *                  wiring the operator does by hand (opencode, openclaw, mcp-generic, http-agent, server).
  *  - `unsupported` v2 refuses with a clear reason (an unrecognized runtime id).

package/dist/injection.js

@@ -1,14 +1,12 @@
 /** Every runtime in the setup matrix (#217), in a stable order — used for usage text and the unsupported reason. */
 export const SETUP_RUNTIMES = [
-    'claude-code', 'codex', 'cursor', 'opencode', 'kiro', 'openclaw', 'mcp-generic', 'http-agent', 'server',
+    'claude-code', 'codex', 'cursor', 'antigravity', 'opencode', 'kiro', 'openclaw', 'mcp-generic', 'http-agent', 'server',
 ];
-/** Runtimes v2 can write config/hooks for and verify. */
-const INSTALLED_RUNTIMES = new Set(['claude-code', 'codex', 'cursor']);
+/** Runtimes v2 can write config/hooks for and verify. Antigravity is MCP-config-only (no lifecycle hook). */
+const INSTALLED_RUNTIMES = new Set(['claude-code', 'codex', 'cursor', 'antigravity', 'opencode', 'kiro']);
 /** Runtimes with no v2 auto-installer but a real manual path. The reason is the short, honest "do it by hand"
  *  line; the precise wiring text is a separate concern (#217 slice 2), not hard-coded here. */
 const MANUAL_RUNTIMES = new Map([
-    ['opencode', 'opencode is consumed passively today; register the evolver MCP server in its config by hand'],
-    ['kiro', 'kiro is consumed passively today; register the evolver MCP server in its config by hand'],
     ['openclaw', 'no v2 auto-installer yet; wire the evolver MCP server (or PrivateHub HTTP/A2A) by hand'],
     ['mcp-generic', 'no config writer for a generic MCP client; register the evolver MCP server by hand'],
     ['http-agent', 'no config writer for an HTTP/API-only agent; wire it to PrivateHub HTTP/A2A by hand'],
@@ -59,12 +57,25 @@ export function planInjection(runtime, server) {
                 config: {},
                 note: 'cursor: 渲染静默 top-gene hints 进 .cursor/rules/evolver.mdc (alwaysApply:true); daemon 在 gene 集变化时重写',
             };
-        case 'kiro':
+        case 'antigravity':
+            return {
+                runtime, mode: 'mcp-config',
+                // Antigravity supports MCP tool discovery through its user-level JSON config. It has no verified
+                // SessionStart lifecycle contract, so this mode deliberately registers only the MCP server.
+                config: { mcpServers: { evolver: { command: server.command, args: server.args ?? [], ...(server.env ? { env: server.env } : {}) } } },
+                note: 'antigravity: write mcpServers.evolver in the user-level MCP config; tool discovery only (no SessionStart hook)',
+            };
         case 'opencode':
             return {
-                runtime, mode: 'passive',
-                config: {},
-                note: `${runtime}: MVP 仅被动消费会话日志(无工具注入); 接入方式待补`,
+                runtime, mode: 'mcp-config',
+                config: { mcp: { evolver: { type: 'local', command: [server.command, ...(server.args ?? [])], ...(server.env ? { environment: server.env } : {}), enabled: true } } },
+                note: 'OpenCode: write opencode.json local MCP registration; no lifecycle prompt injection.',
+            };
+        case 'kiro':
+            return {
+                runtime, mode: 'mcp-config',
+                config: { mcpServers: { evolver: { command: server.command, args: server.args ?? [], ...(server.env ? { env: server.env } : {}), disabled: false } } },
+                note: 'Kiro: write .kiro/settings/mcp.json MCP registration; no lifecycle prompt injection.',
             };
         default: {
             const _exhaustive = runtime;
@@ -76,7 +87,7 @@ export function planInjection(runtime, server) {
  *  故不计入此处;passive runtime 也为 false. */
 export function injectsTools(runtime) {
     const mode = planInjection(runtime, { command: 'x' }).mode;
-    return mode === 'mcp-hooks' || mode === 'mcp-plugin';
+    return mode === 'mcp-hooks' || mode === 'mcp-plugin' || mode === 'mcp-config';
 }
 /** 是否为 active 注入(任何把 gene 价值推回 runtime 的方式:MCP 工具发现 或 cursor rules 记忆注入). */
 export function isActiveInjection(runtime) {

package/dist/installer.d.ts

@@ -32,11 +32,54 @@ export interface InstallOptions {
     hookCommand?: string;
     /** Reinstall even if an evolver install is already present. */
     force?: boolean;
+    /** Plan and validate without writing config or backup files. */
+    dryRun?: boolean;
     /** Cursor only: the top genes to render into .cursor/rules/evolver.mdc. The daemon refreshes these on change;
      *  a one-shot `setup-hooks --runtime=cursor` install seeds the file (empty ⇒ a placeholder the daemon fills). */
     genes?: readonly CursorGene[];
     /** Cursor only: cap on genes rendered into the always-on rules body (token-tax bound). */
     maxGenes?: number;
+    /** Antigravity only: override the user home used to resolve ~/.gemini config roots. Intended for hermetic
+     *  embedding/tests; normal callers omit it. configRoot and scope do not affect Antigravity's user config. */
+    homeDir?: string;
+    /** Kiro user scope only: direct replacement for ~/.kiro, matching KIRO_HOME semantics. */
+    kiroHome?: string;
+    /** OpenCode user scope only: explicit XDG_CONFIG_HOME used to resolve the global config. */
+    xdgConfigHome?: string;
+    /** OpenCode user scope only: explicit OPENCODE_CONFIG file override. */
+    opencodeConfig?: string;
+    /** OpenCode user scope only: explicit OPENCODE_CONFIG_DIR override. */
+    opencodeConfigDir?: string;
+    /** OpenCode only: inline config loaded after project/custom-directory config. */
+    opencodeConfigContent?: string;
+    /** OpenCode only: mirrors truthy OPENCODE_DISABLE_PROJECT_CONFIG handling. */
+    opencodeDisableProjectConfig?: boolean;
+    /** OpenCode only: injectable managed-config directory for hermetic tests. */
+    opencodeManagedConfigDir?: string;
+    /** OpenCode only: injectable macOS managed-preference paths for hermetic tests. */
+    opencodeManagedPreferencePaths?: readonly string[];
+    /** OpenCode only: injectable platform used to resolve system managed paths. */
+    opencodePlatform?: NodeJS.Platform;
+    /** OpenCode only: injectable ProgramData used to resolve the Windows managed path. */
+    opencodeProgramData?: string;
+    /** OpenCode only: injectable username used to resolve macOS managed preferences. */
+    opencodeUsername?: string;
+}
+export interface UninstallOptions {
+    configRoot: string;
+    scope?: InstallScope;
+    /** Antigravity only: override the user home used to resolve ~/.gemini config roots. */
+    homeDir?: string;
+    /** Kiro user scope only: direct replacement for ~/.kiro, matching KIRO_HOME semantics. */
+    kiroHome?: string;
+    /** Validate and report the uninstall without changing config or backup files. */
+    dryRun?: boolean;
+    /** OpenCode user scope only: explicit XDG_CONFIG_HOME used to resolve the global config. */
+    xdgConfigHome?: string;
+    /** OpenCode user scope only: explicit OPENCODE_CONFIG file override. */
+    opencodeConfig?: string;
+    /** OpenCode user scope only: explicit OPENCODE_CONFIG_DIR override. */
+    opencodeConfigDir?: string;
 }
 export interface InstallResult {
     ok: boolean;
@@ -45,6 +88,9 @@ export interface InstallResult {
     /** Absolute paths written (install) or cleaned (uninstall). */
     files: string[];
     alreadyInstalled?: boolean;
+    dryRun?: boolean;
+    verified?: boolean;
+    backups?: string[];
     error?: string;
 }
 export declare class SymlinkRefusedError extends Error {
@@ -60,14 +106,14 @@ export declare class SymlinkRefusedError extends Error {
  * .mcp.json/.claude/settings.json are evolver-owned, so their lenient fresh-start behavior stays unchanged.
  */
 export declare class UnparseableConfigError extends Error {
-    constructor(label: string, path: string);
+    constructor(label: string, path: string, owner?: string);
 }
 /**
  * Thrown when a SHARED user config exists but is empty or whitespace-only. Claude Code writes these files with a
  * truncating write, so present-empty can be a concurrent-write window rather than a fresh config.
  */
 export declare class EmptySharedConfigError extends Error {
-    constructor(label: string, path: string);
+    constructor(label: string, path: string, owner?: string);
 }
 type SharedConfigRaceHook = (path: string, attempt: number) => void;
 export declare function _setSharedConfigRaceHookForTest(hook?: SharedConfigRaceHook): void;
@@ -90,6 +136,8 @@ export declare function stripManaged(data: Record<string, unknown>): {
  *    (delegated to codexInstaller; TOML, not JSON). Same hybrid value (tool discovery + session-start injection).
  *  - cursor (cursor-rules): renders top genes into <root>/.cursor/rules/evolver.mdc (alwaysApply:true) — gene
  *    memory injection, not MCP tool discovery (delegated to cursorRulesInstaller). The daemon keeps it fresh.
+ *  - antigravity (mcp-config): writes mcpServers.evolver to every existing user-level Antigravity config root,
+ *    or the canonical root when none exists. MCP tool discovery only; no SessionStart hook is installed.
  * Idempotent + symlink-safe; passive runtimes (kiro/opencode) return ok:false (nothing to inject).
  */
 export declare function installInjection(plan: InjectionPlan, opts: InstallOptions): InstallResult;
@@ -97,10 +145,7 @@ export declare function installInjection(plan: InjectionPlan, opts: InstallOptio
  *  Pass the SAME scope used at install: 'user' cleans ~/.claude.json + ~/.claude/settings.json; 'project'
  *  (default) cleans <configRoot>/.mcp.json + <configRoot>/.claude/settings.json. stripManaged only removes
  *  the mcpServers.evolver entry (and any evolver-owned hooks/marker), so it is safe on the shared ~/.claude.json. */
-export declare function uninstallInjection(runtime: RuntimeId, opts: {
-    configRoot: string;
-    scope?: InstallScope;
-}): InstallResult;
+export declare function uninstallInjection(runtime: RuntimeId, opts: UninstallOptions): InstallResult;
 /** Convenience: plan + install in one call for a runtime. */
 export declare function setupRuntime(runtime: RuntimeId, opts: InstallOptions): InstallResult;
 export {};

package/dist/installer.js

@@ -22,6 +22,9 @@ import { installCodex, uninstallCodex } from './codexInstaller.js';
 // cursor injection is a different mechanism again (a project rules file, not a config/MCP writer): it renders
 // top genes into .cursor/rules/evolver.mdc. It plugs into the same install/uninstall dispatch below.
 import { installCursorRules, uninstallCursorRules } from './cursorRulesInstaller.js';
+import { installAntigravity, uninstallAntigravity } from './antigravityInstaller.js';
+import { installOpenCode, uninstallOpenCode } from './opencodeInstaller.js';
+import { installKiro, uninstallKiro } from './kiroInstaller.js';
 /** Marks a config file as containing evolver-managed entries, so uninstall only removes what we added. */
 export const MANAGED_MARKER = '_evolver_managed';
 /** A hook entry is evolver-owned if any of its commands mention this — used to replace-not-duplicate on reinstall. */
@@ -49,8 +52,8 @@ export class SymlinkRefusedError extends Error {
  * .mcp.json/.claude/settings.json are evolver-owned, so their lenient fresh-start behavior stays unchanged.
  */
 export class UnparseableConfigError extends Error {
-    constructor(label, path) {
-        super(`[setup-hooks] refusing to overwrite ${label} (${path}): the file exists and is non-empty but is not valid JSON. This is Claude Code's own shared config; merging into it would replace the whole file and could wipe its contents (projects/oauthAccount/userID/history/settings). Fix or remove the corrupt file, then rerun.`);
+    constructor(label, path, owner = 'Claude Code') {
+        super(`[setup-hooks] refusing to overwrite ${label} (${path}): the file exists and is non-empty but is not valid JSON. This is ${owner}'s own shared config; merging into it would replace the whole file and could wipe its contents. Fix or remove the corrupt file, then rerun.`);
         this.name = 'UnparseableConfigError';
     }
 }
@@ -59,8 +62,8 @@ export class UnparseableConfigError extends Error {
  * truncating write, so present-empty can be a concurrent-write window rather than a fresh config.
  */
 export class EmptySharedConfigError extends Error {
-    constructor(label, path) {
-        super(`[setup-hooks] refusing to overwrite ${label} (${path}): the file exists but is empty or contains only whitespace. Claude Code may be in the middle of a truncating write, and treating it as fresh config could wipe shared config data. Fix the empty file or retry after Claude Code finishes writing it.`);
+    constructor(label, path, owner = 'Claude Code') {
+        super(`[setup-hooks] refusing to overwrite ${label} (${path}): the file exists but is empty or contains only whitespace. ${owner} may be in the middle of a truncating write, and treating it as fresh config could wipe shared config data. Fix the empty file or retry after ${owner} finishes writing it.`);
         this.name = 'EmptySharedConfigError';
     }
 }
@@ -386,6 +389,8 @@ function claudeCodeTargets(scope, configRoot) {
  *    (delegated to codexInstaller; TOML, not JSON). Same hybrid value (tool discovery + session-start injection).
  *  - cursor (cursor-rules): renders top genes into <root>/.cursor/rules/evolver.mdc (alwaysApply:true) — gene
  *    memory injection, not MCP tool discovery (delegated to cursorRulesInstaller). The daemon keeps it fresh.
+ *  - antigravity (mcp-config): writes mcpServers.evolver to every existing user-level Antigravity config root,
+ *    or the canonical root when none exists. MCP tool discovery only; no SessionStart hook is installed.
  * Idempotent + symlink-safe; passive runtimes (kiro/opencode) return ok:false (nothing to inject).
  */
 export function installInjection(plan, opts) {
@@ -398,9 +403,17 @@ export function installInjection(plan, opts) {
     if (plan.runtime === 'cursor') {
         return installCursorRules({ configRoot: opts.configRoot, genes: opts.genes ?? [], ...(opts.maxGenes !== undefined ? { maxGenes: opts.maxGenes } : {}) });
     }
+    if (plan.runtime === 'antigravity') {
+        return installAntigravity(plan, opts);
+    }
+    if (plan.runtime === 'opencode') {
+        return installOpenCode(plan, opts);
+    }
+    if (plan.runtime === 'kiro') {
+        return installKiro(plan, opts);
+    }
     if (plan.runtime !== 'claude-code') {
-        // kiro/opencode are passive (handled above); any other active runtime is not yet ported.
-        return { ok: false, runtime: plan.runtime, mode: plan.mode, files: [], error: `installer not yet implemented for ${plan.runtime} (supported: claude-code, codex, cursor)` };
+        return { ok: false, runtime: plan.runtime, mode: plan.mode, files: [], error: `installer not yet implemented for ${plan.runtime} (supported: claude-code, codex, cursor, antigravity, opencode, kiro)` };
     }
     const hookCommand = opts.hookCommand ?? DEFAULT_HOOK_COMMAND;
     const scope = opts.scope ?? 'project';
@@ -478,6 +491,15 @@ export function uninstallInjection(runtime, opts) {
     if (runtime === 'cursor') {
         return uninstallCursorRules(opts);
     }
+    if (runtime === 'antigravity') {
+        return uninstallAntigravity(runtime, opts);
+    }
+    if (runtime === 'opencode') {
+        return uninstallOpenCode(runtime, opts);
+    }
+    if (runtime === 'kiro') {
+        return uninstallKiro(runtime, opts);
+    }
     if (runtime !== 'claude-code') {
         return { ok: false, runtime, mode: 'n/a', files: [], error: `uninstall not implemented for ${runtime}` };
     }

package/dist/jsonMcpInstaller.d.ts

@@ -0,0 +1,75 @@
+import type { InjectionPlan, McpServerCmd, RuntimeId } from './injection.js';
+import { type InstallOptions, type InstallResult, type UninstallOptions } from './installer.js';
+type BeforeReplaceHook = (path: string) => void;
+export declare function _setJsonMcpBeforeReplaceHookForTest(hook?: BeforeReplaceHook): void;
+export declare function _setJsonMcpAfterReplaceHookForTest(hook?: BeforeReplaceHook): void;
+export declare function _setJsonMcpBeforeBackupRemoveHookForTest(hook?: BeforeReplaceHook): void;
+export interface JsonMcpRuntimeSpec {
+    runtime: 'opencode' | 'kiro';
+    configPath(opts: JsonMcpPathOptions): string;
+    resolveConfig?(opts: JsonMcpPathOptions): JsonMcpRuntimeResolution;
+    safeRoot?(opts: JsonMcpPathOptions): string;
+    conflictingPaths?(opts: JsonMcpPathOptions): string[];
+    containerKey: 'mcp' | 'mcpServers';
+    entry(server: McpServerCmd): Record<string, unknown>;
+    installPreflight?(resolution: JsonMcpRuntimeResolution, opts: InstallOptions, expected: Record<string, unknown>): JsonMcpInstallPreflight | undefined;
+}
+export interface JsonMcpInstallPreflight {
+    alreadyInstalled?: boolean;
+    assertUnchanged(): void;
+}
+type JsonMcpPathOptions = Pick<InstallOptions, 'configRoot' | 'scope' | 'homeDir' | 'kiroHome' | 'xdgConfigHome' | 'opencodeConfig' | 'opencodeConfigDir'>;
+export interface JsonMcpRuntimeResolution {
+    configPath: string;
+    safeRoot: string;
+    conflictingPaths: string[];
+    /** An active sibling at the same precedence slot that must remain user-owned and read-only. */
+    activePrecedencePath?: string;
+    /** The writable target was retargeted to a uniquely managed config discovered outside the active path. */
+    managedRetarget?: true;
+    /** Runtime config candidates ordered from lowest to highest precedence; the first path is the default target. */
+    topologyCandidatePaths?: string[];
+    evidencePaths?: string[];
+    /** Config locations that may contain a managed backup from an earlier active-precedence decision. */
+    uninstallCandidatePaths?: string[];
+    /** Broader locations used to reuse a managed target selected from an ancestor project directory. */
+    installDiscoveryPaths?: string[];
+    /** Safe root for install discovery and a selected managed target; does not affect default install writes. */
+    installSafeRoot?: string;
+    /** Broader read-only locations used only to discover managed backups during uninstall. */
+    uninstallDiscoveryPaths?: string[];
+    /** Safe root for uninstall discovery and a selected managed target; does not affect install writes. */
+    uninstallSafeRoot?: string;
+    /** Candidate-local conflicts that must be re-evaluated after uninstall retargeting. */
+    uninstallConflictingPaths?: (configPath: string) => string[];
+}
+export declare class McpConfigConflictError extends Error {
+    readonly diff: {
+        path: string;
+        expected: unknown;
+        actual: unknown;
+    };
+    constructor(runtime: string, path: string, expected: unknown, actual: unknown);
+}
+export declare class McpConfigShapeError extends Error {
+    constructor(runtime: string, path: string, detail: string);
+}
+export declare class McpConfigOwnershipError extends Error {
+    constructor(runtime: string, detail: string);
+}
+export declare class McpConfigVerificationError extends Error {
+    private readonly runtime;
+    private readonly path;
+    restored: boolean;
+    constructor(runtime: string, path: string);
+    markRestored(): void;
+}
+export declare class McpConfigChangedError extends Error {
+    constructor(runtime: string, path: string);
+}
+export declare class McpServerValidationError extends Error {
+    constructor(message: string);
+}
+export declare function installJsonMcpRuntime(spec: JsonMcpRuntimeSpec, plan: InjectionPlan, opts: InstallOptions): InstallResult;
+export declare function uninstallJsonMcpRuntime(spec: JsonMcpRuntimeSpec, runtime: RuntimeId, opts: UninstallOptions): InstallResult;
+export {};