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

package/dist/agency/prepared-input.js

@@ -0,0 +1,124 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { fail } from "../diagnostics.js";
+const DISPLAY_OPTIONS = new Set([
+    "--log-dir",
+    "--log-level",
+    "--session-id",
+    "--new-session-id",
+]);
+const IGNORED_SWITCHES = new Set([
+    "--no-auto-update",
+    "--disable-builtin-mcps",
+]);
+export function isVersionProbe(args) {
+    return (args.length === 1 &&
+        (args[0] === "--version" ||
+            args[0] === "--binary-version" ||
+            args[0] === "-V"));
+}
+export function parsePreparedInvocation(args, cwd, env) {
+    const prepared = {
+        cwd,
+        pluginRoots: [],
+        mcpConfigPaths: [],
+        inlineMcpConfigs: [],
+        extraInstructionRoots: [],
+        readGrants: [],
+        disabledMcpNames: [],
+        findings: [],
+    };
+    for (let i = 0; i < args.length; i++) {
+        const raw = args[i];
+        const equals = raw.indexOf("=");
+        const flag = equals < 0 ? raw : raw.slice(0, equals);
+        if (IGNORED_SWITCHES.has(flag) && equals < 0)
+            continue;
+        const takesValue = DISPLAY_OPTIONS.has(flag) ||
+            [
+                "--additional-mcp-config",
+                "--plugin-dir",
+                "--add-dir",
+                "--agent",
+                "--disable-mcp-server",
+                "-C",
+                "--cwd",
+            ].includes(flag);
+        if (!takesValue)
+            fail("AGENCY_ARGUMENT_UNSUPPORTED", "compatibility", "The prepared Copilot argument has no verified Codex equivalent. Put native Codex options after --.", { field: flag.startsWith("-") ? flag : "(positional argument)" });
+        const value = equals < 0 ? args[++i] : raw.slice(equals + 1);
+        if (value === undefined || value.includes("\0"))
+            fail("HANDOFF_ARGUMENT_INVALID", "handoff", "A prepared option is missing a valid value.", { field: flag }, 6);
+        if (DISPLAY_OPTIONS.has(flag)) {
+            prepared.findings.push({
+                component: flag,
+                state: "adapted",
+                reason: "Agency session metadata remains Agency-owned; Codex uses its own logs and session identity.",
+            });
+        }
+        else if (flag === "--additional-mcp-config") {
+            if (value.startsWith("@"))
+                prepared.mcpConfigPaths.push(path.resolve(cwd, value.slice(1)));
+            else
+                prepared.inlineMcpConfigs.push(value);
+        }
+        else if (flag === "--plugin-dir")
+            prepared.pluginRoots.push(path.resolve(cwd, value));
+        else if (flag === "--add-dir")
+            prepared.readGrants.push(path.resolve(cwd, value));
+        else if (flag === "--agent")
+            prepared.selectedAgent = value;
+        else if (flag === "--disable-mcp-server") {
+            prepared.disabledMcpNames.push(value);
+            prepared.findings.push({
+                component: "profile-isolation",
+                state: "adapted",
+                reason: "Copilot discovery suppression is replaced by isolation of the actual Codex sources.",
+            });
+        }
+        else if (path.resolve(cwd, value) !== path.resolve(cwd)) {
+            fail("CWD_MISMATCH", "handoff", "Agency prepared a different working directory. Launch agencyx from the intended directory.", { field: flag }, 6);
+        }
+    }
+    prepared.pluginRoots = [...new Set(prepared.pluginRoots)];
+    if (env.AGENCY_REPO_DIR)
+        prepared.repositoryRoot = path.resolve(cwd, env.AGENCY_REPO_DIR);
+    prepared.readGrants = [...new Set(prepared.readGrants)];
+    prepared.extraInstructionRoots = [
+        ...new Set((env.COPILOT_CUSTOM_INSTRUCTIONS_DIRS ?? "")
+            .split(",")
+            .map((part) => part.trim())
+            .filter(Boolean)
+            .map((part) => path.resolve(cwd, part))),
+    ];
+    if (env.AGENCY_SESSION_CATEGORIZATION_DISABLED === "1")
+        prepared.findings.push({
+            component: "copilot-session-telemetry",
+            state: "adapted",
+            reason: "Copilot-specific conversation tracking, categorization and analysis are disabled for the Codex branch. Native Codex sessions are not represented as Copilot transcripts.",
+        });
+    return prepared;
+}
+export async function readTextFile(file, maxBytes = 2 * 1024 * 1024) {
+    try {
+        const metadata = await stat(file);
+        if (!metadata.isFile() || metadata.size > maxBytes)
+            fail("CONFIG_FILE_INVALID", "configuration", "Expected a regular file within the supported size limit.", { path: file }, 5);
+        return await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AgencyxError")
+            throw error;
+        fail("CONFIG_FILE_UNREADABLE", "configuration", "A prepared configuration or resource file cannot be read.", { path: file }, 5);
+    }
+}
+export async function readJsonFile(file) {
+    const text = await readTextFile(file);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        fail("CONFIG_JSON_INVALID", "configuration", "The prepared file is not valid JSON.", { path: file }, 5);
+    }
+}
+//# sourceMappingURL=prepared-input.js.map

