@ours.network/fleet 2.2.6 → 2.3.1

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. */

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/owner-channel/commands.js

@@ -1,7 +1,19 @@
 import { execFile, spawn } from 'node:child_process';
 import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
 import { RoomStateError } from '../rooms-tasks/room-state.js';
-import { TaskStateError } from '../rooms-tasks/task-state.js';
+import { resolveTaskRef, TaskStateError } from '../rooms-tasks/task-state.js';
+import { MissionKeyError } from '../rooms-tasks/mission-keys.js';
+/** Canonical ID for an authenticated Owner's task argument (ID or mission key). */
+function ownerTaskRef(value, allowDeleted = false) {
+    try {
+        return resolveTaskRef(value, { allowDeleted });
+    }
+    catch (error) {
+        if (error instanceof MissionKeyError)
+            throw new TaskStateError(error.message);
+        throw error;
+    }
+}
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from '../rooms-tasks/markdown.js';
 import { OWNER_COMMENT_LABEL, ownerNotices } from './notices.js';
 import { TaskRoomApplicationError } from '../application/task-room-service.js';
@@ -21,7 +33,7 @@ class OwnerCommandUsageError extends Error {
 }
 const MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 const REPLY_MAX_CHARS = 3_500;
-const taskListRecord = (task) => `${taskStatus(task.state)} ${markdownCode(task.task_id)} — ${markdownProse(task.title)}`
+const taskListRecord = (task) => `${taskStatus(task.state)} ${task.key ? `${markdownCode(task.key)} ` : ''}${markdownCode(task.task_id)} — ${markdownProse(task.title)}`
     + ` — List ${markdownCode(task.list_name ?? 'default')}`
     + (task.blocked ? ` — 🚧 Blocked: ${markdownProse(task.blocked.reason)}` : '');
 const roomListRecord = (room) => `${roomStatus(room.state)} ${markdownCode(room.room_id)} — ${markdownProse(room.room_name)}`
