@ours.network/fleet 1.1.0-nightly.25 → 1.1.0-nightly.26

package/README.md

@@ -604,8 +604,26 @@ Fleet launches each template member with a dedicated one-time Cowork invite.
 The generated temporary-agent briefing contains the exact identity name, invite,
 Cowork role, and task. The agent creates that identity itself with ours MCP
 `create_temporary_identity`, accepts the invite with `add_contact`, and starts
-work immediately. Fleet activates the room from Cowork's authenticated seat; there
-is no briefing hash, startup ACK, or separate role-briefing readiness gate.
+work immediately. A room is ready only after the Cowork room (and its task, when
+task-bound) is durably active, every configured member seat is authenticated and active with its matching
+live Fleet launch, and the configured Owner seat is active when owner attachment is
+enabled. There is no briefing hash, startup ACK, or separate role-briefing readiness
+gate.
+
+Normal provisioning emits exactly two authenticated Owner lifecycle notices: a
+concise created notice immediately after the Cowork room is visible, and
+`The room <name> is ready.` after the ready predicate above is true. Intermediate
+task, saga, member-spawn, timeout, and recoverable-failure transitions stay in local
+state and logs. A terminal failed task emits one actionable failure notice; the
+command result carries the exact blocker and canonical recovery action.
+
+`task start` and create-and-start wait for readiness. If their bounded wait expires,
+they return an explicit `in_progress` result with the stable
+`ours-fleet task await <id>` handle and start a safe continuation. `task await`
+waits on that same durable operation and returns `ready`, `in_progress`, or
+`failed` in both human and `--json` forms; timeout is not failure. The detached
+continuation is serialized per task and remains alive until convergence or an
+Owner-action blocker; invoking `task await` safely re-arms it after a restart.
 
 Set `room.anonymous: true` on a room template, or pass `--anonymous` to
 `task create`, `task start`, `task work`, or `room create`, to create an

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

@@ -37,6 +37,29 @@ export interface TaskRecoveryResult {
     issues: TaskRecoveryIssue[];
     reason?: 'missing_room' | 'missing_durable_template' | 'non_resumable_phase';
 }
