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

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;
     }>;
 }
@@ -117,7 +117,6 @@ export interface RoleCapabilities {
     };
     input: {
         text: boolean;
-        rawKeys: boolean;
         interrupt: boolean;
         steering: boolean;
     };
@@ -125,12 +124,6 @@ export interface RoleCapabilities {
         observe: boolean;
         respond: boolean;
     };
-    terminal: {
-        available: boolean;
-        reason?: 'wrong_backend' | 'pty_unavailable' | 'offline' | 'incompatible_runner';
-        multiViewer: boolean;
-        writerLease: boolean;
-    };
     lifecycle: {
         start: boolean;
         stop: boolean;

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) {
@@ -190,21 +194,18 @@ export function generateBriefing(role, v, opts) {
         L.push(`7. Await messages. When the monitor wakes you (or the owner requests a manual check),`);
         L.push(`   call **${v.getMessagesTool}**, act on them,`);
         L.push(`   and reply with ${v.sendTool}. No coordinator is configured — the owner drives you`);
-        // NOT `tmux attach -t <name>`: each role's pane lives on its own tmux
-        // socket (#32), so a bare attach finds no server. `ours-fleet attach`
-        // addresses the right one.
         L.push(`   via \`ours-fleet attach ${role.name}\` or by messaging "${id}".`);
     }
     if (role.oversee?.length) {
         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.');
@@ -221,7 +222,7 @@ export function generateBriefing(role, v, opts) {
         L.push('idle or stalled from `readiness=idle` alone.');
         L.push('');
         L.push('Then judge the console content: stuck on a prompt/menu/trust dialog → answer it directly');
-        L.push('with `ours-fleet send <Name> "<text>"` (or `--key <K>` for raw keys); idle with work');
+        L.push('with `ours-fleet send <Name> "<text>"`; idle with work');
         L.push('assigned → nudge; actively working → do nothing, and do not mistake a long turn for a');
         L.push('stall. Escalate over ours messaging only when you cannot resolve it yourself.');
     }

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.0.5",
-  "buildId": "233dcfbef2e0",
-  "commit": "5846aa20eb58d5c4ecf8a98bb6a7d3f578afdc2b",
-  "dirty": false,
-  "builtAt": "2026-08-26T08:39:49.505Z",
+  "version": "1.1.0-nightly.10",
+  "buildId": "7fbfbd6e4119",
+  "commit": "006179e6e9ae9d9e846045a658a64686c8169ebe",
+  "dirty": true,
+  "builtAt": "2026-08-31T14:07:48.123Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]