@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.20

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

@@ -1,14 +1,21 @@
 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 { 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, } 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 { hashTemplate, listTemplates, resolveTemplate, snapshotTemplate } from '../rooms-tasks/templates.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';
+import { recordFleetAuditPresentation } from '../fleet-command-audit.js';
 import { acceptManagedRoomClose, deleteLegacyClosedRooms, deleteManagedRoom, recordManagedRoomCloseError, } from '../rooms-tasks/close.js';
-import { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from '../rooms-tasks/terminal.js';
-import { TASK_CANCELLABLE_STATES, TASK_TERMINAL_STATES } from '../rooms-tasks/types.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';
+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';
 export class TaskRoomApplicationError extends Error {
     code;
     fields;
@@ -19,6 +26,53 @@ export class TaskRoomApplicationError extends Error {
         this.name = 'TaskRoomApplicationError';
     }
 }
+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;
@@ -30,29 +84,78 @@ export class TaskRoomApplicationService {
     }
     async createTask(request) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
-        const template = this.createTemplate(cfg, request.template, request.noRoom);
-        const ref = template && {
-            name: template.name, version: template.version, content_hash: template.content_hash,
-        };
+        let template = this.createTemplate(cfg, request.template, request.noRoom);
+        if (request.noRoom && request.anonymous !== undefined)
+            throw new ConfigError('--anonymous/--no-anonymous cannot be combined with --no-room');
+        const roomPolicy = resolveRoomLaunchPolicy(template, request.anonymous);
+        let launchDefinitions;
+        let executionPlan;
+        let preparedPlan;
+        if (template) {
+            const definition = resolveTemplate(template.name, cfg.roomTemplates ?? {});
+            preparedPlan = prepareExecutionPlan(definition, cfg, request.members ?? {});
+            launchDefinitions = preparedPlan.launchDefinitions;
+        }
         const brief = request.briefFile ? readFileSync(request.briefFile, 'utf8') : request.brief;
-        let task = await withTaskListsLock(() => {
-            const list = resolveTaskList(request.list ?? 'default');
-            return persistTask({
-                title: request.title, brief, brief_file: request.briefFile, template: ref,
-                origin: request.origin, idempotency_key: request.idempotencyKey,
-                start: !request.backlog, no_room: request.noRoom, listId: list.list_id,
+        const unlock = preparedPlan ? acquireLaunchSnapshotLock() : undefined;
+        let sealedHash;
+        let task;
+        try {
+            if (preparedPlan) {
+                template = sealTemplateSnapshot(preparedPlan.snapshot, cfg.agentTemplates ?? {}, preparedPlan.launchDefinitions);
+                sealedHash = template.launch_snapshot_hash;
+                executionPlan = { schema_version: 1, snapshot: template, room_policy: roomPolicy,
+                    overrides: preparedPlan.overrides,
+                    overrides_hash: preparedPlan.overridesHash,
+                    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,
+                });
             });
-        });
+        }
+        catch (error) {
+            unlock?.();
+            if (sealedHash)
+                releaseLaunchSnapshot(sealedHash);
+            throw error;
+        }
+        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: [] });
         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);
+                }, 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) });
             }
             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;
             }
         }
@@ -66,27 +169,25 @@ export class TaskRoomApplicationService {
             const definition = resolveTemplate(request.template, cfg.roomTemplates ?? {});
             if (!definition)
                 throw new TaskRoomApplicationError('template_not_found', `template not found: ${request.template}`, { template: request.template });
-            template = snapshotTemplate(definition);
+            if (request.members && Object.keys(request.members).length) {
+                const prepared = prepareExecutionPlan(definition, cfg, request.members);
+                template = prepared.snapshot;
+                const roomPolicy = resolveRoomLaunchPolicy(template, request.anonymous);
+                return this.provisionRoom(cfg, { title: request.name, brief, goal: request.goal }, template, () => { }, prepared.launchDefinitions, roomPolicy);
+            }
+            template = snapshotTemplate(definition, cfg.agentTemplates);
         }
