@ours.network/fleet 2.2.6 → 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;
@@ -201,10 +201,21 @@ export declare class TaskRoomApplicationService {
         list: TaskListRecord;
         tasks: TaskRecord[];
     }>;
+    /** Run the one-time mission key migration now (service start, `task migrate-keys`). */
+    prepareMissionKeys(): Promise<void>;
+    /** One-time key migration under the list lock, honoring `tasks.default_prefix`. */
+    private ensureMissionKeys;
     createTaskList(input: {
         actor: TaskRoomActor;
         name: string;
+        prefix?: string;
     }): Promise<TaskListRecord>;
+    setTaskListPrefix(input: {
+        actor: TaskRoomActor;
+        name: string;
+        prefix: string;
+    }): Promise<TaskListRecord>;
+    suggestTaskListPrefix(name: string): Promise<string>;
     renameTaskList(input: {
         actor: TaskRoomActor;
         name: string;

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

@@ -7,8 +7,8 @@ import { ConfigError, loadConfig } from '../config.js';
 import { CoworkProtocolError, CoworkUnavailableError, createCoworkAdapter, } from '../rooms-tasks/cowork-adapter.js';
 import { getBinPath, provisionMembers } from '../rooms-tasks/provision.js';
 import { activateRoom, advanceSaga, createRoomRecord, getRoomRecord, listRoomRecords, setOwnerSeat, setSagaError, } from '../rooms-tasks/room-state.js';
-import { activateTask, blockTask as persistBlockTask, createTask as persistTask, getDeletingTask, getTask as readTask, listTasks as readTasks, taskDeletionState, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, updateTaskExecutionPlan, updateTaskBrief, updateTaskLayout, } from '../rooms-tasks/task-state.js';
-import { createTaskListLocked, DEFAULT_TASK_LIST_ID, deleteTaskListRecordLocked, readTaskLists, renameTaskListLocked, resolveTaskList, TaskListError, withTaskListsLock, } from '../rooms-tasks/task-lists.js';
+import { activateTask, blockTask as persistBlockTask, createTask as persistTask, getDeletingTask, getTask as readTask, listTasks as readTasks, taskDeletionState, migrateMissionKeysLocked, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, updateTaskExecutionPlan, updateTaskBrief, updateTaskLayout, } from '../rooms-tasks/task-state.js';
+import { createTaskListLocked, DEFAULT_TASK_LIST_ID, deleteTaskListRecordLocked, readTaskLists, renameTaskListLocked, resolveTaskList, setTaskListPrefixLocked, suggestTaskListPrefix, TaskListError, withTaskListsLock, } from '../rooms-tasks/task-lists.js';
 import { hashTemplate, listTemplates, resolveTemplate, sealTemplateSnapshot, snapshotTemplate } from '../rooms-tasks/templates.js';
 import { acquireLaunchSnapshotLock, releaseLaunchSnapshot } from '../rooms-tasks/launch-snapshot.js';
 import { hashMemberOverrides, prepareExecutionPlan } from '../rooms-tasks/member-overrides.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() {
@@ -100,7 +100,7 @@ export class TaskRoomApplicationService {
         const task = await withTaskListsLock(() => persistTask({
             title: request.title, brief, brief_file: request.briefFile, layout,
             origin: request.origin, idempotency_key: request.idempotencyKey,
-            start: !request.backlog, listId: resolveTaskList(request.list ?? 'default').list_id,
+            start: !request.backlog, list: request.list ?? 'default',
         }));
         recordFleetAuditPresentation({ kind: 'task', operation: 'create', id: task.task_id,
             title: task.title, previousState: 'none', newState: task.state, revision: task.created_at,
@@ -200,6 +200,7 @@ export class TaskRoomApplicationService {
         return this.layouts().view(task);
     }
     async createTask(request) {
+        await this.ensureMissionKeys();
         if (request.layout !== undefined)
             return this.createLayoutTask(request);
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
@@ -229,15 +230,12 @@ export class TaskRoomApplicationService {
                     plan_hash: preparedPlan.planHash };
             }
             const ref = template && { name: template.name, version: template.version, content_hash: template.content_hash };
-            task = await withTaskListsLock(() => {
-                const list = resolveTaskList(request.list ?? 'default');
-                return persistTask({
-                    title: request.title, brief, brief_file: request.briefFile, template: ref,
-                    execution_plan: executionPlan,
-                    origin: request.origin, idempotency_key: request.idempotencyKey,
-                    start: !request.backlog, no_room: request.noRoom, listId: list.list_id,
-                });
-            });
+            task = await withTaskListsLock(() => persistTask({
+                title: request.title, brief, brief_file: request.briefFile, template: ref,
+                execution_plan: executionPlan,
+                origin: request.origin, idempotency_key: request.idempotencyKey,
+                start: !request.backlog, no_room: request.noRoom, list: request.list ?? 'default',
+            }));
         }
         catch (error) {
             unlock?.();
@@ -317,8 +315,31 @@ export class TaskRoomApplicationService {
         const lists = filter?.list ? [resolveTaskList(filter.list)] : readTaskLists();
         return lists.map(list => ({ list, tasks: tasks.filter(task => task.list_id === list.list_id) }));
     }
+    /** Run the one-time mission key migration now (service start, `task migrate-keys`). */
+    prepareMissionKeys() { return this.ensureMissionKeys(); }
+    /** One-time key migration under the list lock, honoring `tasks.default_prefix`. */
+    ensureMissionKeys() {
+        const configured = (() => {
+            try {
+                return (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath).tasks?.default_prefix;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        return withTaskListsLock(() => migrateMissionKeysLocked(configured));
+    }
     async createTaskList(input) {
-        return withTaskListsLock(() => createTaskListLocked(input.name));
+        await this.ensureMissionKeys();
+        return withTaskListsLock(() => createTaskListLocked(input.name, input.prefix));
+    }
+    async setTaskListPrefix(input) {
+        await this.ensureMissionKeys();
+        return withTaskListsLock(() => setTaskListPrefixLocked(input.name, input.prefix));
+    }
+    async suggestTaskListPrefix(name) {
+        await this.ensureMissionKeys();
+        return suggestTaskListPrefix(name);
     }
     async renameTaskList(input) {
         return withTaskListsLock(() => renameTaskListLocked(input.name, input.newName));
@@ -1125,7 +1146,9 @@ export class TaskRoomApplicationService {
                 throw new ConfigError('rooms: configuration is required before creating or querying rooms');
             return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
         })();
-        const roomName = task.task_id ? deriveTaskRoomName(task.title, task.task_id) : task.title;
+        // Only tasks keyed at creation lead with the key: a room create interrupted across the
+        // upgrade must keep the name its earlier attempt used.
+        const roomName = task.task_id ? deriveTaskRoomName(task.title, task.task_id, task.key && !task.key_from_migration ? task.key : undefined) : task.title;
         const unlockSnapshot = template ? acquireLaunchSnapshotLock() : undefined;
         let launchTemplate;
         let room;

package/dist/atomic-file.d.ts

@@ -47,6 +47,8 @@ export interface ReplaceOptions {
      */
     durable?: boolean;
 }
+/** Make completed renames in `dir` durable; throws where the platform cannot. */
+export declare function fsyncDirectory(dir: string): void;
 /**
  * Run `fn` holding a cross-process lock. A fully populated private claim directory
  * is atomically renamed to the canonical path, so contenders never observe partial

package/dist/atomic-file.js

@@ -19,7 +19,8 @@ export class FileLockOwnerUnverifiableError extends Error {
         this.pid = pid;
     }
 }
-function fsyncDirectory(dir) {
+/** Make completed renames in `dir` durable; throws where the platform cannot. */
+export function fsyncDirectory(dir) {
     const dirFd = openSync(dir, 'r');
     try {
         fsyncSync(dirFd);

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "2.2.6",
-  "buildId": "ce1d73f64f81",
-  "commit": "2f3d0b2224caee214965d30a2fbad2c985510b53",
+  "version": "2.3.1",
+  "buildId": "2fbb7f11f70a",
+  "commit": "f7b1dda8a2cb911367ce11617ef38759ba78c5e6",
   "dirty": false,
-  "builtAt": "2026-10-30T14:29:44.502Z",
+  "builtAt": "2026-10-30T19:03:10.573Z",
   "capabilities": [
     "service.refresh-v1",
     "managed-cli.codex-reasoning-effort-v1",

package/dist/config.d.ts

@@ -272,6 +272,12 @@ export interface FleetConfig {
     agentDefinitions?: Record<string, AgentDefinition>;
     /** Canonical inert templates keyed by stable template ID. */
     agentTemplates?: Record<string, AgentTemplateDefinition>;
+    /**
+     * Named Role selected by each Agent Template (`role: { ref: X }`), captured
+     * before roles are flattened to `inline`. Naming provenance only: it is kept
+     * outside the definitions so launch fingerprints are unchanged.
+     */
+    agentTemplateRoleRefs?: Record<string, string>;
     rolePresets?: Record<string, Record<string, unknown>>;
     brainPresets?: Record<string, Record<string, unknown>>;
     /** Required launch-boundary resolver for effective temporary Agent definitions. */

package/dist/config.js

@@ -427,7 +427,7 @@ function mergeTemplateDefinition(template, overrides, file, id) {
         result[key] = merge(result[key], value, key);
     return result;
 }
-function composeSplitRoles(base, baseDoc, yamlMode, diagnostics, files, additionalAgent, templateSink = {}, roleSink = {}, brainSink = {}) {
+function composeSplitRoles(base, baseDoc, yamlMode, diagnostics, files, additionalAgent, templateSink = {}, roleSink = {}, brainSink = {}, roleRefSink = {}) {
     if (baseDoc.api_version !== V2_API_VERSION)
         throw new ConfigError(`${base}: legacy fleet configuration is unsupported; run 'ours-fleet doctor' and rewrite it as ${V2_API_VERSION}`);
     if ('roles' in baseDoc)
@@ -472,6 +472,8 @@ function composeSplitRoles(base, baseDoc, yamlMode, diagnostics, files, addition
         validateBrainValue(templateBrain.value, templateBrain.file, templateBrain.pointer);
         validateAgentScalars(Object.fromEntries(Object.entries(value).filter(([key]) => key !== 'role' && key !== 'brain')), template.file, id);
         canonicalTemplates.set(id, { file: template.file, value });
+        if (isPlainObject(value.role) && typeof value.role.ref === 'string')
+            roleRefSink[id] = value.role.ref;
         const operational = deepSubStrict(Object.fromEntries(Object.entries(value).filter(([key]) => key !== 'role' && key !== 'brain')), vars, template.file, `/agent_templates/${id}`);
         templateSink[id] = {
             role: { inline: deepSubStrict(templateRole.value, vars, templateRole.file, templateRole.pointer) },
@@ -614,6 +616,7 @@ export function loadConfig(configPath, options = {}) {
     const files = [];
     const diagnostics = [];
     const agentTemplates = {};
+    const agentTemplateRoleRefs = {};
     const rolePresets = {};
     const brainPresets = {};
     let docs = [];
@@ -634,7 +637,7 @@ export function loadConfig(configPath, options = {}) {
     const dd = fleetDDir();
     if (existsSync(dd) && readdirSync(dd).some(f => f.endsWith('.yaml') || f.endsWith('.yml')))
         throw new ConfigError(`${dd}: legacy fleet.d configuration is unsupported; run 'ours-fleet doctor' and move agents to ${splitRootFor(base)}/agents/`);
-    docs = [{ file: base, doc: manifestDoc }, ...composeSplitRoles(base, manifestDoc, options.yamlMode ?? 'compat', diagnostics, files, options.additionalAgent, agentTemplates, rolePresets, brainPresets)];
+    docs = [{ file: base, doc: manifestDoc }, ...composeSplitRoles(base, manifestDoc, options.yamlMode ?? 'compat', diagnostics, files, options.additionalAgent, agentTemplates, rolePresets, brainPresets, agentTemplateRoleRefs)];
     const baseDoc = manifestDoc;
     const vars = (baseDoc.vars ?? {});
     const defaults = (baseDoc.defaults ?? {});
@@ -822,7 +825,7 @@ export function loadConfig(configPath, options = {}) {
         }
     }
     const result = {
-        roles, agentDefinitions, agentTemplates, rolePresets, brainPresets, vars, defaults, files, startStaggerMs, diagnostics, watchdogs,
+        roles, agentDefinitions, agentTemplates, agentTemplateRoleRefs, rolePresets, brainPresets, vars, defaults, files, startStaggerMs, diagnostics, watchdogs,
         loops: resolvedLoops.loops,
         rooms, roomTemplates, tasks, ownerInviteFingerprint,
         configMode: 'split-v2',