+export interface TaskProvisioningOutcome {
+    kind: 'ready' | 'in_progress' | 'failed';
+    task: TaskRecord;
+    room?: RoomOrchestrationRecord;
+    handle: {
+        command: string;
+        task_id: string;
+    };
+    launch: {
+        template?: string;
+        anonymous: boolean;
+        owner_attached: boolean;
+    };
+    members: {
+        expected: number;
+        active: number;
+        launched: number;
+    };
+    blocker?: string;
+    next_action?: string;
+}
+/** Repairable terminal observation derived entirely from durable Task/Room state. */
+export declare function recordTaskProvisioningOutcome(outcome: TaskProvisioningOutcome): void;
 export type TaskRecoveryBegin = {
     kind: 'terminal_worker_required';
     taskId: string;
@@ -143,6 +166,12 @@ export declare class TaskRoomApplicationService {
         task: TaskRecord;
         orchestration: RoomOrchestrationRecord | undefined;
     };
+    taskProvisioningOutcome(taskId: string): TaskProvisioningOutcome;
+    awaitTaskProvisioning(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        waitMs?: number;
+    }): Promise<TaskProvisioningOutcome>;
     blockTask(input: {
         actor: TaskRoomActor;
         taskId: string;
@@ -306,7 +335,7 @@ export declare class TaskRoomApplicationService {
         anonymous?: boolean;
     }): Promise<{
         task: TaskRecord;
-        status: 'ready' | 'already_active';
+        status: 'ready' | 'already_active' | 'in_progress';
     }>;
     private createTemplate;
     private existingTemplate;

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

@@ -1,5 +1,4 @@
 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';
@@ -9,7 +8,7 @@ import { createTaskListLocked, DEFAULT_TASK_LIST_ID, deleteTaskListRecordLocked,
 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';
-import { recordFleetAuditPresentation } from '../fleet-command-audit.js';
+import { checkpointFleetAuditPresentations, recordFleetAuditPresentation, recordFleetAuditResource, } from '../fleet-command-audit.js';
 import { acceptManagedRoomClose, deleteLegacyClosedRooms, deleteManagedRoom, recordManagedRoomCloseError, } from '../rooms-tasks/close.js';
 import { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, TASK_OPERATION_LOCK_STALE_MS, taskOperationLockPath, } from '../rooms-tasks/terminal.js';
 import { acceptTaskDeletion, recordTaskDeletionError, settleTaskDeletion, } from '../rooms-tasks/deletion.js';
@@ -17,6 +16,44 @@ import { withFileLock } from '../atomic-file.js';
 import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
 import { storedRoomLaunchPolicy, TASK_CANCELLABLE_STATES, TASK_TERMINAL_STATES } from '../rooms-tasks/types.js';
 import { deriveTaskRoomName } from '../rooms-tasks/task-room-name.js';
+function recordCanonicalRoomCreated(room) {
+    recordFleetAuditPresentation({ kind: 'room', operation: 'create',
+        eventId: `room-created:${room.created_at}`, 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,
+        anonymous: storedRoomLaunchPolicy(room.room_policy).anonymous,
+        memberCount: room.template_snapshot?.members.reduce((sum, member) => sum + member.count, 0) ?? 0,
+        participants: [] });
+}
+/** Repairable terminal observation derived entirely from durable Task/Room state. */
+export function recordTaskProvisioningOutcome(outcome) {
+    const room = outcome.room;
+    recordFleetAuditResource('task', outcome.task.task_id);
+    if (room) {
+        recordFleetAuditResource('room', room.room_id);
+        // Always restate created before a later terminal transition. The stable
+        // digest makes this a no-op when the original checkpoint was delivered,
+        // and repairs a crash after Room persistence but before that checkpoint.
+        recordCanonicalRoomCreated(room);
+    }
+    if (outcome.kind === 'ready' && room)
+        recordFleetAuditPresentation({
+            kind: 'room', operation: 'activate', eventId: `room-ready:${room.activated_at ?? room.created_at}`,
+            id: room.room_id, name: room.room_name, previousState: 'provisioning', newState: 'active',
+            revision: room.activated_at ?? room.created_at, taskId: room.task_id,
+            template: outcome.launch.template, anonymous: outcome.launch.anonymous,
+            memberCount: outcome.members.expected, ownerAttached: outcome.launch.owner_attached,
+            participants: [],
+        });
+    if (outcome.kind === 'failed')
+        recordFleetAuditPresentation({
+            kind: 'lifecycle_failure', resource: 'Task', id: outcome.task.task_id,
+            state: outcome.task.state, category: 'provision_failed',
+            eventId: outcome.task.ended_at ?? room?.created_at ?? outcome.task.created_at,
+        });
+}
 export class TaskRoomApplicationError extends Error {
     code;
     fields;
@@ -31,49 +68,6 @@ export function resolveRoomLaunchPolicy(template, override) {
     const anonymous = override ?? template?.room?.anonymous ?? false;
     return { anonymous };
 }
-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),
-        ...(seat.launch?.presentation ? { configuration: seat.launch.presentation } : {}),
-    }));
-}
-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),
-            ...(seat?.launch?.presentation ? { configuration: seat.launch.presentation } : {}) };
-    });
-}
-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;
@@ -129,35 +123,33 @@ export class TaskRoomApplicationService {
         }
         unlock?.();
         const ref = template && { name: template.name, version: template.version, content_hash: template.content_hash };
-        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: [] });
+        // A create-and-start launch is represented to the Owner solely by the
+        // canonical Room created/ready events. Backlog and no-room tasks retain
+        // their useful Task lifecycle notice.
+        if (request.backlog || request.noRoom)
+            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 {
                 const room = await this.provisionRoom(cfg, task, template, created => {
                     task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
                 }, launchDefinitions, roomPolicy);
                 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) });
+                void 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;
+                // Once the durable Room exists, provisioning errors are resumable
+                // saga state. Return that explicit state so the command can launch a
+                // continuation and give the caller a stable await handle.
+                const current = readTask(task.task_id);
+                if (!current.room_id || !getRoomRecord(current.room_id))
+                    throw error;
+                task = current;
             }
         }
         return task;
@@ -232,6 +224,54 @@ export class TaskRoomApplicationService {
         const task = readTask(taskId);
         return { task, orchestration: task.room_id ? getRoomRecord(task.room_id) : undefined };
     }
