@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.3

package/README.md

@@ -126,19 +126,16 @@ ours-fleet spawn Worker --mission "own the worker repo" \
 ours-fleet spawn --temp Scout --mission "one-off research"   # gone on exit/reboot
 
 # Codex role: ours-codex is preferred automatically; plain codex is the fallback
-ours-fleet spawn Coder --harness codex --model gpt-5.4 \
-  --session acp --approval ask --filesystem workspace \
-  --profile fleet --search --monitor --coordinator FleetCoordinator
-# Note: --monitor is legacy consent for Codex's native monitor. Choose the
-# wake owner separately in fleet.yaml with monitor.mode: fleet|native.
+ours-fleet spawn Coder --brain codex-fleet --role developer \
+  --approval ask --filesystem workspace --coordinator FleetCoordinator
 ```
 
 Inside a managed ACP role, `ours-fleet spawn` is transparently routed through
-that role's live supervisor. `ours-fleet spawn --role DeveloperX --temp` is the
-minimal form: omitted harness, session, cwd, coordinator, neutral permissions,
-fleet monitor policy, and same-harness model inherit from the caller. Explicit
-flags win; changing harness without a model lets the selected harness/fleet
-defaults choose one. After creation succeeds, fleet can deterministically notify
+that role's live supervisor. `ours-fleet spawn DeveloperX --temp` is the
+minimal form: omitted Brain/Role selections, cwd, coordinator, neutral permissions,
+and fleet monitor policy inherit from the caller. Identity, environment, owner routing,
+room startup, and sensitive inline Brain values do not. Explicit flags win. After
+creation succeeds, fleet can deterministically notify
 the caller's owner channel with the caller and spawned-role details. This is an
 honest-actor convenience and attribution path, not a security boundary; host
 shells and deliberately bypassed absolute binaries retain direct behavior.
@@ -305,7 +302,7 @@ ours-fleet up|down|restart|force-restart [-c FILE] [Name...]
 ours-fleet config [-c FILE]         validate + print merged plan
 ours-fleet ls | attach | peek | logs [-f] | status <Name>
 ours-fleet send <Name> "text"
-ours-fleet spawn [--temp] [<Name> | --role <Name>] [--harness --session --mission --model --approval ...]
+ours-fleet spawn [--temp] [<Name> | --name <Name>] --brain <ID|inline:{...}> --role <ID|inline:{...}> [--approval ...]
 ours-fleet loops validate|list|status
 ours-fleet loops reload <Role>
 ours-fleet loops run-now|disable|enable <Role> <Loop>
@@ -359,13 +356,9 @@ defaults:
     max_kb: 1024                        # rotate only above this active-log size
     keep_tail_kb: 256                   # UTF-8 tail; line-aligned when one fits
     max_archives: 12                    # recent beside log; older preserved cold
-Agent document:
-  Name:                                 # filename stem; [A-Za-z0-9_-]+
-    harness: claude-code
-    session: acp                         # optional; ACP is the only supported session
-    session_options:
-      acp:
-        command: claude-agent-acp        # optional advanced override
+Agent document (\`~/fleet/agents/Name.yaml\`):
+  role: { ref: RoleID }
+  brain: { ref: BrainID }                # Brain owns harness/model/session/reasoning
     identity: "Display Name"            # ours identity to bind (default: Name)
     cwd: ${work_root}/repo              # where the harness process runs
     coordinator: FleetCoordinator       # announce target on boot
@@ -1051,10 +1044,9 @@ harness_options:
   config: { model_reasoning_effort: high }
 ```
 
-Equivalent one-off/permanent spawn controls include `--model`, `--permission-mode`,
-`--sandbox`, `--profile`, `--launcher`, `--search`, legacy `--monitor` (native
-Codex monitor consent), repeatable
-`--codex-config key=value`, and repeatable `--add-dir`. Use `env.OURS_PORT`/`env.OURS_CONFIG` for a
+One-off/permanent spawn selects a Brain that owns model, reasoning, native permission,
+sandbox, profile, launcher, search, monitor consent, native config, and additional roots.
+Use `env.OURS_PORT`/`env.OURS_CONFIG` for a
 role-specific ours daemon, or configure the host default in `~/.ours/config.json`.
 
 ## Agent isolation

