agencyx-cli 0.0.0-stage → 0.1.0-dev.4

package/dist/cli.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { parseCommand, HELP } from "./cli-options.js";
+import { asDiagnostic, errorExitCode, formatDiagnostic, } from "./diagnostics.js";
+export async function main(args = process.argv.slice(2)) {
+    let json = false;
+    try {
+        const command = parseCommand(args);
+        json =
+            (command.kind === "doctor" || command.kind === "codex") && command.json;
+        switch (command.kind) {
+            case "help":
+                process.stdout.write(HELP);
+                return 0;
+            case "version": {
+                const manifest = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+                process.stdout.write(`agencyx ${manifest.version}\n`);
+                return 0;
+            }
+            case "passthrough":
+                return await (await import("./commands/passthrough.js")).passthrough(command.args);
+            case "doctor":
+                return await (await import("./commands/doctor.js")).doctor(command.json);
+            case "codex":
+                return await (await import("./commands/codex.js")).runCodex(command);
+            case "bridge":
+                return await (await import("./bridge/main.js")).bridgeMain(args.slice(1));
+        }
+    }
+    catch (error) {
+        const diagnostic = asDiagnostic(error);
+        if (json)
+            process.stdout.write(`${JSON.stringify({ schemaVersion: 1, ready: false, errors: [diagnostic] }, null, 2)}\n`);
+        else
+            process.stderr.write(`${formatDiagnostic(diagnostic)}\n`);
+        return errorExitCode(error);
+    }
+}
+// Setting exitCode lets inherited terminal output and acknowledged IPC flush.
+process.exitCode = await main();
+//# sourceMappingURL=cli.js.map

package/dist/codex/agents.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { chmod, mkdtemp, writeFile } from "node:fs/promises";
+import { stringify } from "smol-toml";
+import { combineInstructions } from "../adapters/instructions.js";
+import { fail } from "../diagnostics.js";
+import { isRecord } from "../validation.js";
+export async function prepareAgents(packages, sessionRoot, inspection, instructions) {
+    const bindings = [];
+    const roles = Object.create(null);
+    const existing = isRecord(inspection.config.agents)
+        ? inspection.config.agents
+        : {};
+    if (!packages.some(({ spec }) => spec.agents.length))
+        return { bindings, overrides: {} };
+    if (existing.enabled === false)
+        fail("AGENT_RUNTIME_DISABLED", "compatibility", "Native Codex agents are disabled in the effective configuration.");
+    if (inspection.requirementsKnown === false ||
+        inspection.requirements?.agents !== undefined)
+        fail("AGENT_POLICY_UNVERIFIED", "compatibility", "Managed agent requirements must be verified before registering plugin agents.");
+    const directory = await mkdtemp(path.join(sessionRoot, "agents-"));
+    await chmod(directory, 0o700);
+    for (const { spec, resourceRoot } of packages) {
+        for (const agent of spec.agents) {
+            const name = `${spec.name}:${agent.name}`;
+            if (Object.hasOwn(existing, name) || Object.hasOwn(roles, name))
+                fail("AGENT_CONFLICT", "compatibility", "A native agent already uses the selected plugin agent's qualified name.", { component: name });
+            if (agent.model !== undefined && agent.model !== inspection.config.model)
+                fail("AGENT_MODEL_UNSUPPORTED", "compatibility", "The plugin agent model does not match the effective Codex model. No model-name substitution is performed.", { component: name, path: agent.sourcePath, field: "model" });
+            const relative = path.relative(spec.root, agent.sourcePath);
+            const source = path.join(resourceRoot, relative);
+            const body = combineInstructions(instructions ??
+                (typeof inspection.config.developer_instructions === "string"
+                    ? inspection.config.developer_instructions
+                    : undefined), [
+                `Plugin resources for this agent: ${JSON.stringify(resourceRoot)}.\nOriginal agent document: ${JSON.stringify(source)}.\nResolve plugin-relative resources within that package.`,
+                agent.instructions,
+            ], {});
+            const file = path.join(directory, `${createHash("sha256").update(name).digest("hex")}.toml`);
+            await writeFile(file, stringify({
+                name,
+                description: agent.description,
+                developer_instructions: body,
+                ...(agent.model !== undefined ? { model: agent.model } : {}),
+            }), { mode: 0o600 });
+            roles[name] = { description: agent.description, config_file: file };
+            bindings.push({
+                name,
+                pluginName: spec.name,
+                sourcePath: agent.sourcePath,
+                configFile: file,
+                ...(agent.declaredTools !== undefined
+                    ? { declaredTools: agent.declaredTools }
+                    : {}),
+            });
+        }
+    }
+    return { bindings, overrides: { agents: roles } };
+}
+export function verifyNativeAgents(bindings, inspection) {
+    const roles = isRecord(inspection.config.agents)
+        ? inspection.config.agents
+        : {};
+    for (const binding of bindings) {
+        const role = roles[binding.name];
+        if (roles.enabled === false ||
+            !isRecord(role) ||
+            role.config_file !== binding.configFile)
+            fail("AGENT_REGISTRATION_FAILED", "compatibility", "The native session did not retain the selected agent configuration.", { component: binding.name });
+    }
+}
+//# sourceMappingURL=agents.js.map