+        const roomPolicy = resolveRoomLaunchPolicy(template, request.anonymous);
         return this.provisionRoom(cfg, {
             title: request.name, brief, goal: request.goal,
-        }, template, () => { });
+        }, template, () => { }, undefined, roomPolicy);
     }
     async startTask(input) {
-        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
-        let task = transitionTask(input.taskId);
-        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);
-        }
-        return task;
+        return (await this.ensureTaskWork(input)).task;
     }
     listTasks(filter) {
         const listId = filter?.list === undefined ? undefined : resolveTaskList(filter.list).list_id;
-        return readTasks({ state: filter?.state, listId });
+        return readTasks({ state: filter?.state, listId, includeDeleting: filter?.includeDeleting });
     }
     listTaskLists() { return readTaskLists(); }
     groupedTasks(filter) {
@@ -139,8 +240,93 @@ export class TaskRoomApplicationService {
     reviewTask(input) {
         return persistReviewTask(input.taskId);
     }
-    deleteTask(input) {
-        return persistDeleteTask(input.taskId);
+    deletionActor(actor) {
+        if (actor.kind === 'local_control')
+            return { kind: 'local_control', surface: actor.surface };
+        if (actor.kind === 'authenticated_owner')
+            return { kind: 'authenticated_owner', surface: 'messenger', cid: actor.cid };
+        throw new Error('internal workers cannot originate a task deletion acceptance');
+    }
+    /** Accept a permanent deletion in any lifecycle state; audit at acceptance. */
+    async requestTaskDeletion(input) {
+        const result = await acceptTaskDeletion(input.taskId, this.deletionActor(input.actor));
+        if (result.status === 'accepted') {
+            const task = result.task;
+            recordFleetAuditPresentation({ kind: 'task', operation: 'delete', id: task.task_id,
+                title: task.title, previousState: task.state, newState: 'deleting',
+                revision: task.deletion?.accepted_at ?? task.created_at, list: task.list_name ?? 'default',
+                roomId: task.room_id,
+                template: task.template ? `${task.template.name}@${task.template.version}` : undefined,
+                agents: [] });
+        }
+        return result;
+    }
+    /** Worker entry: converge an accepted deletion; Cowork is resolved lazily. */
+    async settleTaskDeletion(input) {
+        const result = await settleTaskDeletion({
+            taskId: input.taskId,
+            cowork: () => {
+                // Config resolves only when room work exists: a no-room deletion must
+                // settle even with missing or invalid rooms configuration.
+                const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+                if (!cfg.rooms)
+                    throw new ConfigError('rooms: configuration is required before deleting task rooms');
+                return this.deps.cowork ? this.deps.cowork(cfg)
+                    : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+            },
+        });
+        if (result.deleted && result.previous_state) {
+            recordFleetAuditPresentation({ kind: 'task', operation: 'delete', id: result.task_id,
+                title: result.title, previousState: result.previous_state, newState: 'deleted',
+                revision: new Date().toISOString(), list: 'default', roomId: undefined,
+                template: undefined, agents: [] });
+        }
+        return result;
+    }
+    /**
+     * Launch the external deletion worker outside the caller's lifecycle and
+     * wait boundedly for physical absence. Timeouts and launch failures report
+     * a pending, recoverable state — never success. A concurrent worker that
+     * already removed the record reads as settled.
+     */
+    async launchTaskDeletionWorker(input) {
+        const launch = this.deps.launchDeletionWorker
+            ?? ((taskId) => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, this.configurationPath));
+        const errorAtBefore = (() => {
+            try {
+                return getDeletingTask(input.taskId).deletion?.error_at;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        try {
+            await launch(input.taskId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await recordTaskDeletionError(input.taskId, message, `External delete worker failed to start. Repeat the delete request for ${input.taskId}.`).catch(() => { });
+            return { deleted: false, pending: true, error: message };
+        }
+        const now = this.deps.now ?? Date.now;
+        const sleep = this.deps.sleep
+            ?? ((ms) => new Promise(resolve => { setTimeout(resolve, ms); }));
+        const deadline = now() + (input.waitMs ?? 10_000);
+        while (now() < deadline) {
+            if (taskDeletionState(input.taskId) === 'absent')
+                return { deleted: true, pending: false };
+            try {
+                const current = getDeletingTask(input.taskId).deletion;
+                if (current?.error_at !== errorAtBefore && current?.error)
+                    return { deleted: false, pending: true, error: current.error };
+            }
+            catch { /* re-checked as absence on the next iteration */ }
+            await sleep(100);
+        }
+        return { deleted: false, pending: true };
+    }
+    recordDeletionError(input) {
+        return recordTaskDeletionError(input.taskId, input.error, input.recoveryHint);
     }
     async completeTask(input) {
         const task = readTask(input.taskId);
@@ -179,10 +365,22 @@ export class TaskRoomApplicationService {
         return recordTaskTerminalIntentError(input.taskId, input.error, input.recoveryHint);
     }
     async beginTaskRecovery(input) {
+        // The deletion-vs-terminal routing decision serializes on the common
+        // task-operation lock and must not require configuration: recovery of a
+        // deletion-pending task continues the deletion and never resurrects.
+        const routed = await withFileLock(taskOperationLockPath(input.taskId), () => {
+            const task = readTask(input.taskId);
+            if (task.deletion?.status === 'pending')
+                return 'deletion';
+            if (task.terminal_intent?.status === 'pending')
+                return 'terminal';
+            return 'none';
+        }, {}, TASK_OPERATION_LOCK_STALE_MS);
+        if (routed === 'deletion')
+            return { kind: 'deletion_worker_required', taskId: input.taskId };
         const config = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         this.recovery = { taskId: input.taskId, config };
-        const task = readTask(input.taskId);
-        if (task.terminal_intent?.status === 'pending')
+        if (routed === 'terminal')
             return { kind: 'terminal_worker_required', taskId: input.taskId };
         return { kind: 'final', result: await this.continueTaskRecovery({
                 actor: input.actor, taskId: input.taskId, terminalTimedOut: false,
@@ -259,8 +457,11 @@ 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 => {
+                const ref = member.agent_template;
+                return cfg.agentTemplates?.[ref]
+                    ? [] : [`member ${member.slot}: Agent Template '${ref}' not found`];
+            });
             return issues.length ? [{ template: `${template.name}@${template.version}`, issues }] : [];
         });
     }
@@ -341,6 +542,14 @@ export class TaskRoomApplicationService {
             return { kind: 'deletion_worker_required', roomId: input.roomId };
         const room = await adapter.recoverRoom(input.roomId);
         orchestration = getRoomRecord(input.roomId);
+        if (orchestration) {
+            const policy = storedRoomLaunchPolicy(orchestration.room_policy);
+            if ((room.anonymous ?? false) !== policy.anonymous) {
+                const error = `Cowork anonymity (${String(room.anonymous ?? false)}) does not match Fleet's durable Room policy (${String(policy.anonymous)})`;
+                setSagaError(input.roomId, error, 'Do not respawn members. Repair or upgrade Cowork, then recover the Room without changing its policy.', 'waiting_cowork');
+                throw new Error(error);
+            }
+        }
         if (orchestration && !orchestration.owner_seat_cid
             && (orchestration.provisioning_detail === 'waiting_owner_invite'
                 || orchestration.provisioning_detail === 'owner_cid_mismatch')) {
@@ -410,69 +619,138 @@ export class TaskRoomApplicationService {
     async ensureTaskWork(input) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let task = readTask(input.taskId);
+        const recordedRoom = task.room_id ? getRoomRecord(task.room_id) : undefined;
+        const recordedPolicy = storedRoomLaunchPolicy(recordedRoom?.room_policy ?? task.execution_plan?.room_policy);
+        if (task.room_id && input.anonymous !== undefined && input.anonymous !== recordedPolicy.anonymous)
+            throw new TaskRoomApplicationError('template_mismatch', 'anonymous override does not match the existing Room launch policy', { room: task.room_id });
         if (TASK_TERMINAL_STATES.includes(task.state))
             throw new TaskRoomApplicationError('task_terminal', 'task terminal', { task: input.taskId, state: task.state });
         if (task.state === 'active' && task.room_id) {
-            if (input.template) {
-                const definition = resolveTemplate(input.template, cfg.roomTemplates ?? {});
+            if (input.template || input.members) {
+                const pinned = getRoomRecord(task.room_id)?.template_snapshot ?? task.execution_plan?.snapshot;
+                if (!pinned)
+                    throw new TaskRoomApplicationError('template_mismatch', 'active task has no durable execution plan', { room: task.room_id });
+                const templateName = input.template ?? pinned.name;
+                if ((!input.template || input.template === pinned.name) && input.members
+                    && task.execution_plan?.overrides_hash === hashMemberOverrides(input.members))
+                    return { task, status: 'already_active' };
+                const definition = resolveTemplate(templateName, cfg.roomTemplates ?? {});
                 if (!definition)
-                    throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: input.template });
-                const requested = snapshotTemplate(definition);
-                const pinned = getRoomRecord(task.room_id)?.template_snapshot ?? task.template;
-                if (pinned && (pinned.name !== requested.name || pinned.content_hash !== requested.content_hash))
+                    throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: templateName });
+                const requested = prepareExecutionPlan(definition, cfg, input.members ?? {});
+                const pinnedPlanHash = task.execution_plan?.plan_hash ?? pinned.content_hash;
+                if (pinned.name !== requested.snapshot.name || pinnedPlanHash !== requested.planHash)
                     throw new TaskRoomApplicationError('template_mismatch', 'template mismatch', {
-                        requested: `${requested.name}@${requested.version}`, room: task.room_id,
+                        requested: `${requested.snapshot.name}@${requested.snapshot.version}`, room: task.room_id,
                         provisioned: `${pinned.name}@${pinned.version}`
                     });
             }
             return { task, status: 'already_active' };
         }
         const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
-        const durable = room?.template_snapshot;
+        const durable = room?.template_snapshot ?? task.execution_plan?.snapshot;
         if (durable && (!task.template || task.template.name !== durable.name
             || task.template.version !== durable.version || task.template.content_hash !== durable.content_hash))
-            throw new Error(`task ${task.task_id} template reference does not match room ${room.room_id}'s durable snapshot`);
+            throw new Error(`task ${task.task_id} template reference does not match its durable execution snapshot`);
         const templateName = input.template ?? durable?.name ?? task.template?.name
             ?? cfg.tasks?.default_room_template ?? cfg.rooms?.defaults?.template ?? 'single';
-        const definition = durable && !input.template ? undefined
+        const storedOverridesMatch = !!(durable && input.members && task.execution_plan?.overrides_hash
+            === hashMemberOverrides(input.members));
+        const definition = durable && !input.template && (!input.members || storedOverridesMatch) ? undefined
             : resolveTemplate(templateName, cfg.roomTemplates ?? {});
         if (input.template && !definition)
             throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: templateName });
         if (!durable && !definition)
             throw new TaskRoomApplicationError('template_not_found', 'template not found', { template: templateName });
-        const snapshot = durable ?? snapshotTemplate(definition);
+        let launchDefinitions;
+        let preparedPlan = !durable && definition
+            ? prepareExecutionPlan(definition, cfg, input.members ?? {}) : undefined;
+        let snapshot = durable ?? preparedPlan.snapshot;
+        const roomPolicy = input.anonymous !== undefined
+            ? resolveRoomLaunchPolicy(snapshot, input.anonymous)
+            : task.execution_plan
+                ? storedRoomLaunchPolicy(task.execution_plan.room_policy)
+                : resolveRoomLaunchPolicy(snapshot, undefined);
+        if (preparedPlan)
+            launchDefinitions = preparedPlan.launchDefinitions;
+        if (input.members && Object.keys(input.members).length && !storedOverridesMatch) {
+            if (!definition)
+                throw new TaskRoomApplicationError('template_mismatch', 'member overrides cannot change an existing Room execution plan');
+            const prepared = preparedPlan ?? prepareExecutionPlan(definition, cfg, input.members);
+            preparedPlan = prepared;
+            if (durable && prepared.planHash !== durable.content_hash)
+                throw new TaskRoomApplicationError('template_mismatch', 'member overrides do not match existing execution plan');
+            snapshot = prepared.snapshot;
+            launchDefinitions = prepared.launchDefinitions;
+        }
         if (durable && input.template && definition) {
-            const requested = snapshotTemplate(definition);
+            const requested = snapshotTemplate(definition, cfg.agentTemplates);
             if (requested.name !== durable.name || requested.content_hash !== durable.content_hash)
                 throw new TaskRoomApplicationError('template_mismatch', 'template mismatch', {
                     requested: `${requested.name}@${requested.version}`, room: room.room_id,
                     provisioned: `${durable.name}@${durable.version}`
                 });
         }
-        if (!input.template && task.template && snapshot.content_hash !== task.template.content_hash)
-            throw new TaskRoomApplicationError('task_template_drift', 'task template drift', {
-                template: `${task.template.name}@${task.template.version}`
-            });
+        if (!input.template && task.template && snapshot.content_hash !== task.template.content_hash) {
+            // Pre-execution-plan backlog records used the template-only hash. Accept
+            // that exact legacy pin once, then upgrade it to the complete sealed plan.
+            const legacyHash = definition
+                ? snapshotTemplate(definition, cfg.agentTemplates).content_hash : undefined;
+            if (task.template.content_hash !== legacyHash)
+                throw new TaskRoomApplicationError('task_template_drift', 'task template drift', {
+                    template: `${task.template.name}@${task.template.version}`
+                });
+        }
         if (task.room_id && room?.template_snapshot
             && (room.template_snapshot.name !== snapshot.name || room.template_snapshot.content_hash !== snapshot.content_hash))
             throw new TaskRoomApplicationError('template_mismatch', 'template mismatch', {
                 requested: `${snapshot.name}@${snapshot.version}`, room: task.room_id,
                 provisioned: `${room.template_snapshot.name}@${room.template_snapshot.version}`
             });
-        if (!task.template || task.template.name !== snapshot.name || task.template.content_hash !== snapshot.content_hash)
+        if (preparedPlan && !task.room_id) {
+            const unlock = acquireLaunchSnapshotLock();
+            let sealed;
+            try {
+                sealed = sealTemplateSnapshot(snapshot, cfg.agentTemplates ?? {}, launchDefinitions);
+                task = updateTaskExecutionPlan(task.task_id, { schema_version: 1, snapshot: sealed,
+                    room_policy: roomPolicy,
+                    overrides: preparedPlan.overrides, overrides_hash: preparedPlan.overridesHash,
+                    plan_hash: preparedPlan.planHash });
+                snapshot = sealed;
+            }
+            catch (error) {
+                unlock();
+                if (sealed?.launch_snapshot_hash)
+                    releaseLaunchSnapshot(sealed.launch_snapshot_hash);
+                throw error;
+            }
+            unlock();
+        }
+        else if (!task.room_id && task.execution_plan && input.anonymous !== undefined) {
+            task = updateTaskExecutionPlan(task.task_id, { ...task.execution_plan, room_policy: roomPolicy });
+        }
+        else 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 => {
                     task = updateTaskRoom(task.task_id, created.room_id, created.room_identity_cid);
-                });
+                }, launchDefinitions, roomPolicy);
                 task = readTask(task.task_id);
             }
             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 +769,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) {
@@ -507,17 +799,17 @@ export class TaskRoomApplicationService {
                 throw new TaskRoomApplicationError('template_not_found', `template not found: ${requested}`);
             return undefined;
         }
-        return snapshotTemplate(definition);
+        return snapshotTemplate(definition, cfg.agentTemplates);
     }
     existingTemplate(cfg, task) {
         const ref = task.template;
         const definition = resolveTemplate(ref.name, cfg.roomTemplates ?? {});
-        const snapshot = definition ? snapshotTemplate(definition) : undefined;
+        const snapshot = definition ? snapshotTemplate(definition, cfg.agentTemplates) : undefined;
         if (!snapshot || snapshot.content_hash !== ref.content_hash)
             throw new TaskRoomApplicationError('task_template_drift', `task template snapshot no longer matches ${ref.name}@${ref.version}`);
         return snapshot;
     }
