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

package/dist/adapters/plugins.js

@@ -0,0 +1,484 @@
+import { readdir, realpath, stat } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { parseDocument } from "yaml";
+import { readJsonFile } from "../agency/prepared-input.js";
+import { fail } from "../diagnostics.js";
+import { readPluginAgent } from "./agent.js";
+import { assertKnownFields, isRecord, nonEmptyString, record, stringArray, } from "../validation.js";
+import { markdownDocument } from "./instructions.js";
+import { readTextFile } from "../agency/prepared-input.js";
+async function exists(file) {
+    try {
+        await stat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function componentPath(root, relative) {
+    if (path.isAbsolute(relative))
+        fail("PLUGIN_PATH_UNSUPPORTED", "compatibility", "Plugin component paths must be relative to the plugin root.", { path: root });
+    const resolvedRoot = await realpath(root);
+    const candidate = path.resolve(resolvedRoot, relative);
+    const actual = await realpath(candidate).catch(() => candidate);
+    const within = path.relative(resolvedRoot, actual);
+    if (within.startsWith(`..${path.sep}`) ||
+        within === ".." ||
+        path.isAbsolute(within))
+        fail("PLUGIN_PATH_UNSUPPORTED", "compatibility", "A plugin component escapes its package root.", { path: root });
+    return candidate;
+}
+function manifestPaths(value, fallback, component) {
+    if (value === undefined)
+        return [fallback];
+    return typeof value === "string" ? [value] : stringArray(value, component);
+}
+async function immediateFiles(root, extension) {
+    if (!(await exists(root)))
+        return [];
+    if ((await stat(root)).isFile())
+        return root.endsWith(extension) ? [root] : [];
+    return (await readdir(root, { withFileTypes: true }))
+        .filter((entry) => entry.isFile() && entry.name.endsWith(extension))
+        .map((entry) => path.join(root, entry.name))
+        .sort();
+}
+async function skillFiles(directory) {
+    if (!(await exists(directory)))
+        return [];
+    if ((await stat(directory)).isFile())
+        return path.basename(directory) === "SKILL.md" ? [directory] : [];
+    if (await exists(path.join(directory, "SKILL.md")))
+        return [path.join(directory, "SKILL.md")];
+    const files = [];
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        if (entry.isDirectory() &&
+            (await exists(path.join(directory, entry.name, "SKILL.md"))))
+            files.push(path.join(directory, entry.name, "SKILL.md"));
+    }
+    return files.sort();
+}
+export function validateSharedHooks(value, file) {
+    const document = record(value, "plugin hooks");
+    assertKnownFields(document, ["hooks"], "plugin hooks");
+    const events = record(document.hooks, "plugin hook events");
+    let count = 0;
+    for (const [event, matchers] of Object.entries(events)) {
+        if (event !== "SessionStart")
+            fail("HOOK_EVENT_UNVERIFIED", "compatibility", "Only the verified shared SessionStart command-hook contract is enabled. Other events require an equivalence test before use.", { path: file, field: event });
+        if (!Array.isArray(matchers))
+            fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "The hook event must contain native matcher groups.", { path: file });
+        for (const raw of matchers) {
+            const group = record(raw, "hook matcher");
+            assertKnownFields(group, ["matcher", "hooks"], "hook matcher");
+            if (group.matcher !== undefined && typeof group.matcher !== "string")
+                fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "A hook matcher must be a string.", { path: file });
+            if (!Array.isArray(group.hooks))
+                fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "A matcher group must contain hook handlers.", { path: file });
+            for (const raw of group.hooks) {
+                const handler = record(raw, "hook handler");
+                assertKnownFields(handler, [
+                    "type",
+                    "command",
+                    "command_windows",
+                    "powershell",
+                    "timeout",
+                    "async",
+                    "statusMessage",
+                    "additionalContextLimit",
+                ], "hook handler");
+                if (handler.type !== "command" ||
+                    typeof handler.command !== "string" ||
+                    !handler.command.trim())
+                    fail("HOOK_HANDLER_UNSUPPORTED", "compatibility", "Only native command hooks have a verified mapping.", { path: file });
+                if (handler.async === true)
+                    fail("HOOK_ASYNC_UNVERIFIED", "compatibility", "Asynchronous hook ordering has not been verified.", { path: file, field: "async" });
+                for (const field of ["powershell", "command_windows", "statusMessage"])
+                    if (handler[field] !== undefined &&
+                        typeof handler[field] !== "string")
+                        fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "Platform commands and status messages must be strings.", { path: file, field });
+                if (handler.powershell !== undefined &&
+                    handler.command_windows !== undefined &&
+                    handler.powershell !== handler.command_windows)
+                    fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "The hook declares conflicting Windows commands.", { path: file, field: "powershell" });
+                for (const field of ["timeout", "additionalContextLimit"])
+                    if (handler[field] !== undefined &&
+                        (!Number.isInteger(handler[field]) ||
+                            Number(handler[field]) < (field === "timeout" ? 1 : 0)))
+                        fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "Hook timing and context limits must be valid integers.", { path: file, field });
+                if (handler.async !== undefined && typeof handler.async !== "boolean")
+                    fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "The async hook field must be a boolean.", { path: file, field: "async" });
+                count++;
+            }
+        }
+    }
+    return count;
+}
+export async function inspectPlugin(root, selectedAgent, agentToolsPolicy = "strict") {
+    root = await realpath(root).catch(() => root);
+    const manifests = [
+        ".codex-plugin/plugin.json",
+        ".claude-plugin/plugin.json",
+        ".github/plugin/plugin.json",
+        "plugin.json",
+    ];
+    const availableManifests = (await Promise.all(manifests.map(async (relative) => ({
+        file: path.join(root, relative),
+        exists: await exists(path.join(root, relative)),
+    })))).filter((candidate) => candidate.exists);
+    const manifestFile = availableManifests[0]?.file;
+    if (!manifestFile)
+        fail("PLUGIN_MANIFEST_MISSING", "compatibility", "The prepared plugin has no supported manifest.", { path: root });
+    const manifest = record(await readJsonFile(manifestFile), "plugin manifest");
+    assertKnownFields(manifest, [
+        "name",
+        "version",
+        "description",
+        "author",
+        "homepage",
+        "repository",
+        "license",
+        "keywords",
+        "interface",
+        "displayName",
+        "skills",
+        "hooks",
+        "mcpServers",
+        "agents",
+        "commands",
+    ], "plugin manifest");
+    const name = nonEmptyString(manifest.name, "plugin name");
+    for (const candidate of availableManifests.slice(1)) {
+        const alternate = record(await readJsonFile(candidate.file), "plugin manifest");
+        for (const field of [
+            "name",
+            "skills",
+            "hooks",
+            "mcpServers",
+            "agents",
+            "commands",
+        ]) {
+            if (JSON.stringify(alternate[field]) !== JSON.stringify(manifest[field]))
+                fail("PLUGIN_MANIFEST_CONFLICT", "compatibility", "Engine-specific manifests declare different execution components. A verified compatibility view is required.", { path: candidate.file, field });
+        }
+    }
+    const spec = {
+        root,
+        name,
+        skills: [],
+        hooks: [],
+        mcpNames: [],
+        requiredMcpNames: [],
+        manualInvocationSkills: [],
+        nonUserInvocableSkills: [],
+        mcpFiles: [],
+        mcpNeedsAdapter: false,
+        findings: [],
+        agents: [],
+    };
+    for (const relative of manifestPaths(manifest.skills, "skills", "plugin skills")) {
+        const directory = await componentPath(root, relative);
+        if (manifest.skills !== undefined && !(await exists(directory)))
+            fail("PLUGIN_COMPONENT_MISSING", "compatibility", "A declared skill path does not exist.", { path: directory });
+        spec.skills.push(...(await skillFiles(directory)));
+    }
+    for (const file of spec.skills) {
+        const { metadata } = markdownDocument(await readTextFile(file), file);
+        assertKnownFields(metadata, [
+            "name",
+            "description",
+            "license",
+            "compatibility",
+            "metadata",
+            "disable-model-invocation",
+            "user-invocable",
+            "argument-hint",
+        ], "skill frontmatter", file);
+        nonEmptyString(metadata.name, "skill name");
+        nonEmptyString(metadata.description, "skill description");
+        if (metadata["user-invocable"] !== undefined &&
+            typeof metadata["user-invocable"] !== "boolean")
+            fail("SKILL_POLICY_INVALID", "configuration", "user-invocable must be a boolean.", { path: file, field: "user-invocable" }, 5);
+        if (metadata["user-invocable"] === false)
+            spec.nonUserInvocableSkills.push(file);
+        if (metadata["argument-hint"] !== undefined) {
+            if (typeof metadata["argument-hint"] !== "string")
+                fail("SKILL_METADATA_INVALID", "configuration", "argument-hint must be a string.", { path: file, field: "argument-hint" }, 5);
+            spec.findings.push({
+                component: `skill:${spec.name}:${String(metadata.name)}`,
+                state: "adapted",
+                path: file,
+                field: "argument-hint",
+                reason: "The argument hint is retained as display metadata. It adds no execution or permission requirement; the native CLI may omit the Copilot hint display.",
+            });
+        }
+        if (metadata["disable-model-invocation"] !== undefined &&
+            typeof metadata["disable-model-invocation"] !== "boolean")
+            fail("SKILL_POLICY_INVALID", "configuration", "disable-model-invocation must be a boolean.", { path: file }, 5);
+        let implicitAllowed;
+        if (metadata.compatibility !== undefined && metadata.compatibility !== "")
+            fail("SKILL_COMPATIBILITY_UNVERIFIED", "compatibility", "The skill declares runtime compatibility requirements without a verified adapter.", { path: file, field: "compatibility" });
+        const nativeMetadata = path.join(path.dirname(file), "agents", "openai.yaml");
+        if (await exists(nativeMetadata)) {
+            const document = parseDocument(await readTextFile(nativeMetadata), {
+                uniqueKeys: true,
+            });
+            if (document.errors.length)
+                fail("SKILL_METADATA_INVALID", "configuration", "Native skill metadata must be valid YAML.", { path: nativeMetadata }, 5);
+            let raw;
+            try {
+                raw = document.toJS({ maxAliasCount: 20 });
+            }
+            catch {
+                fail("SKILL_METADATA_INVALID", "configuration", "Native skill metadata contains excessive aliases.", { path: nativeMetadata }, 5);
+            }
+            const extra = record(raw, "native skill metadata");
+            assertKnownFields(extra, ["interface", "policy", "dependencies"], "native skill metadata");
+            if (extra.interface !== undefined)
+                assertKnownFields(record(extra.interface, "skill interface"), [
+                    "display_name",
+                    "short_description",
+                    "icon_small",
+                    "icon_large",
+                    "brand_color",
+                    "default_prompt",
+                ], "skill interface");
+            if (extra.policy !== undefined)
+                assertKnownFields(record(extra.policy, "skill policy"), ["allow_implicit_invocation"], "skill policy");
+            if (isRecord(extra.policy)) {
+                implicitAllowed = extra.policy.allow_implicit_invocation;
+                if (implicitAllowed !== undefined &&
+                    typeof implicitAllowed !== "boolean")
+                    fail("SKILL_POLICY_INVALID", "configuration", "Native implicit invocation policy must be a boolean.", { path: nativeMetadata }, 5);
+            }
+            if (extra.dependencies !== undefined) {
+                const dependencies = record(extra.dependencies, "skill dependencies");
+                assertKnownFields(dependencies, ["tools"], "skill dependencies");
+                if (!Array.isArray(dependencies.tools))
+                    fail("SKILL_DEPENDENCIES_UNVERIFIED", "compatibility", "Native skill dependencies must declare a tool list.", { path: nativeMetadata });
+                for (const raw of dependencies.tools) {
+                    const dependency = record(raw, "skill dependency");
+                    assertKnownFields(dependency, ["type", "value", "description", "transport", "url"], "skill dependency");
+                    if (dependency.type !== "mcp" ||
+                        typeof dependency.value !== "string" ||
+                        dependency.transport !== undefined ||
+                        dependency.url !== undefined)
+                        fail("SKILL_DEPENDENCIES_UNVERIFIED", "compatibility", "Only references to already selected MCP dependencies have a verified mapping.", { path: nativeMetadata });
+                    spec.requiredMcpNames.push(dependency.value);
+                }
+            }
+        }
+        if (metadata["disable-model-invocation"] === true &&
+            implicitAllowed !== false)
+            spec.manualInvocationSkills.push(file);
+    }
+    const agentFiles = [];
+    for (const relative of manifestPaths(manifest.agents, "agents", "plugin agents"))
+        agentFiles.push(...(await immediateFiles(await componentPath(root, relative), ".md")));
+    agentFiles.push(...(await immediateFiles(path.join(root, ".github", "agents"), ".md")));
+    const agentId = selectedAgent?.startsWith(`${name}:`)
+        ? selectedAgent.slice(name.length + 1)
+        : undefined;
+    if (agentId) {
+        const primary = agentFiles.find((file) => path.basename(file).replace(/(?:\.agent)?\.md$/, "") === agentId);
+        if (primary)
+            spec.primaryAgentPath = primary;
+    }
+    const unselectedAgents = agentFiles.filter((file) => file !== spec.primaryAgentPath);
+    if (unselectedAgents.length && agentToolsPolicy !== "inherit") {
+        const first = unselectedAgents[0];
+        const { metadata } = markdownDocument(await readTextFile(first), first);
+        const tools = metadata.tools === undefined
+            ? undefined
+            : typeof metadata.tools === "string"
+                ? metadata.tools.split(",").map((tool) => tool.trim())
+                : stringArray(metadata.tools, "plugin agent tools");
+        if (tools !== undefined && !(tools.length === 1 && tools[0] === "*"))
+            fail("PLUGIN_AGENT_TOOL_SCOPE_UNSUPPORTED", "compatibility", "The plugin agent declares a builtin-tool allow-list without an equivalent native policy. Use --agent-tools=inherit only to explicitly accept native Codex tool permissions instead.", { component: name, path: first, field: "tools" });
+        fail("PLUGIN_AGENT_UNSUPPORTED", "compatibility", "Plugin Markdown subagents are not registered as native Codex agents. The entire selected plugin is blocked.", { path: unselectedAgents[0] });
+    }
+    for (const file of unselectedAgents) {
+        const agent = await readPluginAgent(file);
+        if (spec.agents.some((existing) => existing.name === agent.name))
+            fail("AGENT_CONFLICT", "compatibility", "The plugin declares multiple agents with the same name.", { component: name, path: file });
+        spec.agents.push(agent);
+        spec.findings.push({
+            component: `agent:${name}:${agent.name}`,
+            state: "adapted",
+            path: file,
+            field: "tools",
+            reason: "Explicit inherited-tool mode retains the agent instructions and registers a native Codex role. The source tools allow-list is not applied; native Codex permissions, tool access and managed requirements remain in force.",
+        });
+    }
+    for (const relative of manifestPaths(manifest.commands, "commands", "plugin commands")) {
+        const files = await immediateFiles(await componentPath(root, relative), ".md");
+        if (files.length || manifest.commands !== undefined)
+            fail("PLUGIN_COMMAND_UNSUPPORTED", "compatibility", "Copilot/Claude command registration is not a verified Codex plugin contract.", { path: path.join(root, relative) });
+    }
+    const copilotHooks = path.join(root, ".github", "hooks");
+    if ((await immediateFiles(copilotHooks, ".json")).length)
+        fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "Copilot hook packages require a verified event and blocking-semantics adapter.", { path: copilotHooks });
+    const hookPaths = manifest.hooks === undefined
+        ? ["hooks/hooks.json"]
+        : typeof manifest.hooks === "string" || Array.isArray(manifest.hooks)
+            ? manifestPaths(manifest.hooks, "", "plugin hooks")
+            : [];
+    if (isRecord(manifest.hooks))
+        fail("HOOK_FORMAT_UNSUPPORTED", "compatibility", "Inline plugin hook manifests require a verified native loading path.", { path: manifestFile });
+    for (const relative of hookPaths) {
+        const file = await componentPath(root, relative);
+        if (await exists(file))
+            spec.hooks.push({
+                file,
+                count: validateSharedHooks(await readJsonFile(file), file),
+            });
+        else if (manifest.hooks !== undefined)
+            fail("PLUGIN_COMPONENT_MISSING", "compatibility", "A declared hook file does not exist.", { path: file });
+    }
+    const mcpFiles = manifest.mcpServers === undefined
+        ? [".mcp.json"]
+        : typeof manifest.mcpServers === "string"
+            ? [manifest.mcpServers]
+            : [];
+    if (manifest.mcpServers !== undefined &&
+        typeof manifest.mcpServers !== "string")
+        fail("PLUGIN_MCP_ADAPTER_REQUIRED", "compatibility", "Inline MCP manifests require a prepared native compatibility view.", { path: manifestFile });
+    for (const relative of mcpFiles) {
+        const file = await componentPath(root, relative);
+        if (!(await exists(file))) {
+            if (manifest.mcpServers !== undefined)
+                fail("PLUGIN_COMPONENT_MISSING", "compatibility", "A declared MCP file does not exist.", { path: file });
+            continue;
+        }
+        const document = record(await readJsonFile(file), "plugin MCP");
+        spec.mcpFiles.push(file);
+        const servers = isRecord(document.mcpServers)
+            ? document.mcpServers
+            : document;
+        for (const [serverName, raw] of Object.entries(servers)) {
+            const server = record(raw, "plugin MCP server");
+            assertKnownFields(server, [
+                "command",
+                "args",
+                "cwd",
+                "env",
+                "env_vars",
+                "url",
+                "type",
+                "tools",
+                "timeout",
+                "headers",
+                "oauthClientId",
+                "oauthPublicClient",
+                "oauthGrantType",
+            ], "plugin MCP server");
+            if ([
+                "type",
+                "tools",
+                "timeout",
+                "headers",
+                "oauthClientId",
+                "oauthPublicClient",
+                "oauthGrantType",
+            ].some((field) => server[field] !== undefined) ||
+                JSON.stringify(server).includes("${"))
+                spec.mcpNeedsAdapter = true;
+            spec.mcpNames.push(serverName);
+        }
+    }
+    const agencyFile = path.join(root, "agency.json");
+    if (await exists(agencyFile)) {
+        const metadata = record(await readJsonFile(agencyFile), "agency.json");
+        assertKnownFields(metadata, [
+            "mcpAuth",
+            "engines",
+            "platforms",
+            "category",
+            "authors",
+            "governance",
+            "persona",
+        ], "agency.json", agencyFile);
+        if (metadata.persona !== undefined) {
+            if (typeof metadata.persona !== "string")
+                fail("PLUGIN_PERSONA_INVALID", "configuration", "Plugin persona must be literal instruction text, not an execution or permission object.", { path: agencyFile, field: "persona" }, 5);
+            if (metadata.persona.trim()) {
+                spec.persona = metadata.persona;
+                spec.findings.push({
+                    component: `plugin:${name}`,
+                    state: "adapted",
+                    path: agencyFile,
+                    field: "persona",
+                    reason: "The declared plugin persona is retained as developer-level instruction text; it does not replace native system instructions or enforce tool permissions.",
+                });
+            }
+        }
+        if (metadata.engines !== undefined) {
+            const engines = stringArray(metadata.engines, "agency.json.engines");
+            if (engines.length &&
+                !engines.includes("*") &&
+                !engines.includes("codex") &&
+                !engines.includes("copilot"))
+                fail("PLUGIN_ENGINE_UNSUPPORTED", "compatibility", "The plugin excludes both Codex and Agency's Copilot preparation path. No compatible source-engine preparation was verified.", { path: agencyFile, field: "engines" });
+            if (engines.includes("copilot") &&
+                !engines.includes("codex") &&
+                !engines.includes("*"))
+                spec.findings.push({
+                    component: `plugin:${name}`,
+                    state: "adapted",
+                    path: agencyFile,
+                    field: "engines",
+                    reason: "Agency selected this package through its Copilot preparation path. Codex compatibility is validated for every handed-off component instead of requiring an upstream Codex engine label.",
+                });
+        }
+        if (metadata.platforms !== undefined) {
+            const platforms = stringArray(metadata.platforms, "agency.json.platforms");
+            const current = process.platform === "win32"
+                ? "windows"
+                : process.platform === "darwin"
+                    ? "macos"
+                    : process.platform;
+            if (platforms.length &&
+                !platforms.includes("*") &&
+                !platforms.includes(current))
+                fail("PLUGIN_PLATFORM_UNSUPPORTED", "compatibility", "The plugin excludes the current platform.", { path: agencyFile, field: "platforms" });
+        }
+    }
+    spec.findings.push({
+        component: `plugin:${name}`,
+        state: "native",
+        path: root,
+        reason: "Every declared and default-discoverable component passed the supported format checks. Native runtime readiness is checked separately.",
+    });
+    return spec;
+}
+export async function packageFingerprint(root) {
+    const hash = createHash("sha256");
+    let files = 0;
+    const visit = async (directory) => {
+        for (const entry of (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name, "en"))) {
+            if (entry.name === ".git")
+                continue;
+            const file = path.join(directory, entry.name);
+            if (++files > 20_000)
+                fail("PLUGIN_SIZE_LIMIT", "compatibility", "The plugin exceeds the supported file count.", { path: root });
+            if (entry.isSymbolicLink())
+                fail("PLUGIN_PATH_UNSUPPORTED", "compatibility", "Native cache equivalence for symbolic plugin resources has not been verified.", { path: file });
+            if (entry.isDirectory())
+                await visit(file);
+            else if (entry.isFile()) {
+                hash.update(`${path.relative(root, file).split(path.sep).join("/")}\0`);
+                if (process.platform !== "win32")
+                    hash.update(`${(await stat(file)).mode & 0o111}\0`);
+                for await (const chunk of createReadStream(file))
+                    hash.update(chunk);
+                hash.update("\0");
+            }
+        }
+    };
+    await visit(root);
+    return hash.digest("hex");
+}
+//# sourceMappingURL=plugins.js.map

