@ours.network/fleet 1.2.0-nightly.6 → 1.2.0-nightly.60

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

@@ -1,9 +1,12 @@
+import { TaskLayouts, assertLayoutOpenable, writeTaskBrief } from './task-layouts.js';
+import { FleetError } from './errors.js';
 import { readFileSync } from 'node:fs';
+import { taskLiveReadiness } from '../rooms-tasks/live-readiness.js';
 import { ConfigError, loadConfig } from '../config.js';
 import { CoworkProtocolError, CoworkUnavailableError, createCoworkAdapter, } from '../rooms-tasks/cowork-adapter.js';
 import { getBinPath, provisionMembers } from '../rooms-tasks/provision.js';
 import { activateRoom, advanceSaga, createRoomRecord, getRoomRecord, listRoomRecords, setOwnerSeat, setSagaError, } from '../rooms-tasks/room-state.js';
-import { activateTask, blockTask as persistBlockTask, createTask as persistTask, getDeletingTask, getTask as readTask, listTasks as readTasks, taskDeletionState, moveTaskToList, reviewTask as persistReviewTask, startTask as transitionTask, TaskStateError, unblockTask as persistUnblockTask, updateTaskRoom, updateTaskTemplate, updateTaskExecutionPlan, } 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, updateTaskBrief, updateTaskLayout, } from '../rooms-tasks/task-state.js';
 import { createTaskListLocked, DEFAULT_TASK_LIST_ID, deleteTaskListRecordLocked, readTaskLists, renameTaskListLocked, resolveTaskList, TaskListError, withTaskListsLock, } from '../rooms-tasks/task-lists.js';
 import { hashTemplate, listTemplates, resolveTemplate, sealTemplateSnapshot, snapshotTemplate } from '../rooms-tasks/templates.js';
 import { acquireLaunchSnapshotLock, releaseLaunchSnapshot } from '../rooms-tasks/launch-snapshot.js';
@@ -71,7 +74,127 @@ export class TaskRoomApplicationService {
         this.configurationPath = configurationPath;
         this.deps = deps;
     }
