@ours.network/fleet 2.3.0 → 2.3.2

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/rooms-tasks/task-state.js

@@ -179,7 +179,7 @@ function writeTask(record, options = {}) {
             const next = status(record), before = previous ? status(previous) : undefined;
             pending.push({ eventId: `task:${record.task_id}:${randomUUID()}`, taskId: record.task_id,
                 title: `Task ${!previous ? 'created' : 'updated'}: ${taskLabel(record)}`.slice(0, 160),
-                body: `Task ${record.task_id}: ${before ? `${before} → ` : 'created in '}${next}.`,
+                body: taskSentence(record, `${before ? `${before} → ` : 'created in '}${next}.`),
                 target: { kind: 'task', taskId: record.task_id }, delivery: 'push-only' });
         }
         pending.push(...contributionEvents(previous, record));
@@ -196,6 +196,11 @@ function writeTask(record, options = {}) {
 }
 /** Human label for notification titles: the mission key, when issued, precedes the title. */
 const taskLabel = (record) => record.key ? `${record.key} · ${record.title}` : record.title;
+/**
+ * Notification body naming the task by its mission key. The opaque task ID stays in routing and
+ * event fields only; a task without a key relies on its title, which the notification title shows.
+ */
+const taskSentence = (record, text) => record.key ? `Task ${record.key}: ${text}` : text[0].toUpperCase() + text.slice(1);
 /** Packages written before revisions existed count as revision 1; their next change becomes 2. No package is 0. */
 export const reviewRevision = (review) => review ? review.revision ?? 1 : 0;
 const contributionsChanged = (previous, record) => (record.progress ?? []).some(entry => !(previous.progress ?? []).some(old => old.id === entry.id))
@@ -214,7 +219,7 @@ function contributionEvents(previous, record) {
     const revision = reviewRevision(record.review);
     if (revision > reviewRevision(previous.review))
         events.push({ eventId: `task:${id}:review:${revision}`, taskId: id, title: `To review updated: ${taskLabel(record)}`.slice(0, 160),
-            body: `Task ${id}: the review package changed.`, target: { kind: 'task', taskId: id }, delivery: 'push-only' });
+            body: taskSentence(record, 'the review package changed.'), target: { kind: 'task', taskId: id }, delivery: 'push-only' });
     return events;
 }
 /** Item-based Progress unread and revision-based To review unread. An absent read state means nothing is unread. */

package/dist/web/fleet-config-service.d.ts