package/dist/agency/invocation.js

@@ -0,0 +1,97 @@
+import path from "node:path";
+import { captureProcess } from "../runtime/process.js";
+import { fail } from "../diagnostics.js";
+import { isRecord } from "../validation.js";
+const UNSUPPORTED = [
+    "--keep-alive",
+    "--session-manager",
+    "--generate-result",
+    "--result-type",
+    "--use-custom-provider",
+    "--resume",
+    "--continue",
+    "--ui-server",
+    "--server",
+    "--headless",
+    "--acp",
+];
+export function agencyEnvironment(env) {
+    const inherited = Object.fromEntries(Object.entries(env).filter(([key]) => !key.toUpperCase().startsWith("AGENCYX_")));
+    return {
+        ...inherited,
+        AGENCY_FORCE_PLUGIN_DIR: "1",
+        AGENCY_SESSION_CATEGORIZATION_DISABLED: "1",
+        AGENCY_PROMPT_CATEGORIZATION_DISABLED: "1",
+        AGENCY_SESSION_ANALYSIS_DISABLED: "1",
+    };
+}
+export function validateAgencyOptions(args) {
+    for (const arg of args) {
+        const flag = arg.split("=", 1)[0];
+        if (UNSUPPORTED.includes(flag))
+            fail("AGENCY_FEATURE_UNSUPPORTED", "arguments", "This option depends on Copilot session or execution behavior. Use agencyx agency for the original command.", { field: flag }, 2);
+    }
+}
+export function explicitProfileMode(args) {
+    const merged = args.some((arg) => arg === "--profile" || arg.startsWith("--profile="));
+    const isolated = args.some((arg) => arg === "--profile-only" || arg.startsWith("--profile-only="));
+    if (merged && isolated)
+        fail("ARGUMENT_INVALID", "arguments", "--profile and --profile-only are mutually exclusive.", {}, 2);
+    if (isolated)
+        return "profile-only";
+    if (merged || args.includes("--no-workspace-profile"))
+        return "merged";
+    return undefined;
+}
+export async function resolveProfileMode(agencyPath, args, cwd, env) {
+    const explicit = explicitProfileMode(args);
+    if (explicit)
+        return explicit;
+    // These releases apply persistent workspace selection only under this official switch.
+    // The actual profile contents and merge remain entirely inside Agency.
+    if (!["1", "true", "yes"].includes((env.AGENCY_USE_WORKSPACE_SETTINGS ?? "").toLowerCase()))
+        return "merged";
+    const result = await captureProcess(agencyPath, ["config", "profile-selection", "get", "--json"], { cwd, env });
+    if (result.code !== 0)
+        return "unknown";
+    let selection;
+    try {
+        selection = JSON.parse(result.stdout);
+    }
+    catch {
+        return "unknown";
+    }
+    if (selection === null)
+        return "merged";
+    if (!isRecord(selection) || typeof selection.name !== "string")
+        return "unknown";
+    const profiles = await captureProcess(agencyPath, ["config", "profiles", "--json"], { cwd, env });
+    if (profiles.code !== 0)
+        return "unknown";
+    let names;
+    try {
+        names = JSON.parse(profiles.stdout);
+    }
+    catch {
+        return "unknown";
+    }
+    if (!Array.isArray(names))
+        return "unknown";
+    // Agency falls back to its default when a stored selection no longer exists.
+    if (!names.some((item) => isRecord(item) && item.name === selection.name))
+        return "merged";
+    if (selection.mode === "profile-only")
+        return "profile-only";
+    if (selection.mode === "profile")
+        return "merged";
+    return "unknown";
+}
+export function agencyArguments(launcherPath, originalArgs) {
+    return [
+        "copilot",
+        "--copilot-path",
+        path.resolve(launcherPath),
+        ...originalArgs,
+    ];
+}
+//# sourceMappingURL=invocation.js.map