package/dist/application/role-creation-service.d.ts

@@ -5,21 +5,14 @@ import type { OpsDeps } from '../ops.js';
 import type { ResolvedRole } from '../config.js';
 import { FleetError } from './errors.js';
 import { type ManagedFleetSpawnResult } from '../fleet-proxy.js';
-import { type HarnessModelCatalog, type HarnessModelOption } from './model-catalog.js';
 export interface CreateRoleSessionRequest {
     name: string;
-    harness: 'codex' | 'claude-code';
-    /** null means the selected harness's own default; web blank fields send null. */
-    model?: string | null;
-    reasoningEffort?: string | null;
-    session: 'acp';
+    brain: import('../config.js').AgentSelection;
+    role: import('../config.js').AgentSelection;
     cwd?: string;
     lifetime: 'permanent' | 'temporary';
-    mission?: string;
     coordinator?: string;
     permissions: CommonPermissions;
-    bio?: string;
-    persona?: string;
     monitor?: WebCreationMonitor;
     openAfterCreate: boolean;
     highRiskAcknowledged?: boolean;
@@ -38,17 +31,6 @@ export type WebCreationMonitor = {
 export interface CreationCapabilities {
     available: boolean;
     reasons: string[];
-    harnesses: Array<{
-        id: 'codex' | 'claude-code';
-        available: boolean;
-        sessions: Array<'acp'>;
-        defaultModel?: string;
-        models: string[];
-        modelOptions: HarnessModelOption[];
-        catalogSource: string;
-        customModelAllowed: true;
-        warnings: string[];
-    }>;
     lifetimes: Array<'permanent' | 'temporary'>;
     identityBootstrap: {
         mode: 'current-fleet-first-boot';
@@ -123,7 +105,6 @@ export interface RoleCreationServiceOptions {
     journalDir?: string;
     probeReady?: (name: string, session: 'acp') => Promise<'ready' | 'attention' | 'unknown'>;
     onProgress?: (action: CreationAction) => void;
-    modelCatalogs?: Partial<Record<'codex' | 'claude-code', () => HarnessModelCatalog>>;
     /** Direct/managed callers must not create or restore the web action journal. */
     journal?: boolean;
 }

package/dist/application/role-creation-service.js

@@ -1,17 +1,15 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { isAbsolute, relative } from 'node:path';
-import { loadConfig, NOTIFY_EVENT_TYPES, resolveMonitorConfig, resolveRoleModel, resolvePermissions, ROLE_NAME_RE, validateMonitorConfig, } from '../config.js';
+import { loadConfig, NOTIFY_EVENT_TYPES, resolveMonitorConfig, resolvePermissions, ROLE_NAME_RE, validateMonitorConfig, } from '../config.js';
 import { daemonIdentityProvisioner, } from '../creation.js';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
-import { buildRoleConfig, spawnDryRun, spawnPermanent, spawnTemp, validateSpawnOpts, } from '../spawn.js';
+import { spawnDryRun, spawnPermanent, spawnTemp, validateSpawnOpts, } from '../spawn.js';
 import { FleetError, normalizeError } from './errors.js';
 import { inheritCallerSpawnDefaults } from '../fleet-proxy.js';
 import { effectivePermissionMode } from '../permissions.js';
 import { effectiveRoleModel } from '../model-env.js';
-import { getAdapter } from '../harness/registry.js';
-import { claudeModelCatalog, codexModelCatalog, } from './model-catalog.js';
 const canonical = (value) => {
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
@@ -81,47 +79,16 @@ export class RoleCreationService {
     async capabilities() {
         const reasons = [];
         let defaults = {};
-        let roles = [];
         try {
             const config = loadConfig(this.options.configPath);
             defaults = config.defaults;
-            roles = config.roles;
         }
         catch (error) {
             reasons.push(`configuration is invalid: ${error.message}`);
         }
-        const modelsFor = (harness, catalog) => {
-            const configured = roles.filter(role => role.harness === harness)
-                .flatMap(role => [role.model, ...(role.model_chain ?? [])])
-                .filter((model) => Boolean(model));
-            const inherited = resolveRoleModel(undefined, harness, defaults);
-            const configuredOptions = [...new Set([...(inherited ? [inherited] : []), ...configured])]
-                .filter(id => !catalog.models.some(model => model.id === id))
-                .map(id => ({ id, label: `${id} (configured)`, reasoningEfforts: [], source: 'fleet-config' }));
-            const modelOptions = [...configuredOptions, ...catalog.models];
-            return { modelOptions, models: modelOptions.map(model => model.id) };
-        };
-        const codexCatalog = this.options.modelCatalogs?.codex?.() ?? codexModelCatalog();
-        const claudeCatalog = this.options.modelCatalogs?.['claude-code']?.() ?? claudeModelCatalog();
-        const codexModels = modelsFor('codex', codexCatalog);
-        const claudeModels = modelsFor('claude-code', claudeCatalog);
         return {
             available: reasons.length === 0,
             reasons,
-            harnesses: [
-                {
-                    id: 'codex', available: true, sessions: ['acp'],
-                    defaultModel: resolveRoleModel(undefined, 'codex', defaults),
-                    ...codexModels, catalogSource: 'codex-runtime-catalog', customModelAllowed: true,
-                    warnings: codexCatalog.warnings,
-                },
-                {
-                    id: 'claude-code', available: true, sessions: ['acp'],
-                    defaultModel: resolveRoleModel(undefined, 'claude-code', defaults),
-                    ...claudeModels, catalogSource: 'claude-adapter-2.1', customModelAllowed: true,
-                    warnings: claudeCatalog.warnings,
-                },
-            ],
             lifetimes: ['permanent', 'temporary'],
             identityBootstrap: {
                 mode: 'current-fleet-first-boot',
@@ -145,14 +112,12 @@ export class RoleCreationService {
         const defaults = cfg.defaults;
         const opts = this.spawnOptions(request);
         validateSpawnOpts(opts);
-        buildRoleConfig(opts, defaults.harness);
+        const resolved = spawnDryRun(opts).resolvedRole;
         const cwd = request.cwd ? this.resolveCwd(request.cwd) : undefined;
         const effective = {
             name: request.name, identity: request.name,
-            harness: request.harness ?? defaults.harness ?? 'claude-code',
-            session: request.session ?? defaults.session ?? 'acp',
-            model: resolveRoleModel(request.model, request.harness, defaults),
-            reasoningEffort: request.reasoningEffort ?? undefined,
+            harness: resolved.harness, session: resolved.session, model: resolved.model,
+            reasoningEffort: resolved.effort,
             cwd, lifetime: request.lifetime,
             permissions: resolvePermissions(defaults.permissions, request.permissions),
             monitor: resolveMonitorConfig(defaults.monitor, request.monitor),
@@ -184,9 +149,7 @@ export class RoleCreationService {
         if (existingIdentity === 'unknown' && !request.unverifiedIdentityAcknowledged)
             prerequisites.push('confirm creation with an unverified identity preflight');
         const provenance = {
-            harness: 'request', session: 'request', identity: 'built-in',
-            model: request.model !== undefined ? 'request'
-                : resolveRoleModel(undefined, request.harness, defaults) ? 'fleet-default' : 'built-in',
+            brain: 'request', role: 'request', identity: 'built-in',
             cwd: request.cwd ? 'request' : 'built-in', permissions: 'request',
             monitor: request.monitor ? 'request' : defaults.monitor ? 'fleet-default' : 'built-in',
         };
@@ -297,8 +260,8 @@ export class RoleCreationService {
     }
     validate(input) {
         const allowed = new Set([
-            'name', 'harness', 'model', 'reasoningEffort', 'session', 'cwd', 'lifetime', 'mission',
-            'coordinator', 'permissions', 'bio', 'persona', 'monitor', 'openAfterCreate',
+            'name', 'brain', 'role', 'cwd', 'lifetime',
+            'coordinator', 'permissions', 'monitor', 'openAfterCreate',
             'highRiskAcknowledged', 'reuseExistingIdentityAcknowledged',
             'unverifiedIdentityAcknowledged',
         ]);
@@ -308,26 +271,11 @@ export class RoleCreationService {
             throw new FleetError('invalid_request', `unsupported web creation field: ${unsupported[0]}`);
         if (!ROLE_NAME_RE.test(input.name))
             throw new FleetError('invalid_request', 'invalid role name');
-        if (!['codex', 'claude-code'].includes(input.harness))
-            throw new FleetError('invalid_request', 'unsupported harness');
-        if (input.session !== 'acp')
-            throw new FleetError('invalid_request', 'unsupported session backend');
+        if (!input.brain || !input.role)
+            throw new FleetError('invalid_request', 'brain and role selections are required');
         if (!['permanent', 'temporary'].includes(input.lifetime))
             throw new FleetError('invalid_request', 'unsupported lifetime');
-        bounded(input.model ?? undefined, 'model', 128);
-        bounded(input.reasoningEffort ?? undefined, 'reasoning effort', 16);
-        if (input.reasoningEffort != null) {
-            try {
-                getAdapter(input.harness).agentSession.resolveBrain({ effort: input.reasoningEffort });
-            }
-            catch (error) {
-                throw new FleetError('invalid_request', error.message);
-            }
-        }
-        bounded(input.mission, 'mission', 4_096);
         bounded(input.coordinator, 'coordinator', 128);
-        bounded(input.bio, 'bio', 8_192);
-        bounded(input.persona, 'persona', 16_384);
         resolvePermissions(undefined, input.permissions);
         if (input.monitor) {
             const problems = validateMonitorConfig(input.monitor);
@@ -337,10 +285,8 @@ export class RoleCreationService {
                 throw new FleetError('invalid_request', 'web creation supports monitor.inject=notification only');
         }
         return {
-            ...input, model: input.model === null ? null : input.model?.trim() || undefined,
-            reasoningEffort: input.reasoningEffort === null ? null : input.reasoningEffort?.trim() || undefined,
-            mission: input.mission?.trim() || undefined, coordinator: input.coordinator?.trim() || undefined,
-            bio: input.bio?.trim() || undefined, persona: input.persona?.trim() || undefined,
+            ...input, brain: structuredClone(input.brain), role: structuredClone(input.role),
+            coordinator: input.coordinator?.trim() || undefined,
             monitor: input.monitor ? structuredClone(input.monitor) : undefined,
         };
     }
@@ -367,12 +313,10 @@ export class RoleCreationService {
     spawnOptions(request, creationActionId) {
         return {
             name: request.name, temp: request.lifetime === 'temporary',
-            identity: request.name, harness: request.harness,
-            model: request.model, session: request.session, cwd: request.cwd,
-            reasoningEffort: request.reasoningEffort,
-            mission: request.mission, coordinator: request.coordinator,
+            identity: request.name, brain: request.brain, role: request.role, cwd: request.cwd,
+            coordinator: request.coordinator,
             approval: request.permissions.approval, filesystem: request.permissions.filesystem,
-            unattended: request.permissions.unattended, bio: request.bio, persona: request.persona,
+            unattended: request.permissions.unattended,
             monitorConfig: request.monitor,
             configPath: this.options.configPath,
             surface: creationActionId ? 'web' : undefined, creationActionId,

package/dist/application/task-room-service.js

@@ -259,8 +259,13 @@ export class TaskRoomApplicationService {
     validateTemplates() {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return listTemplates(cfg.roomTemplates ?? {}).flatMap(template => {
-            const issues = template.members.flatMap(member => cfg.roles.some(role => role.name === member.role_ref)
-                ? [] : [`member ${member.slot}: role_ref '${member.role_ref}' not found in fleet roles`]);
+            const issues = template.members.flatMap(member => {
+                if (!('ref' in member.agent))
+                    return [];
+                const ref = member.agent.ref;
+                return cfg.roles.some(role => role.name === ref)
+                    ? [] : [`member ${member.slot}: Agent ref '${ref}' not found`];
+            });
             return issues.length ? [{ template: `${template.name}@${template.version}`, issues }] : [];
         });
     }

package/dist/briefing.js

@@ -174,10 +174,10 @@ export function generateBriefing(role, v, opts) {
         L.push('This ACP role has a supervisor-scoped ours-fleet proxy. Use the ordinary');
         L.push('`ours-fleet spawn` command; the CLI routes it through your live supervisor, which');
         L.push('records you as the caller and reports successful creation to your owner channel.');
-        L.push('A minimal call is `ours-fleet spawn --role DeveloperName --temp`.');
-        L.push('For omitted execution settings, the supervisor inherits your harness, session, model,');
+        L.push('A minimal call is `ours-fleet spawn DeveloperName --temp`.');
+        L.push('For omitted settings, the supervisor inherits your canonical Brain and Role selections,');
         L.push('working directory, neutral permissions, coordinator, and fleet monitor policy. Every');
-        L.push('explicit spawn option wins. An explicit different harness does not inherit your model.');
+        L.push('explicit option wins; identity/session-local and secret material never inherit.');
         L.push('This proxy is attribution and convenience, not a security boundary for unisolated roles.');
     }
     if (role.coordinator) {

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.2",
-  "buildId": "da774e6be6b1",
-  "commit": "f8890b0449f4142a0c27a195e1351555fe599186",
+  "version": "1.1.0-nightly.3",
+  "buildId": "ecb06fff91d3",
+  "commit": "87f6db6848b924074b76ce19f15a6b15866c4da3",
   "dirty": true,
-  "builtAt": "2026-08-30T15:08:00.155Z",
+  "builtAt": "2026-08-30T17:21:38.816Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -9,7 +9,7 @@ import { VERSION } from './version.js';
 import { INIT_COMPLETION_GUIDANCE } from './init-guidance.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 { redactSensitive, resolvedPlan } from './resolved-plan.js';
 import { pickBackend } from './supervisor/index.js';
@@ -74,7 +74,7 @@ const passthrough = (cmd, args) => new Promise(resolve => {
 });
 const program = new Command()
     .name('ours-fleet')
-    .description('Fleet of persistent, identity-bound AI agents — selectable harnesses over ACP sessions.')
+    .description('Fleet of persistent, identity-bound AI agents — canonical Brain + Role definitions over ACP sessions.')
     .enablePositionalOptions()
     .version(VERSION);
 const cOpt = (cmd) => cmd.option('-c, --configuration <file>', 'manifest (default: ~/fleet.yaml; documents under ~/fleet/)');
@@ -218,6 +218,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')
@@ -1112,50 +1130,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: acp (default: acp)')
-    .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,
         };
@@ -1184,7 +1184,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]);
             }
@@ -1497,4 +1497,11 @@ cOpt(program.command('_run-watchdogs', { hidden: true }))
         die(e);
     }
 });
-program.parseAsync(process.argv);
+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');
+    process.exitCode = 1;
+}
+else {
+    program.parseAsync(process.argv);
+}

package/dist/config.d.ts

@@ -137,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;
@@ -171,6 +192,8 @@ export interface ResolvedRole extends Omit<RoleConfig, 'model' | 'owner_channel'
     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;
@@ -190,6 +213,8 @@ export interface FieldProvenance {
 }
 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[];
@@ -229,10 +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;
+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