@ours.network/fleet 1.0.5 → 1.1.0-nightly.10

package/dist/cli.js

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 import { spawn as spawnChild } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { realpathSync } from 'node:fs';
 import { join as joinPath, resolve as resolvePath } from 'node:path';
 import { createInterface } from 'node:readline';
 import { Command } from 'commander';
 import { VERSION } from './version.js';
+import { INIT_COMPLETION_GUIDANCE } from './init-guidance.js';
+import { bootstrapPresets } from './preset-bootstrap.js';
 import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, runningLabel, } from './provenance.js';
 import { agentDir, agentsRoot, tmpRoot, logsRoot, deriveXdgRuntimeDir } from './paths.js';
-import { findRole, loadConfig } from './config.js';
+import { findRole, loadConfig, ROLE_NAME_RE } from './config.js';
 import { formatDuration } from './duration.js';
-import { resolvedPlan } from './resolved-plan.js';
-import { Tmux, tmuxArgs } from './tmux.js';
+import { redactSensitive, resolvedPlan } from './resolved-plan.js';
 import { pickBackend } from './supervisor/index.js';
 import { up, down } from './ops.js';
 import { readRestartLedger, runSupervised, runTemp } from './runner.js';
@@ -37,6 +39,7 @@ import { requestWebControl } from './web/control.js';
 import { WebServiceManager } from './web/service.js';
 import { WebAccessStore, passwordAccess, validatePublicOrigin } from './web/access.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
