@ours.network/fleet 1.1.0-nightly.1 → 1.1.0-nightly.10

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

@@ -1,16 +1,15 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdirSync, readFileSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { isAbsolute, relative } from 'node:path';
-import { loadConfig, NOTIFY_EVENT_TYPES, resolveMonitorConfig, resolveRoleModel, resolvePermissions, ROLE_NAME_RE, validateMonitorConfig, } from '../config.js';
+import { loadConfig, NOTIFY_EVENT_TYPES, resolveMonitorConfig, resolvePermissions, ROLE_NAME_RE, validateMonitorConfig, } from '../config.js';
 import { daemonIdentityProvisioner, } from '../creation.js';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
-import { buildRoleConfig, spawnDryRun, spawnPermanent, spawnTemp, validateSpawnOpts, } from '../spawn.js';
+import { spawnDryRun, spawnPermanent, spawnTemp, validateSpawnOpts, } from '../spawn.js';
 import { FleetError, normalizeError } from './errors.js';
 import { inheritCallerSpawnDefaults } from '../fleet-proxy.js';
 import { effectivePermissionMode } from '../permissions.js';
 import { effectiveRoleModel } from '../model-env.js';
-import { claudeModelCatalog, codexModelCatalog, } from './model-catalog.js';
 const canonical = (value) => {
     if (Array.isArray(value))
         return `[${value.map(canonical).join(',')}]`;
@@ -62,6 +61,16 @@ export class RoleCreationService {
         const creationActionId = randomUUID();
         plan.options.creationActionId = creationActionId;
         const statePath = await this.launchSync(plan.options);
+        const selectionSummary = (kind) => {
+            const value = plan.options[kind];
+            const provenance = plan.inherited.includes(kind) ? 'inherited' : 'explicit';
+            if (!value)
+                return `unresolved (${provenance})`;
+            if ('ref' in value)
+                return `ref:${value.ref} (${provenance})`;
+            const fingerprint = hash(value.inline).slice(0, 16);
+            return `inline:sha256:${fingerprint} (${provenance})`;
+        };
         return {
             caller: plan.caller, role: plan.options.name,
             lifetime: plan.options.temp ? 'temporary' : 'permanent', statePath,
@@ -70,6 +79,7 @@ export class RoleCreationService {
             monitor: { mode: plan.preview.resolvedRole.monitor.mode, interrupt: plan.preview.resolvedRole.monitor.interrupt },
             permissionMode: effectivePermissionMode(plan.preview.resolvedRole), inherited: plan.inherited,
             creationActionId,
+            brainSummary: selectionSummary('brain'), roleSummary: selectionSummary('role'),
         };
     }
     launchSync(options, creation) {
@@ -80,47 +90,16 @@ export class RoleCreationService {
     async capabilities() {
         const reasons = [];
         let defaults = {};
-        let roles = [];
         try {
             const config = loadConfig(this.options.configPath);
             defaults = config.defaults;
-            roles = config.roles;
         }
         catch (error) {
             reasons.push(`configuration is invalid: ${error.message}`);
         }
-        const modelsFor = (harness, catalog) => {
-            const configured = roles.filter(role => role.harness === harness)
-                .flatMap(role => [role.model, ...(role.model_chain ?? [])])
-                .filter((model) => Boolean(model));
-            const inherited = resolveRoleModel(undefined, harness, defaults);
-            const configuredOptions = [...new Set([...(inherited ? [inherited] : []), ...configured])]
-                .filter(id => !catalog.models.some(model => model.id === id))
-                .map(id => ({ id, label: `${id} (configured)`, reasoningEfforts: [], source: 'fleet-config' }));
-            const modelOptions = [...configuredOptions, ...catalog.models];
-            return { modelOptions, models: modelOptions.map(model => model.id) };
-        };
-        const codexCatalog = this.options.modelCatalogs?.codex?.() ?? codexModelCatalog();
-        const claudeCatalog = this.options.modelCatalogs?.['claude-code']?.() ?? claudeModelCatalog();
-        const codexModels = modelsFor('codex', codexCatalog);
-        const claudeModels = modelsFor('claude-code', claudeCatalog);
         return {
             available: reasons.length === 0,
             reasons,
-            harnesses: [
-                {
-                    id: 'codex', available: true, sessions: ['acp'],
-                    defaultModel: resolveRoleModel(undefined, 'codex', defaults),
-                    ...codexModels, catalogSource: 'codex-runtime-catalog', customModelAllowed: true,
-                    warnings: codexCatalog.warnings,
-                },
-                {
-                    id: 'claude-code', available: true, sessions: ['acp'],
-                    defaultModel: resolveRoleModel(undefined, 'claude-code', defaults),
-                    ...claudeModels, catalogSource: 'claude-adapter-2.1', customModelAllowed: true,
-                    warnings: claudeCatalog.warnings,
-                },
-            ],
             lifetimes: ['permanent', 'temporary'],
             identityBootstrap: {
                 mode: 'current-fleet-first-boot',
@@ -144,14 +123,12 @@ export class RoleCreationService {
         const defaults = cfg.defaults;
         const opts = this.spawnOptions(request);
         validateSpawnOpts(opts);
-        buildRoleConfig(opts, defaults.harness);
+        const resolved = spawnDryRun(opts).resolvedRole;
         const cwd = request.cwd ? this.resolveCwd(request.cwd) : undefined;
         const effective = {
             name: request.name, identity: request.name,
-            harness: request.harness ?? defaults.harness ?? 'claude-code',
-            session: request.session ?? defaults.session ?? 'acp',
-            model: resolveRoleModel(request.model, request.harness, defaults),
-            reasoningEffort: request.reasoningEffort ?? undefined,
+            harness: resolved.harness, session: resolved.session, model: resolved.model,
+            reasoningEffort: resolved.effort,
             cwd, lifetime: request.lifetime,
             permissions: resolvePermissions(defaults.permissions, request.permissions),
             monitor: resolveMonitorConfig(defaults.monitor, request.monitor),
@@ -183,9 +160,7 @@ export class RoleCreationService {
         if (existingIdentity === 'unknown' && !request.unverifiedIdentityAcknowledged)
             prerequisites.push('confirm creation with an unverified identity preflight');
         const provenance = {
-            harness: 'request', session: 'request', identity: 'built-in',
-            model: request.model !== undefined ? 'request'
-                : resolveRoleModel(undefined, request.harness, defaults) ? 'fleet-default' : 'built-in',
+            brain: 'request', role: 'request', identity: 'built-in',
             cwd: request.cwd ? 'request' : 'built-in', permissions: 'request',
             monitor: request.monitor ? 'request' : defaults.monitor ? 'fleet-default' : 'built-in',
         };
@@ -296,8 +271,8 @@ export class RoleCreationService {
     }
     validate(input) {
         const allowed = new Set([
-            'name', 'harness', 'model', 'reasoningEffort', 'session', 'cwd', 'lifetime', 'mission',
-            'coordinator', 'permissions', 'bio', 'persona', 'monitor', 'openAfterCreate',
+            'name', 'brain', 'role', 'cwd', 'lifetime',
+            'coordinator', 'permissions', 'monitor', 'openAfterCreate',
             'highRiskAcknowledged', 'reuseExistingIdentityAcknowledged',
             'unverifiedIdentityAcknowledged',
         ]);
@@ -307,20 +282,11 @@ export class RoleCreationService {
             throw new FleetError('invalid_request', `unsupported web creation field: ${unsupported[0]}`);
         if (!ROLE_NAME_RE.test(input.name))
             throw new FleetError('invalid_request', 'invalid role name');
-        if (!['codex', 'claude-code'].includes(input.harness))
-            throw new FleetError('invalid_request', 'unsupported harness');
-        if (input.session !== 'acp')
-            throw new FleetError('invalid_request', 'unsupported session backend');
+        if (!input.brain || !input.role)
+            throw new FleetError('invalid_request', 'brain and role selections are required');
         if (!['permanent', 'temporary'].includes(input.lifetime))
             throw new FleetError('invalid_request', 'unsupported lifetime');
-        bounded(input.model ?? undefined, 'model', 128);
-        bounded(input.reasoningEffort ?? undefined, 'reasoning effort', 16);
-        if (input.reasoningEffort != null && !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(input.reasoningEffort))
-            throw new FleetError('invalid_request', 'unsupported reasoning effort');
-        bounded(input.mission, 'mission', 4_096);
         bounded(input.coordinator, 'coordinator', 128);
-        bounded(input.bio, 'bio', 8_192);
-        bounded(input.persona, 'persona', 16_384);
         resolvePermissions(undefined, input.permissions);
         if (input.monitor) {
             const problems = validateMonitorConfig(input.monitor);
@@ -330,10 +296,8 @@ export class RoleCreationService {
                 throw new FleetError('invalid_request', 'web creation supports monitor.inject=notification only');
         }
         return {
-            ...input, model: input.model === null ? null : input.model?.trim() || undefined,
-            reasoningEffort: input.reasoningEffort === null ? null : input.reasoningEffort?.trim() || undefined,
-            mission: input.mission?.trim() || undefined, coordinator: input.coordinator?.trim() || undefined,
-            bio: input.bio?.trim() || undefined, persona: input.persona?.trim() || undefined,
+            ...input, brain: structuredClone(input.brain), role: structuredClone(input.role),
+            coordinator: input.coordinator?.trim() || undefined,
             monitor: input.monitor ? structuredClone(input.monitor) : undefined,
         };
     }
@@ -360,12 +324,10 @@ export class RoleCreationService {
     spawnOptions(request, creationActionId) {
         return {
             name: request.name, temp: request.lifetime === 'temporary',
-            identity: request.name, harness: request.harness,
-            model: request.model, session: request.session, cwd: request.cwd,
-            reasoningEffort: request.reasoningEffort,
-            mission: request.mission, coordinator: request.coordinator,
+            identity: request.name, brain: request.brain, role: request.role, cwd: request.cwd,
+            coordinator: request.coordinator,
             approval: request.permissions.approval, filesystem: request.permissions.filesystem,
-            unattended: request.permissions.unattended, bio: request.bio, persona: request.persona,
+            unattended: request.permissions.unattended,
             monitorConfig: request.monitor,
             configPath: this.options.configPath,
             surface: creationActionId ? 'web' : undefined, creationActionId,

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

@@ -4,6 +4,7 @@ import { loadConfig, ROLE_NAME_RE } from '../config.js';
 import { agentDir, stateRoot } from '../paths.js';
 import { rmRole } from '../ops.js';
 import { FleetError } from './errors.js';
+import { provesGeneratedAgentSource } from '../generated-agent-source.js';
 export class RoleRemovalService {
     options;
     constructor(options) {
@@ -45,8 +46,9 @@ export class RoleRemovalService {
             `Stop and uninstall the exact backend registration for '${requested}'.`,
             `Archive then remove ${lifetime === 'temporary' ? temporaryState : permanentState}.`,
         ];
-        if (role?.sourceFile.includes('/fleet.d/'))
-            effects.push(`Remove spawned configuration ${role.sourceFile}.`);
+        const generatedSource = role && provesGeneratedAgentSource(agentDir(requested), cfg.files[0], role.sourceFile);
+        if (generatedSource)
+            effects.push(`Remove generated Agent configuration ${role.sourceFile}.`);
         else if (role)
             effects.push(`Keep hand-written configuration ${role.sourceFile}; the role can be recreated from it.`);
         else
@@ -76,7 +78,8 @@ export class RoleRemovalService {
         mkdirSync(recoveryPath, { recursive: true, mode: 0o700 });
         if (existsSync(sourceState))
             cpSync(sourceState, join(recoveryPath, 'state'), { recursive: true });
-        if (role?.sourceFile.includes('/fleet.d/') && existsSync(role.sourceFile))
+        if (role && provesGeneratedAgentSource(agentDir(preview.role), cfg.files[0], role.sourceFile)
+            && existsSync(role.sourceFile))
             cpSync(role.sourceFile, join(recoveryPath, basename(role.sourceFile)));
         if (role || preview.lifetime === 'temporary')
             await rmRole(cfg, preview.role, this.options.ops);

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

@@ -179,7 +179,7 @@ export declare class TaskRoomApplicationService {
         name: string;
         version: number;
         description: string;
-        builtin?: boolean;
+        sourceFile?: string;
         room?: import("../rooms-tasks/types.js").TemplateRoomConfig;
         contract?: string;
         members: import("../rooms-tasks/types.js").TemplateMemberSlot[];

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

@@ -1,10 +1,12 @@
 import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 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, deleteTask as persistDeleteTask, getTask as readTask, listTasks as readTasks, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, } 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 { recordFleetAuditPresentation } from '../fleet-command-audit.js';
 import { hashTemplate, listTemplates, resolveTemplate, snapshotTemplate } from '../rooms-tasks/templates.js';
 import { acceptManagedRoomClose, deleteLegacyClosedRooms, deleteManagedRoom, recordManagedRoomCloseError, } from '../rooms-tasks/close.js';
 import { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from '../rooms-tasks/terminal.js';
@@ -19,6 +21,47 @@ export class TaskRoomApplicationError extends Error {
         this.name = 'TaskRoomApplicationError';
     }
 }
+function launchSelection(definition, key) {
+    const selected = definition?.[key];
+    if (!selected || typeof selected !== 'object' || Array.isArray(selected))
+        return undefined;
+    const value = selected;
+    if (value.kind === 'ref' && typeof value.id === 'string')
+        return `ref:${value.id} (reference)`;
+    if (value.kind === 'inline' && typeof value.fingerprint === 'string')
+        return `inline:${value.fingerprint} (inline)`;
+    return undefined;
+}
+function launchPermissions(definition) {
+    const selected = definition?.permissions;
+    if (!selected || typeof selected !== 'object' || Array.isArray(selected))
+        return undefined;
+    const value = selected;
+    const fields = ['approval', 'filesystem', 'unattended'].flatMap(key => typeof value[key] === 'string' ? [`${key}=${value[key]}`] : []);
+    return fields.length ? fields.join(',') : undefined;
+}
+function roomParticipants(room) {
+    return [...room.member_seats].sort((a, b) => a.role_name.localeCompare(b.role_name)).map(seat => ({
+        name: seat.role_name, id: seat.identity_cid,
+        brain: launchSelection(seat.launch?.agent_definition, 'brain'),
+        role: launchSelection(seat.launch?.agent_definition, 'role') ?? seat.cowork_role,
+        permissions: launchPermissions(seat.launch?.agent_definition),
+    }));
+}
+function taskAgents(task) {
+    const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+    const seats = new Map(room?.member_seats.map(seat => [seat.role_name, seat]) ?? []);
+    return [...task.member_roles].sort((a, b) => a.name.localeCompare(b.name)).map(member => {
+        const seat = seats.get(member.name);
+        return { name: member.name, brain: launchSelection(seat?.launch?.agent_definition, 'brain'),
+            role: launchSelection(seat?.launch?.agent_definition, 'role') ?? member.cowork_role,
+            permissions: launchPermissions(seat?.launch?.agent_definition) };
+    });
+}
+function roomFailureEventId(room) {
+    const evidence = `${room.created_at}\0${room.saga.phase}\0${room.saga.step_index}\0${room.saga.error ?? ''}`;
+    return `sha256:${createHash('sha256').update(evidence).digest('hex')}`;
+}
 /** Exact extraction of the previously CLI-owned task create/start behavior. */
 export class TaskRoomApplicationService {
     configurationPath;
@@ -43,16 +86,34 @@ export class TaskRoomApplicationService {
                 start: !request.backlog, no_room: request.noRoom, listId: list.list_id,
             });
         });
+        recordFleetAuditPresentation({ kind: 'task', operation: 'create', id: task.task_id,
+            title: task.title, previousState: 'none', newState: task.state, revision: task.created_at,
+            list: task.list_name ?? 'default', roomId: task.room_id,
+            template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+            agents: [] });
         if (!request.backlog && !request.noRoom && ref && !task.room_id) {
             try {
-                await this.provisionRoom(cfg, task, template, room => {
-                    task = updateTaskRoom(task.task_id, room.room_id, room.room_identity_cid);
+                const room = await this.provisionRoom(cfg, task, template, created => {
+                    task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
                 });
                 task = readTask(task.task_id);
+                if (task.state === 'active' && room.state === 'active')
+                    recordFleetAuditPresentation({ kind: 'task', operation: 'work', id: task.task_id,
+                        title: task.title, previousState: 'provisioning', newState: task.state,
+                        revision: getRoomRecord(task.room_id)?.activated_at ?? task.started_at ?? task.created_at,
+                        list: task.list_name ?? 'default', roomId: task.room_id,
+                        template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+                        agents: taskAgents(task) });
+                else
+                    recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: task.task_id,
+                        state: task.state, category: 'provision_pending', eventId: roomFailureEventId(room) });
             }
             catch (error) {
                 if (error instanceof CoworkUnavailableError)
                     persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task',
+                    id: task.task_id, state: readTask(task.task_id).state, category: 'provision_failed',
+                    eventId: task.room_id ? roomFailureEventId(getRoomRecord(task.room_id)) : task.created_at });
                 throw error;
             }
         }
@@ -75,12 +136,36 @@ export class TaskRoomApplicationService {
     async startTask(input) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let task = transitionTask(input.taskId);
+        recordFleetAuditPresentation({ kind: 'task', operation: 'start', id: task.task_id,
+            title: task.title, previousState: 'backlog', newState: task.state,
+            revision: task.started_at ?? task.created_at, list: task.list_name ?? 'default',
+            template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+            agents: [] });
         if (task.template && !task.room_id) {
             const template = this.existingTemplate(cfg, task);
-            await this.provisionRoom(cfg, task, template, room => {
-                task = updateTaskRoom(task.task_id, room.room_id, room.room_identity_cid);
-            });
-            task = readTask(task.task_id);
+            try {
+                const room = await this.provisionRoom(cfg, task, template, created => {
+                    task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
+                });
+                task = readTask(task.task_id);
+                if (task.state === 'active' && room.state === 'active')
+                    recordFleetAuditPresentation({ kind: 'task', operation: 'work', id: task.task_id,
+                        title: task.title, previousState: 'provisioning', newState: task.state,
+                        revision: getRoomRecord(task.room_id)?.activated_at ?? task.started_at ?? task.created_at,
+                        list: task.list_name ?? 'default', roomId: task.room_id,
+                        template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+                        agents: taskAgents(task) });
+                else
+                    recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: task.task_id,
+                        state: task.state, category: 'provision_pending', eventId: roomFailureEventId(room) });
+            }
+            catch (error) {
+                const failed = task.room_id ? getRoomRecord(task.room_id) : undefined;
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task', id: task.task_id,
+                    state: readTask(task.task_id).state, category: 'provision_failed',
+                    eventId: failed ? roomFailureEventId(failed) : task.created_at });
+                throw error;
+            }
         }
         return task;
     }
@@ -259,8 +344,13 @@ export class TaskRoomApplicationService {
     validateTemplates() {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return listTemplates(cfg.roomTemplates ?? {}).flatMap(template => {
-            const issues = template.members.flatMap(member => cfg.roles.some(role => role.name === member.role_ref)
-                ? [] : [`member ${member.slot}: role_ref '${member.role_ref}' not found in fleet roles`]);
+            const issues = template.members.flatMap(member => {
+                if (!('ref' in member.agent))
+                    return [];
+                const ref = member.agent.ref;
+                return cfg.roles.some(role => role.name === ref)
+                    ? [] : [`member ${member.slot}: Agent ref '${ref}' not found`];
+            });
             return issues.length ? [{ template: `${template.name}@${template.version}`, issues }] : [];
         });
     }
@@ -461,8 +551,13 @@ export class TaskRoomApplicationService {
             });
         if (!task.template || task.template.name !== snapshot.name || task.template.content_hash !== snapshot.content_hash)
             task = updateTaskTemplate(task.task_id, { name: snapshot.name, version: snapshot.version, content_hash: snapshot.content_hash });
-        if (task.state === 'backlog')
+        if (task.state === 'backlog') {
             task = transitionTask(task.task_id);
+            recordFleetAuditPresentation({ kind: 'task', operation: 'start', id: task.task_id,
+                title: task.title, previousState: 'backlog', newState: task.state,
+                revision: task.started_at ?? task.created_at, list: task.list_name ?? 'default',
+                template: `${snapshot.name}@${snapshot.version}`, agents: [] });
+        }
         if (!task.room_id) {
             try {
                 await this.provisionRoom(cfg, task, snapshot, created => {
@@ -473,6 +568,9 @@ export class TaskRoomApplicationService {
             catch (error) {
                 if (error instanceof CoworkUnavailableError)
                     persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task',
+                    id: task.task_id, state: readTask(task.task_id).state, category: 'provision_failed',
+                    eventId: task.room_id ? roomFailureEventId(getRoomRecord(task.room_id)) : task.created_at });
                 throw error;
             }
         }
@@ -491,9 +589,23 @@ export class TaskRoomApplicationService {
             catch (error) {
                 if (error instanceof CoworkUnavailableError)
                     persistBlockTask(task.task_id, 'Cowork management socket is unavailable');
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task',
+                    id: task.task_id, state: readTask(task.task_id).state, category: 'provision_failed',
+                    eventId: roomFailureEventId(getRoomRecord(task.room_id)) });
                 throw error;
             }
         }
+        const resultingRoom = getRoomRecord(task.room_id);
+        if (task.state === 'active' && resultingRoom?.state === 'active')
+            recordFleetAuditPresentation({ kind: 'task', operation: 'work', id: task.task_id,
+                title: task.title, previousState: 'provisioning', newState: task.state,
+                revision: getRoomRecord(task.room_id)?.activated_at ?? task.started_at ?? task.created_at,
+                list: task.list_name ?? 'default', roomId: task.room_id,
+                template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+                agents: taskAgents(task) });
+        else if (resultingRoom)
+            recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Task',
+                id: task.task_id, state: task.state, category: 'provision_pending', eventId: roomFailureEventId(resultingRoom) });
         return { task, status: 'ready' };
     }
     createTemplate(cfg, requested, noRoom) {
@@ -539,6 +651,11 @@ export class TaskRoomApplicationService {
             room_id: created.room_id, room_name: task.title, room_identity_cid: created.identity_cid,
             task_id: task.task_id, template_snapshot: template,
         });
+        recordFleetAuditPresentation({ kind: 'room', operation: 'create', id: room.room_id,
+            name: room.room_name, previousState: 'none', newState: 'provisioning',
+            revision: room.created_at, taskId: room.task_id,
+            template: room.template_snapshot ? `${room.template_snapshot.name}@${room.template_snapshot.version}` : undefined,
+            participants: [] });
         onCreated(room);
         room = advanceSaga(room.room_id, 'create_room', 1);
         if (attachOwner) {
@@ -553,18 +670,39 @@ export class TaskRoomApplicationService {
                 const mismatch = error instanceof CoworkProtocolError && /CID|expected/i.test(error.message);
                 setSagaError(room.room_id, error instanceof Error ? error.message : String(error), mismatch ? 'Verify rooms.owner.expected_cid and rotate the configured invite if necessary.'
                     : 'Rotate rooms.owner.public_invite or public_invite_file, then run room recover.', mismatch ? 'owner_cid_mismatch' : 'waiting_owner_invite');
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room',
+                    id: room.room_id, state: getRoomRecord(room.room_id)?.state ?? 'provisioning',
+                    category: 'provision_failed', eventId: roomFailureEventId(getRoomRecord(room.room_id) ?? room) });
                 throw error;
             }
         }
         room = advanceSaga(room.room_id, 'create_members', 3);
         if (template?.members.length)
-            return (this.deps.provisionMembers ?? provisionMembers)({
-                cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
-                binPath: (this.deps.binPath ?? getBinPath)(), brief: task.brief,
-                goal: task.task_id ? task.title : task.goal,
-            });
-        room = activateRoom(room.room_id);
-        if (task.task_id)
+            try {
+                room = await (this.deps.provisionMembers ?? provisionMembers)({
+                    cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
+                    binPath: (this.deps.binPath ?? getBinPath)(), brief: task.brief,
+                    goal: task.task_id ? task.title : task.goal,
+                });
+            }
+            catch (error) {
+                const failed = getRoomRecord(room.room_id) ?? room;
+                recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room', id: failed.room_id,
+                    state: failed.state, category: 'provision_failed', eventId: roomFailureEventId(failed) });
+                throw error;
+            }
+        else
+            room = activateRoom(room.room_id);
+        if (room.state === 'active')
+            recordFleetAuditPresentation({ kind: 'room', operation: 'activate', id: room.room_id,
+                name: room.room_name, previousState: 'provisioning', newState: 'active',
+                revision: room.activated_at ?? room.created_at, taskId: room.task_id,
+                template: room.template_snapshot ? `${room.template_snapshot.name}@${room.template_snapshot.version}` : undefined,
+                participants: roomParticipants(room) });
+        else
+            recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Room', id: room.room_id,
+                state: room.state, category: 'provision_pending', eventId: roomFailureEventId(room) });
+        if (task.task_id && !template?.members.length)
             activateTask(task.task_id);
         return room;
     }