+    taskProvisioningOutcome(taskId) {
+        const task = readTask(taskId);
+        const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+        const expected = room?.template_snapshot?.members.reduce((sum, member) => sum + member.count, 0)
+            ?? task.execution_plan?.snapshot.members.reduce((sum, member) => sum + member.count, 0) ?? 0;
+        const active = room?.member_seats.filter(seat => seat.seat_state === 'active').length ?? 0;
+        const launched = room?.member_seats.filter(seat => seat.launch?.state === 'launched').length ?? 0;
+        const failed = task.state === 'failed' || room?.saga.phase === 'failed';
+        const ready = task.state === 'active' && room?.state === 'active'
+            && active === expected && launched === expected;
+        const blocker = task.outcome?.summary ?? task.blocked?.reason ?? room?.saga.error;
+        const nextAction = room?.provisioning_detail === 'waiting_owner_invite'
+            ? 'Rotate rooms.owner.public_invite, then await the same task.'
+            : room?.provisioning_detail === 'owner_cid_mismatch'
+                ? 'Verify rooms.owner.expected_cid, rotate the Owner invite, then await the same task.'
+                : room?.provisioning_detail === 'waiting_cowork'
+                    ? 'Restore ours-cowork, then await the same task.'
+                    : failed
+                        ? `Correct the blocker, then run ours-fleet task recover ${task.task_id}.`
+                        : undefined;
+        return {
+            kind: failed ? 'failed' : ready ? 'ready' : 'in_progress', task, room,
+            handle: { command: `ours-fleet task await ${task.task_id}`, task_id: task.task_id },
+            launch: {
+                ...(room?.template_snapshot
+                    ? { template: `${room.template_snapshot.name}@${room.template_snapshot.version}` }
+                    : task.template ? { template: `${task.template.name}@${task.template.version}` } : {}),
+                anonymous: storedRoomLaunchPolicy(room?.room_policy ?? task.execution_plan?.room_policy).anonymous,
+                owner_attached: Boolean(room?.owner_seat_cid),
+            },
+            members: { expected, active, launched },
+            ...(blocker ? { blocker } : {}),
+            ...(nextAction ? { next_action: nextAction } : {}),
+        };
+    }
+    async awaitTaskProvisioning(input) {
+        const now = this.deps.now ?? Date.now;
+        const sleep = this.deps.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms)));
+        const deadline = now() + (input.waitMs ?? 60_000);
+        for (;;) {
+            const outcome = this.taskProvisioningOutcome(input.taskId);
+            if (outcome.kind !== 'in_progress' || now() >= deadline) {
+                recordTaskProvisioningOutcome(outcome);
+                return outcome;
+            }
+            await sleep(100);
+        }
+    }
     blockTask(input) {
         return persistBlockTask(input.taskId, input.reason);
     }
@@ -422,6 +462,26 @@ export class TaskRoomApplicationService {
                 return { kind: 'provisioning_resume_failed', task, room, issues };
             }
         }
+        if (room.provisioning_detail === 'waiting_owner_invite'
+            || room.provisioning_detail === 'owner_cid_mismatch') {
+            try {
+                await this.recoverRoom({ actor: input.actor, roomId: room.room_id });
+                task = readTask(task.task_id);
+                room = getRoomRecord(room.room_id);
+                if (task.state === 'active' && room?.state === 'active')
+                    return {
+                        kind: 'provisioning_resumed', task, room, issues: [{ code: 'provisioning_resumed' }],
+                    };
+            }
+            catch (error) {
+                issues.push({ code: 'resume_failed', error: error instanceof Error ? error.message : String(error) });
+                return { kind: 'provisioning_resume_failed', task, room, issues };
+            }
+        }
+        if (!room)
+            return {
+                kind: 'provisioning_non_resumable', task, room, issues, reason: 'missing_room',
+            };
         if (room.provisioning_detail === 'waiting_cowork')
             issues.push({ code: 'waiting_cowork' });
         if (room.provisioning_detail === 'waiting_owner_invite')
@@ -625,6 +685,16 @@ export class TaskRoomApplicationService {
                 return { kind: 'provisioning_resume_failed', room, orchestration, issues };
             }
         }
+        if (orchestration?.state === 'provisioning' && !orchestration.template_snapshot) {
+            const seats = await adapter.getSeats(input.roomId);
+            const ownerReady = !orchestration.owner_seat_cid || seats.some(seat => seat.identity_cid.toLowerCase() === orchestration.owner_seat_cid.toLowerCase()
+                && seat.seat_state === 'active');
+            if (ownerReady) {
+                orchestration = activateRoom(input.roomId);
+                if (orchestration.task_id)
+                    activateTask(orchestration.task_id);
+            }
+        }
         return { kind: 'recovered', room, orchestration, issues };
     }
     async finishTask(input) {
@@ -762,10 +832,6 @@ export class TaskRoomApplicationService {
             task = updateTaskTemplate(task.task_id, { name: snapshot.name, version: snapshot.version, content_hash: snapshot.content_hash });
         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 {
@@ -777,10 +843,10 @@ 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;
+                const current = readTask(task.task_id);
+                if (!current.room_id || !getRoomRecord(current.room_id))
+                    throw error;
+                task = current;
             }
         }
         else if (task.state === 'provisioning') {
@@ -798,24 +864,11 @@ 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;
+                task = readTask(task.task_id);
             }
         }
         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' };