package/dist/codex/app-server.js

@@ -0,0 +1,116 @@
+import net from "node:net";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { setTimeout as delay } from "node:timers/promises";
+import { fail } from "../diagnostics.js";
+import { runInteractive, startProcess } from "../runtime/process.js";
+import { websocketClient } from "./rpc.js";
+import { configArguments } from "./toml.js";
+import { createSessionProxy } from "./session-proxy.js";
+import { registerSkillViews, verifySkillViews } from "./skill-views.js";
+import { readNativeSkills } from "./inspection.js";
+export async function reserveLoopbackPort() {
+    const server = net.createServer();
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        fail("BACKEND_ADDRESS_INVALID", "codex", "A private loopback port could not be reserved.", {}, 6);
+    }
+    await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+    return address.port;
+}
+export async function runAppServer(context, plan, options, env, signal) {
+    const token = randomBytes(32).toString("hex");
+    const tokenFile = path.join(context.sessionRoot, "remote-token");
+    await writeFile(tokenFile, token, { mode: 0o600 });
+    const endpoint = `ws://127.0.0.1:${await reserveLoopbackPort()}`;
+    const overrides = configArguments(plan.overrides);
+    const backend = startProcess(context.codexPath, [
+        ...options.configArgs,
+        ...overrides,
+        "app-server",
+        "--listen",
+        endpoint,
+        "--ws-auth",
+        "capability-token",
+        "--ws-token-file",
+        tokenFile,
+    ], {
+        cwd: context.cwd,
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        detached: process.platform !== "win32",
+    });
+    backend.child.stdout.resume();
+    backend.child.stderr.resume();
+    let client;
+    let proxy;
+    let shuttingDown = false;
+    let backendFailed = false;
+    let frontendStarted = false;
+    const frontendAbort = new AbortController();
+    const combinedSignal = AbortSignal.any([signal, frontendAbort.signal]);
+    void backend.exited.then(() => {
+        if (!shuttingDown) {
+            backendFailed = true;
+            frontendAbort.abort("SIGTERM");
+        }
+    }, () => {
+        backendFailed = true;
+        frontendAbort.abort("SIGTERM");
+    });
+    try {
+        const deadline = Date.now() + 15_000;
+        while (!client && Date.now() < deadline && !combinedSignal.aborted) {
+            try {
+                client = await websocketClient(endpoint, token, 1_000);
+            }
+            catch {
+                await delay(50);
+            }
+        }
+        if (!client)
+            fail("BACKEND_START_FAILED", "codex", "The private authenticated Codex app-server did not become ready.", {}, 6);
+        await client.initialize();
+        await registerSkillViews(client, plan.skillViews ?? []);
+        await verifySkillViews(plan.skillViews ?? [], await readNativeSkills(client, context.cwd));
+        client.close();
+        client = undefined;
+        const frontendToken = randomBytes(32).toString("hex");
+        proxy = await createSessionProxy(endpoint, token, frontendToken, plan);
+        const tokenEnv = `AGENCYX_REMOTE_TOKEN_${context.sessionId.replaceAll("-", "_")}`;
+        frontendStarted = true;
+        const result = await runInteractive(context.codexPath, [
+            "--remote",
+            proxy.endpoint,
+            "--remote-auth-token-env",
+            tokenEnv,
+            ...options.original,
+        ], {
+            cwd: context.cwd,
+            env: { ...env, [tokenEnv]: frontendToken },
+            signal: combinedSignal,
+        });
+        if (backendFailed && result.code === 0)
+            fail("BACKEND_EXITED", "codex", "The owned backend exited before its frontend completed.", {}, 6);
+        const protocolFailure = proxy.failure();
+        if (protocolFailure && result.code === 0)
+            fail(protocolFailure.code, protocolFailure.stage, protocolFailure.reason, {}, 6);
+        return result;
+    }
+    finally {
+        shuttingDown = true;
+        client?.close();
+        await proxy?.close();
+        await backend.stop();
+        if (frontendStarted)
+            process.stderr.write("Agencyx session ended; its private Codex backend has stopped.\n");
+    }
+}
+//# sourceMappingURL=app-server.js.map

