@borgee/agents-host 0.2.1 → 0.2.26

package/dist/cli-args.js

@@ -1,26 +1,72 @@
 /**
- * Maps single-agent `agents-host start` CLI flags to the env vars `config.ts`
- * reads. Keeping this as a plain lookup table (rather than duplicating
- * `loadConfigFromEnv`'s parsing logic) means the CLI and the env-var entry
- * point (`index.ts`) always agree on defaults/validation.
+ * Maps `agents-host start` / `agents-host start-managed` agent flags to the env
+ * vars `config.ts` reads. Keeping this as a plain lookup table (rather than
+ * duplicating `loadConfigFromEnv`'s parsing logic) means the CLI and the
+ * standalone env-var entry point (`index.ts`) always agree on
+ * defaults/validation.
  */
 export const CLI_FLAG_TO_ENV = {
     name: 'BORGEE_AGENT_NAME',
     provider: 'RUNTIME_PROVIDER',
     'claude-command': 'CLAUDE_COMMAND',
     'claude-args': 'CLAUDE_ARGS',
+    'codex-command': 'CODEX_COMMAND',
+    'codex-args': 'CODEX_ARGS',
     'copilot-command': 'COPILOT_COMMAND',
     'copilot-args': 'COPILOT_ARGS',
     'copilot-session-ttl-minutes': 'COPILOT_SESSION_TTL_MINUTES',
 };
 const SINGLE_AGENT_FLAG_NAMES = new Set(Object.keys(CLI_FLAG_TO_ENV));
+const FLAGS_ALLOWING_DASH_PREFIX_VALUE = new Set(['claude-args', 'codex-args', 'copilot-args']);
 export class CliUsageError extends Error {
 }