@@ -50,6 +50,14 @@ export declare class FleetConfigService {
     private validationInputs;
     /** Cached during canonical reads; observer filtering must never parse YAML. */
     resourceValidationInputs(): readonly string[];
+    /**
+     * Record the manifest's external file references before a projection that loads
+     * the configuration, so a reference anywhere (including a task workspace) fences
+     * that capture even before the configuration itself has been read. A manifest that
+     * cannot be read keeps the last recorded inputs; the projection reports its error.
+     */
+    observeValidationInputs(): void;
+    private recordValidationInputs;
     constructor(options?: FleetConfigServiceOptions);
     read(includeDefinitions?: boolean): ConfigReadResult;
     preview(baseRevision: string, input: unknown): Promise<ConfigPreviewResult>;

package/dist/web/fleet-config-service.js

@@ -21,6 +21,28 @@ export class FleetConfigService {
     validationInputs = [];
     /** Cached during canonical reads; observer filtering must never parse YAML. */
     resourceValidationInputs() { return this.validationInputs; }
+    /**
+     * Record the manifest's external file references before a projection that loads
+     * the configuration, so a reference anywhere (including a task workspace) fences
+     * that capture even before the configuration itself has been read. A manifest that
+     * cannot be read keeps the last recorded inputs; the projection reports its error.
+     */
+    observeValidationInputs() {
+        try {
+            this.recordValidationInputs(parse(trustedFile(this.path), { prettyErrors: false }));
+        }
+        catch { /* unchanged */ }
+    }
+    recordValidationInputs(parsed) {
+        const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+        const manifest = record(parsed);
+        const vars = record(manifest.vars);
+        const expand = (value) => value.replace(/\$\{(\w+)\}/g, (match, key) => key in vars ? String(vars[key]) : match);
+        const invite = record(record(manifest.rooms).owner).public_invite_file;
+        const prompts = Object.values(record(manifest.watchdogs)).map(value => record(value).prompt_file);
+        this.validationInputs = [...(typeof invite === 'string' ? [expand(expand(invite))] : []),
+            ...prompts.filter((value) => typeof value === 'string').map(expand)].map(value => resolve(value));
+    }
     constructor(options = {}) {
         this.path = options.configPath ?? defaultConfigPath();
         this.preflight = options.preflight ?? (async () => emptyReport());
@@ -30,16 +52,9 @@ export class FleetConfigService {
         const sources = readSources(this.path);
         let raw;
         try {
-            const manifest = parse(sources.documents.get(basename(sources.manifest)), { prettyErrors: false });
-            const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-            const vars = record(manifest.vars);
-            const expand = (value) => value.replace(/\$\{(\w+)\}/g, (match, key) => key in vars ? String(vars[key]) : match);
-            const invite = record(record(manifest.rooms).owner).public_invite_file;
-            const prompts = Object.values(record(manifest.watchdogs)).map(value => record(value).prompt_file);
             // Record even invalid/missing references before validation, so repairing an
             // already observed dependency can never retain a certified stale capture.
-            this.validationInputs = [...(typeof invite === 'string' ? [expand(expand(invite))] : []),
-                ...prompts.filter((value) => typeof value === 'string').map(expand)].map(value => resolve(value));
+            this.recordValidationInputs(parse(sources.documents.get(basename(sources.manifest)), { prettyErrors: false }));
             loadConfig(this.path, { yamlMode: 'strict' });
             raw = modelFrom(sources, includeDefinitions);
         }

package/dist/web/resource-views.d.ts

@@ -135,6 +135,8 @@ export declare class FleetResourceViews {
     private coverage;
     /** Certify each view's last projected source; never a position its capture did not read. */
     private cover;
+    /** Whether `path` is, contains or lies within the manifest, its split definitions or another configuration input. */
+    private configurationDependency;
     private affects;
     private schedule;
     private refresh;

package/dist/web/resource-views.js

@@ -364,22 +364,25 @@ export class FleetResourceViews {
             view.qualifiedAt = now;
         } });
     }
+    /** Whether `path` is, contains or lies within the manifest, its split definitions or another configuration input. */
+    configurationDependency(path) {
+        const manifest = resolve(this.scope.configPath ?? defaultConfigPath());
+        const root = resolve(splitRootFor(manifest)), changed = resolve(path);
+        const within = (candidate, parent) => {
+            const local = relative(parent, candidate);
+            return local === '' || (local !== '..' && !local.startsWith('..' + sep));
+        };
+        // Configuration and provenance read the manifest and split definitions;
+        // loadConfig also rejects legacy YAML files in the global fleet.d root.
+        // Ancestor replacement/unknown directory wakes remain conservative.
+        const legacy = resolve(fleetDDir());
+        return within(changed, root) || within(root, changed) || within(manifest, changed)
+            || within(changed, legacy) || within(legacy, changed)
+            || this.configurationInputs().some(input => within(resolve(input), changed));
+    }
     affects(descriptor, path, structural = false) {
-        if (descriptor.resource === 'configuration') {
-            const manifest = resolve(this.scope.configPath ?? defaultConfigPath());
-            const root = resolve(splitRootFor(manifest)), changed = resolve(path);
-            const within = (candidate, parent) => {
-                const local = relative(parent, candidate);
-                return local === '' || (local !== '..' && !local.startsWith('..' + sep));
-            };
-            // Configuration and provenance read the manifest and split definitions;
-            // loadConfig also rejects legacy YAML files in the global fleet.d root.
-            // Ancestor replacement/unknown directory wakes remain conservative.
-            const legacy = resolve(fleetDDir());
-            return within(changed, root) || within(root, changed) || within(manifest, changed)
-                || within(changed, legacy) || within(legacy, changed)
-                || this.configurationInputs().some(input => within(resolve(input), changed));
-        }
+        if (descriptor.resource === 'configuration')
+            return this.configurationDependency(path);
         // An explicitly selected manifest may use any pathname, including one
         // otherwise reserved for an independent task receipt.
         if (this.scope.configPath && resolve(path) === resolve(this.scope.configPath))
@@ -394,6 +397,14 @@ export class FleetResourceViews {
         if (roleProjection && !inRoleRoot && (/^(?:history\.jsonl|models_cache\.json|(?:thread_history|state|logs|queue|goals)_\d+\.sqlite(?:-wal|-shm|-journal)?)$/.test(relative(resolve(homedir(), '.codex'), path))
             || /^(?:workspace-devices\.db(?:-wal|-shm|-journal)?|audit[/\\]audit\.jsonl)$/.test(relative(resolve(stateRoot(), 'web'), path))))
             return false;
+        // Task and room workspaces hold their agents' own execution artifacts (checkouts,
+        // builds, test logs); role projections read nothing there except declared role
+        // roots and configuration (manifest, split definitions), which stay fenced. Working
+        // agents write there continuously, which otherwise fences every directory capture
+        // until it resyncs. The workspace directories themselves and their ancestors remain full wakes.
+        if (roleProjection && !inRoleRoot && /^(?:tasks|rooms)[/\\][^/\\]+[/\\]/.test(relative(resolve(stateRoot(), 'workspaces'), path))
+            && !this.configurationDependency(path))
+            return false;
         // Preview selection reads role config/state and conversation ledgers, never
         // task layout run/operation/brief receipts. A worker may commit several of
         // these while that independent canonical preview read is in flight.