package/dist/codex/inspection.js

@@ -0,0 +1,217 @@
+import { AgencyxError, fail } from "../diagnostics.js";
+import { isRecord, record } from "../validation.js";
+import { captureProcess, startProcess } from "../runtime/process.js";
+import { RpcError, stdioClient } from "./rpc.js";
+import { verifyMcpReadiness } from "./mcp-readiness.js";
+import { registerSkillViews, verifySkillViews } from "./skill-views.js";
+export async function readNativeSkills(client, cwd) {
+    return nativeComponents(await client.request("skills/list", { cwds: [cwd], forceReload: true }), "skills").map((skill) => {
+        if (typeof skill.path !== "string" ||
+            typeof skill.name !== "string" ||
+            typeof skill.enabled !== "boolean")
+            fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned invalid skill metadata.", {}, 6);
+        return {
+            name: skill.name,
+            path: skill.path,
+            enabled: skill.enabled,
+            pluginId: typeof skill.pluginId === "string" ? skill.pluginId : null,
+        };
+    });
+}
+export function nativeComponents(value, component) {
+    const response = record(value, `Codex ${component}`);
+    if (!Array.isArray(response.data))
+        fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned an invalid component catalog.", {}, 6);
+    const result = [];
+    for (const raw of response.data) {
+        const entry = record(raw, `Codex ${component} entry`);
+        if (Array.isArray(entry.errors) && entry.errors.length)
+            fail("CODEX_COMPONENT_LOAD_FAILED", "configuration", "Codex reported component discovery errors. Check the original Codex diagnostics.", { component }, 5);
+        const items = entry[component];
+        if (!Array.isArray(items))
+            fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned an incomplete component catalog.", {}, 6);
+        for (const item of items)
+            result.push(record(item, `Codex ${component} item`));
+    }
+    return result;
+}
+export function nativePlugins(response) {
+    const body = record(response, "Codex plugins");
+    if (!Array.isArray(body.marketplaces))
+        fail("CODEX_PROTOCOL_INVALID", "codex", "Codex did not return a plugin marketplace list.", {}, 6);
+    const result = [];
+    for (const raw of body.marketplaces) {
+        const marketplace = record(raw, "Codex marketplace");
+        if (!Array.isArray(marketplace.plugins))
+            fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned an invalid marketplace entry.", {}, 6);
+        for (const item of marketplace.plugins) {
+            const plugin = record(item, "Codex plugin");
+            if (typeof plugin.id !== "string" ||
+                typeof plugin.name !== "string" ||
+                typeof plugin.installed !== "boolean" ||
+                typeof plugin.enabled !== "boolean")
+                fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned incomplete plugin state.", {}, 6);
+            result.push({
+                id: plugin.id,
+                name: plugin.name,
+                installed: plugin.installed,
+                enabled: plugin.enabled,
+                source: record(plugin.source, plugin.id),
+                managed: plugin.installPolicySource !== null &&
+                    plugin.installPolicySource !== undefined,
+                ...(typeof marketplace.path === "string"
+                    ? { marketplacePath: marketplace.path }
+                    : {}),
+            });
+        }
+    }
+    return result;
+}
+export async function readNativePlugins(client, cwd) {
+    let response;
+    try {
+        response = await client.request("plugin/installed", { cwds: [cwd] });
+    }
+    catch (error) {
+        if (!(error instanceof RpcError) || error.rpcCode !== -32601)
+            throw error;
+        response = await client.request("plugin/list", {
+            cwds: [cwd],
+            marketplaceKinds: ["local"],
+        });
+    }
+    return nativePlugins(response);
+}
+export async function inspectCodex(codexPath, options, cwd, env, request = {}) {
+    const { selectedMcps, signal, skillViews = [] } = request;
+    if (options.nativeProfile) {
+        // The official app-server rejects --profile, even before the subcommand.
+        // Do not inspect the base config and pretend it describes a different runtime profile.
+        fail("CODEX_PROFILE_INSPECTION_UNSUPPORTED", "compatibility", "The installed app-server cannot inspect native Codex profiles. Agency profiles remain supported before --; native Codex --profile requires a verified runtime inspection path.", { field: "--profile" });
+    }
+    const help = await captureProcess(codexPath, ["--help"], { cwd, env });
+    const serverHelp = await captureProcess(codexPath, ["app-server", "--help"], {
+        cwd,
+        env,
+    });
+    if (help.code !== 0 || serverHelp.code !== 0)
+        fail("CODEX_PROTOCOL_UNSUPPORTED", "discovery", "The installed Codex does not expose the required official CLI and app-server interfaces.", {}, 3);
+    const running = startProcess(codexPath, [...options.configArgs, "app-server", "--listen", "stdio://"], {
+        cwd,
+        env,
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        detached: process.platform !== "win32",
+    });
+    running.child.stderr.resume();
+    const client = stdioClient(running);
+    const cancel = () => {
+        void running.stop(signal?.reason === "SIGINT" ? "SIGINT" : "SIGTERM");
+    };
+    signal?.addEventListener("abort", cancel, { once: true });
+    if (signal?.aborted)
+        cancel();
+    try {
+        let initialized;
+        try {
+            initialized = await client.initialize();
+        }
+        catch {
+            fail("CODEX_CONFIG_INVALID", "configuration", "Codex could not initialize with the existing configuration. Check it with the original Codex CLI; agencyx will not repair or replace it.", {}, 5);
+        }
+        const init = record(initialized, "Codex initialization");
+        if (typeof init.codexHome !== "string")
+            fail("CODEX_PROTOCOL_UNSUPPORTED", "codex", "The installed Codex does not report its active state directory.", {}, 6);
+        const response = record(await client.request("config/read", { cwd, includeLayers: true }), "Codex configuration");
+        const config = record(response.config, "Codex effective configuration");
+        const plugins = await readNativePlugins(client, cwd);
+        await registerSkillViews(client, skillViews);
+        const skills = await readNativeSkills(client, cwd);
+        await verifySkillViews(skillViews, skills);
+        const hooks = nativeComponents(await client.request("hooks/list", { cwds: [cwd] }), "hooks").map((hook) => {
+            if (typeof hook.sourcePath !== "string" ||
+                typeof hook.eventName !== "string" ||
+                typeof hook.enabled !== "boolean" ||
+                typeof hook.trustStatus !== "string")
+                fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned invalid hook metadata.", {}, 6);
+            return {
+                sourcePath: hook.sourcePath,
+                eventName: hook.eventName,
+                enabled: hook.enabled,
+                trustStatus: hook.trustStatus,
+                pluginId: typeof hook.pluginId === "string" ? hook.pluginId : null,
+                ...(typeof hook.command === "string" ? { command: hook.command } : {}),
+                ...(typeof hook.matcher === "string" || hook.matcher === null
+                    ? { matcher: hook.matcher }
+                    : {}),
+                ...(typeof hook.key === "string" ? { key: hook.key } : {}),
+                ...(typeof hook.currentHash === "string"
+                    ? { currentHash: hook.currentHash }
+                    : {}),
+                ...(typeof hook.isManaged === "boolean"
+                    ? { isManaged: hook.isManaged }
+                    : {}),
+            };
+        });
+        if (selectedMcps)
+            await verifyMcpReadiness(client, selectedMcps);
+        let requirements = null;
+        let requirementsKnown = true;
+        try {
+            const response = record(await client.request("configRequirements/read", null), "Codex requirements");
+            requirementsKnown = Object.hasOwn(response, "requirements");
+            if (isRecord(response.requirements))
+                requirements = response.requirements;
+            else if (response.requirements !== null &&
+                response.requirements !== undefined)
+                fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned invalid managed requirements.", {}, 6);
+        }
+        catch (error) {
+            if (!(error instanceof RpcError) || error.rpcCode !== -32601)
+                throw error;
+            requirementsKnown = false;
+        }
+        return {
+            config,
+            rootMcps: config.mcp_servers === undefined
+                ? {}
+                : record(config.mcp_servers, "Codex mcp_servers"),
+            plugins,
+            skills,
+            hooks,
+            codexHome: init.codexHome,
+            requirements,
+            requirementsKnown,
+            ...(Array.isArray(response.layers)
+                ? {
+                    sessionOverrides: response.layers.reduce((result, layer) => isRecord(layer) &&
+                        isRecord(layer.name) &&
+                        layer.name.type === "sessionFlags" &&
+                        isRecord(layer.config)
+                        ? layer.config
+                        : result, {}),
+                }
+                : {}),
+            capabilities: {
+                noDaemon: help.stdout.includes("--no-daemon"),
+                remoteTui: help.stdout.includes("--remote-auth-token-env"),
+                websocketAuth: serverHelp.stdout.includes("--ws-token-file"),
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof AgencyxError)
+            throw error;
+        throw new AgencyxError({
+            code: "CODEX_INSPECTION_FAILED",
+            stage: "codex",
+            reason: "The effective Codex configuration could not be inspected.",
+        }, 6);
+    }
+    finally {
+        signal?.removeEventListener("abort", cancel);
+        client.close();
+        await running.stop();
+    }
+}
+//# sourceMappingURL=inspection.js.map

package/dist/codex/mcp-readiness.js

@@ -0,0 +1,45 @@
+import { fail } from "../diagnostics.js";
+import { isRecord, record, stringArray } from "../validation.js";
+export function verifyMcpCatalog(name, value, expected) {
+    const response = record(value, "Codex MCP catalog");
+    if (!Array.isArray(response.data))
+        fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned an invalid MCP inventory.", { component: name }, 6);
+    const server = response.data.find((entry) => isRecord(entry) && entry.name === name);
+    if (!isRecord(server))
+        fail("MCP_NOT_DISCOVERED", "compatibility", "The selected MCP server is absent from Codex discovery.", { component: name });
+    if (server.authStatus === "notLoggedIn")
+        fail("MCP_AUTH_REQUIRED", "compatibility", "The selected MCP server requires authentication. Complete the original Agency authentication flow.", { component: name });
+    if (server.toolsError !== undefined && server.toolsError !== null)
+        fail("MCP_DISCOVERY_FAILED", "compatibility", "Codex could not retrieve the selected MCP tool catalog. Check Agency authentication and the proxy process. Raw server errors were withheld.", { component: name });
+    const tools = record(server.tools, "Codex MCP tools");
+    const names = Object.values(tools).map((tool) => {
+        if (!isRecord(tool) || typeof tool.name !== "string")
+            fail("CODEX_PROTOCOL_INVALID", "codex", "Codex returned incomplete tool metadata.", { component: name }, 6);
+        return tool.name;
+    });
+    const allowed = expected.enabled_tools === undefined
+        ? undefined
+        : stringArray(expected.enabled_tools, "enabled_tools");
+    const denied = expected.disabled_tools === undefined
+        ? []
+        : stringArray(expected.disabled_tools, "disabled_tools");
+    if (names.some((tool) => denied.includes(tool) ||
+        (allowed !== undefined && !allowed.includes(tool))))
+        fail("MCP_FILTER_NOT_ENFORCED", "compatibility", "The native MCP catalog exposes a tool outside the configured tool policy.", { component: name });
+    if (allowed?.some((tool) => !denied.includes(tool) && !names.includes(tool)))
+        fail("MCP_TOOLS_UNAVAILABLE", "compatibility", "A required allowed tool is missing from the native catalog.", { component: name });
+    if (names.length === 0 &&
+        server.toolsError === undefined &&
+        server.serverInfo === undefined)
+        fail("MCP_READINESS_UNVERIFIED", "compatibility", "This Codex version does not provide enough metadata to distinguish an empty catalog from a failed startup.", { component: name });
+}
+export async function verifyMcpReadiness(client, definitions) {
+    for (const [name, raw] of Object.entries(definitions)) {
+        const expected = record(raw, name);
+        if (expected.enabled === false)
+            continue;
+        const catalog = await client.request("mcpServerStatus/list", { serverName: name, detail: "toolsAndAuthOnly" }, 30_000);
+        verifyMcpCatalog(name, catalog, expected);
+    }
+}
+//# sourceMappingURL=mcp-readiness.js.map

package/dist/codex/native-plugins.js

@@ -0,0 +1,109 @@
+import path from "node:path";
+import { fail } from "../diagnostics.js";
+import { isRecord } from "../validation.js";
+import { packageFingerprint } from "../adapters/plugins.js";
+function packageRoot(resource, relative) {
+    if (!path.isAbsolute(resource))
+        return undefined;
+    let root = resource;
+    for (const _part of relative.split(path.sep))
+        root = path.dirname(root);
+    return path.resolve(root, relative) === path.resolve(resource)
+        ? root
+        : undefined;
+}
+export async function bindNativePlugin(spec, inspection) {
+    // Pure MCP bundles and the materialized primary agent are fully consumed by
+    // Agency's final connection config / rendered-instruction adapter.
+    if (spec.skills.length === 0 && spec.hooks.every((hook) => hook.count === 0))
+        return undefined;
+    const expectedHash = await packageFingerprint(spec.root);
+    for (const native of inspection.plugins.filter((plugin) => plugin.name === spec.name && plugin.installed)) {
+        const roots = new Set();
+        for (const skill of spec.skills) {
+            const relative = path.relative(spec.root, skill);
+            for (const loaded of inspection.skills.filter((candidate) => candidate.pluginId === native.id)) {
+                const root = packageRoot(loaded.path, relative);
+                if (root)
+                    roots.add(root);
+            }
+        }
+        for (const hook of spec.hooks) {
+            const relative = path.relative(spec.root, hook.file);
+            for (const loaded of inspection.hooks.filter((candidate) => candidate.pluginId === native.id)) {
+                const root = packageRoot(loaded.sourcePath, relative);
+                if (root)
+                    roots.add(root);
+            }
+        }
+        for (const root of roots) {
+            if ((await packageFingerprint(root)) === expectedHash)
+                return { spec, native, runtimeRoot: root };
+        }
+    }
+    fail("PLUGIN_NOT_READY", "compatibility", "No equivalent installed native plugin was found. Cold plugin installation currently writes global Codex configuration and is not performed automatically. Prepare a compatible plugin explicitly in Codex or exclude it explicitly through Agency.", { component: spec.name, path: spec.root });
+}
+export function pluginOverrides(bindings, inspection, profileMode) {
+    const plugins = Object.create(null);
+    const selected = new Set(bindings.map((binding) => binding.native.id));
+    if (profileMode === "profile-only") {
+        plugins._default = { enabled: false };
+        const ids = new Set([
+            ...inspection.plugins.map((plugin) => plugin.id),
+            ...Object.keys(isRecord(inspection.config.plugins) ? inspection.config.plugins : {}).filter((key) => key !== "_default"),
+        ]);
+        for (const id of ids) {
+            if (selected.has(id))
+                continue;
+            if (inspection.plugins.some((plugin) => plugin.id === id && plugin.managed && plugin.enabled))
+                fail("PROFILE_PLUGIN_ISOLATION_UNSUPPORTED", "compatibility", "A managed native plugin cannot be excluded to satisfy Agency profile-only isolation.", { component: id });
+            plugins[id] = { enabled: false };
+        }
+    }
+    for (const binding of bindings) {
+        const mcpServers = Object.fromEntries(binding.spec.mcpNames.map((name) => [name, { enabled: false }]));
+        plugins[binding.native.id] = {
+            enabled: true,
+            ...(Object.keys(mcpServers).length ? { mcp_servers: mcpServers } : {}),
+        };
+    }
+    return Object.keys(plugins).length ? { plugins } : {};
+}
+export function verifyNativePlugins(bindings, inspection, profileMode) {
+    const selected = new Set(bindings.map((binding) => binding.native.id));
+    if (profileMode === "profile-only" &&
+        inspection.plugins.some((plugin) => plugin.enabled && !selected.has(plugin.id)))
+        fail("PROFILE_PLUGIN_ISOLATION_UNSUPPORTED", "compatibility", "Codex still enables a plugin outside the Agency final selection.");
+    for (const { spec, native, runtimeRoot } of bindings) {
+        if (!inspection.plugins.some((plugin) => plugin.id === native.id && plugin.installed && plugin.enabled))
+            fail("PLUGIN_NOT_ENABLED", "compatibility", "The selected native plugin did not become enabled for this session.", { component: native.id });
+        for (const file of spec.skills) {
+            const expected = path.resolve(runtimeRoot, path.relative(spec.root, file));
+            if (!inspection.skills.some((skill) => skill.pluginId === native.id &&
+                skill.enabled &&
+                path.resolve(skill.path) === expected))
+                fail("PLUGIN_SKILL_MISSING", "compatibility", "A required plugin skill is absent or disabled in the native catalog.", { component: native.id, path: file });
+        }
+        for (const hook of spec.hooks) {
+            const expected = path.resolve(runtimeRoot, path.relative(spec.root, hook.file));
+            const hooks = inspection.hooks.filter((loaded) => loaded.pluginId === native.id &&
+                path.resolve(loaded.sourcePath) === expected);
+            if (hooks.length !== hook.count ||
+                hooks.some((loaded) => !loaded.enabled))
+                fail("PLUGIN_HOOK_MISSING", "compatibility", "A required hook was omitted or disabled by native discovery.", { component: native.id, path: hook.file });
+            if (hooks.some((loaded) => !["trusted", "managed"].includes(loaded.trustStatus)))
+                fail("PLUGIN_HOOK_UNTRUSTED", "compatibility", "A required hook needs the original Codex trust flow. The wrapper does not create trust records or bypass trust.", { component: native.id, path: hook.file });
+        }
+        const config = isRecord(inspection.config.plugins)
+            ? inspection.config.plugins[native.id]
+            : undefined;
+        for (const name of spec.mcpNames) {
+            const mcp = isRecord(config) && isRecord(config.mcp_servers)
+                ? config.mcp_servers[name]
+                : undefined;
+            if (!isRecord(mcp) || mcp.enabled !== false)
+                fail("PLUGIN_MCP_DUPLICATE", "compatibility", "A plugin MCP was not suppressed at its native policy source.", { component: native.id, field: name });
+        }
+    }
+}
+//# sourceMappingURL=native-plugins.js.map