+function parseSingleAgentPositionals(positionals) {
+    const [serverUrl, apiKey, ...extra] = positionals;
+    if (!serverUrl) {
+        throw new CliUsageError('Missing <serverUrl>');
+    }
+    if (!apiKey) {
+        throw new CliUsageError('Missing <apiKey>');
+    }
+    if (extra.length > 0) {
+        throw new CliUsageError(`Unexpected argument: ${extra[0]}`);
+    }
+    return { serverUrl, apiKey };
+}
+function readSingleAgentFlagValue(argv, index, flag) {
+    const value = argv[index + 1];
+    if (value === undefined ||
+        (value.startsWith('--') && !FLAGS_ALLOWING_DASH_PREFIX_VALUE.has(flag))) {
+        throw new CliUsageError(`Missing value for --${flag}`);
+    }
+    return value;
+}
+function applySingleAgentFlag(argv, index, env, seenSingleAgentFlags) {
+    const flag = argv[index]?.slice(2) ?? '';
+    const envKey = CLI_FLAG_TO_ENV[flag];
+    if (!envKey) {
+        throw new CliUsageError(`Unknown option: --${flag}`);
+    }
+    env[envKey] = readSingleAgentFlagValue(argv, index, flag);
+    seenSingleAgentFlags.add(flag);
+    return index + 1;
+}
+function parseNonNegativeInteger(value, flag) {
+    if (!/^\d+$/u.test(value)) {
+        throw new CliUsageError(`--${flag} must be a non-negative integer`);
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(parsed)) {
+        throw new CliUsageError(`--${flag} must be a non-negative integer`);
+    }
+    return parsed;
+}
 export function parseStartArgs(argv) {
     const positionals = [];
     const env = {};
     const seenSingleAgentFlags = new Set();
     let configPath;
+    let debug = false;
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
         if (!arg.startsWith('--')) {
@@ -28,25 +74,22 @@ export function parseStartArgs(argv) {
             continue;
         }
         const flag = arg.slice(2);
-        const value = argv[i + 1];
-        if (value === undefined || value.startsWith('--')) {
-            throw new CliUsageError(`Missing value for --${flag}`);
+        if (flag === 'debug') {
+            if (debug) {
+                throw new CliUsageError('--debug may only be specified once');
+            }
+            debug = true;
+            continue;
         }
         if (flag === 'config') {
             if (configPath !== undefined) {
                 throw new CliUsageError('--config may only be specified once');
             }
-            configPath = value;
+            configPath = readSingleAgentFlagValue(argv, i, flag);
             i++;
             continue;
         }
-        const envKey = CLI_FLAG_TO_ENV[flag];
-        if (!envKey) {
-            throw new CliUsageError(`Unknown option: --${flag}`);
-        }
-        env[envKey] = value;
-        seenSingleAgentFlags.add(flag);
-        i++;
+        i = applySingleAgentFlag(argv, i, env, seenSingleAgentFlags);
     }
     if (configPath !== undefined) {
         if (positionals.length > 0) {
@@ -58,25 +101,49 @@ export function parseStartArgs(argv) {
         return {
             mode: 'local-config',
             configPath,
+            debug,
         };
     }
-    const [serverUrl, apiKey, ...extra] = positionals;
-    if (!serverUrl) {
-        throw new CliUsageError('Missing <serverUrl>');
-    }
-    if (!apiKey) {
-        throw new CliUsageError('Missing <apiKey>');
-    }
-    if (extra.length > 0) {
-        throw new CliUsageError(`Unexpected argument: ${extra[0]}`);
-    }
+    const { serverUrl, apiKey } = parseSingleAgentPositionals(positionals);
     return {
         mode: 'single-agent',
         serverUrl,
         apiKey,
+        debug,
         env,
     };
 }
+export function parseManagedStartArgs(argv) {
+    const positionals = [];
+    const env = {};
+    const seenSingleAgentFlags = new Set();
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const flag = arg.slice(2);
+        if (flag === 'debug') {
+            throw new CliUsageError('start-managed does not support --debug; use foreground start for debug logging');
+        }
+        if (flag === 'config') {
+            throw new CliUsageError('start-managed does not support --config');
+        }
+        i = applySingleAgentFlag(argv, i, env, seenSingleAgentFlags);
+    }
+    if (positionals.length === 1) {
+        if (seenSingleAgentFlags.size > 0) {
+            throw new CliUsageError(`Cannot combine bare start-managed <serverUrl> resume with agent option --${[...seenSingleAgentFlags][0]}; provide <apiKey> to bootstrap or update an agent`);
+        }
+        return {
+            serverUrl: positionals[0],
+            env,
+        };
+    }
+    const { serverUrl, apiKey } = parseSingleAgentPositionals(positionals);
+    return { serverUrl, apiKey, env };
+}
 export function parseValidateArgs(argv) {
     const positionals = [];
     let configPath;
@@ -218,27 +285,234 @@ export function parseGenerateConfigArgs(argv) {
     }
     return { rootPath, input: 'argv', specJson };
 }
+export function parseDaemonArgs(argv) {
+    const positionals = [];
+    let rootPath;
+    let debug = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const flag = arg.slice(2);
+        if (flag === 'debug') {
+            if (debug) {
+                throw new CliUsageError('--debug may only be specified once');
+            }
+            debug = true;
+            continue;
+        }
+        if (flag === 'root') {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith('--')) {
+                throw new CliUsageError('Missing value for --root');
+            }
+            if (rootPath !== undefined) {
+                throw new CliUsageError('--root may only be specified once');
+            }
+            rootPath = value;
+            i++;
+            continue;
+        }
+        throw new CliUsageError(`Unknown option: --${flag}`);
+    }
+    if (positionals.length > 0) {
+        throw new CliUsageError(`Unexpected argument: ${positionals[0]}`);
+    }
+    if (!rootPath) {
+        throw new CliUsageError('Missing required --root <dir>');
+    }
+    return { rootPath, debug };
+}
+export function parseLogArgs(argv) {
+    const positionals = [];
+    let lines = 100;
+    let follow = false;
+    let pathOnly = false;
+    let linesSpecified = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const flag = arg.slice(2);
+        if (flag === 'follow') {
+            if (follow) {
+                throw new CliUsageError('--follow may only be specified once');
+            }
+            follow = true;
+            continue;
+        }
+        if (flag === 'path') {
+            if (pathOnly) {
+                throw new CliUsageError('--path may only be specified once');
+            }
+            pathOnly = true;
+            continue;
+        }
+        if (flag === 'lines') {
+            if (linesSpecified) {
+                throw new CliUsageError('--lines may only be specified once');
+            }
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith('--')) {
+                throw new CliUsageError('Missing value for --lines');
+            }
+            lines = parseNonNegativeInteger(value, 'lines');
+            linesSpecified = true;
+            i++;
+            continue;
+        }
+        throw new CliUsageError(`Unknown option: --${flag}`);
+    }
+    const [serverUrl, ...extra] = positionals;
+    if (!serverUrl) {
+        throw new CliUsageError('Missing <serverUrl>');
+    }
+    if (extra.length > 0) {
+        throw new CliUsageError(`Unexpected argument: ${extra[0]}`);
+    }
+    if (pathOnly && (follow || linesSpecified)) {
+        throw new CliUsageError('--path cannot be combined with --follow or --lines');
+    }
+    return { serverUrl, lines, follow, pathOnly };
+}
+export function parseDescribeManagedArgs(argv) {
+    const [serverUrl, ...extra] = argv;
+    if (!serverUrl) {
+        throw new CliUsageError('Missing <serverUrl>');
+    }
+    if (serverUrl.startsWith('--')) {
+        throw new CliUsageError(`Unknown option: ${serverUrl}`);
+    }
+    if (extra.length > 0) {
+        throw new CliUsageError(`Unexpected argument: ${extra[0]}`);
+    }
+    return { serverUrl };
+}
+export function parseCleanupManagedArgs(argv) {
+    const positionals = [];
+    let purge = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const flag = arg.slice(2);
+        if (flag === 'purge') {
+            if (purge) {
+                throw new CliUsageError('--purge may only be specified once');
+            }
+            purge = true;
+            continue;
+        }
+        throw new CliUsageError(`Unknown option: --${flag}`);
+    }
+    const [serverUrl, ...extra] = positionals;
+    if (!serverUrl) {
+        throw new CliUsageError('Missing <serverUrl>');
+    }
+    if (extra.length > 0) {
+        throw new CliUsageError(`Unexpected argument: ${extra[0]}`);
+    }
+    return { serverUrl, purge };
+}
+export function parseApplyManagedArgs(argv) {
+    const positionals = [];
+    let specJson;
+    let stdin = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        const flag = arg.slice(2);
+        if (flag === 'stdin') {
+            if (stdin) {
+                throw new CliUsageError('--stdin may only be specified once');
+            }
+            stdin = true;
+            continue;
+        }
+        if (flag === 'spec-json') {
+            const value = argv[i + 1];
+            if (value === undefined || value.startsWith('--')) {
+                throw new CliUsageError('Missing value for --spec-json');
+            }
+            if (specJson !== undefined) {
+                throw new CliUsageError('--spec-json may only be specified once');
+            }
+            specJson = value;
+            i++;
+            continue;
+        }
+        throw new CliUsageError(`Unknown option: --${flag}`);
+    }
+    const [serverUrl, ...extra] = positionals;
+    if (!serverUrl) {
+        throw new CliUsageError('Missing <serverUrl>');
+    }
+    if (extra.length > 0) {
+        throw new CliUsageError(`Unexpected argument: ${extra[0]}`);
+    }
+    if (stdin && specJson !== undefined) {
+        throw new CliUsageError('apply-managed accepts exactly one input source: --stdin or --spec-json');
+    }
+    if (stdin) {
+        return { serverUrl, input: 'stdin' };
+    }
+    if (!specJson) {
+        throw new CliUsageError('Missing required input: use --stdin or --spec-json <json>');
+    }
+    return { serverUrl, input: 'argv', specJson };
+}
 export const USAGE = `Usage:
   agents-host start <serverUrl> <apiKey> [options]
-  agents-host start --config <path-to-host-config>
+  agents-host start-managed <serverUrl>
+  agents-host start-managed <serverUrl> <apiKey> [agent-options]
+  agents-host describe-managed <serverUrl>
+  agents-host cleanup-managed <serverUrl> [--purge]
+  agents-host apply-managed <serverUrl> --stdin
+  agents-host apply-managed <serverUrl> --spec-json <json>
+  agents-host log <serverUrl> [--lines <n>] [--follow]
+  agents-host log <serverUrl> --path
+  agents-host start --config <path-to-host-config> [--debug]
   agents-host validate --config <path-to-host-config>
   agents-host describe --config <path-to-host-config>
   agents-host print-layout --root <dir>
   agents-host generate-config --root <dir> --stdin
   agents-host generate-config --root <dir> --spec-json <json>
 
-Single-agent options:
+Foreground start options:
+  --debug                         Enable host/provider debug logs (or set AGENTS_HOST_DEBUG=1)
+
+Single-agent agent options:
   --name <name>                   Display name (default: Assistant)
-  --provider <claude|copilot>     Runtime provider (default: claude)
+  --provider <claude|codex|copilot>
+                                   Runtime provider (default: claude)
   --claude-command <cmd>          Local Claude CLI command (default: claude)
-  --claude-args <args>            Local Claude CLI args (default: --print)
+  --claude-args <args>            Local Claude CLI args (default: --print --permission-mode bypassPermissions)
+  --codex-command <cmd>           Local Codex ACP adapter command (default: codex-acp)
+  --codex-args <args>             Local Codex ACP adapter args
   --copilot-command <cmd>         Local Copilot CLI command (default: copilot)
   --copilot-args <args>           Ignored by the Copilot ACP prototype
   --copilot-session-ttl-minutes <minutes>
                                    Idle session TTL for Copilot ACP sessions (default: 2880)
 
-Local-config mode:
+Command summary:
+  start <serverUrl> <apiKey>      Start one foreground hosted agent (legacy-compatible behavior)
   start --config <path>           Start agents + supervisor + watchers from a host config file
+  start-managed <serverUrl>       Restart or resume an existing per-serverUrl managed daemon
+  start-managed <serverUrl> <apiKey>
+                                   Upsert one agent into the per-serverUrl local daemon and exit after reconcile
+  describe-managed <serverUrl>    Print managed-runtime spec JSON for machine callers
+  cleanup-managed <serverUrl>     Stop one managed-runtime daemon locally; --purge also removes its runtime root
+  apply-managed <serverUrl>       Apply one managed-runtime full-set spec for machine callers
+  log <serverUrl>                 Print the managed daemon log tail for one server runtime
   validate --config <path>        Validate local-config files without starting agents or watchers
   describe --config <path>        Print the current managed full-set spec as JSON
   print-layout --root <dir>       Print the canonical default local-config layout as JSON
@@ -247,8 +521,15 @@ Local-config mode:
                                    Compatibility input; JSON is exposed in process arguments
 
 Examples:
-  agents-host start https://borgee.example.com bgr_xxxxxxxx --provider copilot
-  agents-host start --config ./agents-host.yaml
+  agents-host start https://borgee.example.com bgr_xxxxxxxx --provider copilot --debug
+  agents-host start-managed https://borgee.example.com
+  agents-host start-managed https://borgee.example.com bgr_xxxxxxxx --provider copilot
+  agents-host describe-managed https://borgee.example.com
+  agents-host cleanup-managed https://borgee.example.com --purge
+  printf '%s' '{"host":{"borgeeBaseUrl":"https://borgee.example.com"},"agents":[{"key":"cp1","name":"Copilot","apiKey":"bgr_xxx","provider":"copilot"}]}' | agents-host apply-managed https://borgee.example.com --stdin
+  agents-host log https://borgee.example.com --lines 200 --follow
+  agents-host log https://borgee.example.com --path
+  agents-host start --config ./agents-host.yaml --debug
   agents-host validate --config ./agents-host.yaml
   agents-host describe --config ./agents-host.yaml
   agents-host print-layout --root ./runtime-root

package/dist/cli.d.ts

@@ -1,14 +1,23 @@
 #!/usr/bin/env node
+import { applyManagedSpec, bootstrapManagedDaemonStart, cleanupManagedRuntime, describeManagedSpec } from './managed-daemon.js';
+import { runManagedDaemonLogCommand } from './managed-daemon-log.js';
 import { describeLocalConfig, generateLocalConfig, printLocalConfigLayout, runMain, validateLocalConfig } from './run.js';
 export interface CliDeps {
     env?: NodeJS.ProcessEnv;
     logger?: Pick<Console, 'error'>;
     runMain?: typeof runMain;
+    bootstrapManagedDaemonStart?: typeof bootstrapManagedDaemonStart;
+    startManagedDaemon?: (rootPath: string, debug: boolean) => Promise<void>;
     validateLocalConfig?: typeof validateLocalConfig;
     describeLocalConfig?: typeof describeLocalConfig;
     printLocalConfigLayout?: typeof printLocalConfigLayout;
     generateLocalConfig?: typeof generateLocalConfig;
     readStdin?: () => Promise<string>;
+    runManagedDaemonLogCommand?: typeof runManagedDaemonLogCommand;
+    describeManagedSpec?: typeof describeManagedSpec;
+    cleanupManagedRuntime?: typeof cleanupManagedRuntime;
+    applyManagedSpec?: typeof applyManagedSpec;
+    stdout?: Pick<Console, 'log'>;
 }
 interface CliEntrypointDeps {
     realpath?: (path: string) => string;

package/dist/cli.js

@@ -1,36 +1,85 @@
 #!/usr/bin/env node
 import { realpathSync } from 'node:fs';
-import { resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { CliUsageError, parseDescribeArgs, parseGenerateConfigArgs, parsePrintLayoutArgs, parseStartArgs, parseValidateArgs, USAGE, } from './cli-args.js';
-import { describeLocalConfig, generateLocalConfig, printLocalConfigLayout, runMain, validateLocalConfig } from './run.js';
+import { CliUsageError, parseApplyManagedArgs, parseDaemonArgs, parseDescribeArgs, parseDescribeManagedArgs, parseCleanupManagedArgs, parseGenerateConfigArgs, parseLogArgs, parseManagedStartArgs, parsePrintLayoutArgs, parseStartArgs, parseValidateArgs, USAGE, } from './cli-args.js';
+import { resolveAgentsHostDebugMode } from './debug.js';
+import { applyManagedSpec, bootstrapManagedDaemonStart, cleanupManagedRuntime, describeManagedSpec, ManagedAgentsHostDaemon, } from './managed-daemon.js';
+import { runManagedDaemonLogCommand } from './managed-daemon-log.js';
+import { describeLocalConfig, generateLocalConfig, printLocalConfigLayout, runMain, validateLocalConfig, } from './run.js';
 function formatErrorMessage(error) {
     if (error instanceof Error) {
         return error.message;
     }
     return String(error);
 }
+const TASK_WORKSPACE_ROOT_DIR_ENV = 'AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR';
 export async function dispatchCli(argv, deps = {}) {
     const [command, ...rest] = argv;
     const env = deps.env ?? process.env;
     const runMainImpl = deps.runMain ?? runMain;
+    const bootstrapManagedDaemonStartImpl = deps.bootstrapManagedDaemonStart ?? bootstrapManagedDaemonStart;
     const validateLocalConfigImpl = deps.validateLocalConfig ?? validateLocalConfig;
     const describeLocalConfigImpl = deps.describeLocalConfig ?? describeLocalConfig;
     const printLocalConfigLayoutImpl = deps.printLocalConfigLayout ?? printLocalConfigLayout;
     const generateLocalConfigImpl = deps.generateLocalConfig ?? generateLocalConfig;
+    const runManagedDaemonLogCommandImpl = deps.runManagedDaemonLogCommand ?? runManagedDaemonLogCommand;
+    const describeManagedSpecImpl = deps.describeManagedSpec ?? describeManagedSpec;
+    const cleanupManagedRuntimeImpl = deps.cleanupManagedRuntime ?? cleanupManagedRuntime;
+    const applyManagedSpecImpl = deps.applyManagedSpec ?? applyManagedSpec;
+    const startManagedDaemonImpl = deps.startManagedDaemon ??
+        (async (rootPath, debug) => {
+            env[TASK_WORKSPACE_ROOT_DIR_ENV] = rootPath;
+            const daemon = new ManagedAgentsHostDaemon(rootPath, debug, {
+                logPath: env.AGENTS_HOST_MANAGED_DAEMON_LOG_PATH,
+            });
+            const shutdown = async (signal) => {
+                console.log(`[agents-host] managed daemon received ${signal}, shutting down`);
+                await daemon.stop().catch((error) => {
+                    console.error('[agents-host] managed daemon shutdown failed', error);
+                });
+                process.exit(0);
+            };
+            process.on('SIGINT', () => void shutdown('SIGINT'));
+            process.on('SIGTERM', () => void shutdown('SIGTERM'));
+            await daemon.start();
+        });
     const readStdin = deps.readStdin ?? readAllStdin;
+    const stdout = deps.stdout ?? console;
     if (command === 'start') {
         const parsed = parseStartArgs(rest);
+        const debug = resolveAgentsHostDebugMode(parsed.debug, env);
         if (parsed.mode === 'single-agent') {
             env.BORGEE_BASE_URL = parsed.serverUrl;
             env.BORGEE_AGENT_API_KEY = parsed.apiKey;
             for (const [key, value] of Object.entries(parsed.env)) {
                 env[key] = value;
             }
-            await runMainImpl();
+            await runMainImpl({ debug });
             return;
         }
-        await runMainImpl({ configPath: parsed.configPath });
+        env[TASK_WORKSPACE_ROOT_DIR_ENV] = dirname(resolve(parsed.configPath));
+        await runMainImpl({ configPath: parsed.configPath, debug });
+        return;
+    }
+    if (command === 'start-managed') {
+        const parsed = parseManagedStartArgs(rest);
+        if (resolveAgentsHostDebugMode(false, env)) {
+            throw new CliUsageError('start-managed does not support debug mode; use foreground start or start --config --debug instead');
+        }
+        if (parsed.apiKey === undefined) {
+            await bootstrapManagedDaemonStartImpl({
+                serverUrl: parsed.serverUrl,
+                processEnv: env,
+            });
+            return;
+        }
+        await bootstrapManagedDaemonStartImpl({
+            serverUrl: parsed.serverUrl,
+            apiKey: parsed.apiKey,
+            env: parsed.env,
+            processEnv: env,
+        });
         return;
     }
     if (command === 'validate') {
@@ -58,6 +107,64 @@ export async function dispatchCli(argv, deps = {}) {
         }
         return;
     }
+    if (command === 'describe-managed') {
+        const parsed = parseDescribeManagedArgs(rest);
+        stdout.log(JSON.stringify(await describeManagedSpecImpl({
+            serverUrl: parsed.serverUrl,
+            processEnv: env,
+        })));
+        return;
+    }
+    if (command === 'cleanup-managed') {
+        const parsed = parseCleanupManagedArgs(rest);
+        await cleanupManagedRuntimeImpl({
+            serverUrl: parsed.serverUrl,
+            purge: parsed.purge,
+            processEnv: env,
+        });
+        return;
+    }
+    if (command === 'apply-managed') {
+        const parsed = parseApplyManagedArgs(rest);
+        const specJson = parsed.input === 'stdin' ? await readStdin() : parsed.specJson;
+        let parsedSpec;
+        try {
+            parsedSpec = JSON.parse(specJson);
+        }
+        catch (error) {
+            stdout.log(JSON.stringify({
+                ok: false,
+                error: {
+                    code: 'MANAGED_SPEC_INVALID',
+                    message: `Invalid managed spec JSON: ${formatErrorMessage(error)}`,
+                },
+            }));
+            return;
+        }
+        stdout.log(JSON.stringify(await applyManagedSpecImpl({
+            serverUrl: parsed.serverUrl,
+            spec: parsedSpec,
+            processEnv: env,
+        })));
+        return;
+    }
+    if (command === 'log') {
+        const parsed = parseLogArgs(rest);
+        await runManagedDaemonLogCommandImpl({
+            serverUrl: parsed.serverUrl,
+            lines: parsed.lines,
+            follow: parsed.follow,
+            pathOnly: parsed.pathOnly,
+            env,
+        });
+        return;
+    }
+    if (command === 'daemon') {
+        const parsed = parseDaemonArgs(rest);
+        env[TASK_WORKSPACE_ROOT_DIR_ENV] = parsed.rootPath;
+        await startManagedDaemonImpl(parsed.rootPath, parsed.debug);
+        return;
+    }
     throw new CliUsageError(`Unknown command: ${command}`);
 }
 async function readAllStdin() {

package/dist/compatibility-gates.d.ts

@@ -0,0 +1,35 @@
+export declare const CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE = "claude-provider-v2";
+export declare const COPILOT_PROVIDER_V2_COMPATIBILITY_GATE = "copilot-provider-v2";
+export declare const CODEX_PROVIDER_COMPATIBILITY_GATE = "codex-provider";
+export declare const CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE = "connections-state-layer";
+export declare const CONTEXT_INJECTION_COMPATIBILITY_GATE = "context-injection";
+export declare const SKILL_RUNTIME_COMPATIBILITY_GATE = "skill-runtime";
+export declare const LOCALHOST_GATEWAY_COMPATIBILITY_GATE = "localhost-gateway";
+export declare const COLLABORATION_SKILL_FIRST_COMPATIBILITY_GATE = "collaboration-skill-first";
+export declare const TOKEN_BINDING_COMPATIBILITY_GATE = "token-binding";
+export declare const POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE = "policy-audit-enforcement";
+export declare const MANAGED_RUNTIME_CONVERGENCE_COMPATIBILITY_GATE = "managed-runtime-convergence";
+export declare const COMPATIBILITY_GATES_ENV = "AGENTS_HOST_INTERNAL_COMPATIBILITY_GATES";
+export declare const INTERNAL_POLICY_MODE_ENV = "AGENTS_HOST_INTERNAL_POLICY_MODE";
+export declare const INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV = "AGENTS_HOST_INTERNAL_PROVIDER_IMPLEMENTATIONS";
+export declare const MANAGED_RUNTIME_SETTINGS_SCHEMA_VERSION = 1;
+export type InternalPolicyMode = 'audit-only' | 'enforce';
+export type InternalProviderImplementationPath = 'v1' | 'v2';
+export type InternalProviderImplementationKey = 'claude' | 'copilot';
+export type InternalProviderImplementationOverrides = Partial<Record<InternalProviderImplementationKey, InternalProviderImplementationPath>>;
+export interface ManagedRuntimeSettingsSnapshot {
+    schemaVersion: number;
+    compatibilityGates: string[];
+    providerImplementationOverrides: string[];
+    internalPolicyMode: InternalPolicyMode;
+}
+export declare function parseCompatibilityGates(rawValue: string | undefined): ReadonlySet<string>;
+export declare function resolveInternalCompatibilityGates(): ReadonlySet<string>;
+export declare function normalizeInternalProviderImplementationOverrides(rawValue: string | undefined): string[];
+export declare function parseInternalProviderImplementationOverrides(rawValue: string | undefined): InternalProviderImplementationOverrides;
+export declare function resolveManagedRuntimeProviderImplementationOverrides(env?: NodeJS.ProcessEnv, compatibilityGates?: string[]): string[];
+export declare function resolveManagedRuntimeCompatibilityGates(env?: NodeJS.ProcessEnv): string[];
+export declare function resolveInternalPolicyMode(gateEnabled: boolean, env?: NodeJS.ProcessEnv): InternalPolicyMode;
+export declare function resolveManagedRuntimeSettingsSnapshot(env?: NodeJS.ProcessEnv): ManagedRuntimeSettingsSnapshot;
+export declare function serializeManagedRuntimeSettingsSnapshot(snapshot: ManagedRuntimeSettingsSnapshot): string;
+export declare function createManagedRuntimeSettingsFingerprint(snapshot: ManagedRuntimeSettingsSnapshot): string;