@ours.network/fleet 2.3.0 → 2.3.1

package/README.md

@@ -1853,7 +1853,7 @@ and member status and choose supported recovery. These checks do not restart age
 recreate identities, redeem invites, or rewrite lifecycle state. Temporary room agents
 remain transient across host reboot; retained launch records do not restore them.
 
-See [predefined Brain models and runtime requirements](presets/README.md) for the verified model/effort matrix and regeneration instructions.
+See [models, efforts and Brains](presets/README.md) for the adapter model catalog, the three purpose Brains setup creates, and runtime requirements.
 
 ### YAML room layouts
 

package/dist/application/harness-capabilities.d.ts

@@ -0,0 +1,60 @@
+import type { PrereqCheck } from '../harness/types.js';
+import type { OfferedModels } from '../subscriptions/cli.js';
+/**
+ * A selectable model. `efforts: null` means the efforts are unknown (a model the
+ * adapter does not maintain); `[]` means the model is known to have no effort setting.
+ */
+export interface CapabilityModel {
+    id: string;
+    label: string;
+    efforts: string[] | null;
+    available: boolean;
+    reason?: string;
+    source: 'adapter' | 'runtime-discovery';
+}
+export interface HarnessCapability {
+    harness: string;
+    ready: boolean;
+    checks: PrereqCheck[];
+    sessions: string[];
+    modelRequired: boolean;
+    customModels: boolean;
+    models: CapabilityModel[];
+    discovery?: {
+        state: 'known';
+    } | {
+        state: 'unknown';
+        reason: string;
+    };
+}
+export interface HarnessCapabilitiesReport {
+    harnesses: HarnessCapability[];
+}
+export interface HarnessCapabilityDeps {
+    harnesses?: string[];
+    codexModels?: () => Promise<OfferedModels>;
+    /** Skip executable checks when only model facts are needed. */
+    checkReadiness?: boolean;
+}
+/** Each production adapter's maintained models, narrowed by what the active Codex account offers. */
+export declare function harnessCapabilities(deps?: HarnessCapabilityDeps): Promise<HarnessCapabilitiesReport>;
+export interface BrainChoice {
+    harness: string;
+    session?: string;
+    model?: string | null;
+    effort?: string | null;
+}
+export type BrainChoiceCheck = {
+    ok: true;
+    model?: CapabilityModel;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+};
+/**
+ * Strict check of a new harness/model/effort choice. Nothing is substituted: an
+ * effort is kept only when the chosen model supports it; an omitted effort keeps
+ * the harness default. Existing Brains are resolved by their adapter as before.
+ */
+export declare function validateBrainChoice(report: HarnessCapabilitiesReport, choice: BrainChoice): BrainChoiceCheck;

package/dist/application/harness-capabilities.js