@@ -106,6 +118,7 @@ function ownerRoomFailure(error) {
 const taskAction = (title, task, fields = []) => renderMarkdownResult({
     icon: '📋', title,
     fields: [
+        ...(task.key ? [{ label: 'Key', value: task.key, kind: 'code' }] : []),
         { label: 'ID', value: task.task_id, kind: 'code' },
         { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
         ...fields,
@@ -437,19 +450,19 @@ export const ownerCommands = [
                         const destination = trailingLines ?? rest.find(r => r.startsWith('--list='))?.slice('--list='.length);
                         if (!rest[0] || !destination)
                             throw new OwnerCommandUsageError('usage: /task move <id> --list=<name>');
-                        await showTask((await ctx.moveTask(rest[0], destination)).task_id);
+                        await showTask((await ctx.moveTask(ownerTaskRef(rest[0]), destination)).task_id);
                         break;
                     }
                     case 'show': {
                         if (rest.length !== 1 || rest[0].startsWith('--'))
                             throw new OwnerCommandUsageError('usage: /task show <id>');
-                        await showTask(rest[0]);
+                        await showTask(ownerTaskRef(rest[0]));
                         break;
                     }
                     case 'start': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task start <id>');
-                        const started = await ctx.startTask(rest[0]);
+                        const started = await ctx.startTask(ownerTaskRef(rest[0]));
                         await ctx.reply('kind' in started
                             ? taskProvisioningAction(started) : taskAction('Task started', started));
                         break;
@@ -458,21 +471,21 @@ export const ownerCommands = [
                         if (!rest[0] || !rest[1])
                             throw new OwnerCommandUsageError('usage: /task block <id> <reason>');
                         const reason = rest.slice(1).join(' ');
-                        const t = ctx.blockTask(rest[0], reason);
+                        const t = ctx.blockTask(ownerTaskRef(rest[0]), reason);
                         await ctx.reply(taskAction('Task blocked', t, [{ label: 'Reason', value: reason }]));
                         break;
                     }
                     case 'unblock': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task unblock <id>');
-                        const t = ctx.unblockTask(rest[0]);
+                        const t = ctx.unblockTask(ownerTaskRef(rest[0]));
                         await ctx.reply(taskAction('Task unblocked', t));
                         break;
                     }
                     case 'review': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task review <id>');
-                        const t = ctx.reviewTask(rest[0]);
+                        const t = ctx.reviewTask(ownerTaskRef(rest[0]));
                         await ctx.reply(taskAction('Task ready for review', t));
                         break;
                     }
@@ -480,26 +493,26 @@ export const ownerCommands = [
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task done <id> [summary]');
                         const summary = rest.slice(1).join(' ') || undefined;
-                        await ctx.terminalTask(rest[0], 'done', summary ? { summary } : undefined);
+                        await ctx.terminalTask(ownerTaskRef(rest[0]), 'done', summary ? { summary } : undefined);
                         break;
                     }
                     case 'cancel': {
                         if (rest.length < 2 || rest[0] !== rest[1])
                             throw new OwnerCommandUsageError('destructive: /task cancel <id> <id> — provide the task ID twice');
-                        await ctx.terminalTask(rest[0], 'cancelled');
+                        await ctx.terminalTask(ownerTaskRef(rest[0]), 'cancelled');
                         break;
                     }
                     case 'delete': {
                         if (rest.length !== 2 || rest[0] !== rest[1])
                             throw new OwnerCommandUsageError('destructive: /task delete <id> <id> — provide the task ID twice');
-                        await ctx.deleteTask(rest[0]);
+                        await ctx.deleteTask(ownerTaskRef(rest[0], true));
                         break;
                     }
                     default:
                         // bare /task <id> → show
                         if (sub === 'recover' || sub === 'await' || rest.length)
                             throw new OwnerCommandUsageError(`unknown task subcommand: ${sub}`);
-                        await showTask(sub);
+                        await showTask(ownerTaskRef(sub));
                 }
             }
             catch (e) {

package/dist/reports/tasks.js

@@ -29,7 +29,7 @@ const allowlistList = (list) => ({
     list_id: list.list_id, name: bounded(list.name) ?? 'Unnamed list', built_in: list.built_in,
 });
 const allowlistTask = (task) => ({
-    task_id: task.task_id, list_id: task.list_id, list_name: bounded(task.list_name) ?? 'default',
+    task_id: task.task_id, ...(task.key ? { key: task.key } : {}), list_id: task.list_id, list_name: bounded(task.list_name) ?? 'default',
     title: bounded(task.title) ?? 'Untitled task', ...(task.brief === undefined ? {} : { brief: bounded(task.brief) ?? '' }),
     state: task.state, ...(task.blocked ? { blocked: { reason: bounded(task.blocked.reason) ?? 'Blocked' } } : {}),
     ...(task.room_id ? { room_id: bounded(task.room_id) ?? undefined } : {}),
@@ -41,11 +41,12 @@ const allowlistTask = (task) => ({
 });
 function safeTask(task) {
     const status = STATUS_LABEL[task.state];
-    const title = bounded(task.title) ?? 'Untitled task';
+    // The mission key leads the title so it is discoverable; the opaque ID stays as the record ID.
+    const title = `${task.key ? `${task.key} · ` : ''}${bounded(task.title) ?? 'Untitled task'}`;
     const brief = briefPreview(task.brief);
     const groups = [
         { title: '1. Identity and lifecycle', values: [
-                field('Task ID', task.task_id), field('Title', title),
+                ...(task.key ? [field('Mission key', task.key)] : []), field('Task ID', task.task_id), field('Title', bounded(task.title) ?? 'Untitled task'),
                 field('Lifecycle status', status, STATUS_TONE[task.state]), field('List', task.list_name),
                 field('Blocked indicator', task.blocked ? bounded(task.blocked.reason) : 'No — unblocked', task.blocked ? 'warning' : undefined),
             ] },

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;