@ours.network/fleet 2.3.0 → 2.3.1

package/dist/init-wizard.js

@@ -4,58 +4,25 @@ import { basename, dirname, join, resolve } from 'node:path';
 import { replaceFileAtomically, withFileLock } from './atomic-file.js';
 import { loadConfig, splitRootFor } from './config.js';
 import { packagedPresetRoot } from './preset-bootstrap.js';
+import { packagedModelCatalog } from './application/model-catalog.js';
+import { parse as parseYaml } from 'yaml';
 import { listTemplates } from './rooms-tasks/templates.js';
 const WORK_KINDS = ['development', 'review', 'coordination'];
 const ROLE_WORK = {
     Developer: 'development', Engineer: 'development', Critic: 'review',
     LocalCoordinator: 'coordination', Coordinator: 'coordination', FleetCoordinator: 'coordination',
 };
-const REASONING_EFFORT = {
-    quick: 'low', balanced: 'medium', thorough: 'high',
+/** The three editable purpose Brains setup creates, by kind of work. */
+export const PURPOSE_BRAINS = {
+    development: { id: 'development', label: 'Development' },
+    review: { id: 'critic', label: 'Critic' },
+    coordination: { id: 'coordination', label: 'Coordination' },
 };
-const MODEL_LABELS = {
-    'gpt-6.1-sol': 'GPT-6.1 Sol',
-    'gpt-6-sol': 'GPT-6 Sol',
-    'gpt-6-luna': 'GPT-6 Luna',
-    'claude-fable-5-1': 'Claude Fable 5.1',
-    'claude-opus-5-5': 'Claude Opus 5.5',
-    'claude-haiku-4-5-20251001': 'Claude Haiku 4.5',
-    'gpt-6-astra': 'GPT-6 Astra',
-    'gpt-5.6-sol': 'GPT-5.6 Sol',
-    'gpt-5.6-terra': 'GPT-5.6 Terra',
-    'gpt-5.6-luna': 'GPT-5.6 Luna',
-    'gpt-5.5': 'GPT-5.5',
-    'gpt-5.4': 'GPT-5.4',
-    'gpt-5.4-mini': 'GPT-5.4 Mini',
-    'gpt-5.3-codex-spark': 'GPT-5.3 Codex Spark',
-    'claude-fable-5': 'Claude Fable 5',
-    'claude-opus-5': 'Claude Opus 5',
-    'claude-sonnet-5': 'Claude Sonnet 5',
-};
-export function validateCatalog(value, path = 'supported model catalog') {
-    if (value.schema_version !== 1 || !Array.isArray(value.models) || value.models.length === 0)
-        throw new Error(`invalid supported model catalog: ${path}`);
-    const tuples = new Set();
-    for (const model of value.models) {
-        if (!['codex', 'claude-code'].includes(model.harness) || model.session !== 'acp'
-            || typeof model.model !== 'string' || !MODEL_LABELS[model.model]
-            || !Array.isArray(model.efforts)
-            || new Set(model.efforts).size !== model.efforts.length
-            || model.efforts.some(effort => !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(effort))
-            || (model.efforts.length > 0 && !['low', 'medium', 'high'].every(effort => model.efforts.includes(effort))))
-            throw new Error(`unsupported model state in ${path}`);
-        const tuple = `${model.harness}\0${model.session}\0${model.model}`;
-        if (tuples.has(tuple))
-            throw new Error(`duplicate supported model in ${path}: ${model.model}`);
-        tuples.add(tuple);
-    }
-    return value;
-}
-function catalog() {
-    const path = join(packagedPresetRoot(), 'brain-catalog.json');
-    return validateCatalog(JSON.parse(readFileSync(path, 'utf8')), path);
-}
+// Legacy --settings files chose one reasoning level for every purpose.
+const LEGACY_REASONING = { quick: 'low', balanced: 'medium', thorough: 'high' };
+const labelOf = (choice) => packagedModelCatalog().find(model => model.harness === choice.harness && model.model === choice.model)?.label ?? choice.model;
 const hasExactKeys = (value, keys) => Object.keys(value).sort().join('\0') === [...keys].sort().join('\0');
+const isObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 /** Read and validate the complete public InitAnswers JSON shape without side effects. */
 export function readInitSettings(path) {
     let value;
@@ -65,21 +32,38 @@ export function readInitSettings(path) {
     catch (error) {
         throw new Error(`cannot read valid Fleet init settings ${path}: ${error.message}`, { cause: error });
     }
-    if (!value || typeof value !== 'object' || Array.isArray(value)
-        || !hasExactKeys(value, ['subscriptions', 'assignmentStrategy', 'models', 'reasoning']))
-        throw new Error('Fleet init settings must contain exactly subscriptions, assignmentStrategy, models, and reasoning');
-    const candidate = value;
-    const models = candidate.models;
-    if (!models || typeof models !== 'object' || Array.isArray(models)
-        || !hasExactKeys(models, WORK_KINDS))
+    if (!isObject(value))
+        throw new Error('Fleet init settings must be a JSON object');
+    const legacy = hasExactKeys(value, ['subscriptions', 'assignmentStrategy', 'models', 'reasoning']);
+    if (!legacy && !hasExactKeys(value, ['subscriptions', 'assignmentStrategy', 'models']))
+        throw new Error('Fleet init settings must contain exactly subscriptions, assignmentStrategy, and models');
+    const models = value.models;
+    if (!isObject(models) || !hasExactKeys(models, WORK_KINDS))
         throw new Error('Fleet init settings models must contain exactly development, review, and coordination');
+    const chosen = {};
     for (const work of WORK_KINDS) {
         const model = models[work];
-        if (!model || typeof model !== 'object' || Array.isArray(model)
-            || !hasExactKeys(model, ['harness', 'session', 'model', 'efforts']))
-            throw new Error(`Fleet init settings ${work} model must contain exactly harness, session, model, and efforts`);
+        if (legacy) {
+            // The earlier shape: catalog entries plus one reasoning level; each purpose gets that exact effort.
+            if (!isObject(model) || !hasExactKeys(model, ['harness', 'session', 'model', 'efforts']))
+                throw new Error(`Fleet init settings ${work} model must contain exactly harness, session, model, and efforts`);
+            const effort = LEGACY_REASONING[String(value.reasoning)];
+            if (!effort)
+                throw new Error(`unsupported reasoning preference: ${String(value.reasoning)}`);
+            chosen[work] = { harness: model.harness, session: model.session,
+                model: model.model, effort };
+        }
+        else {
+            if (!isObject(model) || !hasExactKeys(model, ['harness', 'session', 'model', 'effort']))
+                throw new Error(`Fleet init settings ${work} model must contain exactly harness, session, model, and effort`);
+            chosen[work] = model;
+        }
     }
-    const answers = value;
+    const answers = {
+        subscriptions: value.subscriptions,
+        assignmentStrategy: value.assignmentStrategy,
+        models: chosen,
+    };
     // Generation is the single semantic/catalog validator for wizard and file input.
     generateSetup(answers);
     return answers;
@@ -96,9 +80,7 @@ export async function askInitQuestions(prompter, configuration) {
         return undefined;
     if (subscriptions.length === 0)
         throw new Error('Select at least one subscription.');
-    // The wizard assigns low/medium/high; no-effort models remain available as named presets.
-    const available = catalog().models.filter(model => subscriptions.includes(subscriptionFor(model))
-        && model.efforts.length > 0);
+    const available = packagedModelCatalog().filter(model => subscriptions.includes(subscriptionFor(model)));
     if (!available.length)
         throw new Error('None of the selected subscriptions has a supported model.');
     prompter.note([
@@ -112,35 +94,41 @@ export async function askInitQuestions(prompter, configuration) {
     if (!assignmentStrategy)
         return undefined;
     const choices = available.map(model => ({
-        label: `${MODEL_LABELS[model.model]} (${subscriptionFor(model) === 'codex' ? 'Codex' : 'Claude'}) — ${model.model}; supported catalog ID, not a recommendation`,
+        label: `${model.label} (${subscriptionFor(model) === 'codex' ? 'Codex' : 'Claude'}) — ${model.model}; supported catalog ID, not a recommendation`,
         value: model,
     }));
+    const askEffort = async (purpose, model) => {
+        if (!model.efforts.length) {
+            prompter.note(`${model.label} has no effort setting; the ${purpose} Brain sets none.`);
+            return null;
+        }
+        const initial = Math.max(0, model.efforts.indexOf('medium'));
+        return prompter.select(`Which effort should the ${purpose} Brain use with ${model.label}?`, model.efforts.map(effort => ({ label: effort, value: effort })), initial);
+    };
     const selected = {};
     if (assignmentStrategy === 'one-model') {
         const model = await prompter.select('Which model should handle every job?', choices, 0);
         if (!model)
             return undefined;
-        for (const work of WORK_KINDS)
-            selected[work] = model;
+        for (const work of WORK_KINDS) {
+            const effort = await askEffort(PURPOSE_BRAINS[work].label, model);
+            if (effort === undefined)
+                return undefined;
+            selected[work] = { harness: model.harness, session: model.session, model: model.model, effort };
+        }
     }
     else {
         for (const work of WORK_KINDS) {
-            const model = await prompter.select(`Which model should handle ${work}?`, choices, 0);
+            const model = await prompter.select(`Which model should the ${PURPOSE_BRAINS[work].label} Brain use?`, choices, 0);
             if (!model)
                 return undefined;
-            selected[work] = model;
+            const effort = await askEffort(PURPOSE_BRAINS[work].label, model);
+            if (effort === undefined)
+                return undefined;
+            selected[work] = { harness: model.harness, session: model.session, model: model.model, effort };
         }
     }
-    const reasoning = await prompter.select('How much reasoning should Fleet use?', [
-        { label: 'Quick — favor speed', value: 'quick' },
-        { label: 'Balanced — everyday work', value: 'balanced' },
-        { label: 'Thorough — harder work', value: 'thorough' },
-    ], 1);
-    if (!reasoning)
-        return undefined;
-    const answers = {
-        subscriptions: [...subscriptions].sort(), assignmentStrategy, models: selected, reasoning,
-    };
+    const answers = { subscriptions: [...subscriptions].sort(), assignmentStrategy, models: selected };
     const summary = formatSetupSummary(answers, configuration);
     const finalized = await prompter.confirm('Create this default Fleet setup?', `${summary}\n\nNo changes have been made yet.`);
     return finalized ? answers : undefined;
@@ -153,18 +141,17 @@ export function formatSetupSummary(answers, configuration) {
     const existing = configExists && rootExists ? 'both targets exist'
         : configExists ? 'only the manifest exists'
             : rootExists ? 'only the split configuration directory exists' : 'neither target exists';
-    const friendly = (work) => `${MODEL_LABELS[answers.models[work].model]} (${subscriptionFor(answers.models[work]) === 'codex' ? 'Codex' : 'Claude'}, ${answers.models[work].model})`;
-    const effort = REASONING_EFFORT[answers.reasoning];
+    const friendly = (work) => {
+        const choice = answers.models[work];
+        return `${PURPOSE_BRAINS[work].label} Brain (${PURPOSE_BRAINS[work].id}): ${labelOf(choice)} (${subscriptionFor(choice) === 'codex' ? 'Codex' : 'Claude'}, ${choice.model}), effort ${choice.effort ?? 'none (model has no effort setting)'}`;
+    };
     return [
         'Your default Fleet setup:',
         `  Manifest: ${configPath}`,
         `  Split configuration: ${splitRoot}`,
         `  Existing state: ${existing}`,
         `  Model assignment: ${answers.assignmentStrategy === 'one-model' ? 'one model for every job' : 'different models by job'}`,
-        `  Development: ${friendly('development')}`,
-        `  Review: ${friendly('review')}`,
-        `  Coordination: ${friendly('coordination')}`,
-        `  Reasoning: ${answers.reasoning[0].toUpperCase()}${answers.reasoning.slice(1)} -> ${effort}`,
+        ...WORK_KINDS.map(work => `  ${friendly(work)}`),
         '  Availability: catalog support is not a recommendation or entitlement claim',
         '  Entitlement check: run ours-fleet doctor for Codex; Claude is validated when a role launches',
         '  Automatic model fallback: none (no model_chain is generated)',
@@ -172,8 +159,8 @@ export function formatSetupSummary(answers, configuration) {
         '  Reviewed pair: Developer + independent Critic',
         '  Team: LocalCoordinator + Developer + Critic',
         '  Gated engineering: Engineer (gate pipeline) + independent Critic',
-        '  FleetCoordinator: coordination model',
-        '  Brains: the packaged presets; each prepared agent references the preset of its chosen model',
+        '  FleetCoordinator: Coordination Brain',
+        '  Brains: three editable purpose Brains (development, critic, coordination); change them or add more in Settings > Brains',
         '',
         'After the final Yes, Fleet performs host service setup before publishing the complete configuration.',
         'A hard termination after that Yes can leave host integration or private stage/recovery evidence to inspect.',
@@ -182,23 +169,26 @@ export function formatSetupSummary(answers, configuration) {
 function preset(relative) {
     return readFileSync(join(packagedPresetRoot(), 'fleet', relative), 'utf8');
 }
-/** The packaged Brain preset for a catalog model at one effort; the same naming the presets are generated with. */
-export function brainPresetId(model, effort) {
-    return `${model.harness === 'claude-code' ? 'claude' : 'codex'}-${model.model
-        .replace(/^claude-/, '').replace(/\./g, '-').toLowerCase()}-${effort}`;
+/** The YAML of one purpose Brain holding exactly the chosen triple. */
+export function purposeBrainYaml(work, choice) {
+    return [
+        `# ${PURPOSE_BRAINS[work].label} Brain created by Fleet setup. Edit it in Settings > Brains.`,
+        `harness: ${choice.harness}`,
+        `session: ${choice.session}`,
+        `model: ${choice.model}`,
+        ...(choice.effort === null ? [] : [`effort: ${choice.effort}`]),
+        '',
+    ].join('\n');
 }
 /** Build the exact, deterministic default experience without writing to disk. */
 export function generateSetup(answers) {
-    const effort = REASONING_EFFORT[answers.reasoning];
-    if (!effort)
-        throw new Error(`unsupported reasoning preference: ${String(answers.reasoning)}`);
     if (!['one-model', 'per-job'].includes(answers.assignmentStrategy))
         throw new Error(`unsupported model assignment strategy: ${String(answers.assignmentStrategy)}`);
     if (!Array.isArray(answers.subscriptions) || answers.subscriptions.length === 0
         || new Set(answers.subscriptions).size !== answers.subscriptions.length
         || answers.subscriptions.some(subscription => !['codex', 'claude'].includes(subscription)))
         throw new Error('subscriptions must be a non-empty unique selection of Codex and/or Claude');
-    const supported = catalog().models;
+    const supported = packagedModelCatalog();
     const files = new Map();
     files.set('fleet.yaml', [
         'api_version: ours.network/fleet/v2',
@@ -207,9 +197,8 @@ export function generateSetup(answers) {
         '  permissions: { approval: ask, filesystem: workspace, unattended: deny }',
         '',
     ].join('\n'));
-    const assigned = {};
     for (const work of WORK_KINDS) {
-        const proposed = answers.models[work];
+        const proposed = answers.models?.[work];
         if (!proposed || !answers.subscriptions.includes(subscriptionFor(proposed)))
             throw new Error(`${work} uses a model outside the selected subscriptions`);
         const matches = supported.filter(model => model.harness === proposed.harness
@@ -217,18 +206,16 @@ export function generateSetup(answers) {
         if (matches.length !== 1)
             throw new Error(`${work} uses an unknown or ambiguous supported model`);
         const model = matches[0];
-        if (JSON.stringify(proposed.efforts) !== JSON.stringify(model.efforts))
-            throw new Error(`${work} contains tampered model capabilities`);
-        if (!model.efforts.includes(effort))
-            throw new Error(`${MODEL_LABELS[model.model]} does not support ${answers.reasoning} reasoning`);
-        // The chosen model is assigned by reference to its packaged Brain preset; setup defines no Brain of its own.
-        const id = brainPresetId(model, effort);
-        if (!existsSync(join(packagedPresetRoot(), 'fleet', 'brains', `${id}.yaml`)))
-            throw new Error(`no packaged Brain preset for ${MODEL_LABELS[model.model]} at ${effort} reasoning`);
-        assigned[work] = id;
+        // The chosen effort is kept exactly; nothing is substituted.
+        if (model.efforts.length === 0) {
+            if (proposed.effort !== null)
+                throw new Error(`${model.label} has no effort setting; ${work} effort must be null`);
+        }
+        else if (typeof proposed.effort !== 'string' || !model.efforts.includes(proposed.effort)) {
+            throw new Error(`${model.label} does not support effort '${String(proposed.effort)}' for ${work}; choose one of: ${model.efforts.join(', ')}`);
+        }
+        files.set(`brains/${PURPOSE_BRAINS[work].id}.yaml`, purposeBrainYaml(work, proposed));
     }
-    for (const name of readdirSync(join(packagedPresetRoot(), 'fleet', 'brains')).filter(name => name.endsWith('.yaml')).sort())
-        files.set(`brains/${name}`, preset(`brains/${name}`));
     if (answers.assignmentStrategy === 'one-model') {
         const tuples = new Set(WORK_KINDS.map(work => {
             const model = answers.models[work];
@@ -243,7 +230,7 @@ export function generateSetup(answers) {
             continue;
         files.set(`agent_templates/${role}.yaml`, [
             `role: { ref: ${role} }`,
-            `brain: { ref: ${assigned[ROLE_WORK[role]]} }`,
+            `brain: { ref: ${PURPOSE_BRAINS[ROLE_WORK[role]].id} }`,
             'coordinator: FleetCoordinator',
             // Temporary default while the product is being tested: prepared agents work without asking.
             'permissions: { approval: allow, filesystem: unrestricted, unattended: deny }',
@@ -252,13 +239,40 @@ export function generateSetup(answers) {
         ].join('\n'));
     }
     files.set('agents/FleetCoordinator.yaml', preset('agents/FleetCoordinator.yaml')
-        .replace('brain: { ref: claude-default }', `brain: { ref: ${assigned.coordination} }`));
+        .replace('brain: { ref: claude-default }', `brain: { ref: ${PURPOSE_BRAINS.coordination.id} }`));
     for (const name of ['single', 'pair', 'team', 'engineering']) {
         files.set(`room_templates/${name}.yaml`, preset(`room_templates/${name}.yaml`));
         files.set(`room_layouts/${name}.yaml`, preset(`room_layouts/${name}.yaml`));
     }
     return { files, answers };
 }
+/** Setup stopped because an existing purpose Brain holds other settings than the chosen ones. */
+export class PurposeBrainConflictError extends Error {
+}
+/**
+ * Setup preserves existing files. A purpose Brain that already exists with a different
+ * harness, session, model or effort is never overwritten; setup stops and says so.
+ */
+export function purposeBrainConflicts(configuration, answers) {
+    const brains = join(splitRootFor(resolve(configuration)), 'brains');
+    return WORK_KINDS.flatMap(work => {
+        const { id } = PURPOSE_BRAINS[work];
+        const path = join(brains, `${id}.yaml`);
+        if (!existsSync(path))
+            return [];
+        let value;
+        try {
+            value = (parseYaml(readFileSync(path, 'utf8')) ?? {});
+        }
+        catch {
+            return [`brains/${id}.yaml exists and cannot be read`];
+        }
+        const wanted = answers.models[work];
+        const same = value.harness === wanted.harness && (value.session ?? 'acp') === wanted.session
+            && value.model === wanted.model && (value.effort ?? null) === wanted.effort;
+        return same ? [] : [`brains/${id}.yaml already exists with different settings`];
+    });
+}
 /** Run the mutation boundary only after the complete questionnaire is accepted. */
 export async function executeInitWizard(prompter, configuration, deps) {
     const answers = await askInitQuestions(prompter, configuration);
@@ -273,6 +287,10 @@ export async function executeInitAnswers(answers, configuration, deps) {
     // deterministically in tests.
     const setup = (deps.generate ?? generateSetup)(answers);
     (deps.preflight ?? preflightInitPaths)(configuration);
+    const conflicts = purposeBrainConflicts(configuration, answers);
+    if (conflicts.length)
+        throw new PurposeBrainConflictError(`Setup would not use the chosen models: ${conflicts.join('; ')}. `
+            + 'Existing Brains are kept; change them in Settings > Brains or choose matching models.');
     try {
         await deps.hostSetup();
     }

package/dist/rooms-tasks/add-member.d.ts

@@ -6,13 +6,25 @@ import type { TaskLayouts } from '../application/task-layouts.js';
 export declare class MemberAdditionRejected extends TaskStateError {
     readonly accepted = false;
 }
+/** A one-off harness/model/effort for this member only; no Brain is saved. Omitted model/effort keep the harness default. */
+export interface ManualBrain {
+    harness: string;
+    session?: string;
+    model?: string;
+    effort?: string;
+}
+/** `brain` omitted: the member uses its Agent Template's own Brain, unchanged. */
 export interface AddMemberRequest {
     requestId: string;
     slot: string;
     role: string;
-    brain: string;
+    brain?: string | {
+        inline: ManualBrain;
+    };
     agentTemplate: string;
 }
+/** No Brain, a saved Brain name, or exactly one manual harness/model/effort. */
+export declare function validMemberBrain(brain: unknown): brain is AddMemberRequest['brain'];
 export declare function memberAddition(taskId: string, requestId: string): {
     requestId: string;
     taskId: string;
@@ -35,6 +47,8 @@ export declare function requestMemberAddition(input: {
     binPath: string;
     provision?: typeof provisionMembers;
     layouts?: TaskLayouts;
+    /** Checks a new request only; a retry of an accepted request returns its receipt. */
+    checkNewRequest?: (request: AddMemberRequest) => Promise<void>;
 }): Promise<{
     requestId: string;
     taskId: string;

package/dist/rooms-tasks/add-member.js

@@ -16,6 +16,28 @@ import { validLayoutKey } from './layout-config.js';
 export class MemberAdditionRejected extends TaskStateError {
     accepted = false;
 }
+const MANUAL_KEYS = ['harness', 'session', 'model', 'effort'];
+const text = (v, max = 128) => typeof v === 'string' && v.length > 0 && v.length <= max;
+/** No Brain, a saved Brain name, or exactly one manual harness/model/effort. */
+export function validMemberBrain(brain) {
+    if (brain === undefined || text(brain))
+        return true;
+    const inline = brain?.inline;
+    return Boolean(brain) && typeof brain === 'object' && Object.keys(brain).join() === 'inline'
+        && Boolean(inline) && typeof inline === 'object' && !Array.isArray(inline)
+        && Object.keys(inline).every(key => MANUAL_KEYS.includes(key)) && text(inline.harness)
+        && ['session', 'model', 'effort'].every(key => inline[key] === undefined || text(inline[key]));
+}
+/** The member override: a saved Brain by name, or the manual triple as this member's own inline Brain. */
+function brainOverride(brain) {
+    if (brain === undefined)
+        return {};
+    if (typeof brain === 'string')
+        return { brain };
+    const { harness, session, model, effort } = brain.inline;
+    return { overrides: { brain: { inline: { harness, session: session ?? 'acp',
+                    ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}) } } } };
+}
 const running = new Set();
 function pathFor(taskId, requestId) {
     if (!/^[a-z0-9]{10,40}$/.test(taskId) || !/^[a-zA-Z0-9_-]{8,80}$/.test(requestId))
@@ -34,9 +56,9 @@ export function memberAddition(taskId, requestId) {
 export async function requestMemberAddition(input) {
     const { request: r, taskId } = input;
     if (!r || typeof r.slot !== 'string' || !/^[A-Za-z][A-Za-z0-9_-]{0,31}$/.test(r.slot)
-        || ![r.role, r.brain, r.agentTemplate].every(v => typeof v === 'string' && v.length > 0 && v.length <= 128))
+        || ![r.role, r.agentTemplate].every(v => text(v)) || !validMemberBrain(r.brain))
         // No receipt lookup has happened yet: this request ID may already be accepted.
-        throw new TaskStateError('Slot, Role, Brain and Agent Template are required');
+        throw new TaskStateError('Slot, Role and Agent Template are required; Brain must be a saved Brain or a harness, model and effort');
     const path = pathFor(taskId, r.requestId);
     const hash = createHash('sha256').update(canonicalJson(r)).digest('hex');
     mkdirSync(join(stateRoot(), 'member-additions', taskId), { recursive: true, mode: 0o700 });
@@ -47,6 +69,7 @@ export async function requestMemberAddition(input) {
                 throw new TaskStateError('Request ID was already used with different settings');
             return memberAddition(taskId, r.requestId);
         }
+        await input.checkNewRequest?.(r);
         const task = getTask(taskId);
         const room = task.room_id && getRoomRecord(task.room_id);
         if (task.layout?.name === EMPTY_TASK_LAYOUT && input.layouts) {
@@ -63,7 +86,7 @@ export async function requestMemberAddition(input) {
             const definition = (() => {
                 try {
                     const plan = prepareExecutionPlan({ name: 'additional-member', version: 1, description: 'Additional task participant',
-                        members: [{ slot: r.slot, role: r.slot, count: 1, agent_template: r.agentTemplate }] }, input.cfg, { [r.slot]: { role: r.role, brain: r.brain, ...(task.workspace ? { cwd: task.workspace.path } : {}) } });
+                        members: [{ slot: r.slot, role: r.slot, count: 1, agent_template: r.agentTemplate }] }, input.cfg, { [r.slot]: { role: r.role, ...brainOverride(r.brain), ...(task.workspace ? { cwd: task.workspace.path } : {}) } });
                     return Object.values(plan.launchDefinitions)[0];
                 }
                 catch (error) {
@@ -106,7 +129,7 @@ export async function requestMemberAddition(input) {
         const plan = (() => {
             try {
                 return prepareExecutionPlan({ name: 'additional-member', version: 1, description: 'Additional task participant',
-                    contract: room.template_snapshot?.contract, members: [{ slot: r.slot, role: r.role, count: 1, agent_template: r.agentTemplate }] }, input.cfg, { [r.slot]: { role: r.role, brain: r.brain } });
+                    contract: room.template_snapshot?.contract, members: [{ slot: r.slot, role: r.role, count: 1, agent_template: r.agentTemplate }] }, input.cfg, { [r.slot]: { role: r.role, ...brainOverride(r.brain) } });
             }
             catch (error) {
                 throw new MemberAdditionRejected(error instanceof Error ? error.message : 'Invalid member configuration');

package/dist/web/server.js

@@ -7,15 +7,13 @@ import { registerConversationStream } from './conversation-stream.js';
 import { conversationHasAttachment } from '../application/conversation-history.js';
 import { readDeliveredFile } from '../file-delivery/store.js';
 import { WorkspaceDeviceAuthError } from './workspace-devices.js';
-import { readFileSync } from 'node:fs';
-import { packagedPresetRoot } from '../preset-bootstrap.js';
-import { validateCatalog } from '../init-wizard.js';
+import { PURPOSE_BRAINS, PurposeBrainConflictError } from '../init-wizard.js';
+import { harnessCapabilities, validateBrainChoice } from '../application/harness-capabilities.js';
 import { getAdapter } from '../harness/registry.js';
 import { storeAgentAttachment, attachmentPrompt, MAX_ATTACHMENT_BODY, readAgentAttachment, prepareAttachmentPresentation, presentAttachmentEvent } from './agent-attachments.js';
 import { readChatIdle } from '../temp-idle.js';
 import { agentDir } from '../paths.js';
 import { SupervisorOursTools } from '../application/supervisor-ours-tools.js';
-import { join } from 'node:path';
 import Fastify from 'fastify';
 import fastifyWebsocket from '@fastify/websocket';
 import { createHmac, randomBytes } from 'node:crypto';
@@ -215,12 +213,12 @@ export async function buildWebServer(services, boundary, options = {}) {
                 return { harness, ok: false, checks: [{ name: 'availability', ok: false, detail: 'Harness checks unavailable' }] };
             }
         }));
-        const catalog = validateCatalog(JSON.parse(readFileSync(join(packagedPresetRoot(), 'brain-catalog.json'), 'utf8')));
-        // Codex models are offered only when the runtime itself listed them for the active account.
-        // When it could not be asked, none is offered and the reason is reported.
-        const codexModels = services.codexModels ? await services.codexModels() : undefined;
-        const offered = (model) => model.harness !== 'codex' || !codexModels || (codexModels.state === 'known' && codexModels.models.includes(model.model));
-        const payload = { harnesses, catalog: catalog.models.filter(offered), ...(codexModels ? { codexModels: codexModels.state === 'known' ? { state: 'known' } : codexModels } : {}), providers: services.subscriptions ? await services.subscriptions.list() : [], coordinator: 'FleetCoordinator', configured: onboardingConfigured() };
+        // The catalog is each adapter's maintained models, narrowed to what the active Codex account offers.
+        const capabilities = await harnessCapabilities({ harnesses: ['codex', 'claude-code'], codexModels: services.codexModels, checkReadiness: false });
+        const codex = capabilities.harnesses.find(item => item.harness === 'codex');
+        const catalog = capabilities.harnesses.flatMap(item => item.models.filter(model => model.available && model.efforts !== null)
+            .map(model => ({ harness: item.harness, session: 'acp', model: model.id, label: model.label, efforts: model.efforts })));
+        const payload = { harnesses, catalog, ...(codex?.discovery ? { codexModels: codex.discovery } : {}), providers: services.subscriptions ? await services.subscriptions.list() : [], coordinator: 'FleetCoordinator', configured: onboardingConfigured() };
         if (revision === services.configuration?.read().revision) {
             onboardingObserved = { owner: browser.id, revision, payload };
             events.publish('onboarding.changed', {});
@@ -245,15 +243,25 @@ export async function buildWebServer(services, boundary, options = {}) {
         if (!services.configuration || !services.onboardingSetup)
             throw new FleetError('capability_unavailable', 'first-time Fleet setup is unavailable');
         const requested = request.body?.models;
-        const codexModels = services.codexModels ? await services.codexModels() : undefined;
-        const supported = validateCatalog(JSON.parse(readFileSync(join(packagedPresetRoot(), 'brain-catalog.json'), 'utf8'))).models
-            .filter(model => model.harness !== 'codex' || !codexModels || (codexModels.state === 'known' && codexModels.models.includes(model.model)));
+        const capabilities = await harnessCapabilities({ harnesses: ['codex', 'claude-code'], codexModels: services.codexModels, checkReadiness: false });
         const models = {};
         for (const work of ONBOARDING_WORK) {
-            const matches = supported.filter(model => model.harness === requested?.[work]?.harness && model.model === requested?.[work]?.model);
-            if (matches.length !== 1)
-                throw new FleetError('invalid_request', `choose a supported model for ${work}`);
-            models[work] = matches[0];
+            const choice = requested?.[work];
+            const label = PURPOSE_BRAINS[work].label;
+            if (!choice || typeof choice !== 'object' || !('effort' in choice))
+                throw new FleetError('invalid_request', `choose a harness, model and effort for the ${label} Brain`);
+            const { harness, model, effort } = choice;
+            if (typeof harness !== 'string' || typeof model !== 'string' || (effort !== null && typeof effort !== 'string'))
+                throw new FleetError('invalid_request', `choose a harness, model and effort for the ${label} Brain`);
+            const check = validateBrainChoice(capabilities, { harness, session: 'acp', model, effort });
+            // Setup offers the adapters' maintained models only, each with an explicit effort when it has one.
+            if (!check.ok)
+                throw new FleetError('invalid_request', `${label} Brain: ${check.message}`);
+            if (!check.model || check.model.source !== 'adapter')
+                throw new FleetError('invalid_request', `${label} Brain: choose a supported model`);
+            if (check.model.efforts?.length && effort === null)
+                throw new FleetError('invalid_request', `${label} Brain: choose an effort for ${check.model.label} (${check.model.efforts.join(', ')})`);
+            models[work] = { harness: harness, session: 'acp', model, effort: effort };
         }
         const chosen = Object.values(models);
         const subscriptions = [...new Set(chosen.map(model => model.harness === 'codex' ? 'codex' : 'claude'))];
@@ -264,31 +272,49 @@ export async function buildWebServer(services, boundary, options = {}) {
             if (onboardingConfigured())
                 throw new FleetError('conflict', 'Fleet is already set up; change its models in the configuration');
             try {
-                await setup({ subscriptions, assignmentStrategy: oneModel ? 'one-model' : 'per-job', models, reasoning: 'balanced' });
+                await setup({ subscriptions, assignmentStrategy: oneModel ? 'one-model' : 'per-job', models });
             }
             catch (error) {
+                if (error instanceof PurposeBrainConflictError)
+                    throw new FleetError('conflict', error.message);
                 throw new FleetError('backend_failure', `Fleet setup did not complete: ${error.message}`);
             }
-            // Setup preserves files it finds, so confirm the published models are the ones this request chose.
-            // The prepared agents reference packaged Brain presets, so resolve what each of them now points at:
-            // a preserved file of a packaged name may hold another model, session or reasoning than its name says.
+            // Setup preserves files it finds, so confirm each prepared agent now resolves to exactly the chosen triple.
             const published = configuration.read(true).model, brains = published.brains ?? {};
             const brainOf = (holder) => brains[String(holder?.brain?.ref ?? '')];
             const assigned = { coordination: brainOf(published.agents.FleetCoordinator), development: brainOf(published.agent_templates?.Developer), review: brainOf(published.agent_templates?.Critic) };
             for (const work of ONBOARDING_WORK)
-                if (assigned[work]?.harness !== models[work].harness || assigned[work]?.model !== models[work].model || assigned[work]?.session !== models[work].session || assigned[work]?.effort !== 'medium')
+                if (assigned[work]?.harness !== models[work].harness || assigned[work]?.model !== models[work].model || assigned[work]?.session !== models[work].session || (assigned[work]?.effort ?? null) !== models[work].effort)
                     throw new FleetError('conflict', 'Fleet was set up with different models; review its configuration');
             return { configured: true };
         });
         onboardingSetupQueue = run.catch(() => { });
         return run;
     });
+    app.get('/api/v1/harness-capabilities', async (request) => {
+        auth.authenticate(request);
+        return harnessCapabilities({ codexModels: services.codexModels });
+    });
     app.get('/api/v1/creation-capabilities', async (request) => {
         auth.authenticate(request);
         return services.creation.capabilities();
     });
+    // A new agent's own harness/model/effort must be one its adapter supports; saved Brains are used as they are.
+    const checkBrainChoice = async (brain) => {
+        if (!brain || typeof brain !== 'object')
+            return;
+        const value = brain;
+        const check = validateBrainChoice(await harnessCapabilities({ codexModels: services.codexModels, checkReadiness: false }), {
+            harness: String(value.harness), session: value.session,
+            model: value.model, effort: value.effort
+        });
+        if (!check.ok)
+            throw new FleetError('invalid_request', `Brain: ${check.message}`);
+    };
+    const checkInlineBrain = (creation) => checkBrainChoice(creation?.brain?.inline);
     app.post('/api/v1/roles/preview', async (request) => {
         auth.authenticate(request, true);
+        await checkInlineBrain(request.body);
         return services.creation.preview(request.body);
     });
     app.post('/api/v1/roles', async (request, reply) => {
@@ -297,7 +323,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         const idempotencyKey = String(request.headers['idempotency-key'] ?? '');
         if (!body?.request || !body.previewHash)
             throw new FleetError('invalid_request', 'request and previewHash are required');
-        const action = await services.creation.create(body.request, body.previewHash, idempotencyKey, session.id);
+        const action = await services.creation.create(body.request, body.previewHash, idempotencyKey, session.id, checkInlineBrain);
         events.publish('creation.changed', action, action.roleId);
         reply.header('Location', `/api/v1/creation-actions/${encodeURIComponent(action.actionId)}`);
         reply.code(202);
@@ -702,7 +728,12 @@ export async function buildWebServer(services, boundary, options = {}) {
         auth.authenticate(request, true);
         const body = request.body;
         try {
-            const result = await taskApi(() => requireTaskRooms().addMember(taskRef(request), body));
+            // A new manual harness/model/effort must be one the adapter supports; nothing is substituted.
+            // A retry of an accepted request returns its receipt even if the account's models changed since.
+            const result = await taskApi(() => requireTaskRooms().addMember(taskRef(request), body, async (member) => {
+                if (typeof member.brain === 'object')
+                    await checkBrainChoice(member.brain.inline);
+            }));
             reply.code(result.state === 'running' ? 202 : 200);
             return result;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",