-    async provisionRoom(cfg, task, template, onCreated) {
+    async provisionRoom(cfg, task, template, onCreated, launchDefinitions, policy = resolveRoomLaunchPolicy(template, undefined)) {
         const rooms = cfg.rooms;
         if (!rooms)
             throw new ConfigError('rooms: configuration is required');
@@ -529,17 +821,52 @@ export class TaskRoomApplicationService {
                 throw new ConfigError('rooms: configuration is required before creating or querying rooms');
             return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
         })();
-        const created = await cowork.createRoom({
-            room_name: task.title, goal: task.goal?.trim() || task.title,
-            briefing: task.brief?.trim() || template?.contract?.trim() || task.goal?.trim() || task.title,
-            quiet_membership: template?.room?.quiet_membership,
-            anonymous: template?.room?.anonymous,
-        });
-        let room = createRoomRecord({
-            room_id: created.room_id, room_name: task.title, room_identity_cid: created.identity_cid,
-            task_id: task.task_id, template_snapshot: template,
-        });
-        onCreated(room);
+        const unlockSnapshot = template ? acquireLaunchSnapshotLock() : undefined;
+        let launchTemplate;
+        let room;
+        try {
+            launchTemplate = template ? (template.launch_snapshot_hash ? template
+                : sealTemplateSnapshot(template, cfg.agentTemplates ?? {}, launchDefinitions)) : undefined;
+            // Room publication window: for a task-bound room, hold the common
+            // task-operation lock across remote creation, local record creation, and
+            // the task link, so an accepted deletion linearizes strictly before
+            // (bounded task_deleting abort) or strictly after (record visible to the
+            // deletion scan). Lock order stays launch-snapshot → task-operation.
+            const publishRoom = async () => {
+                if (task.task_id) {
+                    const fresh = readTask(task.task_id);
+                    if (fresh.deletion?.status === 'pending')
+                        throw new TaskRoomApplicationError('task_deleting', `task ${task.task_id} is pending deletion`, { task: task.task_id });
+                }
+                const created = await cowork.createRoom({
+                    room_name: task.title, goal: task.goal?.trim() || task.title,
+                    briefing: task.brief?.trim() || launchTemplate?.contract?.trim() || task.goal?.trim() || task.title,
+                    quiet_membership: launchTemplate?.room?.quiet_membership,
+                    anonymous: policy.anonymous,
+                });
+                const record = createRoomRecord({
+                    room_id: created.room_id, room_name: task.title, room_identity_cid: created.identity_cid,
+                    task_id: task.task_id, template_snapshot: launchTemplate, room_policy: policy,
+                });
+                onCreated(record);
+                return record;
+            };
+            room = task.task_id
+                ? await withFileLock(taskOperationLockPath(task.task_id), publishRoom, {}, TASK_OPERATION_LOCK_STALE_MS)
+                : await publishRoom();
+        }
+        catch (error) {
+            unlockSnapshot?.();
+            if (launchTemplate?.launch_snapshot_hash)
+                releaseLaunchSnapshot(launchTemplate.launch_snapshot_hash);
+            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: [] });
         room = advanceSaga(room.room_id, 'create_room', 1);
         if (attachOwner) {
             try {
@@ -553,18 +880,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)
+        if (launchTemplate?.members.length)
+            try {
+                room = await (this.deps.provisionMembers ?? provisionMembers)({
+                    cfg, cowork, roomId: room.room_id, taskId: task.task_id, template: launchTemplate,
+                    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 && !launchTemplate?.members.length)
             activateTask(task.task_id);
         return room;
     }