+import { beginFleetAuditCollection, consumeFleetAuditCollection, FleetCliExit, } from './fleet-command-audit.js';
 import './harness/claude-code.js'; // registers the claude-code adapter
 import './harness/codex.js'; // registers the codex adapter
 import { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './rooms-tasks/cli.js';
@@ -66,7 +69,10 @@ const roleLifecycle = (configPath, operationDeps) => {
     return new RoleLifecycleService({ repository, ops: operationDeps, configPath,
         status: async (roleId) => (await query.detail(roleId)).status });
 };
-const die = (e) => { console.error(String(e instanceof Error ? e.message : e)); process.exit(1); };
+const die = (e) => {
+    console.error(String(e instanceof Error ? e.message : e));
+    throw new FleetCliExit(1);
+};
 /** Exec a child with our stdio (logs/attach). */
 const passthrough = (cmd, args) => new Promise(resolve => {
     const c = spawnChild(cmd, args, { stdio: 'inherit' });
@@ -74,10 +80,11 @@ const passthrough = (cmd, args) => new Promise(resolve => {
 });
 const program = new Command()
     .name('ours-fleet')
-    .description('Fleet of persistent, identity-bound AI agents — selectable harness and tmux/ACP sessions.')
+    .description('Fleet of persistent, identity-bound AI agents — canonical Brain + Role definitions over ACP sessions.')
     .enablePositionalOptions()
+    .exitOverride()
     .version(VERSION);
-const cOpt = (cmd) => cmd.option('-c, --configuration <file>', 'config file (default: ~/fleet.yaml + ~/fleet.d/)');
+const cOpt = (cmd) => cmd.option('-c, --configuration <file>', 'manifest (default: ~/fleet.yaml; documents under ~/fleet/)');
 const collect = (value, previous) => [...previous, value];
 program.command('docs')
     .alias('man')
@@ -218,6 +225,24 @@ function parseCodexConfig(values) {
     }
     return out;
 }
+function parseAgentSelection(raw, kind) {
+    if (raw === undefined)
+        return undefined;
+    if (ROLE_NAME_RE.test(raw))
+        return { ref: raw };
+    if (!raw.startsWith('inline:'))
+        throw new Error(`invalid --${kind}; use a declared ID or inline:{...}`);
+    let value;
+    try {
+        value = JSON.parse(raw.slice('inline:'.length));
+    }
+    catch {
+        throw new Error(`invalid --${kind} inline mapping`);
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`invalid --${kind} inline mapping`);
+    return { inline: value };
+}
 cOpt(program.command('config').description('validate + print the merged plan (no side effects)'))
     .option('--json', 'emit the stable, versioned, secret-safe resolved plan')
     .option('--yaml-mode <mode>', 'non-plain YAML policy: compat|strict', 'compat')
@@ -261,14 +286,16 @@ cOpt(program.command('config').description('validate + print the merged plan (no
                 console.log(`    cwd:         ${r.cwd}`);
             if (r.model)
                 console.log(`    model:       ${r.model}`);
+            if (r.effort)
+                console.log(`    effort:      ${r.effort}`);
             if (r.harness_options && Object.keys(r.harness_options).length)
-                console.log(`    options:     ${JSON.stringify(r.harness_options)}`);
+                console.log(`    options:     ${JSON.stringify(redactSensitive(r.harness_options))}`);
             if (r.coordinator)
                 console.log(`    coordinator: ${r.coordinator}`);
             if (r.mission)
                 console.log(`    mission:     ${r.mission.split('\n')[0]}`);
             if (r.oversee?.length)
-                console.log(`    oversees:    ${r.oversee.map(o => `${o.role}@${o.interval}`).join(', ')}`);
+                console.log(`    oversees:    ${r.oversee.map(o => `${o.agent}@${o.interval}`).join(', ')}`);
             if (r.isolation) {
                 const iso = r.isolation;
                 const caps = [
@@ -369,15 +396,11 @@ cOpt(program.command('force-restart [names...]').description('re-sync + bounce F
 });
 program.command('ls').description('list running fleet sessions')
     .action(async () => {
-    // Each session has its own tmux server (#32), so there is no single server
-    // to ask: the known role names ARE the list of servers to poll.
-    const names = [];
     const acp = [];
     for (const root of [agentsRoot(), tmpRoot()]) {
         if (!existsSync(root))
             continue;
         for (const name of readdirSync(root)) {
-            names.push(name);
             const stateDir = joinPath(root, name);
             if (!existsSync(controlSocketPath(stateDir)))
                 continue;
@@ -395,14 +418,13 @@ program.command('ls').description('list running fleet sessions')
             catch { /* ignore stale sockets */ }
         }
     }
-    const tmux = await new Tmux().list(names);
-    console.log([tmux, ...acp].filter(Boolean).join('\n') || '(none)');
+    console.log(acp.join('\n') || '(none)');
 });
 program.command('attach <name>').description('open the live console (Ctrl-b d to leave)')
     .action(async (name) => {
     const stateDir = acpStateDir(name);
     if (!stateDir)
-        process.exit(await passthrough('tmux', tmuxArgs(name, ['attach', '-t', name])));
+        throw new SessionControlError('offline', 'agent session is offline');
     try {
         const { socket, send } = await followControl(stateDir, message => {
             if ('event' in message)
@@ -439,7 +461,7 @@ program.command('attach <name>').description('open the live console (Ctrl-b d to
         die(e);
     }
 });
-/** Classify a raw tmux failure: only "no such session" proves the pane is gone. */
+/** Preserve typed control failures and classify only definite missing-session errors as offline. */
 const asControlError = (e) => {
     if (e instanceof SessionControlError)
         return e;
@@ -467,23 +489,17 @@ program.command('peek <name> [lines]').description('pane snapshot without attach
             for (const event of events.slice(-(lines ? Number(lines) : 40)))
                 renderSessionEvent(event);
         }
-        else {
-            console.log(await new Tmux().capture(name, lines ? Number(lines) : 40));
-        }
+        else
+            throw new SessionControlError('offline', 'agent session is offline');
     }
     catch (e) {
         die(controlFailure(name, 'peek', e));
     }
 });
 program.command('send <name> [text...]').description("type into the agent's console")
-    .option('--key <key>', 'send a raw key instead (Escape, Up, C-c, ...)')
     .action(async (name, text, opts) => {
     const stateDir = acpStateDir(name);
-    if (stateDir && opts.key)
-        die('--key is available only for tmux sessions');
-    if (!stateDir && !opts.key && !text?.length)
-        die('nothing to send: give text or --key');
-    if (stateDir && !text?.length)
+    if (!text?.length)
         die('nothing to send: give text');
     try {
         if (stateDir) {
@@ -496,10 +512,8 @@ program.command('send <name> [text...]').description("type into the agent's cons
                 ? `queued for ${name} behind ${queued.queuedBehind} running turn(s)`
                 : `queued for ${name}`);
         }
-        else if (opts.key)
-            await new Tmux().sendKey(name, opts.key);
         else
-            await new Tmux().sendText(name, text.join(' '));
+            throw new SessionControlError('offline', 'agent session is offline');
     }
     catch (e) {
         die(controlFailure(name, 'send', e, asControlError(e).kind === 'timeout'
@@ -1123,50 +1137,32 @@ cOpt(program.command('rm <name>').description('stop + remove a role (temporary e
     }
 });
 cOpt(program.command('spawn [name]').description('spawn a new agent (permanent by default)'))
-    .option('--role <name>', 'role name (alternative to the positional name)')
+    .option('--name <name>', 'agent name (alternative to the positional name)')
+    .option('--brain <selection>', 'Brain ID or inline:{...} definition')
+    .option('--role <selection>', 'Role ID or inline:{...} definition')
     .option('--temp', 'temporary: independent transient supervisor, archived on retirement, gone on reboot')
-    .option('--harness <id>', 'harness adapter (default: defaults.harness)')
-    .option('--session <backend>', 'session backend: tmux|acp (default: defaults.session or tmux)')
-    .option('--mission <text>', 'one-line mission')
-    .option('--mission-file <path>', 'UTF-8 mission text (mutually exclusive with --mission)')
-    .option('--identity <name>', 'ours identity to bind (default: role name)')
+    .option('--identity <name>', 'ours identity to bind (default: Agent name)')
     .option('--cwd <dir>', 'working directory')
     .option('--coordinator <name>', 'announce target')
-    .option('--model <id>', 'model id to launch on (e.g. claude-fable-5); default: launcher default')
-    .option('--permission-mode <mode>', 'harness permission mode (Codex: untrusted|on-request|never; Claude: native values)')
     .option('--approval <mode>', 'fleet permission mode: ask|auto|allow (Codex ACP allow selects agent-full-access; deny is deprecated)')
     .option('--filesystem <mode>', 'common filesystem intent: read-only|workspace|unrestricted')
     .option('--unattended <mode>', 'permission behavior without a console: deny|wait')
-    .option('--sandbox <mode>', 'Codex sandbox: read-only|workspace-write|danger-full-access')
-    .option('--profile <name>', 'Codex profile file name ($CODEX_HOME/<name>.config.toml)')
-    .option('--launcher <mode>', 'Codex launcher: auto|ours-codex|codex (default: auto)')
-    .option('--search', 'enable Codex live web search')
-    .option('--codex-config <key=value>', 'Codex config override (repeatable)', collect, [])
-    .option('--add-dir <dir>', 'additional Codex writable directory (repeatable)', collect, [])
-    .option('--monitor', 'legacy: consent to arm Codex\'s native monitor (wake owner is monitor.mode in YAML)')
-    .option('--bio-file <file>', 'public bio (file)')
-    .option('--persona-file <file>', 'persona / operating contract (file)')
     .option('--isolation-file <path>', 'file holding an isolation: mapping (same schema as fleet.yaml)')
     .option('--dry-run', 'validate and print without reserving or creating anything')
     .option('--json', 'with --dry-run, emit a stable secret-safe JSON result')
     .action(async (name, opts) => {
     try {
-        const roleName = String(name ?? opts.role ?? '');
+        const roleName = String(name ?? opts.name ?? '');
         if (!roleName)
-            throw new Error('role name is required (positional or --role)');
-        if (name && opts.role && name !== opts.role)
-            throw new Error(`positional role '${name}' conflicts with --role '${opts.role}'`);
+            throw new Error('agent name is required (positional or --name)');
+        if (name && opts.name && name !== opts.name)
+            throw new Error(`positional agent name conflicts with --name`);
         const o = {
-            name: roleName, temp: opts.temp, harness: opts.harness, session: opts.session, mission: opts.mission,
-            missionFile: opts.missionFile,
+            name: roleName, temp: opts.temp,
+            brain: parseAgentSelection(opts.brain, 'brain'), role: parseAgentSelection(opts.role, 'role'),
             identity: opts.identity, cwd: opts.cwd, coordinator: opts.coordinator,
-            model: opts.model,
-            permissionMode: opts.permissionMode, approval: opts.approval,
+            approval: opts.approval,
             filesystem: opts.filesystem, unattended: opts.unattended,
-            sandbox: opts.sandbox, profile: opts.profile,
-            launcher: opts.launcher, search: opts.search,
-            codexConfig: parseCodexConfig(opts.codexConfig), addDirs: opts.addDir, monitor: opts.monitor,
-            bioFile: opts.bioFile, personaFile: opts.personaFile,
             isolationFile: opts.isolationFile, configPath: opts.configuration,
             dryRun: opts.dryRun, json: opts.json,
         };
@@ -1195,7 +1191,7 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
         if (proxyStateDir) {
             // Paths entered in the agent shell belong to that shell's cwd, not the
             // supervisor process. Normalize before crossing the control boundary.
-            for (const key of ['missionFile', 'bioFile', 'personaFile', 'isolationFile']) {
+            for (const key of ['isolationFile']) {
                 if (o[key])
                     o[key] = resolvePath(o[key]);
             }
@@ -1259,15 +1255,19 @@ cOpt(program.command('doctor').description('prerequisite report'))
     });
     for (const c of rep.checks)
         console.log(`${c.ok ? 'ok  ' : 'MISS'} ${c.name.padEnd(22)} ${c.detail}`);
-    process.exit(rep.ok ? 0 : 1);
+    if (!rep.ok)
+        throw new FleetCliExit(1);
 });
-program.command('init').description('one-time host setup (units, dirs, linger)')
-    .action(async () => {
+cOpt(program.command('init').description('idempotent host setup plus missing packaged presets'))
+    .action(async (opts) => {
     for (const d of [agentsRoot(), tmpRoot(), logsRoot()])
         mkdirSync(d, { recursive: true });
     for (const m of await pickBackend().init(binPath))
         console.log(m);
-    console.log('\nNext: copy examples/fleet.yaml to ~/fleet.yaml, edit, then: ours-fleet up');
+    const seeded = bootstrapPresets(opts.configuration);
+    console.log(`Packaged preset revision ${seeded.revision}: ${seeded.sourceRoot}`);
+    console.log(`Created ${seeded.created.length}; preserved ${seeded.preserved.length} existing file(s).`);
+    console.log(INIT_COMPLETION_GUIDANCE);
 });
 const webCommand = cOpt(program.command('web').description('start or open the secure localhost fleet web console'))
     .enablePositionalOptions()
@@ -1508,4 +1508,84 @@ cOpt(program.command('_run-watchdogs', { hidden: true }))
         die(e);
     }
 });
-program.parseAsync(process.argv);
+async function parseFleetCli() {
+    const spawnIndex = process.argv.indexOf('spawn');
+    if (spawnIndex >= 0 && process.argv.slice(spawnIndex + 1).some(arg => arg === '--harness' || arg.startsWith('--harness=') || arg === '--model' || arg.startsWith('--model='))) {
+        console.error('error: --harness and --model were removed; select a Brain with --brain');
+        throw new FleetCliExit(1);
+    }
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        const commander = error;
+        if (commander.exitCode === 0)
+            return;
+        if (typeof commander.exitCode === 'number')
+            throw new FleetCliExit(commander.exitCode, 'validation', 'not_started');
+        throw error;
+    }
+}
+async function runFleetCli() {
+    const stateDir = process.env[FLEET_PROXY_STATE_DIR_ENV];
+    const caller = process.env[FLEET_PROXY_CALLER_ENV];
+    if (!stateDir || !caller) {
+        await parseFleetCli();
+        return;
+    }
+    const requestId = randomUUID();
+    let attempt;
+    const begun = await controlRequest(stateDir, {
+        command: 'fleet_audit_begin', audit: { requestId, argv: process.argv.slice(2) },
+    });
+    if (!begun.ok)
+        throw new SessionControlError(begun.kind ?? 'rejected', begun.error ?? 'fleet command audit refused');
+    attempt = begun.result;
+    if (attempt.caller !== caller)
+        throw new SessionControlError('rejected', `fleet audit caller mismatch: expected '${caller}', got '${attempt.caller}'`);
+    let exitCode = 0;
+    let outcomeClass = 'success';
+    let effect = 'completed';
+    beginFleetAuditCollection();
+    if (attempt.classification.decision !== 'allow') {
+        exitCode = 1;
+        outcomeClass = 'denied';
+        effect = 'not_started';
+        console.error(`fleet supervisor proxy ${attempt.classification.decision}: ${attempt.classification.command}`);
+    }
+    else {
+        const originalExit = process.exit;
+        process.exit = ((code) => { throw new FleetCliExit(code ?? 0); });
+        try {
+            await parseFleetCli();
+        }
+        catch (error) {
+            exitCode = error instanceof FleetCliExit ? error.exitCode : 1;
+            outcomeClass = error instanceof FleetCliExit ? error.outcomeClass : 'runtime';
+            effect = error instanceof FleetCliExit ? error.effect : 'unknown';
+            if (!(error instanceof FleetCliExit))
+                console.error(error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            process.exit = originalExit;
+        }
+    }
+    const metadata = consumeFleetAuditCollection();
+    if (metadata.failure) {
+        outcomeClass = metadata.failure.class;
+        effect = metadata.failure.effect;
+    }
+    const finished = await controlRequest(stateDir, { command: 'fleet_audit_finish', audit: {
+            correlationId: attempt.correlationId, class: outcomeClass, exitCode, effect,
+            ...(metadata.resourceIds ? { resourceIds: metadata.resourceIds } : {}),
+            ...(metadata.presentations ? { presentations: metadata.presentations } : {}),
+        } });
+    if (!finished.ok)
+        throw new SessionControlError(finished.kind ?? 'backend', finished.error ?? `audit delivery failed after execution; effect status=${effect}`);
+    process.exitCode = exitCode;
+}
+void runFleetCli().catch(error => {
+    if (!(error instanceof FleetCliExit))
+        console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = error instanceof FleetCliExit ? error.exitCode : 1;
+});

package/dist/config-yaml.d.ts

@@ -1,5 +1,5 @@
 export type YamlMode = 'compat' | 'strict';
-export type ConfigDiagnosticKind = 'anchor' | 'alias' | 'explicit-tag' | 'non-scalar-key' | 'multiple-documents';
+export type ConfigDiagnosticKind = 'anchor' | 'alias' | 'explicit-tag' | 'non-scalar-key' | 'multiple-documents' | 'deprecated-field';
 export interface ConfigDiagnostic {
     severity: 'warning';
     kind: ConfigDiagnosticKind;

package/dist/config.d.ts

@@ -3,7 +3,7 @@ import type { IsolationConfig, WrapContext } from './isolation/types.js';
 import type { ResolvedWatchdog } from './watchdog/config.js';
 import type { ResolvedLoop, ResolvedRoleLoop } from './loops/config.js';
 export interface OverseeEntry {
-    role: string;
+    agent: string;
     interval: string;
 }
 export interface WorklogPolicy {
@@ -25,7 +25,7 @@ export declare const NOTIFY_EVENT_TYPES: readonly ["message_received", "file_rec
 export type NotifyEventType = (typeof NOTIFY_EVENT_TYPES)[number];
 export type InjectMode = 'notification' | 'full';
 export type MonitorMode = 'fleet' | 'native';
-export type SessionBackendId = 'tmux' | 'acp';
+export type SessionBackendId = 'acp';
 /** Public, harness-neutral permission policy. */
 export type FleetPermissionMode = 'ask' | 'auto' | 'allow';
 /** `deny` is a deprecated, fail-closed compatibility alias retained for old fleet files. */
@@ -44,9 +44,6 @@ export interface SessionOptions {
         /** ACP agent command and arguments. Defaults are supplied by the harness adapter. */
         command?: string | string[];
     };
-    tmux?: {
-        boot_grace_ms?: number;
-    };
 }
 /** Resolved per-role supervisor-monitor config. */
 export interface MonitorConfig {
@@ -126,6 +123,8 @@ export interface RoleConfig {
     briefing_file?: string;
     /** Explicit null means use the selected harness's own default, bypassing fleet defaults. */
     model?: string | null;
+    /** Neutral Brain reasoning effort, retained for inspection after adapter translation. */
+    effort?: string;
     model_chain?: string[];
     max_tokens?: number;
     autocompact_pct?: number;
@@ -138,6 +137,27 @@ export interface RoleConfig {
     worklog?: WorklogPolicyInput;
     auth_proxy?: Partial<AuthProxyConfig>;
 }
+export type AgentSelection<T extends Record<string, unknown> = Record<string, unknown>> = {
+    ref: string;
+} | {
+    inline: T;
+};
+/** Canonical authoring contract shared by configured, spawned, and room agents. */
+export interface AgentDefinition {
+    role: AgentSelection;
+    brain: AgentSelection;
+    permissions?: Partial<CommonPermissions>;
+    identity?: string;
+    cwd?: string;
+    coordinator?: string;
+    env?: Record<string, string>;
+    oversee?: OverseeEntry[];
+    isolation?: IsolationConfig;
+    monitor?: Partial<MonitorConfig>;
+    owner_channel?: OwnerChannelConfigInput;
+    worklog?: WorklogPolicyInput;
+    auth_proxy?: Partial<AuthProxyConfig>;
+}
 /** Internal first-boot payload for a Fleet-provisioned Cowork room member. */
 export interface RoomMemberStartup {
     room_id: string;
@@ -169,14 +189,41 @@ export interface ResolvedRole extends Omit<RoleConfig, 'model' | 'owner_channel'
     worklog?: WorklogPolicy;
     auth_proxy?: AuthProxyConfig;
     loops?: ResolvedRoleLoop[];
+    provenance?: Record<string, FieldProvenance>;
     /** Internal/transient: never accepted as a user-authored RoleConfig key. */
     roomMemberStartup?: RoomMemberStartup;
+    /** Original unresolved selections only; denied operational fields never enter inheritance state. */
+    agentSelections?: Pick<AgentDefinition, 'role' | 'brain'>;
+}
+export interface FieldProvenance {
+    sourceFile: string;
+    sourcePointer: string;
+    sourceKind: 'Agent' | 'Role' | 'Brain' | 'Manifest' | 'built-in';
+    sourceId?: string;
+    origin: 'explicit' | 'typed-default' | 'built-in';
+    viaReference?: {
+        sourcePointer: string;
+        kind: 'Role' | 'Brain';
+        id: string;
+    };
+    transforms: Array<{
+        kind: 'substitution' | 'adapter-normalization' | 'validation-default';
+        detail: string;
+    }>;
 }
 export interface FleetConfig {
     roles: ResolvedRole[];
+    /** Canonical, variable-resolved Agent authoring documents keyed by stable Agent ID. */
+    agentDefinitions?: Record<string, AgentDefinition>;
     vars: Record<string, string>;
     defaults: Record<string, unknown>;
     files: string[];
+    configMode?: 'split-v2';
+    sourceDocuments?: Array<{
+        kind: 'Manifest' | 'Agent' | 'Role' | 'Brain' | 'RoomTemplate';
+        id?: string;
+        path: string;
+    }>;
     /** Fleet-wide delay (ms) enforced between agent launches to avoid boot bursts (0 = none). */
     startStaggerMs: number;
     /** Warning-first non-plain YAML migration diagnostics, in source order. */
@@ -207,9 +254,22 @@ export declare function resolveRoleModel(model: string | null | undefined, harne
  */
 export declare function isolationContextFor(role: ResolvedRole): WrapContext;
 export declare const ROLE_NAME_RE: RegExp;
-/** Load ~/fleet.yaml (or an explicit path) merged with ~/fleet.d/*.yaml drop-ins. */
+export declare const ROLE_PRESET_KEYS: string[];
+export declare const BRAIN_PRESET_KEYS: string[];
+export declare const AGENT_KEYS: string[];
+type BarePreset = Record<string, unknown>;
+export declare function validateRoleValue(value: BarePreset, file: string, pointer: string): void;
+export declare function validateBrainValue(value: BarePreset, file: string, pointer: string): void;
+export declare function assertBareKeys(value: unknown, allowed: string[], label: string): BarePreset;
+export declare function splitRootFor(base: string): string;
+/** Load a v2 manifest and bare Agent/Role/Brain documents from its stem directory. */
 export declare function loadConfig(configPath?: string, options?: {
     yamlMode?: YamlMode;
+    additionalAgent?: {
+        id: string;
+        definition: AgentDefinition;
+    };
+    skipWatchdogs?: boolean;
 }): FleetConfig;
 /**
  * Canonical form of a 64-hex container ID for authorization decisions. Hex