package/dist/bridge/execution.js

@@ -0,0 +1,119 @@
+import path from "node:path";
+import { writeFile } from "node:fs/promises";
+import { parsePreparedInvocation } from "../agency/prepared-input.js";
+import { AgencyxError, asDiagnostic } from "../diagnostics.js";
+import { engineEnvironment } from "../runtime/session.js";
+import { exitCode, observeSignals, runInteractive, } from "../runtime/process.js";
+import { mergedOverrides, parseCodexOptions } from "../codex/options.js";
+import { configArguments } from "../codex/toml.js";
+import { inspectCodex } from "../codex/inspection.js";
+import { verifyNativePlugins } from "../codex/native-plugins.js";
+import { buildLaunchPlan, verifyMcpOverrides } from "./plan.js";
+import { diagnosticPlan } from "../diagnostics/plan.js";
+import { runAppServer } from "../codex/app-server.js";
+import { verifyNativeAgents } from "../codex/agents.js";
+import { hookTrustOverrides, verifySessionHooks, } from "../codex/plugin-hooks.js";
+export async function executeBridge(args, env, control) {
+    const localAbort = new AbortController();
+    let engineStarted = false;
+    const removeSignals = observeSignals((signal) => localAbort.abort(signal), Boolean(process.stdin.isTTY), () => !engineStarted);
+    const signal = AbortSignal.any([control.signal, localAbort.signal]);
+    try {
+        const { context } = control;
+        const prepared = parsePreparedInvocation(args, context.cwd, env);
+        const nativeOptions = parseCodexOptions(context.options.codexArgs, context.cwd);
+        const codexEnv = engineEnvironment(env);
+        const inspection = await inspectCodex(context.codexPath, nativeOptions, context.cwd, codexEnv, { signal });
+        const { plan, bindings } = await buildLaunchPlan(context, prepared, inspection, nativeOptions);
+        if (signal.aborted)
+            throw new AgencyxError({
+                code: "LAUNCH_CANCELLED",
+                stage: "codex",
+                reason: "The session was cancelled during preparation.",
+            }, 130);
+        if (!plan.errors.length) {
+            try {
+                const inspectPlan = (checkMcps) => inspectCodex(context.codexPath, {
+                    ...nativeOptions,
+                    configArgs: [
+                        ...nativeOptions.configArgs,
+                        ...configArguments(plan.overrides),
+                    ],
+                }, context.cwd, codexEnv, {
+                    ...(checkMcps ? { selectedMcps: plan.expectedMcps ?? {} } : {}),
+                    signal,
+                    skillViews: plan.skillViews,
+                });
+                let effective = await inspectPlan(true);
+                if (nativeOptions.bypassHookTrust) {
+                    // The frontend's CLI switch does not activate trust in a separate
+                    // app-server. Apply its explicit intent through a native session
+                    // layer, then require native discovery to confirm trusted status.
+                    const trust = hookTrustOverrides(effective);
+                    if (Object.keys(trust).length) {
+                        plan.overrides = mergedOverrides(plan.overrides, trust);
+                        effective = await inspectPlan(false);
+                    }
+                }
+                verifyMcpOverrides(plan, effective);
+                verifyNativePlugins(bindings, effective, context.profileMode);
+                verifyNativeAgents(plan.agents ?? [], effective);
+                verifySessionHooks(plan.sessionHooks ?? [], effective);
+            }
+            catch (error) {
+                plan.errors.push(asDiagnostic(error));
+            }
+        }
+        if (signal.aborted)
+            throw new AgencyxError({
+                code: "LAUNCH_CANCELLED",
+                stage: "codex",
+                reason: "The session was cancelled during preparation.",
+            }, 130);
+        const publicPlan = diagnosticPlan(plan);
+        await writeFile(path.join(context.sessionRoot, "plan.json"), `${JSON.stringify(publicPlan, null, 2)}\n`, { mode: 0o600 });
+        await control.reportPlan(publicPlan);
+        if (context.options.dryRun) {
+            const code = plan.errors.length ? 4 : 0;
+            await control.reportExit({ code, signal: null });
+            return code;
+        }
+        if (plan.errors.length)
+            throw new AgencyxError(plan.errors[0], 4);
+        if (context.options.agentToolsPolicy === "inherit" &&
+            ((plan.agents?.length ?? 0) > 0 || prepared.selectedAgent))
+            process.stderr.write("Agencyx: source agent tools allow-lists are not applied (--agent-tools=inherit). Native Codex tool access and permissions remain in force.\n");
+        if (signal.aborted) {
+            await control.reportFailure({
+                code: "LAUNCH_CANCELLED",
+                stage: "codex",
+                reason: "The session was cancelled before Codex started.",
+            });
+            return 130;
+        }
+        control.engineStarted();
+        engineStarted = true;
+        const result = plan.strategy === "app-server"
+            ? await runAppServer(context, plan, nativeOptions, codexEnv, signal)
+            : await runInteractive(context.codexPath, [
+                "--no-daemon",
+                ...nativeOptions.original,
+                ...configArguments(plan.overrides),
+            ], { cwd: context.cwd, env: codexEnv, signal });
+        await control.reportExit(result);
+        return exitCode(result);
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw new AgencyxError({
+                code: "LAUNCH_CANCELLED",
+                stage: "codex",
+                reason: "The owned session was cancelled.",
+            }, signal.reason === "SIGINT" ? 130 : 143);
+        throw error;
+    }
+    finally {
+        removeSignals();
+    }
+}
+//# sourceMappingURL=execution.js.map

