@xenosystem/acp-agent 0.1.1

package/dist/cli.js

@@ -0,0 +1,1059 @@
+#!/usr/bin/env node
+/**
+ * xeno-acp-agent CLI.
+ *
+ * Commands:
+ *   xeno-acp-agent --version
+ *   xeno-acp-agent check                      # lists providers + safety (human-readable)
+ *   xeno-acp-agent agent --provider fixture [--delay-ms N] [--fail] [--stderr-test]
+ *
+ * stdout contract: `--version`/`check`/`--help` are NON-ACP and print human text. `agent` is
+ * ACP mode → stdout is JSON-RPC ONLY; all diagnostics go to stderr. Provider selection goes
+ * through the registry; an unknown or not-implemented provider fails safely (never falls back
+ * to fixture).
+ */
+import process from "node:process";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { startAcpAgent } from "./acpAgentServer.js";
+import { createDefaultRegistry } from "./providers/providerRegistry.js";
+import { ProviderError } from "./providers/providerErrors.js";
+import { buildProviderDiagnostic } from "./security/securityDiagnostics.js";
+import { loadProviderPolicyConfig, getPolicyEntry } from "./config/providerPolicyConfig.js";
+import { ProviderApprovalStore, createApprovalRecord } from "./config/providerApprovalStore.js";
+import { resolveProviderStatus, approvalDecisionsFor } from "./config/providerRunnability.js";
+import { buildPolicyReview } from "./config/providerPolicyDiagnostics.js";
+import { buildSecretBindingReview } from "./security/secretBinding.js";
+import { buildProviderDiscoverySummary } from "./providers/providerDiscovery.js";
+import { discoverCodexCliModels } from "./providers/codexModelCatalog.js";
+import { enforcementSummaryLines, minimalSupervisorEnforcement } from "./process/providerProcessDiagnostics.js";
+import { emitXenoLocalStream, XENO_LOCAL_ID } from "./providers/xenoLocalProvider.js";
+import { CLAUDE_LOCAL_ENV_ALLOWLIST_KEYS } from "./providers/claudeLocalProvider.js";
+import { CODEX_LOCAL_DEFAULT_EXECUTABLE, CODEX_LOCAL_ENV_ALLOWLIST_KEYS, CODEX_LOCAL_ID, } from "./providers/codexLocalProvider.js";
+import { AGENT_NAME, VERSION } from "./version.js";
+import { logStderr } from "./stdioJsonRpc.js";
+function approvalStorePath(flagStore) {
+    return flagStore ?? process.env.XENO_ACP_APPROVALS_FILE ?? join(process.cwd(), ".xeno-acp", "approvals.json");
+}
+/**
+ * Minimal, NON-SECRET env a real local-adapter CLI needs for ITS OWN local auth + execution
+ * (XACP-021/022). The supervisor uses a clean allowlist (no ambient inheritance); this forwards
+ * only these documented keys so e.g. the Claude CLI can find its own local session. It NEVER
+ * includes `CLAUDECODE` (nested-session guard) or any `*_API_KEY`/`*_TOKEN`/`*_SECRET`.
+ */
+function minimalNonSecretProviderEnv(keys) {
+    const out = {};
+    for (const k of keys) {
+        const v = process.env[k];
+        if (v)
+            out[k] = v;
+    }
+    return out;
+}
+function providerEnvKeysFor(providerId) {
+    if (providerId === "claude-local")
+        return CLAUDE_LOCAL_ENV_ALLOWLIST_KEYS;
+    if (providerId === "codex-local")
+        return CODEX_LOCAL_ENV_ALLOWLIST_KEYS;
+    return [];
+}
+function payloadString(payload, key) {
+    if (typeof payload !== "object" || payload === null)
+        return "";
+    const value = payload[key];
+    return typeof value === "string" ? value : "";
+}
+function messageTextFrom(events) {
+    return events
+        .filter((event) => event.kind === "message_delta")
+        .map((event) => payloadString(event.payload, "text"))
+        .join("");
+}
+function formatUsage(usage) {
+    if (!usage)
+        return undefined;
+    return `input=${usage.inputTokens ?? "?"} output=${usage.outputTokens ?? "?"} total=${usage.totalTokens ?? "?"}`;
+}
+function flagValue(args, name) {
+    const i = args.indexOf(name);
+    if (i !== -1 && i + 1 < args.length)
+        return args[i + 1];
+    const eq = args.find((a) => a.startsWith(`${name}=`));
+    return eq ? eq.slice(name.length + 1) : undefined;
+}
+function flagValues(args, name) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === name && i + 1 < args.length)
+            out.push(args[++i]);
+        else if (a.startsWith(`${name}=`))
+            out.push(a.slice(name.length + 1));
+    }
+    return out;
+}
+function stripColorFlags(args) {
+    const out = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--no-color" || a.startsWith("--color="))
+            continue;
+        if (a === "--color") {
+            if (i + 1 < args.length && !args[i + 1].startsWith("-"))
+                i++;
+            continue;
+        }
+        out.push(a);
+    }
+    return out;
+}
+function usage() {
+    return [
+        `${AGENT_NAME} ${VERSION} — XENO-owned ACP agent-side endpoint`,
+        "",
+        "Usage:",
+        "  xeno-acp-agent --version",
+        "  xeno-acp-agent check [--config <p>] [--store <p>] [--json]",
+        "  xeno-acp-agent doctor [--config <p>] [--store <p>] [--json]",
+        "  xeno-acp-agent support-bundle [--config <p>] [--store <p>] [--provider <id>]",
+        "  xeno-acp-agent certify --provider <id> [--config <p>] [--store <p>] [--json]",
+        "  xeno-acp-agent process check",
+        "  xeno-acp-agent providers list [--config <p>] [--store <p>] [--json]",
+        "  xeno-acp-agent providers setup --provider <id> [--config <p>] [--store <p>] [--json]",
+        "  xeno-acp-agent providers review --provider <id> [--config <p>] [--store <p>]",
+        "  xeno-acp-agent providers models --provider <id> [--config <p>] [--store <p>] --json",
+        "  xeno-acp-agent providers approve --provider <id> (--dry-run|--yes|--interactive) [--config <p>] [--store <p>] [--json]",
+        "  xeno-acp-agent providers approvals [--config <p>] [--store <p>] [--json]",
+        "  xeno-acp-agent providers revoke --provider <id> --yes [--config <p>] [--store <p>] [--json]",
+        "  xeno-acp-agent providers test --provider <id> [--config <p>] [--store <p>] [--prompt <text>] [--json]",
+        "  xeno-acp-agent providers diagnose --provider <id> [--config <p>] [--store <p>] [--bind REF=kind:alias] [--json]",
+        "  xeno-acp-agent providers secrets --provider <id> [--bind REF=kind:alias]",
+        "  xeno-acp-agent adapter --provider xeno-local [--mode normal] [--request-id ID]",
+        "  xeno-acp-agent agent --provider fixture [--delay-ms N] [--fail] [--stderr-test]",
+        "  xeno-acp-agent agent --provider xeno-local --provider-policy <p> --provider-approvals <p>",
+        "",
+        "Notes:",
+        "  'agent' speaks ACP v1 (JSON-RPC 2.0) over stdio. In that mode stdout is JSON-RPC ONLY.",
+        "  Output is plain text by default; --no-color and --color=never are accepted as no-ops.",
+        "  Runnable providers: 'fixture'; 'xeno-local', 'claude-local', and 'codex-local' after policy + approval.",
+        "  Gemini/OpenCode/Kimi/GLM/Hermes remain blocked placeholders until scoped provider milestones.",
+        "",
+    ].join("\n");
+}
+function parseAgentArgs(rest) {
+    const out = { fail: false, stderrTest: false };
+    for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a === "--provider")
+            out.provider = rest[++i];
+        else if (a.startsWith("--provider="))
+            out.provider = a.slice("--provider=".length);
+        else if (a === "--delay-ms")
+            out.delayMs = Number(rest[++i]);
+        else if (a.startsWith("--delay-ms="))
+            out.delayMs = Number(a.slice("--delay-ms=".length));
+        else if (a === "--fail")
+            out.fail = true;
+        else if (a === "--stderr-test")
+            out.stderrTest = true;
+        else if (a === "--provider-policy")
+            out.providerPolicy = rest[++i];
+        else if (a.startsWith("--provider-policy="))
+            out.providerPolicy = a.slice("--provider-policy=".length);
+        else if (a === "--provider-approvals")
+            out.providerApprovals = rest[++i];
+        else if (a.startsWith("--provider-approvals="))
+            out.providerApprovals = a.slice("--provider-approvals=".length);
+        else if (a === "--mode")
+            out.mode = rest[++i];
+        else if (a.startsWith("--mode="))
+            out.mode = a.slice("--mode=".length);
+        else if (a === "--malformed-output-test") {
+            /* reserved self-test flag; no-op */
+        }
+        else {
+            logStderr(`ignoring unknown agent flag: ${a}`);
+        }
+    }
+    return out;
+}
+function nodeMajor() {
+    return Number(process.versions.node.split(".")[0] ?? "0");
+}
+async function confirmProviderApproval(providerId) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        const answer = await rl.question(`Approve provider '${providerId}'? Type '${providerId}' to confirm: `);
+        return answer.trim() === providerId;
+    }
+    finally {
+        rl.close();
+    }
+}
+function runCheck(rest = []) {
+    const configAware = rest.includes("--json")
+        || rest.some((a) => a === "--config" || a.startsWith("--config=") || a === "--store" || a.startsWith("--store="));
+    if (configAware) {
+        const ctx = buildDoctorContext(flagValue(rest, "--config"), flagValue(rest, "--store"));
+        const out = { command: "check", ...ctx.report };
+        if (rest.includes("--json")) {
+            process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+        }
+        else {
+            process.stdout.write([
+                `check: ${ctx.ready ? "ready" : "attention"}`,
+                `node: ${ctx.report.node.version} ${ctx.report.node.ok ? "ok" : "requires Node >= 20"}`,
+                `config: ${ctx.report.config.source ?? "none"} ${ctx.report.config.ok ? "ok" : "INVALID"}`,
+                `providers: runnable=${ctx.report.providers.filter((p) => p.runnable).length} total=${ctx.report.providers.length}`,
+                ...ctx.report.providers.map((p) => `  - ${p.id} status=${p.status} runnable=${p.runnable} approval=${p.approval}`),
+                `process: platform=${ctx.report.process.platform} network=${ctx.report.process.enforcement.network} filesystem=${ctx.report.process.enforcement.filesystem}`,
+            ].join("\n") + "\n");
+        }
+        if (!ctx.ready)
+            process.exitCode = 1;
+        return;
+    }
+    const registry = createDefaultRegistry();
+    const ok = nodeMajor() >= 20;
+    const lines = [
+        `${AGENT_NAME} ${VERSION}`,
+        `node: ${process.version}`,
+        `acp protocol: v1`,
+        `transport: JSON-RPC 2.0 over stdio`,
+        `status: ${ok ? "ready" : "requires Node >= 20"}`,
+        ``,
+        `providers:`,
+    ];
+    for (const def of registry.list()) {
+        const diag = buildProviderDiagnostic(def);
+        const tag = registry.isRunnable(def.id) ? "[runnable]" : "[blocked] ";
+        lines.push(`  - ${def.id.padEnd(10)} ${tag} trust=${diag.trustClass} safety=${diag.safety.overall} (${diag.safety.reason})`);
+        // Secret REFERENCE ids only (never values); allowed egress hosts. No credentials printed.
+        if (diag.secretRefs.length) {
+            lines.push(`      secret-refs: ${diag.secretRefs.map((r) => r.id).join(", ")}`);
+        }
+        if (diag.allowedHosts.length) {
+            lines.push(`      egress-allowlist: ${diag.allowedHosts.join(", ")}`);
+        }
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+    if (!ok)
+        process.exitCode = 1;
+}
+function buildDoctorContext(configPath, storePathArg) {
+    const cfg = loadProviderPolicyConfig(configPath ? { path: configPath } : {});
+    const store = new ProviderApprovalStore(approvalStorePath(storePathArg));
+    const registry = createDefaultRegistry();
+    const nodeOk = nodeMajor() >= 20;
+    const providers = registry.list().map((def) => {
+        const policyEntry = getPolicyEntry(cfg.config, def.id);
+        const approval = store.get(def.id);
+        const s = resolveProviderStatus(def, {
+            ...(policyEntry ? { policyEntry } : {}),
+            ...(approval ? { approval } : {}),
+            policyInvalid: !cfg.ok,
+        });
+        const discovery = buildProviderDiscoverySummary(def, s);
+        return {
+            id: def.id,
+            displayName: discovery.displayName,
+            implemented: def.enabled,
+            status: s.status,
+            runnable: s.runnable,
+            approval: approval ? "present" : "missing",
+            modelDiscovery: {
+                status: discovery.modelDiscovery.status,
+                defaultModelId: discovery.modelDiscovery.defaultModelId,
+                modelCount: discovery.modelDiscovery.models.length,
+                allowCustomModel: discovery.modelDiscovery.allowCustomModel,
+            },
+            versionReadiness: discovery.versionReadiness,
+            streaming: discovery.streaming,
+        };
+    });
+    const ready = nodeOk && cfg.ok;
+    const processInfo = { platform: process.platform, enforcement: minimalSupervisorEnforcement() };
+    const report = {
+        status: ready ? "ready" : "attention",
+        node: { version: process.version, ok: nodeOk },
+        config: { source: cfg.source ?? null, ok: cfg.ok, errors: cfg.errors },
+        approvalStore: { repaired: store.repaired, count: store.list().length },
+        providers,
+        process: processInfo,
+    };
+    return { cfg, store, registry, ready, report };
+}
+function runDoctor(rest) {
+    const ctx = buildDoctorContext(flagValue(rest, "--config"), flagValue(rest, "--store"));
+    if (rest.includes("--json")) {
+        process.stdout.write(JSON.stringify(ctx.report, null, 2) + "\n");
+    }
+    else {
+        process.stdout.write([
+            `doctor: ${ctx.ready ? "ready" : "attention"}`,
+            `node: ${ctx.report.node.version} ${ctx.report.node.ok ? "ok" : "requires Node >= 20"}`,
+            `config: ${ctx.report.config.source ?? "none"} ${ctx.report.config.ok ? "ok" : "INVALID"}`,
+            `providers: runnable=${ctx.report.providers.filter((p) => p.runnable).length} total=${ctx.report.providers.length}`,
+            ...ctx.report.providers.map((p) => `  - ${p.id} status=${p.status} runnable=${p.runnable} approval=${p.approval}`),
+            `process: platform=${ctx.report.process.platform} network=${ctx.report.process.enforcement.network} filesystem=${ctx.report.process.enforcement.filesystem}`,
+        ].join("\n") + "\n");
+    }
+    if (!ctx.ready)
+        process.exitCode = 1;
+}
+function runSupportBundle(rest) {
+    const ctx = buildDoctorContext(flagValue(rest, "--config"), flagValue(rest, "--store"));
+    const provider = flagValue(rest, "--provider");
+    const defs = provider ? [ctx.registry.get(provider)] : ctx.registry.list();
+    if (provider && !defs[0])
+        return failProviders(`unknown provider: ${provider}`);
+    const generatedAt = new Date().toISOString();
+    const providers = defs.map((def) => {
+        const policyEntry = getPolicyEntry(ctx.cfg.config, def.id);
+        const approval = ctx.store.get(def.id);
+        const input = {
+            ...(policyEntry ? { policyEntry } : {}),
+            ...(approval ? { approval } : {}),
+            policyInvalid: !ctx.cfg.ok,
+        };
+        const status = resolveProviderStatus(def, input);
+        const discovery = buildProviderDiscoverySummary(def, status);
+        const refs = policyEntry?.auth.allowedSecretRefs ?? def.authPolicy?.allowedSecretRefs ?? [];
+        const binding = buildSecretBindingReview(def.id, refs, []);
+        return {
+            providerId: def.id,
+            displayName: discovery.displayName,
+            runnability: {
+                status: status.status,
+                runnable: status.runnable,
+                reason: status.reason,
+                safeMessage: status.safeMessage,
+            },
+            modelDiscovery: discovery.modelDiscovery,
+            versionReadiness: discovery.versionReadiness,
+            streaming: discovery.streaming,
+            setupHints: discovery.setupHints,
+            policyReview: buildPolicyReview(def, input),
+            secretBinding: {
+                requiredRefs: binding.requiredRefs,
+                optionalRefs: binding.optionalRefs,
+                missingRequiredRefs: binding.missingRequiredRefs,
+                errors: binding.errors,
+                complete: binding.complete,
+                bindingCount: binding.bindings.length,
+                valuePolicy: binding.valuePolicy,
+            },
+        };
+    });
+    const auditTimeline = [
+        {
+            sequence: 1,
+            at: generatedAt,
+            event: "support_bundle.generated",
+            status: "ok",
+            safeMessage: "redacted support bundle generated",
+        },
+        {
+            sequence: 2,
+            at: generatedAt,
+            event: "config.evaluated",
+            status: ctx.cfg.ok ? "ok" : "invalid",
+            safeMessage: ctx.cfg.ok ? "provider policy config loaded" : "provider policy config invalid",
+        },
+        {
+            sequence: 3,
+            at: generatedAt,
+            event: "doctor.evaluated",
+            status: ctx.ready ? "ready" : "attention",
+            safeMessage: ctx.ready ? "local doctor checks passed" : "local doctor checks need attention",
+        },
+        ...providers.map((p, i) => ({
+            sequence: i + 4,
+            at: generatedAt,
+            event: "provider.runnability.evaluated",
+            providerId: p.providerId,
+            status: p.runnability.status,
+            safeMessage: p.runnability.safeMessage,
+        })),
+    ];
+    process.stdout.write(JSON.stringify({
+        bundleVersion: 1,
+        generatedAt,
+        command: "support-bundle",
+        redaction: {
+            policy: "metadata_only_no_secret_values_no_env_values_no_logs",
+            note: "Secret refs and env key names may appear; values, credential paths, and recent logs are not included.",
+        },
+        doctor: ctx.report,
+        providers,
+        auditTimeline,
+    }, null, 2) + "\n");
+    if (!ctx.ready)
+        process.exitCode = 1;
+}
+const HUB_REPO_NAME = "xeno" + "-hub";
+const HUB_CONFIG_PREFIX = `docs/${HUB_REPO_NAME}`;
+const HUB_CONFIG_PLACEHOLDER = `<${HUB_REPO_NAME}-config.json>`;
+const HUB_CONFIG_EXAMPLES = {
+    fixture: `${HUB_CONFIG_PREFIX}-agent-endpoint-config.example.json`,
+    "xeno-local": `${HUB_CONFIG_PREFIX}-xeno-local-provider-config.example.json`,
+    "claude-local": `${HUB_CONFIG_PREFIX}-claude-local-provider-config.example.json`,
+    "codex-local": `${HUB_CONFIG_PREFIX}-codex-local-provider-config.example.json`,
+};
+function runCertify(rest) {
+    const provider = flagValue(rest, "--provider");
+    const configPath = flagValue(rest, "--config");
+    const storePath = flagValue(rest, "--store");
+    const json = rest.includes("--json");
+    const ctx = buildDoctorContext(configPath, storePath);
+    if (!provider)
+        return failProviders("certify requires --provider <id>");
+    const def = ctx.registry.get(provider);
+    if (!def)
+        return failProviders(`unknown provider: ${provider}`);
+    const policyEntry = getPolicyEntry(ctx.cfg.config, def.id);
+    const approval = ctx.store.get(def.id);
+    const runnability = {
+        ...(policyEntry ? { policyEntry } : {}),
+        ...(approval ? { approval } : {}),
+        policyInvalid: !ctx.cfg.ok,
+    };
+    const status = resolveProviderStatus(def, runnability);
+    const discovery = buildProviderDiscoverySummary(def, status);
+    const preflightStatus = ctx.ready && status.runnable ? "ready_for_hub_handoff" : "blocked";
+    const agentCommand = [
+        "node",
+        "packages/agent/dist/cli.js",
+        "agent",
+        "--provider",
+        def.id,
+        ...(configPath ? ["--provider-policy", configPath] : []),
+        ...(storePath ? ["--provider-approvals", storePath] : []),
+    ];
+    const out = {
+        command: "certify",
+        mode: "local_preflight_only",
+        providerId: def.id,
+        displayName: discovery.displayName,
+        preflightStatus,
+        hubCertification: "not_run_by_this_command",
+        config: { source: ctx.cfg.source ?? null, ok: ctx.cfg.ok, errors: ctx.cfg.errors },
+        runnability: {
+            status: status.status,
+            runnable: status.runnable,
+            reason: status.reason,
+            safeMessage: status.safeMessage,
+        },
+        modelDiscovery: discovery.modelDiscovery,
+        versionReadiness: discovery.versionReadiness,
+        streaming: discovery.streaming,
+        setupHints: discovery.setupHints,
+        approval: approval ? "present" : "missing",
+        agentCommand,
+        hubHandoff: {
+            runFrom: HUB_REPO_NAME,
+            script: `node scripts/agent-acp-external-certify.mjs --config ${HUB_CONFIG_PLACEHOLDER}`,
+            configExample: HUB_CONFIG_EXAMPLES[def.id] ?? null,
+            note: "This command does not certify; the XENO Hub certification harness must run separately.",
+        },
+        claimPolicy: {
+            notOfficialProviderAcp: true,
+            notProductionReady: true,
+            noBroadThirdPartyCertificationClaim: true,
+        },
+    };
+    if (json) {
+        process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+    }
+    else {
+        process.stdout.write([
+            `certify preflight: ${def.id}`,
+            `status: ${preflightStatus}`,
+            `hub certification: not run by this command`,
+            `config: ${ctx.cfg.source ?? "none"} ${ctx.cfg.ok ? "ok" : "INVALID"}`,
+            `provider: ${status.status} runnable=${status.runnable}`,
+            `agent command: ${agentCommand.join(" ")}`,
+            `hub handoff: run from ${out.hubHandoff.runFrom}: ${out.hubHandoff.script}`,
+            ...(out.hubHandoff.configExample ? [`hub config example: ${out.hubHandoff.configExample}`] : []),
+            `claim policy: no official-provider, broad-third-party, or production-ready claim`,
+            ...(status.runnable ? [] : [`next: ${status.safeMessage}`]),
+        ].join("\n") + "\n");
+    }
+    if (preflightStatus !== "ready_for_hub_handoff")
+        process.exitCode = 1;
+}
+function runAgent(rest) {
+    const args = parseAgentArgs(rest);
+    if (!args.provider) {
+        failCli("AGENT_CONFIG_ERROR", "missing required --provider (e.g. --provider fixture)");
+        return;
+    }
+    const registry = createDefaultRegistry();
+    const def = registry.get(args.provider);
+    if (!def) {
+        failCli("AGENT_UNKNOWN_PROVIDER", `unknown provider: ${args.provider}. Run 'providers list' to see providers.`);
+        return;
+    }
+    // Gate via definition + policy config + approvals (read-only here). Local-only store paths may
+    // be supplied for test/dev isolation (never a default user-home write).
+    const cfg = loadProviderPolicyConfig(args.providerPolicy ? { path: args.providerPolicy } : {});
+    const store = new ProviderApprovalStore(approvalStorePath(args.providerApprovals));
+    const policyEntry = getPolicyEntry(cfg.config, def.id);
+    const approval = store.get(def.id);
+    const sandboxInputs = {
+        ...(policyEntry ? { policyEntry } : {}),
+        ...(approval ? { approval } : {}),
+        policyInvalid: !cfg.ok,
+    };
+    const status = resolveProviderStatus(def, sandboxInputs);
+    if (!status.runnable) {
+        failCli("AGENT_PROVIDER_NOT_RUNNABLE", `provider '${args.provider}' is not runnable (${status.status}). Runnable providers today: 'fixture'; local adapters with current policy + approval.`);
+        return;
+    }
+    // A real local-adapter CLI that needs auth/network (e.g. claude-local) gets the minimal
+    // non-secret env so it can use its OWN local auth; the supervisor forwards nothing else.
+    const providerEnvKeys = providerEnvKeysFor(def.id);
+    const needsProviderEnv = providerEnvKeys.length > 0;
+    let runtime;
+    try {
+        runtime = registry.createRuntime(args.provider, {
+            options: {
+                ...(args.delayMs !== undefined ? { delayMs: args.delayMs } : {}),
+                fail: args.fail,
+                stderrTest: args.stderrTest,
+                // xeno-local / claude-local re-verify runnability inside the harness and select their mode.
+                runnability: sandboxInputs,
+                ...(needsProviderEnv ? { envAllowlist: minimalNonSecretProviderEnv(providerEnvKeys) } : {}),
+                cwd: process.cwd(),
+                ...(args.mode ? { mode: args.mode } : {}),
+            },
+            log: (m) => logStderr(m),
+        });
+    }
+    catch (err) {
+        failCli("AGENT_RUNTIME_ERROR", err instanceof ProviderError ? err.safeMessage : String(err?.message ?? err));
+        return;
+    }
+    // ACP MODE — stdout is JSON-RPC only from here on.
+    let handle;
+    handle = startAcpAgent({
+        runtime,
+        sandboxInputs,
+        onClose: () => {
+            handle?.close();
+            process.exitCode = 0;
+        },
+    });
+    logStderr(`agent ready (provider=${args.provider})`);
+}
+async function runProviders(rest) {
+    const sub = rest[0];
+    const args = rest.slice(1);
+    if (sub === undefined || sub === "help" || sub === "--help" || sub === "-h" || args[0] === "help" || args[0] === "--help" || args[0] === "-h") {
+        process.stdout.write(usage());
+        return;
+    }
+    const configPath = flagValue(args, "--config");
+    const storePathArg = flagValue(args, "--store");
+    const provider = flagValue(args, "--provider");
+    const yes = args.includes("--yes");
+    const dryRun = args.includes("--dry-run");
+    const interactive = args.includes("--interactive");
+    const cfg = loadProviderPolicyConfig(configPath ? { path: configPath } : {});
+    const store = new ProviderApprovalStore(approvalStorePath(storePathArg));
+    const registry = createDefaultRegistry();
+    const ctxFor = (def) => {
+        const policyEntry = getPolicyEntry(cfg.config, def.id);
+        const approval = store.get(def.id);
+        return {
+            ...(policyEntry ? { policyEntry } : {}),
+            ...(approval ? { approval } : {}),
+            policyInvalid: !cfg.ok,
+        };
+    };
+    const runProviderTest = async () => {
+        if (!provider)
+            return failProviders("test requires --provider <id>");
+        if (!cfg.ok)
+            return failProviders("provider policy config is invalid; fix it before testing");
+        const def = registry.get(provider);
+        if (!def)
+            return failProviders(`unknown provider: ${provider}`);
+        const runnability = ctxFor(def);
+        const status = resolveProviderStatus(def, runnability);
+        if (!status.runnable) {
+            return failProviders(`${status.safeMessage}. Run 'providers review --provider ${provider}' and approve it if required before testing.`);
+        }
+        const options = { runnability };
+        const providerEnvKeys = providerEnvKeysFor(def.id);
+        if (providerEnvKeys.length)
+            options.envAllowlist = minimalNonSecretProviderEnv(providerEnvKeys);
+        options.cwd = process.cwd();
+        let runtime;
+        const events = [];
+        try {
+            runtime = registry.createRuntime(def.id, { options, log: (m) => logStderr(m) });
+            await runtime.initialize();
+            const session = runtime.createSession();
+            const controller = new AbortController();
+            const result = await runtime.prompt({
+                sessionId: session.sessionId,
+                requestId: `provider-test-${def.id}-${Date.now()}`,
+                prompt: [{ type: "text", text: flagValue(args, "--prompt") ?? "xeno-acp provider test" }],
+            }, { emit: (event) => events.push(event), signal: controller.signal, log: (m) => logStderr(m) });
+            const message = messageTextFrom(events);
+            const eventKinds = events.map((event) => event.kind);
+            const json = args.includes("--json");
+            if (json) {
+                process.stdout.write(JSON.stringify({
+                    providerId: def.id,
+                    displayName: def.displayName,
+                    status: result.disposition,
+                    eventCount: events.length,
+                    eventKinds,
+                    message,
+                    ...(result.usage ? { usage: result.usage } : {}),
+                    ...(result.error ? { error: result.error.safeMessage } : {}),
+                }, null, 2) + "\n");
+            }
+            else {
+                const usage = formatUsage(result.usage);
+                const lines = [
+                    `provider test: ${def.id}`,
+                    `status: ${result.disposition}`,
+                    `events: ${events.length}`,
+                    `event kinds: ${eventKinds.join(", ")}`,
+                    ...(message ? [`message: ${message}`] : []),
+                    ...(usage ? [`usage: ${usage}`] : []),
+                    ...(result.error ? [`error: ${result.error.safeMessage}`] : []),
+                ];
+                process.stdout.write(lines.join("\n") + "\n");
+            }
+            if (result.disposition !== "completed")
+                process.exitCode = 1;
+        }
+        catch (err) {
+            failCli("PROVIDER_TEST_FAILED", err instanceof ProviderError ? err.safeMessage : String(err?.message ?? err));
+        }
+        finally {
+            if (runtime)
+                await runtime.dispose();
+        }
+    };
+    switch (sub) {
+        case "list":
+        case "check": {
+            const providers = registry.list().map((def) => {
+                const s = resolveProviderStatus(def, ctxFor(def));
+                const discovery = buildProviderDiscoverySummary(def, s);
+                return {
+                    providerId: def.id,
+                    displayName: discovery.displayName,
+                    implemented: def.enabled,
+                    status: s.status,
+                    runnable: s.runnable,
+                    approval: store.get(def.id) ? "present" : "missing",
+                    modelDiscovery: {
+                        status: discovery.modelDiscovery.status,
+                        defaultModelId: discovery.modelDiscovery.defaultModelId,
+                        modelCount: discovery.modelDiscovery.models.length,
+                        allowCustomModel: discovery.modelDiscovery.allowCustomModel,
+                    },
+                    versionReadiness: discovery.versionReadiness,
+                    streaming: discovery.streaming,
+                };
+            });
+            if (args.includes("--json")) {
+                process.stdout.write(JSON.stringify({
+                    config: { source: cfg.source ?? null, ok: cfg.ok, errors: cfg.errors },
+                    providers,
+                }, null, 2) + "\n");
+                if (!cfg.ok)
+                    process.exitCode = 1;
+                return;
+            }
+            const lines = [`providers (config: ${cfg.source ?? "none (fixture only)"}${cfg.ok ? "" : " — INVALID"}):`];
+            for (const p of providers) {
+                const appr = p.approval === "present" ? " approval=present" : "";
+                lines.push(`  - ${p.providerId.padEnd(10)} impl=${p.implemented ? "yes" : "no "} status=${p.status} runnable=${p.runnable}${appr}`);
+            }
+            if (!cfg.ok)
+                lines.push("", "config errors:", ...cfg.errors.map((e) => "  ! " + e));
+            process.stdout.write(lines.join("\n") + "\n");
+            if (!cfg.ok)
+                process.exitCode = 1;
+            return;
+        }
+        case "models": {
+            if (!provider)
+                return failProviders("models requires --provider <id>");
+            const def = registry.get(provider);
+            if (!def)
+                return failProviders(`unknown provider: ${provider}`);
+            const status = resolveProviderStatus(def, ctxFor(def));
+            const discovery = buildProviderDiscoverySummary(def, status);
+            if (status.runnable && def.id === CODEX_LOCAL_ID) {
+                const env = minimalNonSecretProviderEnv(CODEX_LOCAL_ENV_ALLOWLIST_KEYS);
+                discovery.modelDiscovery = await discoverCodexCliModels({
+                    executable: CODEX_LOCAL_DEFAULT_EXECUTABLE,
+                    cwd: process.cwd(),
+                    envAllowlist: env,
+                    platformBasics: env,
+                });
+            }
+            process.stdout.write(JSON.stringify({
+                ...discovery,
+                config: { source: cfg.source ?? null, ok: cfg.ok, errors: cfg.errors },
+            }, null, 2) + "\n");
+            if (!cfg.ok || !status.runnable)
+                process.exitCode = 1;
+            return;
+        }
+        case "review": {
+            if (!provider)
+                return failProviders("review requires --provider <id>");
+            const def = registry.get(provider);
+            if (!def)
+                return failProviders(`unknown provider: ${provider}`);
+            process.stdout.write(JSON.stringify(buildPolicyReview(def, ctxFor(def)), null, 2) + "\n");
+            return;
+        }
+        case "setup": {
+            if (!provider)
+                return failProviders("setup requires --provider <id>");
+            const def = registry.get(provider);
+            if (!def)
+                return failProviders(`unknown provider: ${provider}`);
+            const input = ctxFor(def);
+            const status = resolveProviderStatus(def, input);
+            const policyEntry = getPolicyEntry(cfg.config, def.id);
+            const refs = policyEntry?.auth.allowedSecretRefs ?? def.authPolicy?.allowedSecretRefs ?? [];
+            const needsApproval = status.status === "requires_approval" || status.status === "stale_approval";
+            const canApprove = needsApproval && Boolean(policyEntry);
+            const canRunAfterSetup = status.runnable || canApprove;
+            const setupStatus = !cfg.ok ? "blocked" : status.runnable ? "ready" : canApprove ? "needs_approval" : "blocked";
+            const base = ["node", "packages/agent/dist/cli.js"];
+            const cfgFlags = [...(configPath ? ["--config", configPath] : []), ...(storePathArg ? ["--store", storePathArg] : [])];
+            const agentFlags = [...(configPath ? ["--provider-policy", configPath] : []), ...(storePathArg ? ["--provider-approvals", storePathArg] : [])];
+            const steps = [
+                { name: "review", command: [...base, "providers", "review", "--provider", def.id, ...cfgFlags] },
+                ...(refs.length ? [{ name: "secrets", command: [...base, "providers", "secrets", "--provider", def.id, ...cfgFlags] }] : []),
+                ...(canApprove ? [{ name: "approve", command: [...base, "providers", "approve", "--provider", def.id, "--yes", ...cfgFlags] }] : []),
+                ...(canRunAfterSetup ? [
+                    { name: "test", command: [...base, "providers", "test", "--provider", def.id, ...cfgFlags] },
+                    { name: "agent", command: [...base, "agent", "--provider", def.id, ...agentFlags] },
+                    { name: "certify", command: [...base, "certify", "--provider", def.id, ...cfgFlags] },
+                ] : []),
+            ];
+            const discovery = buildProviderDiscoverySummary(def, status);
+            const out = {
+                providerId: def.id,
+                displayName: discovery.displayName,
+                setupStatus,
+                config: { source: cfg.source ?? null, ok: cfg.ok, errors: cfg.errors },
+                runnability: {
+                    status: status.status,
+                    runnable: status.runnable,
+                    safeMessage: status.safeMessage,
+                },
+                modelDiscovery: discovery.modelDiscovery,
+                versionReadiness: discovery.versionReadiness,
+                streaming: discovery.streaming,
+                setupHints: discovery.setupHints,
+                next: setupStatus === "blocked" ? status.safeMessage : steps[0]?.command.join(" "),
+                steps,
+            };
+            if (args.includes("--json")) {
+                process.stdout.write(JSON.stringify(out, null, 2) + "\n");
+            }
+            else {
+                process.stdout.write([
+                    `provider setup: ${def.id}`,
+                    `status: ${setupStatus}`,
+                    `runnability: ${status.status} runnable=${status.runnable}`,
+                    ...steps.map((s, i) => `${i + 1}. ${s.name}: ${s.command.join(" ")}`),
+                    ...(setupStatus === "blocked" ? [`next: ${status.safeMessage}`] : []),
+                ].join("\n") + "\n");
+            }
+            if (setupStatus === "blocked")
+                process.exitCode = 1;
+            return;
+        }
+        case "approvals": {
+            const recs = store.list();
+            const approvals = recs.map((r) => {
+                const def = registry.get(r.providerId);
+                const s = def ? resolveProviderStatus(def, ctxFor(def)) : undefined;
+                const current = Boolean(s?.policyHash && r.policyHash === s.policyHash && r.providerDefinitionHash === s.defHash);
+                return {
+                    providerId: r.providerId,
+                    approvalId: r.approvalId,
+                    approvedAt: r.approvedAt,
+                    current,
+                    status: s?.status ?? "unknown_provider",
+                };
+            });
+            if (args.includes("--json")) {
+                process.stdout.write(JSON.stringify({
+                    store: approvalStorePath(storePathArg),
+                    repaired: store.repaired,
+                    approvals,
+                }, null, 2) + "\n");
+                return;
+            }
+            const lines = [`approvals (${approvalStorePath(storePathArg)}):`];
+            if (store.repaired)
+                lines.push("  (note: prior store was missing/corrupt; starting empty)");
+            for (const r of approvals) {
+                lines.push(`  - ${r.providerId.padEnd(10)} ${r.approvalId} approvedAt=${r.approvedAt} ${r.current ? "[current]" : "[stale]"}`);
+            }
+            if (!approvals.length)
+                lines.push("  (none)");
+            process.stdout.write(lines.join("\n") + "\n");
+            return;
+        }
+        case "secrets": {
+            if (!provider)
+                return failProviders("secrets requires --provider <id>");
+            if (!cfg.ok)
+                return failProviders("provider policy config is invalid; fix it before reviewing secrets");
+            const def = registry.get(provider);
+            if (!def)
+                return failProviders(`unknown provider: ${provider}`);
+            const policyEntry = getPolicyEntry(cfg.config, def.id);
+            const refs = policyEntry?.auth.allowedSecretRefs ?? def.authPolicy?.allowedSecretRefs ?? [];
+            const review = buildSecretBindingReview(def.id, refs, flagValues(args, "--bind"));
+            process.stdout.write(JSON.stringify(review, null, 2) + "\n");
+            if (review.errors.length)
+                process.exitCode = 1;
+            return;
+        }
+        case "diagnose": {
+            if (!provider)
+                return failProviders("diagnose requires --provider <id>");
+            const def = registry.get(provider);
+            if (!def)
+                return failProviders(`unknown provider: ${provider}`);
+            const runnability = ctxFor(def);
+            const status = resolveProviderStatus(def, runnability);
+            const policyReview = buildPolicyReview(def, runnability);
+            const policyEntry = getPolicyEntry(cfg.config, def.id);
+            const refs = policyEntry?.auth.allowedSecretRefs ?? def.authPolicy?.allowedSecretRefs ?? [];
+            const secretBinding = buildSecretBindingReview(def.id, refs, flagValues(args, "--bind"));
+            const processInfo = { platform: process.platform, enforcement: minimalSupervisorEnforcement() };
+            if (args.includes("--json")) {
+                process.stdout.write(JSON.stringify({
+                    providerId: def.id,
+                    displayName: def.displayName,
+                    config: { source: cfg.source ?? null, ok: cfg.ok, errors: cfg.errors },
+                    runnability: {
+                        status: status.status,
+                        runnable: status.runnable,
+                        reason: status.reason,
+                        safeMessage: status.safeMessage,
+                    },
+                    approval: policyReview.approval ?? null,
+                    policyReview,
+                    secretBinding,
+                    process: processInfo,
+                }, null, 2) + "\n");
+            }
+            else {
+                const missing = secretBinding.missingRequiredRefs.length ? secretBinding.missingRequiredRefs.join(", ") : "none";
+                const approval = policyReview.approval ? (policyReview.approval.current ? "current" : "stale") : "missing";
+                process.stdout.write([
+                    `provider diagnose: ${def.id}`,
+                    `config: ${cfg.source ?? "none"} ${cfg.ok ? "ok" : "INVALID"}`,
+                    `status: ${status.status} runnable=${status.runnable}`,
+                    `approval: ${approval}`,
+                    `secrets: ${secretBinding.complete ? "complete" : `incomplete missing=${missing}`}`,
+                    `process: platform=${process.platform} network=${processInfo.enforcement.network} filesystem=${processInfo.enforcement.filesystem}`,
+                    `next: ${status.runnable && secretBinding.complete ? `providers test --provider ${def.id}` : status.safeMessage}`,
+                ].join("\n") + "\n");
+            }
+            if (!cfg.ok || !status.runnable || !secretBinding.complete || secretBinding.errors.length)
+                process.exitCode = 1;
+            return;
+        }
+        case "test": {
+            await runProviderTest();
+            return;
+        }
+        case "approve": {
+            if (!provider)
+                return failProviders("approve requires --provider <id>");
+            if (!yes && !dryRun && !interactive)
+                return failProviders("approve requires --yes, --dry-run, or --interactive");
+            const def = registry.get(provider);
+            if (!def)
+                return failProviders(`unknown provider: ${provider}`);
+            if (!cfg.ok)
+                return failProviders("provider policy config is invalid; fix it before approving");
+            const entry = getPolicyEntry(cfg.config, def.id);
+            const needsPolicy = def.authRequirement === "required" || def.networkRequirement === "required" ||
+                def.capabilities.requiresAuth || def.capabilities.usesNetwork;
+            if (needsPolicy && !entry)
+                return failProviders(`provider '${provider}' requires a policy; declare it in the providers config first`);
+            const s = resolveProviderStatus(def, ctxFor(def));
+            if (s.status === "blocked_io_authority" || s.status === "blocked_unknown_trust") {
+                return failProviders(`cannot approve '${provider}': ${s.status}`);
+            }
+            const interactiveApprove = interactive && !yes && !dryRun;
+            if (interactiveApprove && !(await confirmProviderApproval(def.id))) {
+                return failProviders(`approval cancelled for '${provider}'`);
+            }
+            const record = createApprovalRecord({
+                providerId: def.id,
+                providerDefinitionHash: s.defHash,
+                policyHash: s.policyHash ?? "",
+                decisions: approvalDecisionsFor(s.gate),
+                approvedAt: new Date().toISOString(),
+            });
+            const after = dryRun
+                ? resolveProviderStatus(def, {
+                    ...(entry ? { policyEntry: entry } : {}),
+                    approval: record,
+                    policyInvalid: !cfg.ok,
+                })
+                : (store.approve(record), resolveProviderStatus(def, ctxFor(def)));
+            const result = {
+                providerId: def.id,
+                dryRun,
+                interactive: interactiveApprove,
+                written: !dryRun,
+                approvalId: record.approvalId,
+                statusBefore: s.status,
+                statusAfter: after.status,
+                runnableAfter: after.runnable,
+                notImplemented: !def.enabled,
+            };
+            if (args.includes("--json")) {
+                process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+            }
+            else {
+                process.stdout.write(`${dryRun ? "approval dry-run" : "approved"} '${provider}' (approvalId=${record.approvalId}). status=${after.status} runnable=${after.runnable}\n`);
+                if (!def.enabled) {
+                    process.stdout.write(`note: '${provider}' is not implemented; the approval is ${dryRun ? "not written and would not make it" : "recorded for the future but the provider is NOT"} runnable.\n`);
+                }
+            }
+            return;
+        }
+        case "revoke": {
+            if (!provider)
+                return failProviders("revoke requires --provider <id>");
+            if (!yes)
+                return failProviders("revoke requires --yes to confirm");
+            const removed = store.revoke(provider);
+            if (args.includes("--json")) {
+                process.stdout.write(JSON.stringify({ providerId: provider, revoked: removed, written: removed }, null, 2) + "\n");
+            }
+            else {
+                process.stdout.write(removed ? `revoked approval for '${provider}'\n` : `no approval to revoke for '${provider}'\n`);
+            }
+            return;
+        }
+        default:
+            return failProviders(`unknown providers subcommand: ${sub ?? "(none)"}. Use list|check|setup|review|models|secrets|diagnose|test|approve|approvals|revoke`);
+    }
+}
+function failProviders(message) {
+    failCli("CLI_OPERATOR_ERROR", message);
+}
+function failCli(code, message) {
+    logStderr(`${code}: ${message}`);
+    process.exitCode = 1;
+}
+/**
+ * `adapter` — run the XENO-owned adapter PROCESS for a provider. This is NOT ACP mode: stdout is
+ * the adapter event protocol (v1 JSON lines), which the harness/supervisor reads. Only the
+ * XENO-owned `xeno-local` adapter is provided; no third-party provider CLI is launched.
+ */
+function runAdapterProcess(rest) {
+    const provider = flagValue(rest, "--provider");
+    const mode = (flagValue(rest, "--mode") ?? "normal");
+    const requestId = flagValue(rest, "--request-id") ?? "xeno-local-req";
+    if (provider !== XENO_LOCAL_ID) {
+        failCli("ADAPTER_PROVIDER_UNSUPPORTED", `unsupported provider '${provider ?? "(none)"}'. Only '${XENO_LOCAL_ID}' is a XENO-owned local adapter.`);
+        return;
+    }
+    emitXenoLocalStream((line) => void process.stdout.write(line), { mode, requestId });
+    if (mode === "delayed") {
+        // Keep the process alive (cancellable) so the supervisor can exercise timeout/cancel. The
+        // supervisor force-kills (SIGKILL / taskkill /F) on cancel/timeout; otherwise we exit at ~2s.
+        setTimeout(() => {
+            process.exitCode = 0;
+        }, 2000);
+    }
+}
+/**
+ * `process check` — print the minimal supervisor's platform + HONEST enforcement classification.
+ * It runs NOTHING (no spawn, no provider) — it only reports what the supervisor would and would
+ * NOT enforce. This is a non-ACP, human-readable command.
+ */
+function runProcessCheck(rest) {
+    const sub = rest[0];
+    if (sub !== undefined && sub !== "check") {
+        return failProviders(`unknown process subcommand: ${sub}. Use: process check`);
+    }
+    const lines = [
+        `${AGENT_NAME} ${VERSION} — minimal provider process supervisor (XACP-010)`,
+        `arch: ${process.arch}  node: ${process.version}`,
+        "",
+        ...enforcementSummaryLines(process.platform),
+        "",
+        "NOTE: this is a minimal supervisor / process boundary, NOT a sandbox. It runs no real",
+        "provider CLI. network and filesystem are NOT enforced against a hostile process.",
+    ];
+    process.stdout.write(lines.join("\n") + "\n");
+}
+async function main() {
+    process.on("unhandledRejection", (reason) => logStderr("unhandledRejection", reason?.message ?? String(reason)));
+    process.on("uncaughtException", (err) => logStderr("uncaughtException", err?.message ?? String(err)));
+    const argv = stripColorFlags(process.argv.slice(2));
+    if (argv.includes("--version") || argv[0] === "version") {
+        process.stdout.write(`${AGENT_NAME} ${VERSION}\n`);
+        return;
+    }
+    if (argv[0] === "check") {
+        runCheck(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "doctor") {
+        runDoctor(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "support-bundle") {
+        runSupportBundle(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "certify") {
+        runCertify(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "providers") {
+        await runProviders(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "process") {
+        runProcessCheck(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "adapter") {
+        runAdapterProcess(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "agent") {
+        runAgent(argv.slice(1));
+        return;
+    }
+    if (argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help" || argv.length === 0) {
+        process.stdout.write(usage());
+        return;
+    }
+    failCli("CLI_UNKNOWN_COMMAND", `unknown command: ${argv.join(" ")}`);
+    process.stderr.write(usage());
+}
+void main().catch((err) => {
+    failCli("CLI_FATAL", err instanceof Error ? err.message : String(err));
+});
+//# sourceMappingURL=cli.js.map