+        return { task, status: task.state === 'active' && resultingRoom?.state === 'active' ? 'ready' : 'in_progress' };
     }
     createTemplate(cfg, requested, noRoom) {
         if (noRoom)
@@ -892,11 +945,10 @@ export class TaskRoomApplicationService {
             throw error;
         }
         unlockSnapshot?.();
-        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: [] });
+        recordCanonicalRoomCreated(room);
+        // The created notice is observable while member admission is still in
+        // progress; it is not delayed behind task-start command completion.
+        await checkpointFleetAuditPresentations();
         room = advanceSaga(room.room_id, 'create_room', 1);
         if (attachOwner) {
             try {
@@ -910,14 +962,11 @@ 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 (launchTemplate?.members.length)
+        if (launchTemplate && (launchTemplate.members.length > 0 || attachOwner))
             try {
                 room = await (this.deps.provisionMembers ?? provisionMembers)({
                     cfg, cowork, roomId: room.room_id, taskId: task.task_id, template: launchTemplate,
@@ -926,22 +975,36 @@ export class TaskRoomApplicationService {
                 });
             }
             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 if (attachOwner) {
+            const now = this.deps.now ?? Date.now;
+            const sleep = this.deps.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms)));
+            const deadline = now() + 60_000;
+            for (;;) {
+                const seats = await cowork.getSeats(room.room_id);
+                if (room.owner_seat_cid && seats.some(seat => seat.identity_cid.toLowerCase() === room.owner_seat_cid.toLowerCase()
+                    && seat.seat_state === 'active')) {
+                    room = activateRoom(room.room_id);
+                    break;
+                }
+                if (now() >= deadline) {
+                    room = advanceSaga(room.room_id, 'wait_seats', 5, 'waiting_seats');
+                    break;
+                }
+                await sleep(250);
+            }
+        }
         else
             room = activateRoom(room.room_id);
         if (room.state === 'active')
-            recordFleetAuditPresentation({ kind: 'room', operation: 'activate', id: room.room_id,
+            recordFleetAuditPresentation({ kind: 'room', operation: 'activate',
+                eventId: `room-ready:${room.activated_at ?? room.created_at}`, 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) });
+                anonymous: policy.anonymous, memberCount: room.member_seats.length, ownerAttached: attachOwner,
+                participants: [] });
         if (task.task_id && !launchTemplate?.members.length)
             activateTask(task.task_id);
         return room;

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.0-nightly.25",
-  "buildId": "648d41abce4a",
-  "commit": "d258b3f616a842c4f4ff00b755880d080d885db3",
+  "version": "1.1.0-nightly.26",
+  "buildId": "ecccd36d964c",
+  "commit": "d8242c7a62cd89e52b082241f0e26946a14b0d14",
   "dirty": true,
-  "builtAt": "2026-09-02T15:13:51.477Z",
+  "builtAt": "2026-09-03T11:39:31.486Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -40,7 +40,7 @@ import { requestWebControl } from './web/control.js';
 import { WebServiceManager } from './web/service.js';
 import { WebAccessStore, passwordAccess, validatePublicOrigin } from './web/access.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
-import { beginFleetAuditCollection, consumeFleetAuditCollection, FleetCliExit, } from './fleet-command-audit.js';
+import { beginFleetAuditCollection, consumeFleetAuditCollection, FleetCliExit, setFleetAuditLifecycleCheckpoint, } from './fleet-command-audit.js';
 import './harness/claude-code.js'; // registers the claude-code adapter
 import './harness/codex.js'; // registers the codex adapter
 import { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './rooms-tasks/cli.js';
@@ -1621,6 +1621,13 @@ async function runFleetCli() {
     let outcomeClass = 'success';
     let effect = 'completed';
     beginFleetAuditCollection();
+    setFleetAuditLifecycleCheckpoint(async (presentations) => {
+        const response = await controlRequest(stateDir, {
+            command: 'fleet_audit_present', audit: { presentations },
+        });
+        if (!response.ok)
+            throw new SessionControlError(response.kind ?? 'backend', response.error ?? 'Fleet lifecycle checkpoint delivery failed');
+    });
     if (attempt.classification.decision !== 'allow') {
         exitCode = 1;
         outcomeClass = 'denied';
@@ -1644,6 +1651,7 @@ async function runFleetCli() {
             process.exit = originalExit;
         }
     }
+    setFleetAuditLifecycleCheckpoint(undefined);
     const metadata = consumeFleetAuditCollection();
     if (metadata.failure) {
         outcomeClass = metadata.failure.class;