package/dist/bridge/main.js

@@ -0,0 +1,26 @@
+import { isVersionProbe } from "../agency/prepared-input.js";
+import { asDiagnostic, errorExitCode } from "../diagnostics.js";
+import { connectBridge } from "../runtime/ipc.js";
+// This is an Agency launch-protocol compatibility version, not a Codex version.
+import { COPILOT_PROTOCOL_VERSION } from "./version.js";
+export { COPILOT_PROTOCOL_VERSION } from "./version.js";
+export async function bridgeMain(args, env = process.env) {
+    const probe = isVersionProbe(args);
+    const control = await connectBridge(env, probe ? "probe" : "execution");
+    try {
+        if (probe) {
+            process.stdout.write(`GitHub Copilot CLI ${COPILOT_PROTOCOL_VERSION}\n`);
+            return 0;
+        }
+        // Keep Agency's separate five-second probe free of heavy engine adapters.
+        return await (await import("./execution.js")).executeBridge(args, env, control);
+    }
+    catch (error) {
+        await control.reportFailure(asDiagnostic(error), errorExitCode(error));
+        return errorExitCode(error);
+    }
+    finally {
+        control.close();
+    }
+}
+//# sourceMappingURL=main.js.map

package/dist/bridge/plan.js

@@ -0,0 +1,268 @@
+import path from "node:path";
+import { readJsonFile } from "../agency/prepared-input.js";
+import { AgencyxError, asDiagnostic, fail } from "../diagnostics.js";
+import { isRecord, record } from "../validation.js";
+import { equivalentMcp, parseMcpDocument, planMcps } from "../adapters/mcp.js";
+import { collectInstructions, combineInstructions, } from "../adapters/instructions.js";
+import { adaptPrimaryAgent } from "../adapters/agent.js";
+import { validateReadGrants } from "../adapters/permissions.js";
+import { inspectPlugin } from "../adapters/plugins.js";
+import { bindNativePlugin, pluginOverrides } from "../codex/native-plugins.js";
+import { mergedOverrides } from "../codex/options.js";
+import { validateAmbientCopilotContracts } from "../adapters/ambient.js";
+import { createSkillView } from "../codex/skill-views.js";
+import { prepareAgents } from "../codex/agents.js";
+import { prepareSessionHooks } from "../codex/plugin-hooks.js";
+export async function buildLaunchPlan(context, prepared, inspection, options) {
+    const plan = {
+        strategy: "direct-cli",
+        reason: "All selected components can use the native CLI with session-only overrides.",
+        cwd: context.cwd,
+        profileMode: context.profileMode,
+        mcpNames: [],
+        reusedMcpNames: [],
+        disabledMcpNames: [],
+        serverAliases: {},
+        pluginIds: [],
+        skillViews: [],
+        findings: [...prepared.findings],
+        errors: [],
+        overrides: {},
+        agentToolsPolicy: context.options.agentToolsPolicy ?? "strict",
+    };
+    const incoming = Object.create(null);
+    const bindings = [];
+    const specs = [];
+    const additions = [];
+    const sessionPackages = [];
+    const attempt = async (operation) => {
+        try {
+            await operation();
+        }
+        catch (error) {
+            const diagnostic = asDiagnostic(error);
+            plan.errors.push(diagnostic);
+            plan.findings.push({
+                component: diagnostic.component ?? diagnostic.code,
+                state: "unsupported",
+                reason: diagnostic.reason,
+                ...(diagnostic.path ? { path: diagnostic.path } : {}),
+                ...(diagnostic.field ? { field: diagnostic.field } : {}),
+            });
+        }
+    };
+    await attempt(() => validateAmbientCopilotContracts(prepared));
+    await attempt(() => {
+        if (context.profileMode === "profile-only" &&
+            inspection.requirementsKnown === false)
+            fail("PROFILE_REQUIREMENTS_UNVERIFIED", "compatibility", "The installed Codex cannot report the managed requirements needed to prove profile isolation.");
+    });
+    await attempt(async () => {
+        const documents = [
+            ...(await Promise.all(prepared.mcpConfigPaths.map(readJsonFile))),
+            ...prepared.inlineMcpConfigs.map((text) => {
+                try {
+                    return JSON.parse(text);
+                }
+                catch {
+                    fail("CONFIG_JSON_INVALID", "configuration", "An inline Agency MCP configuration is not valid JSON.", {}, 5);
+                }
+            }),
+        ];
+        for (const document of documents) {
+            for (const [name, value] of Object.entries(parseMcpDocument(document))) {
+                if (Object.hasOwn(incoming, name) &&
+                    JSON.stringify(incoming[name]) !== JSON.stringify(value))
+                    fail("MCP_MERGE_UNVERIFIED", "compatibility", "Multiple prepared sources define the same MCP differently. Agency must deliver one resolved result.", { component: name });
+                incoming[name] = value;
+            }
+        }
+        plan.mcpNames = Object.keys(incoming);
+        if (prepared.disabledMcpNames.length &&
+            (context.profileMode !== "profile-only" ||
+                prepared.disabledMcpNames.some((name) => Object.hasOwn(incoming, name))))
+            fail("MCP_DISABLE_UNVERIFIED", "compatibility", "The prepared Copilot server-disable policy cannot be silently applied to different Codex discovery sources.");
+        const mcp = planMcps(incoming, inspection.rootMcps, context.profileMode, context.options.conflictPolicy, context.cwd);
+        if (mcp.disabled.some((name) => isRecord(inspection.rootMcps[name]) &&
+            inspection.rootMcps[name].required === true))
+            fail("MCP_REQUIRED_CONFLICT", "compatibility", "A required Codex MCP server cannot be disabled by this session plan.");
+        if (mcp.disabled.length &&
+            (inspection.requirementsKnown === false ||
+                (inspection.requirements &&
+                    (inspection.requirements.mcp_servers !== undefined ||
+                        inspection.requirements.mcpServers !== undefined))))
+            fail("MCP_MANAGED_OVERRIDE_UNVERIFIED", "compatibility", "The requested replacement or isolation intersects managed MCP requirements.");
+        plan.overrides = mcp.overrides;
+        plan.expectedMcps = mcp.expected;
+        plan.mcpNames = mcp.names;
+        plan.reusedMcpNames = mcp.reused;
+        plan.disabledMcpNames = mcp.disabled;
+        plan.serverAliases = mcp.aliases;
+        plan.findings.push(...mcp.findings);
+    });
+    for (const root of prepared.pluginRoots) {
+        await attempt(async () => {
+            const spec = await inspectPlugin(root, prepared.selectedAgent, context.options.agentToolsPolicy);
+            specs.push(spec);
+            for (const name of spec.mcpNames)
+                if (!Object.hasOwn(incoming, name))
+                    fail("PLUGIN_MCP_FINAL_MISSING", "compatibility", "A required plugin MCP is absent from the Agency final result.", { component: spec.name, field: name });
+            for (const name of spec.requiredMcpNames)
+                if (!plan.mcpNames.includes(name) ||
+                    plan.serverAliases[name] !== undefined)
+                    fail("SKILL_DEPENDENCY_UNAVAILABLE", "compatibility", "A native skill dependency is absent or renamed; its structured reference requires a compatible resource view.", { component: spec.name, field: name });
+            try {
+                if (spec.agents.length)
+                    throw new AgencyxError({
+                        code: "PLUGIN_NOT_READY",
+                        stage: "compatibility",
+                        reason: "Plugin Markdown agents require native session role registration.",
+                    });
+                const binding = await bindNativePlugin(spec, inspection);
+                if (spec.manualInvocationSkills.length ||
+                    spec.nonUserInvocableSkills.length ||
+                    (spec.mcpNeedsAdapter &&
+                        (spec.skills.length > 0 ||
+                            spec.hooks.some((hook) => hook.count > 0))))
+                    throw new AgencyxError({
+                        code: "PLUGIN_NOT_READY",
+                        stage: "compatibility",
+                        component: spec.name,
+                        reason: "Skill invocation restrictions require a session compatibility view.",
+                    });
+                if (binding) {
+                    bindings.push(binding);
+                    plan.pluginIds.push(binding.native.id);
+                }
+                plan.findings.push(...spec.findings);
+            }
+            catch (error) {
+                if (!(error instanceof AgencyxError) ||
+                    error.diagnostic.code !== "PLUGIN_NOT_READY")
+                    throw error;
+                if (inspection.requirementsKnown === false ||
+                    (isRecord(inspection.config.features) &&
+                        inspection.config.features.plugins === false) ||
+                    inspection.requirements?.plugins !== undefined)
+                    fail("PLUGIN_POLICY_UNVERIFIED", "compatibility", "Plugin restrictions require a verified policy mapping before a skill-only resource view can be used.", { component: spec.name });
+                const view = await createSkillView(spec, context.sessionRoot, {
+                    allowHooks: true,
+                });
+                for (const skill of view.skills) {
+                    const collision = inspection.skills.some((existing) => existing.enabled &&
+                        existing.name === skill.name &&
+                        !(context.profileMode === "profile-only" &&
+                            existing.pluginId !== null));
+                    if (collision ||
+                        plan.skillViews.some((existing) => existing.skills.some((candidate) => candidate.name === skill.name)))
+                        fail("SKILL_CONFLICT", "compatibility", "An existing skill has the selected package's qualified name.", { component: skill.name });
+                }
+                plan.skillViews.push(view);
+                sessionPackages.push({
+                    spec,
+                    resourceRoot: path.join(view.root, "package"),
+                });
+                plan.findings.push(...spec.findings.filter((finding) => finding.field !== undefined));
+                plan.findings.push({
+                    component: `plugin:${spec.name}`,
+                    state: "adapted",
+                    path: spec.root,
+                    reason: "Required skills, supported agents and SessionStart hooks use complete session resources and native registration. MCP connections remain Agency-owned. Native discovery and hook trust are checked before launch.",
+                });
+            }
+        });
+    }
+    await attempt(async () => {
+        if (prepared.selectedAgent) {
+            const agents = specs.flatMap((spec) => spec.primaryAgentPath ? [spec.primaryAgentPath] : []);
+            if (agents.length !== 1)
+                fail("AGENT_RENDERED_FILE_MISSING", "compatibility", "The selected primary agent could not be matched to exactly one Agency-rendered file.");
+            additions.push(await adaptPrimaryAgent(agents[0], inspection.config, context.options.agentToolsPolicy));
+            plan.findings.push({
+                component: "primary-agent",
+                state: "adapted",
+                reason: "Agency-rendered instructions enter the developer instruction layer; all declared execution metadata was checked.",
+            });
+            if (context.options.agentToolsPolicy === "inherit")
+                plan.findings.push({
+                    component: "primary-agent",
+                    state: "adapted",
+                    field: "tools",
+                    reason: "Explicit inherited-tool mode does not apply the source tools allow-list. The primary agent uses native Codex permissions and tool access.",
+                });
+        }
+        additions.push(...(await collectInstructions(prepared.extraInstructionRoots)));
+        for (const spec of specs) {
+            if (spec.persona &&
+                !additions.some((text) => text.includes(spec.persona)) &&
+                !(typeof inspection.config.developer_instructions === "string" &&
+                    inspection.config.developer_instructions.includes(spec.persona))) {
+                additions.push(`Plugin ${JSON.stringify(spec.name)} instructions:\n${spec.persona}`);
+            }
+        }
+        plan.findings.push(...validateReadGrants(prepared.readGrants, inspection.config, inspection.requirements));
+        plan.overrides = mergedOverrides(plan.overrides, pluginOverrides(bindings, inspection, context.profileMode));
+        if (additions.length || Object.keys(plan.serverAliases).length) {
+            const combined = combineInstructions(inspection.config.developer_instructions, additions, plan.serverAliases);
+            if (combined !== undefined)
+                plan.developerInstructions = combined;
+            const additional = combineInstructions(undefined, additions, plan.serverAliases);
+            if (additional !== undefined)
+                plan.additionalDeveloperInstructions = additional;
+            plan.strategy = "app-server";
+            plan.reason =
+                "Additional Agency instructions require the authenticated thread configuration interface.";
+        }
+        if (plan.skillViews.length) {
+            plan.strategy = "app-server";
+            plan.reason =
+                "A validated cold skill bundle requires native skill roots in a private app-server.";
+        }
+        const agents = await prepareAgents(sessionPackages, context.sessionRoot, inspection, plan.developerInstructions);
+        plan.agents = agents.bindings;
+        plan.overrides = mergedOverrides(plan.overrides, agents.overrides);
+        const hooks = await prepareSessionHooks(sessionPackages, inspection);
+        plan.sessionHooks = hooks.bindings;
+        plan.overrides = mergedOverrides(plan.overrides, hooks.overrides);
+        if (agents.bindings.length || hooks.bindings.length) {
+            plan.strategy = "app-server";
+            plan.reason =
+                "Plugin agents and hooks require native session registration with retained resources.";
+        }
+        if (hooks.bindings.length && options.bypassHookTrust)
+            plan.findings.push({
+                component: "session-hooks",
+                state: "adapted",
+                field: "trust",
+                reason: "The user explicitly supplied native --dangerously-bypass-hook-trust for this invocation. Persistent trust records are not created by the wrapper.",
+            });
+        if (plan.strategy === "app-server") {
+            if (options.entry !== "interactive" ||
+                options.addDirs.length ||
+                options.nativeProfile)
+                fail("CODEX_SESSION_MODE_UNSUPPORTED", "compatibility", "This instruction-bearing plan requires a verified new interactive app-server session. Native exec, add-dir, and native profiles are not silently downgraded.");
+            if (!inspection.capabilities.remoteTui ||
+                !inspection.capabilities.websocketAuth)
+                fail("CODEX_REMOTE_UNSUPPORTED", "compatibility", "The installed Codex lacks the authenticated original-TUI handoff required by this plan.");
+        }
+        else if (!inspection.capabilities.noDaemon) {
+            fail("CODEX_ISOLATION_UNSUPPORTED", "compatibility", "The installed CLI lacks --no-daemon; private direct-session isolation is not verified for this version.");
+        }
+    });
+    return { plan, bindings };
+}
+export function verifyMcpOverrides(plan, inspection) {
+    for (const name of plan.mcpNames) {
+        if (!Object.hasOwn(inspection.rootMcps, name))
+            fail("MCP_OVERRIDE_REJECTED", "configuration", "Codex did not retain a planned MCP definition.", { component: name }, 5);
+        const expected = plan.expectedMcps?.[name];
+        if (expected !== undefined &&
+            !equivalentMcp(record(inspection.rootMcps[name], name), record(expected, name), plan.cwd))
+            fail("MCP_OVERRIDE_REJECTED", "configuration", "Codex changed the planned MCP connection or tool policy.", { component: name }, 5);
+    }
+    for (const name of plan.disabledMcpNames) {
+        if (record(inspection.rootMcps[name], name).enabled !== false)
+            fail("MCP_OVERRIDE_REJECTED", "configuration", "Codex did not disable an old MCP definition.", { component: name }, 5);
+    }
+}
+//# sourceMappingURL=plan.js.map