@@ -0,0 +1,96 @@
+import { getAdapter, knownAdapters, productionAdapters } from '../harness/registry.js';
+/** Each production adapter's maintained models, narrowed by what the active Codex account offers. */
+export async function harnessCapabilities(deps = {}) {
+    // Only harnesses whose adapter is registered in this process can report facts.
+    const ids = (deps.harnesses ?? productionAdapters()).filter(id => knownAdapters().includes(id));
+    const harnesses = await Promise.all(ids.map(async (id) => {
+        const adapter = getAdapter(id);
+        const capabilities = adapter.modelCapabilities?.();
+        if (!capabilities)
+            return undefined;
+        let ready = true, checks = [];
+        if (deps.checkReadiness !== false) {
+            try {
+                ({ ok: ready, checks } = await adapter.checkPrereqs());
+            }
+            catch {
+                ready = false;
+                checks = [{ name: 'availability', ok: false, detail: 'Harness checks unavailable' }];
+            }
+        }
+        let models = capabilities.models.map(model => ({
+            id: model.id, label: model.label, efforts: [...model.efforts], available: true, source: 'adapter',
+        }));
+        let discovery;
+        if (id === 'codex' && deps.codexModels) {
+            const offered = await deps.codexModels();
+            discovery = offered.state === 'known' ? { state: 'known' } : { state: 'unknown', reason: offered.reason };
+            if (offered.state === 'known') {
+                models = models.map(model => offered.models.includes(model.id) ? model
+                    : { ...model, available: false, reason: 'The active Codex account does not offer this model.' });
+                // Offered models the adapter does not maintain: selectable, but their efforts are not known.
+                for (const extra of offered.models.filter(model => !models.some(known => known.id === model)))
+                    models.push({ id: extra, label: extra, efforts: null, available: true, source: 'runtime-discovery' });
+            }
+            else {
+                models = models.map(model => ({ ...model, available: false,
+                    reason: `Codex could not report the models offered to the active account: ${offered.reason}` }));
+            }
+        }
+        return { harness: id, ready, checks, sessions: [...capabilities.sessions], modelRequired: capabilities.modelRequired,
+            customModels: capabilities.customModels, models, ...(discovery ? { discovery } : {}) };
+    }));
+    return { harnesses: harnesses.filter((item) => item !== undefined) };
+}
+/**
+ * Strict check of a new harness/model/effort choice. Nothing is substituted: an
+ * effort is kept only when the chosen model supports it; an omitted effort keeps
+ * the harness default. Existing Brains are resolved by their adapter as before.
+ */
+export function validateBrainChoice(report, choice) {
+    const harness = report.harnesses.find(item => item.harness === choice.harness);
+    if (!harness)
+        return { ok: false, code: 'harness_unsupported',
+            message: `Harness '${String(choice.harness)}' is not available; choose one of: ${report.harnesses.map(item => item.harness).join(', ')}` };
+    if (choice.session !== undefined && !harness.sessions.includes(choice.session))
+        return { ok: false, code: 'session_unsupported',
+            message: `${harness.harness} does not support session '${choice.session}'; choose one of: ${harness.sessions.join(', ')}` };
+    const effort = choice.effort ?? undefined;
+    if (effort !== undefined && (typeof effort !== 'string' || !effort))
+        return { ok: false, code: 'effort_invalid', message: 'Effort must be a non-empty string or omitted' };
+    const modelId = choice.model ?? undefined;
+    if (modelId === undefined) {
+        if (harness.modelRequired)
+            return { ok: false, code: 'model_required', message: `${harness.harness} requires an explicit model` };
+        if (effort !== undefined)
+            return { ok: false, code: 'effort_unknown',
+                message: `The ${harness.harness} default model has no known effort list; choose a model to set effort, or leave effort at the harness default` };
+        return { ok: true };
+    }
+    if (typeof modelId !== 'string' || !modelId.trim())
+        return { ok: false, code: 'model_invalid', message: 'Model must be a non-empty string' };
+    const model = harness.models.find(item => item.id === modelId);
+    if (!model) {
+        if (!harness.customModels)
+            return { ok: false, code: 'model_unsupported',
+                message: `${harness.harness} does not support model '${modelId}'` };
+        if (effort !== undefined)
+            return { ok: false, code: 'effort_unknown',
+                message: `Efforts for '${modelId}' are unknown to ${harness.harness}; leave effort at the harness default or choose a listed model` };
+        return { ok: true };
+    }
+    if (!model.available)
+        return { ok: false, code: 'model_unavailable', message: `${model.label}: ${model.reason ?? 'unavailable'}` };
+    if (effort === undefined)
+        return { ok: true, model };
+    if (model.efforts === null)
+        return { ok: false, code: 'effort_unknown',
+            message: `Efforts for ${model.label} are unknown; leave effort at the harness default` };
+    if (!model.efforts.length)
+        return { ok: false, code: 'effort_unsupported',
+            message: `${model.label} has no effort setting; remove the effort` };
+    if (!model.efforts.includes(effort))
+        return { ok: false, code: 'effort_unsupported',
+            message: `${model.label} does not support effort '${effort}'; choose one of: ${model.efforts.join(', ')}` };
+    return { ok: true, model };
+}