+    async addMember(taskId, request) {
+        const { requestMemberAddition } = await import('../rooms-tasks/add-member.js');
+        const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+        return requestMemberAddition({ taskId, request, cfg, configPath: this.configurationPath,
+            cowork: (this.deps.cowork ?? createCoworkAdapter)(cfg), binPath: (this.deps.binPath ?? getBinPath)(), provision: this.deps.provisionMembers });
+    }
+    async memberAddition(taskId, requestId) { const { memberAddition } = await import('../rooms-tasks/add-member.js'); return memberAddition(taskId, requestId); }
+    layouts() {
+        return this.deps.taskLayouts ?? new TaskLayouts(this.configurationPath, { binPath: this.deps.binPath });
+    }
+    async createLayoutTask(request) {
+        if (request.template || request.noRoom || request.members || request.anonymous !== undefined)
+            throw new FleetError('invalid_request', 'a layout task cannot be combined with a room template, no-room mode, member overrides or anonymity');
+        let layout;
+        try {
+            layout = this.layouts().resolve(request.layout);
+        }
+        catch (error) {
+            throw new FleetError('invalid_request', error.message, { details: { layout: request.layout } });
+        }
+        const brief = request.briefFile ? readFileSync(request.briefFile, 'utf8') : request.brief;
+        const task = await withTaskListsLock(() => persistTask({
+            title: request.title, brief, brief_file: request.briefFile, layout,
+            origin: request.origin, idempotency_key: request.idempotencyKey,
+            start: !request.backlog, listId: resolveTaskList(request.list ?? 'default').list_id,
+        }));
+        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: undefined, template: `layout:${layout.name}`, agents: [] });
+        return task.state === 'provisioning' ? (await this.ensureLayoutWork(task)).task : task;
+    }
+    /** Layout tasks never provision the legacy single room; their run is a local snapshot. */
+    async ensureLayoutWork(task) {
+        if (TASK_TERMINAL_STATES.includes(task.state))
+            throw new TaskRoomApplicationError('task_terminal', 'task terminal', { task: task.task_id, state: task.state });
+        if (task.state === 'active' || task.state === 'review')
+            return { task, status: 'already_active' };
+        if (task.state === 'backlog') {
+            // Verify the pinned source before leaving Backlog, so a stale choice stays editable on the task page.
+            if (!this.layouts().runExists(task.layout) && this.layouts().resolve(task.layout.name).definition_hash !== task.layout.definition_hash)
+                throw new FleetError('conflict', `room layout ${task.layout.name} changed after it was chosen for this task; choose it again on the task page to use the edited version`);
+            task = transitionTask(task.task_id);
+        }
+        try {
+            await this.layouts().ensureRun(task);
+        }
+        catch (error) {
+            const reason = `layout run could not be created: ${error.message}`;
+            persistBlockTask(task.task_id, reason);
+            throw new FleetError('conflict', reason, { details: { task: task.task_id } });
+        }
+        return { task: activateTask(task.task_id), status: 'ready' };
+    }
+    /** Compact room list for task listings; never fails the listing on an unreadable run. */
+    withLayoutRooms(task) {
+        if (!task.layout)
+            return task;
+        try {
+            const view = this.layouts().view(task);
+            return { ...task, layout_rooms: (view?.rooms ?? []).map(({ key, state, room_id, identity_cid }) => ({ key, state, ...(room_id ? { room_id } : {}), ...(identity_cid ? { identity_cid } : {}) })) };
+        }
+        catch {
+            return { ...task, layout_rooms: [] };
+        }
+    }
+    /** Backlog only: choose, change or clear the task's Room Layout before it starts. */
+    async setTaskLayout(input) {
+        let next = null;
+        if (input.layout !== null) {
+            try {
+                next = this.layouts().resolve(input.layout);
+            }
+            catch (error) {
+                throw new FleetError('invalid_request', error.message, { details: { layout: input.layout } });
+            }
+        }
+        const current = readTask(input.taskId);
+        if (current.layout && this.layouts().runExists(current.layout))
+            throw new FleetError('conflict', 'this task already has a layout run; its room layout is fixed');
+        let result;
+        try {
+            result = updateTaskLayout(input.taskId, input.expectedLayout, next);
+        }
+        catch (error) {
+            if (error instanceof TaskStateError && !/task not found/.test(error.message))
+                throw new FleetError('conflict', error.message);
+            throw error;
+        }
+        // Only after the task stopped referencing it; release re-checks every retained reference under its lock.
+        if (result.releasedSnapshot)
+            releaseLaunchSnapshot(result.releasedSnapshot);
+        return result.task;
+    }
+    taskLayout(taskId) {
+        const task = readTask(taskId);
+        if (!task.layout)
+            throw new FleetError('resource_not_found', 'task has no room layout');
+        return this.layouts().view(task);
+    }
+    async launchTaskLayoutOperation(input) {
+        const task = readTask(input.taskId);
+        if (!task.layout)
+            throw new FleetError('resource_not_found', 'task has no room layout');
+        if (input.operation === 'open')
+            assertLayoutOpenable(task);
+        else if (task.deletion?.status === 'pending' || task.terminal_intent)
+            throw new FleetError('conflict', 'task is closing; its layout rooms are cleaned up by the terminal operation');
+        return this.layouts().launch(task, input.operation, input.room);
+    }
+    /** Worker entry for detached layout operations. */
+    async runTaskLayoutOperation(input) {
+        const task = readTask(input.taskId);
+        // Preconditions are enforced inside the worker before side effects; the worker is directly callable.
+        if (input.operation === 'open')
+            assertLayoutOpenable(task);
+        await this.layouts().run(task, input.operation, input.room, input.operationId);
+        return this.layouts().view(task);
+    }
     async createTask(request) {
+        if (request.layout !== undefined)
+            return this.createLayoutTask(request);
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let template = this.createTemplate(cfg, request.template, request.noRoom);
         if (request.noRoom && request.anonymous !== undefined)
@@ -219,38 +342,61 @@ export class TaskRoomApplicationService {
             return { deleted: source, moved: assigned.length, destination };
         });
     }
+    editTaskDescription(input) {
+        const task = updateTaskBrief(input.taskId, input.brief, input.expectedBrief);
+        // Layout rooms reference the brief file, so rooms opened later read the edited brief.
+        if (task.layout)
+            writeTaskBrief(task);
+        return task;
+    }
     getTask(taskId) {
-        const task = readTask(taskId);
+        const task = this.withLayoutRooms(readTask(taskId));
         return { task, orchestration: task.room_id ? getRoomRecord(task.room_id) : undefined };
     }