package/dist/bridge/version.js

@@ -0,0 +1,2 @@
+export const COPILOT_PROTOCOL_VERSION = "1.0.93";
+//# sourceMappingURL=version.js.map

package/dist/cli-options.js

@@ -0,0 +1,96 @@
+import { fail } from "./diagnostics.js";
+export function parseCommand(args) {
+    const first = args[0];
+    if (first === "--help" || first === "-h")
+        return { kind: "help" };
+    if (first === "--version" || first === "-V")
+        return { kind: "version" };
+    if (first === "__bridge")
+        return { kind: "bridge" };
+    if (first === "doctor") {
+        if (args.slice(1).some((arg) => arg !== "--json"))
+            fail("ARGUMENT_INVALID", "arguments", "Usage: agencyx doctor [--json]", {}, 2);
+        return { kind: "doctor", json: args.includes("--json") };
+    }
+    if (first !== "codex")
+        return {
+            kind: "passthrough",
+            args: args.slice(first === "agency" ? 1 : 0),
+        };
+    const rest = args.slice(1);
+    if (rest.length === 1 && (rest[0] === "--help" || rest[0] === "-h"))
+        return { kind: "help" };
+    const separator = rest.indexOf("--");
+    const before = separator < 0 ? rest : rest.slice(0, separator);
+    const codexArgs = separator < 0 ? [] : rest.slice(separator + 1);
+    const agencyArgs = [];
+    let dryRun = false;
+    let json = false;
+    let conflictPolicy = "error";
+    let agentToolsPolicy = "strict";
+    for (let i = 0; i < before.length; i++) {
+        const arg = before[i];
+        if (arg === "--dry-run")
+            dryRun = true;
+        else if (arg === "--json")
+            json = true;
+        else if (arg === "--mcp-conflict" || arg.startsWith("--mcp-conflict=")) {
+            const value = arg.includes("=")
+                ? arg.slice(arg.indexOf("=") + 1)
+                : before[++i];
+            if (value !== "error" && value !== "prefer-agency")
+                fail("ARGUMENT_INVALID", "arguments", "--mcp-conflict must be error or prefer-agency.", {}, 2);
+            conflictPolicy = value;
+        }
+        else if (arg === "--agent-tools" || arg.startsWith("--agent-tools=")) {
+            const value = arg.includes("=")
+                ? arg.slice(arg.indexOf("=") + 1)
+                : before[++i];
+            if (value !== "strict" && value !== "inherit")
+                fail("ARGUMENT_INVALID", "arguments", "--agent-tools must be strict or inherit.", {}, 2);
+            agentToolsPolicy = value;
+        }
+        else if (arg.startsWith("--dry-run=") || arg.startsWith("--json=")) {
+            fail("ARGUMENT_INVALID", "arguments", "--dry-run and --json do not take values.", {}, 2);
+        }
+        else if (arg === "--copilot-path" || arg.startsWith("--copilot-path=")) {
+            fail("ARGUMENT_INVALID", "arguments", "The wrapper owns the engine handoff path.", { field: "--copilot-path" }, 2);
+        }
+        else {
+            agencyArgs.push(arg);
+        }
+    }
+    if (json && !dryRun)
+        fail("ARGUMENT_INVALID", "arguments", "--json requires --dry-run for agencyx codex.", {}, 2);
+    return {
+        kind: "codex",
+        agencyArgs,
+        codexArgs,
+        dryRun,
+        json,
+        conflictPolicy,
+        agentToolsPolicy,
+    };
+}
+export const HELP = `agencyx: Agency configuration, Codex execution
+
+Usage:
+  agencyx codex [Agency options] [--dry-run [--json]] [-- Codex options]
+  agencyx doctor [--json]
+  agencyx agency <original Agency arguments>
+  agencyx <Agency command> [arguments]
+
+Examples:
+  agencyx config set --global --mcp kusto
+  agencyx codex --profile oncall
+  agencyx codex --mcp-conflict=prefer-agency -- --model MODEL
+  agencyx codex --agent-tools=inherit --mcp-conflict=prefer-agency
+  agencyx copilot
+
+Agency profiles go before --. Codex options go after --.
+Selected unsupported components stop the launch. No global Codex injection
+configuration is rewritten. Plugin cold installation is not automatic.
+--agent-tools=inherit registers supported plugin agents with native Codex tool
+permissions; source tools allow-lists are not applied in this explicit mode.
+`;
+//# sourceMappingURL=cli-options.js.map