package/dist/application/model-catalog.d.ts

@@ -10,6 +10,23 @@ export interface HarnessModelCatalog {
     models: HarnessModelOption[];
     warnings: string[];
 }
+/** One model a harness adapter knows, with the exact efforts it supports ([] = no effort setting). */
+export interface PackagedModel {
+    harness: 'codex' | 'claude-code';
+    session: 'acp';
+    model: string;
+    label: string;
+    efforts: string[];
+}
+export interface PackagedModelCatalog {
+    schema_version: 2;
+    catalog_revision: number;
+    models: PackagedModel[];
+}
+/** Validate the packaged model catalog maintained with the Claude Code and Codex adapters. */
+export declare function validatePackagedModelCatalog(value: unknown, path?: string): PackagedModelCatalog;
+/** The packaged catalog, optionally limited to one harness. */
+export declare function packagedModelCatalog(harness?: PackagedModel['harness']): PackagedModel[];
 /** Read Codex's locally materialized `model/list` result; never invent fallback aliases. */
 export declare function codexModelCatalog(path?: string): HarnessModelCatalog;
 /**

package/dist/application/model-catalog.js

@@ -1,6 +1,35 @@
 import { readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { packagedPresetRoot } from '../preset-bootstrap.js';
+const KNOWN_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+/** Validate the packaged model catalog maintained with the Claude Code and Codex adapters. */
+export function validatePackagedModelCatalog(value, path = 'packaged model catalog') {
+    const catalog = value;
+    if (!catalog || catalog.schema_version !== 2 || !Number.isInteger(catalog.catalog_revision)
+        || !Array.isArray(catalog.models) || catalog.models.length === 0)
+        throw new Error(`invalid ${path}`);
+    const tuples = new Set();
+    for (const model of catalog.models) {
+        if (!model || !['codex', 'claude-code'].includes(model.harness) || model.session !== 'acp'
+            || typeof model.model !== 'string' || !model.model
+            || typeof model.label !== 'string' || !model.label.trim()
+            || !Array.isArray(model.efforts) || new Set(model.efforts).size !== model.efforts.length
+            || model.efforts.some(effort => !KNOWN_EFFORTS.includes(effort)))
+            throw new Error(`unsupported model state in ${path}: ${String(model?.model)}`);
+        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 catalog;
+}
+/** The packaged catalog, optionally limited to one harness. */
+export function packagedModelCatalog(harness) {
+    const path = join(packagedPresetRoot(), 'brain-catalog.json');
+    const models = validatePackagedModelCatalog(JSON.parse(readFileSync(path, 'utf8')), path).models;
+    return harness ? models.filter(model => model.harness === harness) : models;
+}
 const validId = (value) => typeof value === 'string' && /^[A-Za-z0-9][A-Za-z0-9._[\]-]{0,127}$/.test(value);
 /** Read Codex's locally materialized `model/list` result; never invent fallback aliases. */
 export function codexModelCatalog(path = join(homedir(), '.codex', 'models_cache.json')) {
@@ -45,16 +74,10 @@ export function codexModelCatalog(path = join(homedir(), '.codex', 'models_cache
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export function claudeModelCatalog() {
-    const reasoningEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
     return {
-        models: [
-            { id: 'claude-fable-5-1', label: 'Claude Fable 5.1', reasoningEfforts, source: 'claude-adapter-2.1' },
-            { id: 'claude-opus-5-5', label: 'Claude Opus 5.5', reasoningEfforts, source: 'claude-adapter-2.1' },
-            { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5', reasoningEfforts: [], source: 'claude-adapter-2.1' },
-            { id: 'claude-fable-5', label: 'Claude Fable 5', reasoningEfforts, source: 'claude-adapter-2.1' },
-            { id: 'claude-opus-5', label: 'Claude Opus 5', reasoningEfforts, source: 'claude-adapter-2.1' },
-            { id: 'claude-sonnet-5', label: 'Claude Sonnet 5', reasoningEfforts, source: 'claude-adapter-2.1' },
-        ],
+        models: packagedModelCatalog('claude-code').map(model => ({
+            id: model.model, label: model.label, reasoningEfforts: model.efforts, source: 'claude-adapter-2.1',
+        })),
         warnings: ['Claude Code exposes no typed model-list endpoint; choices require a current Claude runtime (verified with 2.1.281); older bundled SDKs need CLAUDE_CODE_EXECUTABLE. Entitlement is validated at launch.'],
     };
 }

package/dist/application/preset-provenance.d.ts

@@ -5,7 +5,7 @@ export declare const PROVENANCE_KINDS: {
     readonly layout: "room_layouts";
 };
 export type ProvenanceKind = keyof typeof PROVENANCE_KINDS;
-export type ProvenanceStatus = 'predefined' | 'changed' | 'custom';
+export type ProvenanceStatus = 'predefined' | 'changed' | 'custom' | 'legacy';
 export interface ProvenanceEntry {
     status: ProvenanceStatus;
     preset?: string;

package/dist/application/preset-provenance.js

@@ -1,7 +1,9 @@
 /** Where each configured definition came from, compared with the packaged presets.
  * A definition is `predefined` when it has the same value as the shipped preset of
  * the same name, `changed` when a preset of that name exists but the value differs,
- * and `custom` otherwise. Values are compared after parsing, so the formatting the
+ * and `custom` otherwise. A Brain whose name and value match a preset that earlier
+ * releases generated for every model and effort is `legacy`; one of such a name
+ * with another value is `changed`. Values are compared after parsing, so the formatting the
  * configuration editor writes does not count as a change. Preset text is returned
  * so users can see exactly what ships; it contains no host data.
  */
@@ -29,6 +31,14 @@ function yamlFiles(dir) {
     }
     return files;
 }
+/** Brain presets earlier releases generated per model and effort; no longer shipped or installed. */
+function legacyBrains(presetRoot) {
+    const path = join(presetRoot, '..', 'legacy', 'generated-brains-rev4.json');
+    if (!existsSync(path))
+        return new Map();
+    const { brains } = JSON.parse(readFileSync(path, 'utf8'));
+    return new Map(Object.entries(brains).map(([name, value]) => [name, Object.entries(value).map(([key, item]) => `${key}: ${item}`).join('\n') + '\n']));
+}
 const parsed = (text) => { try {
     return parse(text);
 }
@@ -47,10 +57,15 @@ export class PresetProvenance {
         const result = {};
         for (const [kind, dir] of Object.entries(PROVENANCE_KINDS)) {
             const presets = yamlFiles(join(this.presetRoot, dir)), installed = yamlFiles(join(split, dir));
+            const legacy = kind === 'brain' ? legacyBrains(this.presetRoot) : new Map();
             result[kind] = Object.fromEntries([...installed].map(([name, text]) => {
                 const preset = presets.get(name);
-                if (preset === undefined)
-                    return [name, { status: 'custom' }];
+                if (preset === undefined) {
+                    const old = legacy.get(name);
+                    if (old === undefined)
+                        return [name, { status: 'custom' }];
+                    return [name, { status: isDeepStrictEqual(parsed(text), parsed(old)) ? 'legacy' : 'changed', preset: old }];
+                }
                 return [name, { status: isDeepStrictEqual(parsed(text), parsed(preset)) ? 'predefined' : 'changed', preset }];
             }));
         }

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

@@ -145,7 +145,9 @@ export declare class RoleCreationService {
     private launchSync;
     capabilities(): Promise<CreationCapabilities>;
     preview(input: CreateRoleSessionRequest): Promise<CreationPreview>;
-    create(input: CreateRoleSessionRequest, previewHash: string, idempotencyKey: string, browserSession: string): Promise<CreationAction>;
+    create(input: CreateRoleSessionRequest, previewHash: string, idempotencyKey: string, browserSession: string, 
+    /** Checks a new request only; a retry of an accepted request returns its action. */
+    checkNewRequest?: (input: CreateRoleSessionRequest) => Promise<void>): Promise<CreationAction>;
     get(actionId: string): CreationAction | undefined;
     private run;
     private waitForReady;

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

@@ -184,7 +184,9 @@ export class RoleCreationService {
             identityBootstrap, previewHash,
         };
     }
-    async create(input, previewHash, idempotencyKey, browserSession) {
+    async create(input, previewHash, idempotencyKey, browserSession, 
+    /** Checks a new request only; a retry of an accepted request returns its action. */
+    checkNewRequest) {
         if (!/^[A-Za-z0-9_-]{22,256}$/.test(idempotencyKey))
             throw new FleetError('invalid_request', 'Idempotency-Key must contain at least 128 bits');
         const requestHash = hash(this.validate(input));
@@ -195,6 +197,7 @@ export class RoleCreationService {
                 throw new FleetError('idempotency_conflict', 'Idempotency-Key was already used for another request');
             return this.actions.get(existing.actionId);
         }
+        await checkNewRequest?.(input);
         const preview = await this.preview(input);
         if (preview.previewHash !== previewHash)
             throw new FleetError('stale_state', 'preview is stale; review the effective plan again');

package/dist/application/task-room-service.d.ts

@@ -114,7 +114,7 @@ export declare class TaskRoomApplicationService {
     private readonly configurationPath?;
     private readonly deps;
     constructor(configurationPath?: string | undefined, deps?: TaskRoomServiceDeps);
-    addMember(taskId: string, request: AddMemberRequest): Promise<{
+    addMember(taskId: string, request: AddMemberRequest, checkNewRequest?: (request: AddMemberRequest) => Promise<void>): Promise<{
         requestId: string;
         taskId: string;
         roleId: string;

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

@@ -76,11 +76,11 @@ export class TaskRoomApplicationService {
         this.configurationPath = configurationPath;
         this.deps = deps;
     }
-    async addMember(taskId, request) {
+    async addMember(taskId, request, checkNewRequest) {
         const { requestMemberAddition } = await import('../rooms-tasks/add-member.js');
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return requestMemberAddition({ taskId, request, cfg, configPath: this.configurationPath,
-            cowork: readTask(taskId).layout ? undefined : (this.deps.cowork ?? createCoworkAdapter)(cfg), binPath: (this.deps.binPath ?? getBinPath)(), provision: this.deps.provisionMembers, layouts: this.layouts() });
+            cowork: readTask(taskId).layout ? undefined : (this.deps.cowork ?? createCoworkAdapter)(cfg), binPath: (this.deps.binPath ?? getBinPath)(), provision: this.deps.provisionMembers, layouts: this.layouts(), checkNewRequest });
     }
     async memberAddition(taskId, requestId) { const { memberAddition } = await import('../rooms-tasks/add-member.js'); return memberAddition(taskId, requestId); }
     layouts() {

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "2.3.0",
-  "buildId": "246fc0d15b6e",
-  "commit": "ce34aa31bf25ec6d0af430270b65f013e3681900",
+  "version": "2.3.1",
+  "buildId": "2fbb7f11f70a",
+  "commit": "f7b1dda8a2cb911367ce11617ef38759ba78c5e6",
   "dirty": false,
-  "builtAt": "2026-10-30T17:28:38.538Z",
+  "builtAt": "2026-10-30T19:03:10.573Z",
   "capabilities": [
     "service.refresh-v1",
     "managed-cli.codex-reasoning-effort-v1",

package/dist/harness/claude-code.js

@@ -9,6 +9,7 @@ import { harnessRuntimeDir } from '../isolation/policy.js';
 import { bundledAcpAgent, resolveBundledAcpAgent } from './acp-agent.js';
 import { hostClaude } from './claude-runtime.js';
 import { ClaudeCodeAgentSessionAdapter } from './claude-code-session.js';
+import { packagedModelCatalog } from '../application/model-catalog.js';
 const OPTION_KEYS = [
     'plugins', 'mem_palace', 'mem_palace_midsession_autosave', 'permission_mode', 'effort',
     'mcp_servers', 'mcp_servers_only',
@@ -196,6 +197,12 @@ export function makeClaudeCodeAdapter(exec = realExec, transport) {
             },
         }, transport),
         supportsResume: true,
+        modelCapabilities: () => ({
+            sessions: ['acp'],
+            models: packagedModelCatalog('claude-code').map(model => ({ id: model.model, label: model.label, efforts: model.efforts })),
+            modelRequired: false,
+            customModels: true,
+        }),
         async checkPrereqs() {
             const r = await exec('claude', ['--version']);
             const ok = r.code === 0;

package/dist/harness/codex.js

@@ -9,6 +9,7 @@ import { resolveBundledAcpAgent, } from './acp-agent.js';
 import { VERIFIED_CODEX_ACP_VERSIONS, probeCodexRuntime, codexVersionAtLeast, hostCodex } from './codex-runtime.js';
 import { CodexAgentSessionAdapter } from './codex-session.js';
 import { CODEX_REASONING_EFFORTS, isCodexReasoningEffort } from './codex-reasoning.js';
+import { packagedModelCatalog } from '../application/model-catalog.js';
 const OPTION_KEYS = [
     'launcher', 'sandbox', 'approval', 'permission_mode', 'search', 'profile', 'config', 'add_dirs',
     'monitor',
@@ -361,6 +362,12 @@ export function makeCodexAdapter(exec = realExec, transport, nativeTransport) {
             addDirs: role => role.harness_options?.add_dirs,
         }, transport, nativeTransport),
         supportsResume: true,
+        modelCapabilities: () => ({
+            sessions: ['acp', 'codex-app-server'],
+            models: packagedModelCatalog('codex').map(model => ({ id: model.model, label: model.label, efforts: model.efforts })),
+            modelRequired: false,
+            customModels: true,
+        }),
         async checkPrereqs() {
             const [r, hasOursCodex, plugins] = await Promise.all([
                 exec('codex', ['--version']),

package/dist/harness/hermes.js

@@ -21,6 +21,8 @@ export function makeHermesAdapter(exec = realExec, transport) {
             },
         }),
         supportsResume: false,
+        // Hermes models come from the provider configured in the role home; Fleet knows none of them and sets no effort.
+        modelCapabilities: () => ({ sessions: ['acp'], models: [], modelRequired: true, customModels: true }),
         async checkPrereqs() {
             const result = await exec('hermes-acp', ['--help'], { timeout: 10_000 });
             const ok = result.code === 0;

package/dist/harness/types.d.ts

@@ -112,12 +112,32 @@ export interface ValidationError {
     path: string;
     message: string;
 }
+/** A model the adapter knows, with the exact efforts it supports; [] means the model has no effort setting. */
+export interface HarnessKnownModel {
+    id: string;
+    label: string;
+    efforts: string[];
+}
+/**
+ * Models and efforts a harness adapter maintains. Brain choices made in onboarding,
+ * Settings and launch flows are validated against this; existing Brains are not.
+ */
+export interface HarnessModelCapabilities {
+    sessions: string[];
+    models: HarnessKnownModel[];
+    /** A Brain must name a model; otherwise `model: null` selects the harness default. */
+    modelRequired: boolean;
+    /** Models outside `models` may be named; their efforts are unknown. */
+    customModels: boolean;
+}
 export interface HarnessAdapter {
     id: string;
     /** Harness-specific construction behind Fleet's shared live-session contract. */
     agentSession: AgentSessionAdapter;
     supportsResume: boolean;
     checkPrereqs(): Promise<PrereqReport>;
+    /** Models and efforts this adapter supports. Optional for test adapters. */
+    modelCapabilities?(): HarnessModelCapabilities;
     /**
      * `role` is the SESSION-AWARE half: some harness options can only be honoured
      * on some session types, and an option that is silently dropped is worse than

package/dist/init-wizard.d.ts

@@ -2,19 +2,18 @@ import type { Stats } from 'node:fs';
 import type { ReadStream, WriteStream } from 'node:tty';
 export type Subscription = 'codex' | 'claude';
 export type WorkKind = 'development' | 'review' | 'coordination';
-export type ReasoningPreference = 'quick' | 'balanced' | 'thorough';
 export type AssignmentStrategy = 'one-model' | 'per-job';
-export interface CatalogModel {
+/** The exact harness, model and effort chosen for one purpose; `effort: null` only for a model without effort. */
+export interface PurposeChoice {
     harness: 'codex' | 'claude-code';
     session: 'acp';
     model: string;
-    efforts: string[];
+    effort: string | null;
 }
 export interface InitAnswers {
     subscriptions: Subscription[];
     assignmentStrategy: AssignmentStrategy;
-    models: Record<WorkKind, CatalogModel>;
-    reasoning: ReasoningPreference;
+    models: Record<WorkKind, PurposeChoice>;
 }
 export interface Choice<T> {
     label: string;
@@ -26,10 +25,6 @@ export interface InitPrompter {
     select<T>(message: string, choices: Choice<T>[], initial?: number): Promise<T | undefined>;
     note(message: string): void;
 }
-export interface BrainCatalog {
-    schema_version: number;
-    models: CatalogModel[];
-}
 export interface GeneratedSetup {
     files: Map<string, string>;
     answers: InitAnswers;
@@ -48,15 +43,27 @@ export interface InitExecutionDeps {
     generate?(answers: InitAnswers): GeneratedSetup;
     preflight?(configuration: string): InitPathState;
 }
-export declare function validateCatalog(value: BrainCatalog, path?: string): BrainCatalog;
+/** The three editable purpose Brains setup creates, by kind of work. */
+export declare const PURPOSE_BRAINS: Record<WorkKind, {
+    id: string;
+    label: string;
+}>;
 /** Read and validate the complete public InitAnswers JSON shape without side effects. */
 export declare function readInitSettings(path: string): InitAnswers;
 export declare function askInitQuestions(prompter: InitPrompter, configuration: string): Promise<InitAnswers | undefined>;
 export declare function formatSetupSummary(answers: InitAnswers, configuration: string): string;
-/** The packaged Brain preset for a catalog model at one effort; the same naming the presets are generated with. */
-export declare function brainPresetId(model: Pick<CatalogModel, 'harness' | 'model'>, effort: string): string;
+/** The YAML of one purpose Brain holding exactly the chosen triple. */
+export declare function purposeBrainYaml(work: WorkKind, choice: PurposeChoice): string;
 /** Build the exact, deterministic default experience without writing to disk. */
 export declare function generateSetup(answers: InitAnswers): GeneratedSetup;
+/** Setup stopped because an existing purpose Brain holds other settings than the chosen ones. */
+export declare 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 declare function purposeBrainConflicts(configuration: string, answers: InitAnswers): string[];
 /** Run the mutation boundary only after the complete questionnaire is accepted. */
 export declare function executeInitWizard(prompter: InitPrompter, configuration: string, deps: InitExecutionDeps): Promise<InitPublishResult | undefined>;
 /** Execute already-collected answers through the same validation and mutation boundary. */