package/dist/application/types.d.ts

@@ -18,7 +18,7 @@ export interface ResolvedRoleView {
         sandbox?: string;
     };
     oversee?: Array<{
-        role: string;
+        agent: string;
         interval: string;
     }>;
 }

package/dist/briefing.js

@@ -172,12 +172,16 @@ export function generateBriefing(role, v, opts) {
     if (role.session === 'acp') {
         L.push('', '### Managed fleet commands');
         L.push('This ACP role has a supervisor-scoped ours-fleet proxy. Use the ordinary');
-        L.push('`ours-fleet spawn` command; the CLI routes it through your live supervisor, which');
-        L.push('records you as the caller and reports successful creation to your owner channel.');
-        L.push('A minimal call is `ours-fleet spawn --role DeveloperName --temp`.');
-        L.push('For omitted execution settings, the supervisor inherits your harness, session, model,');
+        L.push('`ours-fleet` command; the CLI routes public commands through your live supervisor.');
+        L.push('Your existing OS sandbox remains the executor and ordinary CLI validation still applies.');
+        L.push('Reads, help, validation failures, retries, and command invocations are silent in the');
+        L.push('Owner channel. Only confirmed Agent, Task, and Room lifecycle changes are announced.');
+        L.push('A minimal call is `ours-fleet spawn DeveloperName --temp`.');
+        L.push('For omitted settings, the supervisor inherits your canonical Brain and Role selections,');
         L.push('working directory, neutral permissions, coordinator, and fleet monitor policy. Every');
-        L.push('explicit spawn option wins. An explicit different harness does not inherit your model.');
+        L.push('explicit option wins; identity/session-local and secret material never inherit.');
+        L.push('All public CLI surfaces are available; hidden worker entry points remain internal.');
+        L.push('Lifecycle notice delivery failures stay in service diagnostics and never rerun effects.');
         L.push('This proxy is attribution and convenience, not a security boundary for unisolated roles.');
     }
     if (role.coordinator) {
@@ -196,12 +200,12 @@ export function generateBriefing(role, v, opts) {
         L.push('', '## Oversight assignments');
         L.push('These agents are your wards — you keep them unstuck:');
         for (const o of role.oversee)
-            L.push(`- **${o.role}** — check every ${o.interval}`);
+            L.push(`- **${o.agent}** — check every ${o.interval}`);
         L.push('');
         L.push('Procedure (see also the oversee-agents skill if available). On each tick, for each ward');
         L.push('run BOTH — they answer different questions:');
         for (const o of role.oversee)
-            L.push(`\`ours-fleet status ${o.role}\` then \`ours-fleet peek ${o.role}\``);
+            L.push(`\`ours-fleet status ${o.agent}\` then \`ours-fleet peek ${o.agent}\``);
         L.push('');
         L.push('**One console command is not a liveness verdict.** A `peek` or `send` that fails tells');
         L.push('you what happened to YOUR REQUEST, and only one of its outcomes says the agent is gone.');

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.1",
-  "buildId": "bf3c406ba57c",
-  "commit": "10d6da8bfd9903d216bce80a9ef89a42c282f8d9",
+  "version": "1.1.0-nightly.10",
+  "buildId": "7fbfbd6e4119",
+  "commit": "006179e6e9ae9d9e846045a658a64686c8169ebe",
   "dirty": true,
-  "builtAt": "2026-08-30T07:44:27.551Z",
+  "builtAt": "2026-08-31T14:07:48.123Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]