+    /** Durable provisioning progress only; use active task start/work for a live readiness check. */
     taskProvisioningOutcome(taskId) {
         const task = readTask(taskId);
+        if (task.layout) {
+            const failed = task.state === 'failed';
+            const ready = ['active', 'review', 'done'].includes(task.state);
+            const blocker = task.outcome?.summary ?? task.blocked?.reason;
+            return {
+                kind: failed ? 'failed' : ready ? 'ready' : 'in_progress', task, room: undefined,
+                launch: { template: `layout:${task.layout.name}`, anonymous: false, owner_attached: false },
+                members: { expected: 0, active: 0, launched: 0 },
+                ...(blocker ? { blocker } : {}),
+                ...(!ready && !failed ? { next_action: `Correct the blocker, then run ours-fleet task start ${task.task_id}.` } : {}),
+            };
+        }
         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 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)
+            + (room?.additional_member_templates ?? []).reduce((n, t) => n + t.members.reduce((m, s) => m + s.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 = task.terminal_intent
-            ? `Complete the accepted ${task.terminal_intent.kind} operation; do not restart provisioning.`
-            : room?.state === 'closing' || room?.state === 'closed'
-                ? `Complete room cleanup; do not restart provisioning.`
-                : room?.provisioning_detail === 'member_failed'
-                    ? `Inspect the failed launch, then run ours-fleet task start ${task.task_id}.`
-                    : room?.provisioning_detail === 'waiting_owner_authorization'
-                        ? `Ensure ours-cowork 1.3.0 or newer is running and available, then run ours-fleet task start ${task.task_id}.`
-                        : room?.provisioning_detail === 'waiting_owner_invite'
-                            ? `Rotate rooms.owner.public_invite, then run ours-fleet task start ${task.task_id}.`
-                            : room?.provisioning_detail === 'owner_cid_mismatch'
-                                ? `Verify rooms.owner.expected_cid, rotate the Owner invite, then run ours-fleet task start ${task.task_id}.`
-                                : room?.provisioning_detail === 'waiting_cowork'
-                                    ? `Restore ours-cowork, then run ours-fleet task start ${task.task_id}.`
-                                    : failed
-                                        ? `Correct the blocker, then run ours-fleet task start ${task.task_id}.`
-                                        : undefined;
+        const nextAction = blocker === 'FLEET_SERVICE_NOT_INSTALLED: run ours-fleet init'
+            ? `Run ours-fleet init, then retry ours-fleet task start ${task.task_id}.`
+            : task.terminal_intent
+                ? `Complete the accepted ${task.terminal_intent.kind} operation; do not restart provisioning.`
+                : room?.state === 'closing' || room?.state === 'closed'
+                    ? `Complete room cleanup; do not restart provisioning.`
+                    : room?.provisioning_detail === 'member_failed'
+                        ? `Inspect the failed launch, then run ours-fleet task start ${task.task_id}.`
+                        : room?.provisioning_detail === 'waiting_owner_authorization'
+                            ? `Ensure ours-cowork 1.3.0 or newer is running and available, then run ours-fleet task start ${task.task_id}.`
+                            : room?.provisioning_detail === 'waiting_owner_invite'
+                                ? `Rotate rooms.owner.public_invite, then run ours-fleet task start ${task.task_id}.`
+                                : room?.provisioning_detail === 'owner_cid_mismatch'
+                                    ? `Verify rooms.owner.expected_cid, rotate the Owner invite, then run ours-fleet task start ${task.task_id}.`
+                                    : room?.provisioning_detail === 'waiting_cowork'
+                                        ? `Restore ours-cowork, then run ours-fleet task start ${task.task_id}.`
+                                        : failed
+                                            ? `Correct the blocker, then run ours-fleet task start ${task.task_id}.`
+                                            : undefined;
         return {
             kind: failed ? 'failed' : ready ? 'ready' : 'in_progress', task, room,
             launch: {
@@ -271,6 +417,10 @@ export class TaskRoomApplicationService {
         const deadline = now() + (input.waitMs ?? 60_000);
         for (;;) {
             const outcome = this.taskProvisioningOutcome(input.taskId);
+            if (outcome.kind === 'ready') {
+                const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+                await this.assertTaskLiveReadiness(outcome.task, outcome.room, cfg);
+            }
             if (outcome.kind !== 'in_progress' || now() >= deadline) {
                 recordTaskProvisioningOutcome(outcome);
                 return outcome;
@@ -310,6 +460,15 @@ export class TaskRoomApplicationService {
     }
     /** Worker entry: converge an accepted deletion; Cowork is resolved lazily. */
     async settleTaskDeletion(input) {
+        // Layout resources close first; a failure stays a retryable pending deletion.
+        const deleting = (() => { try {
+            return getDeletingTask(input.taskId);
+        }
+        catch {
+            return undefined;
+        } })();
+        if (deleting?.layout)
+            await this.layouts().closeAndForget(deleting);
         const result = await settleTaskDeletion({
             taskId: input.taskId,
             cowork: () => {
@@ -338,7 +497,7 @@ export class TaskRoomApplicationService {
      */
     async launchTaskDeletionWorker(input) {
         const launch = this.deps.launchDeletionWorker
-            ?? ((taskId) => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, this.configurationPath));
+            ?? ((taskId) => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, this.configurationPath, this.deps.binPath?.()));
         const errorAtBefore = (() => {
             try {
                 return getDeletingTask(input.taskId).deletion?.error_at;
@@ -391,6 +550,20 @@ export class TaskRoomApplicationService {
         }
         return this.acceptTerminal(input.taskId, 'done', roomId, input.outcome);
     }
+    /** Terminal layout tasks archive their rooms and retire only agents their run created. */
+    async withLayoutCleanup(plan) {
+        // The task is already terminal; a worker launch failure is recorded on the run for retry.
+        if (plan.task.layout && this.layouts().runExists(plan.task.layout))
+            await this.layouts().launch(plan.task, 'close').catch(() => { });
+        return plan;
+    }
+    /** Retry terminal layout cleanup for known resources (e.g. after a failed close). */
+    async retryTaskLayoutCleanup(input) {
+        const task = readTask(input.taskId);
+        if (!task.layout || !TASK_TERMINAL_STATES.includes(task.state))
+            throw new TaskStateError('layout cleanup applies to finished or cancelled layout tasks');
+        return this.layouts().launch(task, 'close');
+    }
     async cancelTask(input) {
         const task = readTask(input.taskId);
         if (!TASK_CANCELLABLE_STATES.includes(task.state))
@@ -399,6 +572,23 @@ export class TaskRoomApplicationService {
             (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return this.acceptTerminal(input.taskId, 'cancelled', task.room_id);
     }
+    /** Continue accepted operations outside the HTTP connection's lifetime. */
+    async launchTaskSettlement(taskId) {
+        try {
+            await launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, this.configurationPath, this.deps.binPath?.());
+        }
+        catch (error) {
+            await recordTaskTerminalIntentError(taskId, error instanceof Error ? error.message : String(error), 'The settlement worker could not start. Inspect the task before retrying.');
+        }
+        return readTask(taskId);
+    }
+    async launchTaskProvisioning(taskId) {
+        const outcome = this.taskProvisioningOutcome(taskId);
+        if (outcome.kind === 'in_progress' && !outcome.next_action) {
+            await launchFleetWorker(['task', '_provision', taskId], `task-provision-${taskId}`, this.configurationPath, this.deps.binPath?.());
+        }
+        return outcome;
+    }
     async settleTask(input) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         if (!cfg.rooms)
@@ -494,7 +684,7 @@ export class TaskRoomApplicationService {
                 throw new ConfigError('rooms: configuration is required before creating or querying rooms');
             const cowork = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
             await (this.deps.provisionMembers ?? provisionMembers)({
-                cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
+                configPath: this.configurationPath, cfg, cowork, roomId: room.room_id, taskId: task.task_id, template,
                 binPath: (this.deps.binPath ?? getBinPath)(), brief: task.brief, goal: task.title,
             });
             task = readTask(task.task_id);
@@ -557,7 +747,8 @@ export class TaskRoomApplicationService {
     }
     async acceptTerminal(taskId, kind, roomId, outcome) {
         const task = await acceptTaskTerminalIntent({ taskId, kind, roomId, outcome });
-        return { task, settlementRequired: task.terminal_intent?.status === 'pending' && !!roomId };
+        // Every terminal path (complete, finish, cancel) closes a layout task's rooms.
+        return this.withLayoutCleanup({ task, settlementRequired: task.terminal_intent?.status === 'pending' && !!roomId });
     }
     listTemplates() {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
@@ -632,7 +823,7 @@ export class TaskRoomApplicationService {
             createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
         const room = getRoomRecord(input.roomId);
         if (!room) {
-            throw new TaskRoomApplicationError('room_record_not_found', 'room record not found', { room: input.roomId });
+            return { room: undefined, settlementRequired: true };
         }
         return { room: await acceptManagedRoomClose(input.roomId), settlementRequired: true };
     }
@@ -657,9 +848,42 @@ export class TaskRoomApplicationService {
             (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         return this.acceptTerminal(task.task_id, 'done', task.room_id, input.outcome);
     }
+    /** Point-in-time health, separate from durable provisioning and lifecycle. */
+    async observeTaskReadiness(taskId) {
+        const task = readTask(taskId);
+        const room = task.room_id ? getRoomRecord(task.room_id) : undefined;
+        try {
+            const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
+            return await this.observeLiveReadiness(task, room, cfg) ?? { state: 'ready' };
+        }
+        catch {
+            return { state: 'unknown', reason: 'readiness_unavailable' };
+        }
+    }
+    async observeLiveReadiness(task, room, cfg) {
+        const cowork = this.deps.cowork ? this.deps.cowork(cfg, { timeoutMs: 2_000 })
+            : createCoworkAdapter({ configPath: cfg.rooms?.cowork?.config, timeoutMs: 2_000 });
+        const issue = await taskLiveReadiness(task, room, cowork, this.deps.liveReadiness);
+        if (issue)
+            return issue;
+        if (JSON.stringify(readTask(task.task_id)) !== JSON.stringify(task)
+            || (room && JSON.stringify(getRoomRecord(room.room_id)) !== JSON.stringify(room)))
+            return { state: 'unknown', reason: 'records_changed' };
+    }
+    async assertTaskLiveReadiness(task, room, cfg) {
+        const issue = await this.observeLiveReadiness(task, room, cfg);
+        if (issue)
+            throw new TaskRoomApplicationError('task_not_ready', `Task readiness is ${issue.state}: ${issue.reason}. Ask Fleet Coordinator to inspect the room and member status and choose supported recovery; do not blindly relaunch or reuse invites.`, { task: task.task_id, room: task.room_id ?? 'missing', readiness: issue.state,
+                reason: issue.reason, ...(issue.member ? { member: issue.member } : {}) });
+    }
     async ensureTaskWork(input) {
         const cfg = (this.deps.loadConfiguration ?? loadConfig)(this.configurationPath);
         let task = readTask(input.taskId);
+        if (task.layout) {
+            if (input.template || input.members || input.anonymous !== undefined)
+                throw new FleetError('invalid_request', 'a layout task cannot take a room template or member overrides');
+            return this.ensureLayoutWork(task);
+        }
         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)
@@ -681,8 +905,10 @@ export class TaskRoomApplicationService {
                 const pinned = durableTemplate;
                 if (!pinned)
                     throw new TaskRoomApplicationError('template_mismatch', 'active task has no durable execution plan', { room: task.room_id });
-                if (durableRequestMatches)
+                if (durableRequestMatches) {
+                    await this.assertTaskLiveReadiness(task, recordedRoom, cfg);
                     return { task, status: 'already_active' };
+                }
                 const templateName = input.template ?? pinned.name;
                 const definition = resolveTemplate(templateName, cfg.roomTemplates ?? {});
                 if (!definition)
@@ -695,6 +921,7 @@ export class TaskRoomApplicationService {
                         provisioned: `${pinned.name}@${pinned.version}`
                     });
             }
+            await this.assertTaskLiveReadiness(task, recordedRoom, cfg);
             return { task, status: 'already_active' };
         }
         let room = task.room_id ? getRoomRecord(task.room_id) : undefined;
@@ -821,7 +1048,7 @@ export class TaskRoomApplicationService {
                 if (!cfg.rooms)
                     throw new ConfigError('rooms: configuration is required before creating or querying rooms');
                 const cowork = this.deps.cowork ? this.deps.cowork(cfg) : createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
-                await (this.deps.provisionMembers ?? provisionMembers)({ cfg, cowork, roomId: room.room_id,
+                await (this.deps.provisionMembers ?? provisionMembers)({ configPath: this.configurationPath, cfg, cowork, roomId: room.room_id,
                     taskId: task.task_id, template: snapshot, binPath: (this.deps.binPath ?? getBinPath)(),
                     brief: task.brief, goal: task.title });
                 task = readTask(task.task_id);
@@ -833,7 +1060,11 @@ export class TaskRoomApplicationService {
             }
         }
         const resultingRoom = getRoomRecord(task.room_id);
-        return { task, status: task.state === 'active' && resultingRoom?.state === 'active' ? 'ready' : 'in_progress' };
+        if (task.state === 'active' && resultingRoom?.state === 'active') {
+            await this.assertTaskLiveReadiness(task, resultingRoom, cfg);
+            return { task, status: 'ready' };
+        }
+        return { task, status: 'in_progress' };
     }
     createTemplate(cfg, requested, noRoom) {
         if (noRoom)
@@ -872,6 +1103,7 @@ export class TaskRoomApplicationService {
         const unlockSnapshot = template ? acquireLaunchSnapshotLock() : undefined;
         let launchTemplate;
         let room;
+        let reusedRoom = false;
         try {
             launchTemplate = template ? (template.launch_snapshot_hash ? template
                 : sealTemplateSnapshot(template, cfg.agentTemplates ?? {}, launchDefinitions)) : undefined;
@@ -885,6 +1117,25 @@ export class TaskRoomApplicationService {
                     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 });
+                    // A concurrent caller or a restart after local Room publication must
+                    // reuse the task's one durable room, never create a second workspace/room.
+                    const candidates = listRoomRecords().filter(record => record.task_id === task.task_id);
+                    if (candidates.length > 1)
+                        throw new Error('ambiguous task room ownership');
+                    const existing = fresh.room_id ? getRoomRecord(fresh.room_id) : candidates[0];
+                    if (fresh.room_id && !existing)
+                        throw new Error('recorded task room is missing; refusing duplicate creation');
+                    if (existing) {
+                        reusedRoom = true;
+                        // Heal a crash between durable room publication and task linkage.
+                        // Return a resumable phase, leaving owner admission/member launch to
+                        // the existing continuation rather than racing the original creator.
+                        const resumable = ['persist_intent', 'create_room'].includes(existing.saga.phase)
+                            ? advanceSaga(existing.room_id, attachOwner ? 'attach_owner' : 'create_members', attachOwner ? 2 : 3)
+                            : existing;
+                        onCreated(resumable);
+                        return resumable;
+                    }
                 }
                 const requiredRoles = new Map();
                 if (attachOwner)
@@ -902,8 +1153,9 @@ export class TaskRoomApplicationService {
                     room_id: created.room_id, room_name: roomName, room_identity_cid: created.identity_cid,
                     task_id: task.task_id, template_snapshot: launchTemplate, room_policy: policy,
                 });
-                onCreated(record);
-                return record;
+                const resumable = advanceSaga(record.room_id, attachOwner ? 'attach_owner' : 'create_members', attachOwner ? 2 : 3);
+                onCreated(resumable);
+                return resumable;
             };
             room = task.task_id
                 ? await withFileLock(taskOperationLockPath(task.task_id), publishRoom, {}, TASK_OPERATION_LOCK_STALE_MS)
@@ -916,7 +1168,8 @@ export class TaskRoomApplicationService {
             throw error;
         }
         unlockSnapshot?.();
-        room = advanceSaga(room.room_id, 'create_room', 1);
+        if (reusedRoom)
+            return room;
         if (attachOwner) {
             room = advanceSaga(room.room_id, 'attach_owner', 2);
             await this.setOwnerRoomCommands(cowork, room.room_id, rooms.owner.role);
@@ -941,7 +1194,7 @@ export class TaskRoomApplicationService {
         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,
+                    configPath: this.configurationPath, 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,
                 });

package/dist/application/types.d.ts

@@ -26,6 +26,8 @@ export interface RoleRecord {
     id: string;
     lifetime: RoleLifetime;
     configured: boolean;
+    /** Read-only display ownership; never authorizes lifecycle operations. */
+    taskId?: string;
     config?: ResolvedRoleView;
     stateRef?: {
         lifetime: 'permanent' | 'temporary';

package/dist/atomic-file.d.ts

@@ -36,3 +36,8 @@ export declare function withFileLock<T>(lockPath: string, fn: () => T | Promise<
  * intact.
  */
 export declare function replaceFileAtomically(path: string, contents: string, mode?: number, deps?: WriteDeps): void;
+/** Synchronous Lamport bakery lock: unique claims are never reused, so stale
+ * reclamation cannot remove a successor's lock. Atomic claim replacement keeps
+ * choosing/ticket reads complete. Dead claims can be removed by any contender.
+ */
+export declare function withSynchronousFileLock<T>(path: string, work: () => T): T;

package/dist/atomic-file.js

@@ -1,4 +1,4 @@
-import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync, writeSync, } from 'node:fs';
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, writeSync, } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 const DEFAULT_STALE_MS = 10_000;
@@ -136,3 +136,64 @@ export function replaceFileAtomically(path, contents, mode = 0o600, deps = {}) {
     }
     catch { /* platform does not allow fsync on a directory */ }
 }
+/** Synchronous Lamport bakery lock: unique claims are never reused, so stale
+ * reclamation cannot remove a successor's lock. Atomic claim replacement keeps
+ * choosing/ticket reads complete. Dead claims can be removed by any contender.
+ */
+export function withSynchronousFileLock(path, work) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    const token = `${process.pid}-${randomUUID()}.json`;
+    const own = join(path, token);
+    const deadline = Date.now() + 10_000;
+    const claims = () => {
+        const result = [];
+        for (const name of readdirSync(path).filter(name => /^[0-9]+-[a-f0-9-]{36}\.json$/.test(name))) {
+            const file = join(path, name);
+            let value;
+            try {
+                value = JSON.parse(readFileSync(file, 'utf8'));
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            if (!Number.isSafeInteger(value.pid) || value.pid <= 0 || !Number.isSafeInteger(value.ticket) || value.ticket < 0)
+                throw new Error('Invalid synchronous lock claim');
+            if (name !== token) {
+                try {
+                    process.kill(value.pid, 0);
+                }
+                catch (error) {
+                    if (error.code === 'ESRCH') {
+                        // This dead contender alone owned this UUID path. Never remove
+                        // the namespace or a successor's differently named claim.
+                        rmSync(file, { force: true });
+                        continue;
+                    }
+                }
+            }
+            result.push({ name, value });
+        }
+        return result;
+    };
+    replaceFileAtomically(own, JSON.stringify({ pid: process.pid, choosing: true, ticket: 0 }));
+    try {
+        const ticket = Math.max(0, ...claims().map(claim => claim.value.ticket)) + 1;
+        if (!Number.isSafeInteger(ticket))
+            throw new Error('Synchronous lock ticket overflow');
+        replaceFileAtomically(own, JSON.stringify({ pid: process.pid, choosing: false, ticket }));
+        for (;;) {
+            const preceding = claims().some(claim => claim.name !== token && (claim.value.choosing
+                || claim.value.ticket < ticket || (claim.value.ticket === ticket && claim.name < token)));
+            if (!preceding)
+                return work();
+            if (Date.now() >= deadline)
+                throw new Error('Timed out acquiring synchronous journal lock');
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+    finally {
+        rmSync(own, { force: true });
+    }
+}

package/dist/briefing.d.ts

@@ -8,13 +8,15 @@ export interface BriefingOpts {
     briefingBody?: string;
     /**
      * What spawn established about a persistent role's ours identity.
-     * Temporary roles always create their own session-owned identity.
+     * The supervisor provisions temporary identities as well.
      * Defaults to `unverified`, because a briefing generated without that
      * knowledge must not claim one.
      */
     identityGuarantee?: 'verified' | 'created' | 'unverified';
     /** Temporary spawn whose newly-created identity should share the session lifecycle. */
     temporaryIdentity?: boolean;
+    /** Fleet-prepared invocation guidance (src/managed-cli.ts); empty when none applies. */
+    managedCli?: string[];
 }
 /** Render a role's briefing.md: narrative (or curated body) + mechanical boot steps. */
 export declare function generateBriefing(role: ResolvedRole, v: BriefingVocab, opts: BriefingOpts): string;