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

package/dist/rooms-tasks/cowork-http.js

@@ -0,0 +1,70 @@
+import { randomUUID } from 'node:crypto';
+import { attachOursClient } from '@ours.network/sdk/client';
+import { readPrivateFile } from '@ours.network/sdk/connector';
+import { CoworkProtocolError, CoworkUnavailableError } from './cowork-adapter.js';
+/** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
+export async function coworkHttpCall(profile, method, params, timeoutMs) {
+    const id = randomUUID();
+    const signal = AbortSignal.timeout(timeoutMs);
+    const body = JSON.stringify({ version: 1, id, method, params });
+    if (Buffer.byteLength(body) > 1024 * 1024)
+        throw new CoworkProtocolError(method, 'request exceeded 1 MiB');
+    try {
+        const client = await attachOursClient({ endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken: `fleet-cowork-check-${id}`, env: {}, requestSignal: signal });
+        await client.close();
+        const token = readPrivateFile(profile.credentialPath, 4096).toString('utf8').trim();
+        const response = await fetch(profile.serverUrl + '/cowork/management/rpc', {
+            method: 'POST', redirect: 'error', signal,
+            headers: { 'content-type': 'application/json', 'x-ours-api-token': token },
+            body,
+        });
+        if (response.status === 401 || response.status === 403) {
+            await response.body?.cancel();
+            throw new CoworkProtocolError(method, 'server credential was rejected', 'unauthorized');
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new CoworkProtocolError(method, 'empty HTTP response');
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.length;
+                if (size > 4 * 1024 * 1024)
+                    throw new CoworkProtocolError(method, 'response exceeded 4 MiB');
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel();
+        }
+        let rpc;
+        try {
+            rpc = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        }
+        catch {
+            throw new CoworkProtocolError(method, 'server returned malformed JSON');
+        }
+        if (!rpc || Array.isArray(rpc) || rpc.version !== 1 || rpc.id !== id
+            || Object.hasOwn(rpc, 'result') === Object.hasOwn(rpc, 'error'))
+            throw new CoworkProtocolError(method, 'server returned an invalid RPC response');
+        if (Object.hasOwn(rpc, 'error')) {
+            const error = rpc.error;
+            if (!error || typeof error.code !== 'string' || typeof error.message !== 'string')
+                throw new CoworkProtocolError(method, 'server returned an invalid RPC error');
+            throw new CoworkProtocolError(method, error.message, error.code);
+        }
+        if (!response.ok)
+            throw new CoworkProtocolError(method, `management answered HTTP ${response.status}`);
+        return rpc.result;
+    }
+    catch (error) {
+        if (error instanceof CoworkProtocolError)
+            throw error;
+        throw new CoworkUnavailableError('Cowork HTTP management failed; check the selected server and credential', { cause: error });
+    }
+}

package/dist/rooms-tasks/deletion.js

@@ -1,13 +1,16 @@
+import { proveArchivedAbsence, verifyArchivedAbsence, verifyArchivedMemberStillAbsent } from './archived-absence.js';
 import { existsSync } from 'node:fs';
 import { withFileLock } from '../atomic-file.js';
 import { agentDir } from '../paths.js';
+import { deleteWorkspace, assertWorkspaceDeletable } from './workspace.js';
+import { collectWorkspaceArchives } from './workspace-artifacts.js';
 import { secureStoppedTempArchive, stopTempSupervisor } from '../temp-lifecycle.js';
 import { closeManagedRoom, identityCidPresent, inspectMember, removeExactMemberIdentity, waitForLivenessAbsent, } from './close.js';
 import { CoworkProtocolError } from './cowork-adapter.js';
 import { deleteRoomRecord, getRoomRecord, listRoomRecords } from './room-state.js';
 import { acquireLaunchSnapshotLock, releaseLaunchSnapshotForDeletingTask } from './launch-snapshot.js';
 import { TASK_OPERATION_LOCK_STALE_MS, taskOperationLockPath } from './terminal.js';
-import { advanceTaskDeletionMember, beginTaskDeletionIntent, completeTaskDeletionReceipt, ensureTaskDeletionReceipt, getDeletingTask, importTaskDeletionRetirementEvidence, setTaskDeletionError, TaskStateError, unlinkDeletedTask, upsertTaskDeletionMembersFromSeats, } from './task-state.js';
+import { advanceTaskDeletionMember, beginTaskDeletionIntent, completeTaskDeletionReceipt, ensureTaskDeletionReceipt, getDeletingTask, importTaskDeletionRetirementEvidence, setTaskDeletionError, TaskStateError, beginTaskWorkspaceCleanup, unlinkDeletedTask, upsertTaskDeletionMembersFromSeats, } from './task-state.js';
 export { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
 import { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
 /**
@@ -137,6 +140,8 @@ export async function settleTaskDeletion(input) {
             // aborts settlement (fail closed).
             ensureTaskDeletionReceipt(taskId);
             const records = listRoomRecords().filter(room => room.task_id === taskId);
+            if (task.deletion.workspace_cleanup_started_at && records.length)
+                throw new TaskStateError(`task ${taskId} room records reappeared after workspace cleanup began`);
             const recordIds = new Set(records.map(room => room.room_id));
             const recordedRoomId = task.deletion.room_id ?? task.room_id;
             const needsCowork = records.length > 0 || recordedRoomId !== undefined;
@@ -145,10 +150,31 @@ export async function settleTaskDeletion(input) {
                 upsertTaskDeletionMembersFromSeats(taskId, record.member_seats);
                 await closeManagedRoom({ roomId: record.room_id, cowork: cowork, deps: deps.roomClose });
                 const closed = getRoomRecord(record.room_id);
-                importTaskDeletionRetirementEvidence(taskId, closed?.member_seats ?? record.member_seats);
+                const seats = closed?.member_seats ?? record.member_seats;
+                const proofs = [];
+                for (const seat of seats) {
+                    if (!seat.identity_cid && seat.retirement?.launch_id !== 'never-launched')
+                        proofs.push(await proveArchivedAbsence(seat));
+                }
+                // No await between the last live-state fence and durable checkpoint.
+                for (const proof of proofs) {
+                    const latest = getRoomRecord(record.room_id)?.member_seats.find(seat => seat.role_name === proof.name);
+                    if (existsSync(agentDir(proof.name, true)) || latest?.identity_cid
+                        || latest?.launch?.launch_id !== proof.launch_id || latest.launch.action_id !== proof.action_id)
+                        throw new Error('Archived absence seat changed before checkpoint');
+                }
+                importTaskDeletionRetirementEvidence(taskId, seats, proofs);
                 await cowork.deleteRoom(record.room_id);
+                for (const proof of proofs)
+                    await verifyArchivedAbsence(proof);
+                for (const proof of proofs)
+                    if (existsSync(agentDir(proof.name, true)))
+                        throw new Error('Archived member replacement before room unlink');
                 deleteRoomRecord(record.room_id);
             }
+            const deletion = getDeletingTask(taskId).deletion;
+            for (const proof of deletion.archived_absences ?? [])
+                await (deletion.workspace_cleanup_started_at && !existsSync(proof.archive_path) ? verifyArchivedMemberStillAbsent : verifyArchivedAbsence)(proof);
             // Members whose room record is gone (crash after record deletion, or
             // legacy state): resume from the durable cursors.
             for (const cursor of getDeletingTask(taskId).deletion.members) {
@@ -176,7 +202,7 @@ export async function settleTaskDeletion(input) {
         completeTaskDeletionReceipt(taskId);
         return { task_id: taskId, deleted: false };
     }
-    const finalize = () => withFileLock(taskOperationLockPath(taskId), () => {
+    const finalize = () => withFileLock(taskOperationLockPath(taskId), async () => {
         try {
             const task = getDeletingTask(taskId);
             if (task.deletion?.status !== 'pending')
@@ -185,8 +211,19 @@ export async function settleTaskDeletion(input) {
                 throw new TaskStateError(`task ${taskId} room records reappeared during deletion finalization`);
             if (task.deletion.members.some(member => member.phase !== 'identity_absent'))
                 throw new TaskStateError(`task ${taskId} has unretired members at deletion finalization`);
+            for (const proof of task.deletion.archived_absences ?? [])
+                await (task.deletion.workspace_cleanup_started_at && !existsSync(proof.archive_path) ? verifyArchivedMemberStillAbsent : verifyArchivedAbsence)(proof);
+            for (const proof of task.deletion.archived_absences ?? [])
+                if (existsSync(agentDir(proof.name, true)))
+                    throw new Error('Archived member replacement before task unlink');
             if (cleanup.snapshotHash)
                 releaseLaunchSnapshotForDeletingTask(cleanup.snapshotHash, taskId);
+            if (task.workspace) {
+                assertWorkspaceDeletable(task.workspace, 'task', taskId);
+                beginTaskWorkspaceCleanup(taskId);
+                collectWorkspaceArchives(task.workspace);
+                deleteWorkspace(task.workspace, 'task', taskId);
+            }
             unlinkDeletedTask(taskId);
         }
         catch (error) {

package/dist/rooms-tasks/member-startup.d.ts

@@ -6,6 +6,7 @@ export interface RoomTaskMember {
 }
 /** Build the complete task text Fleet places directly in a temporary member's briefing. */
 export declare function buildRoomMemberTask(input: {
+    workspace?: string;
     taskId?: string;
     roomId: string;
     roomIdentityCid: string;

package/dist/rooms-tasks/member-startup.js

@@ -7,6 +7,8 @@ export function buildRoomMemberTask(input) {
         `Fleet Task ${input.taskId ?? '(standalone)'} — ${member.cowork_role} in room ${input.roomId}`,
         '',
     ];
+    if (input.workspace)
+        lines.push(`Task-owned workspace: ${input.workspace}`, 'Start and keep all execution artifacts, dependency checkouts, and Git worktrees inside this workspace.', 'Clone repositories inside this workspace before adding worktrees; never attach to an external Git common directory.', 'Use distinct per-agent branches/directories for concurrent edits. Configured cwd is source context, not artifact ownership.', 'Completion, cancellation and room retirement retain artifacts. Only explicit owner deletion removes them.', 'Do not delete the workspace or its ownership marker yourself.', '');
     if (input.goal)
         lines.push(`Goal: ${input.goal}`);
     if (input.brief)

package/dist/rooms-tasks/provision.d.ts

@@ -21,6 +21,17 @@ export interface StartupWaitPolicy {
     sleep(ms: number): Promise<void>;
 }
 export declare function provisionMembers(input: ProvisionMembersInput): Promise<RoomOrchestrationRecord>;
+/** Reconcile proven, admitted launches without any spawn, archive, invite or recovery path. */
+export declare function reconcileExistingTaskMembers(input: {
+    taskId: string;
+    checkOnly?: boolean;
+    cowork: Pick<CoworkAdapter, 'getRoom'>;
+    expectedLaunches: ReadonlyArray<{
+        role_name: string;
+        launch_id: string;
+        identity_cid: string;
+    }>;
+}): Promise<RoomOrchestrationRecord>;
 export declare function cleanupMembers(input: {
     roomId: string;
     taskId?: string;

package/dist/rooms-tasks/provision.js

@@ -1,3 +1,5 @@
+import { readRoomReadiness } from '../agent-ours/service.js';
+import { ensureWorkspace, validateWorkspace } from './workspace.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
@@ -13,7 +15,7 @@ import { readLaunchSnapshot, redactLaunchDefinition } from './launch-snapshot.js
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from '../fleet-proxy.js';
 import { controlRequest } from '../session/control.js';
 import { SessionControlError } from '../session/types.js';
-import { closeManagedRoom } from './close.js';
+import { closeManagedRoom, roomCloseLockPath, CLOSE_LOCK_STALE_MS } from './close.js';
 import { withFileLock } from '../atomic-file.js';
 import { TASK_OPERATION_LOCK_STALE_MS, taskOperationLockPath } from './terminal.js';
 import { TaskStateError, taskDeletionState } from './task-state.js';
@@ -115,6 +117,7 @@ function settingsFor(member, cfg, sealed) {
 }
 function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid, anonymous) {
     return buildRoomMemberTask({
+        workspace: getRoomRecord(input.roomId)?.workspace?.path,
         taskId: input.taskId,
         roomId: input.roomId,
         roomIdentityCid,
@@ -141,6 +144,10 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
     try {
         const role = parse(readFileSync(`${dir}/role.yaml`, 'utf8'));
         const startup = role.roomMemberStartup;
+        const workspace = getRoomRecord(roomId)?.workspace;
+        if (workspace && (role.cwd !== workspace.path
+            || JSON.stringify(startup?.workspace) !== JSON.stringify(workspace)))
+            return false;
         return role.identity === member.name
             && startup?.room_id === roomId
             && startup.room_identity_cid === roomIdentityCid
@@ -149,8 +156,7 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
             && (startup.anonymous ?? false) === anonymous
             && sha256Text(startup.task ?? '') === taskSha
             && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
-            && typeof startup.invite === 'string'
-            && startup.invite.length > 0;
+            && startup.invite === '';
     }
     catch {
         return false;
@@ -234,25 +240,9 @@ async function retainRunningLaunch(input) {
     }
     return false;
 }
-/**
- * Member-launch publication window: for a task-bound room, the durable launch
- * intent, spawn, and launch record publish under the common task-operation
- * lock so an accepted deletion linearizes strictly before (bounded abort — no
- * spawn happens) or strictly after (the seat's launch record is visible to
- * deletion retirement). The lock is held per member only, never across
- * seat-wait loops.
- */
 async function launchMember(input) {
-    const taskId = input.provision.taskId;
-    if (!taskId)
-        return launchMemberUnlocked(input);
-    return withFileLock(taskOperationLockPath(taskId), () => {
-        if (taskDeletionState(taskId) !== 'none')
-            throw new Error(`task ${taskId} is pending deletion; aborting member launch for ${input.member.name}`);
-        return launchMemberUnlocked(input);
-    }, {}, TASK_OPERATION_LOCK_STALE_MS);
-}
-async function launchMemberUnlocked(input) {
+    // provisionMembers holds the task and room lifecycle locks through every launch.
+    assertProvisioningOpen(input.provision);
     const { provision, member, settings, startup } = input;
     const seat = getRoomRecord(provision.roomId).member_seats
         .find(candidate => candidate.role_name === member.name);
@@ -345,7 +335,14 @@ function reconcileMemberSeats(roomId, members, observed, ownerSeatCid) {
         && seat.seat_state === 'active');
     const seats = current.member_seats.map(seat => {
         const member = members.find(candidate => candidate.name === seat.role_name);
+        const readiness = readRoomReadiness(current.room_identity_cid, member.name);
+        if (!readiness || readiness.room !== roomId || readiness.invite !== seat.invite_id) {
+            complete = false;
+            return seat;
+        }
         const found = exactCoworkSeat(observed, member, seat.invite_id);
+        if (found && found.identity_cid !== readiness.cid)
+            throw new Error('Cowork seat CID does not match supervisor provisioned identity');
         if (!found || found.seat_state !== 'active') {
             complete = false;
             return seat;
@@ -364,9 +361,29 @@ function assertCoworkRoomPolicy(room, expectedAnonymous) {
     if ((room.anonymous ?? false) !== expectedAnonymous)
         throw new Error(`Cowork anonymity (${String(room.anonymous ?? false)}) does not match Fleet's durable Room policy (${String(expectedAnonymous)})`);
 }
+function assertProvisioningOpen(input) {
+    if (input.taskId && getTask(input.taskId).terminal_intent)
+        throw new Error(`task ${input.taskId} has an accepted terminal intent; refusing to provision members`);
+    const room = getRoomRecord(input.roomId);
+    if (room?.state === 'closing' || room?.state === 'closed')
+        throw new Error(`room ${input.roomId} is ${room.state}; refusing to provision members`);
+}
 export async function provisionMembers(input) {
+    // Same lock order as terminal/deletion settlement. Serialize concurrent retries
+    // and standalone retirement as well as member publication. Seat waits are bounded.
+    const run = () => withFileLock(roomCloseLockPath(input.roomId), () => {
+        assertProvisioningOpen(input);
+        if (!getRoomRecord(input.roomId))
+            throw new Error(`room ${input.roomId} is missing; refusing provisioning`);
+        return provisionMembersUnlocked(input);
+    }, {}, CLOSE_LOCK_STALE_MS);
+    return input.taskId
+        ? withFileLock(taskOperationLockPath(input.taskId), run, {}, TASK_OPERATION_LOCK_STALE_MS)
+        : run();
+}
+async function provisionMembersUnlocked(input) {
     const { cfg, cowork, roomId, taskId, template } = input;
-    // Deletion-epoch pre-check; each member launch re-checks under the lock.
+    // The common task-operation lock protects this epoch through all member launches.
     if (taskId && taskDeletionState(taskId) !== 'none')
         throw new Error(`task ${taskId} is pending deletion; refusing to provision members`);
     const prefix = taskId ? shortId(taskId) : `room-${shortId(roomId)}`;
@@ -378,6 +395,12 @@ export async function provisionMembers(input) {
     const existing = getRoomRecord(roomId);
     if (!existing?.room_identity_cid)
         throw new Error(`room ${roomId} has no pinned room identity CID`);
+    if (existing.workspace) {
+        validateWorkspace(existing.workspace, taskId ? 'task' : 'room', taskId ?? roomId);
+        ensureWorkspace(existing.workspace);
+        for (const setting of settings.values())
+            setting.definition.cwd = existing.workspace.path;
+    }
     const roomIdentityCid = existing.room_identity_cid;
     const ownerSeatCid = existing.owner_seat_cid ?? null;
     const roomPolicy = storedRoomLaunchPolicy(existing.room_policy);
@@ -439,17 +462,31 @@ export async function provisionMembers(input) {
                 provision: input, member, settings: settings.get(member.name), task, roomIdentityCid,
             }))
                 continue;
+            // A previous failed launch keeps its invite pointer durably. Never
+            // overwrite that requirement until the supported revoke has succeeded;
+            // a transport failure must fence subsequent invite issuance too.
+            if (currentSeat.invite_id) {
+                const observed = await cowork.getRoom(roomId);
+                if (!observed || observed.identity_cid !== roomIdentityCid)
+                    throw new Error('cannot verify room before failed-attempt invite cleanup');
+                if (observed.seats.some(seat => seat.invite_id === currentSeat.invite_id
+                    && seat.seat_state !== 'removed'))
+                    throw new Error('failed-attempt invite has an admitted seat; reconcile before replacing the member');
+                await cowork.revokeInvite(roomId, currentSeat.invite_id);
+            }
             const issued = await cowork.issueInvite(roomId, {
                 mode: 'one_time', role: member.coworkRole, min_accepts: 1,
             });
-            const seats = getRoomRecord(roomId).member_seats.map(seat => seat.role_name === member.name ? { ...seat, invite_id: issued.invite_id } : seat);
-            updateMemberSeats(roomId, seats);
             try {
+                assertProvisioningOpen(input);
+                const seats = getRoomRecord(roomId).member_seats.map(seat => seat.role_name === member.name ? { ...seat, invite_id: issued.invite_id } : seat);
+                updateMemberSeats(roomId, seats);
                 await launchMember({
                     provision: input,
                     member,
                     settings: settings.get(member.name),
                     startup: {
+                        workspace: existing.workspace,
                         room_id: roomId,
                         room_identity_cid: roomIdentityCid,
                         identity_name: member.name,
@@ -463,7 +500,12 @@ export async function provisionMembers(input) {
                 });
             }
             catch (error) {
-                await cowork.revokeInvite(roomId, issued.invite_id).catch(() => { });
+                try {
+                    await cowork.revokeInvite(roomId, issued.invite_id);
+                }
+                catch (cleanupError) {
+                    throw new AggregateError([error, cleanupError], 'member launch failed and invite cleanup is unresolved; retry must revoke the retained requirement first');
+                }
                 throw error;
             }
         }
@@ -491,7 +533,7 @@ export async function provisionMembers(input) {
         const remote = await cowork.recoverRoom(roomId);
         assertCoworkRoomPolicy(remote, roomPolicy.anonymous);
         const reconciled = reconcileMemberSeats(roomId, members, remote.seats, ownerSeatCid ?? undefined);
-        if (reconciled.complete)
+        if (reconciled.complete && remote.state === 'active')
             break;
         if (policy.now() >= deadline) {
             advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
@@ -531,6 +573,76 @@ export async function provisionMembers(input) {
         activateTask(taskId);
     return record;
 }
+/** Reconcile proven, admitted launches without any spawn, archive, invite or recovery path. */
+export async function reconcileExistingTaskMembers(input) {
+    return withFileLock(taskOperationLockPath(input.taskId), async () => {
+        const task = getTask(input.taskId);
+        if (!['provisioning', 'active'].includes(task.state) || task.terminal_intent || taskDeletionState(input.taskId) !== 'none'
+            || !task.room_id)
+            throw new Error('task is not open for existing-member reconciliation');
+        const roomId = task.room_id;
+        return withFileLock(roomCloseLockPath(roomId), async () => {
+            const current = getRoomRecord(roomId);
+            if (!current || !['provisioning', 'active'].includes(current.state) || current.close
+                || current.task_id !== input.taskId || !current.room_identity_cid
+                || task.room_identity_cid !== current.room_identity_cid)
+                throw new Error('room is not open for existing-member reconciliation');
+            const names = new Set(input.expectedLaunches.map(seat => seat.role_name));
+            if (!names.size || names.size !== input.expectedLaunches.length
+                || current.member_seats.length !== names.size
+                || current.member_seats.some(seat => !names.has(seat.role_name)))
+                throw new Error('expected launch roster does not match the persisted room');
+            const remote = await input.cowork.getRoom(roomId);
+            if (!remote || remote.room_id !== roomId || remote.identity_cid !== current.room_identity_cid
+                || remote.state !== 'active')
+                throw new Error('Cowork room is not the exact active room');
+            assertCoworkRoomPolicy(remote, storedRoomLaunchPolicy(current.room_policy).anonymous);
+            if (current.owner_seat_cid && !remote.seats.some(seat => seat.identity_cid === current.owner_seat_cid && seat.seat_state === 'active'))
+                throw new Error('expected Owner seat is not active');
+            const seats = [];
+            for (const seat of current.member_seats) {
+                const expected = input.expectedLaunches.find(item => item.role_name === seat.role_name);
+                const launch = seat.launch;
+                if (seat.seat_state === 'removed' || !seat.invite_id || launch?.state !== 'launched'
+                    || launch.launch_id !== expected.launch_id || !launch.action_id || !launch.mission_sha256
+                    || (seat.identity_cid && seat.identity_cid !== expected.identity_cid))
+                    throw new Error('persisted member launch does not match reconciliation evidence');
+                const dir = agentDir(seat.role_name, true);
+                if (!launchMatches(dir, { name: seat.role_name, coworkRole: seat.cowork_role }, launch.action_id, launch.mission_sha256, roomId, current.room_identity_cid, seat.invite_id, storedRoomLaunchPolicy(current.room_policy).anonymous))
+                    throw new Error('member startup provenance mismatch');
+                const supervisor = readTempSupervisor(dir);
+                if (!supervisor || supervisor.role !== seat.role_name || supervisor.launchId !== expected.launch_id
+                    || await tempSupervisorLiveness(dir) !== 'running')
+                    throw new Error('expected member supervisor is not running');
+                const ready = readRoomReadiness(current.room_identity_cid, seat.role_name);
+                const matches = remote.seats.filter(item => item.display_name === seat.role_name
+                    && item.seat_state !== 'removed');
+                const found = matches[0];
+                if (!ready || ready.room !== roomId || ready.invite !== seat.invite_id
+                    || ready.cid !== expected.identity_cid || matches.length !== 1 || !found
+                    || found.identity_cid !== expected.identity_cid || found.role !== seat.cowork_role
+                    || found.seat_state !== 'active' || found.invite_id !== seat.invite_id)
+                    throw new Error('member readiness or authenticated Cowork seat mismatch');
+                seats.push({ ...seat, identity_cid: expected.identity_cid, seat_state: 'active' });
+            }
+            if (input.checkOnly)
+                return current;
+            // No mutation until the complete roster has passed; these writes are replayable
+            // under the same task/room lifecycle locks if interrupted between files.
+            updateMemberSeats(roomId, seats);
+            updateTaskMembers(input.taskId, seats.map(seat => ({ name: seat.role_name,
+                identity_cid: seat.identity_cid, slot: seat.slot, cowork_role: seat.cowork_role })));
+            if (getTask(input.taskId).blocked)
+                unblockTask(input.taskId);
+            if (current.state !== 'active')
+                advanceSaga(roomId, 'activate', 6);
+            const activated = current.state === 'active' ? getRoomRecord(roomId) : activateRoom(roomId);
+            if (task.state !== 'active')
+                activateTask(input.taskId);
+            return activated;
+        }, {}, TASK_OPERATION_LOCK_STALE_MS);
+    }, {}, TASK_OPERATION_LOCK_STALE_MS);
+}
 export async function cleanupMembers(input) {
     const room = getRoomRecord(input.roomId);
     if (!room)

package/dist/rooms-tasks/room-state.js

@@ -2,6 +2,8 @@ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:f
 import { join } from 'node:path';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { stateRoot } from '../paths.js';
+import { planWorkspace, ensureWorkspace } from './workspace.js';
+import { getTask } from './task-state.js';
 import { storedRoomLaunchPolicy } from './types.js';
 import { releaseLaunchSnapshot } from './launch-snapshot.js';
 export const roomsDir = () => join(stateRoot(), 'rooms');
@@ -25,6 +27,8 @@ export function createRoomRecord(input) {
         const requested = storedRoomLaunchPolicy(input.room_policy);
         if (JSON.stringify(before) !== JSON.stringify(requested))
             throw new RoomStateError(`room ${input.room_id} launch policy mismatch`);
+        if (existing.workspace)
+            ensureWorkspace(existing.workspace);
         return existing;
     }
     const record = {
@@ -40,7 +44,10 @@ export function createRoomRecord(input) {
         state: 'provisioning',
         created_at: new Date().toISOString(),
     };
+    record.workspace = input.task_id ? getTask(input.task_id).workspace : planWorkspace('room', input.room_id);
     writeRoom(record);
+    if (record.workspace)
+        ensureWorkspace(record.workspace);
     return record;
 }
 export function getRoomRecord(id) {
@@ -112,6 +119,8 @@ export function setOwnerSeat(id, ownerSeatCid, inviteFingerprint) {
 }
 export function updateMemberSeats(id, seats) {
     const r = readRoom(id);
+    if (r.state === 'closing' || r.state === 'closed')
+        throw new RoomStateError(`room ${id} is ${r.state}; member provisioning is fenced`);
     r.member_seats = seats;
     writeRoom(r);
     return r;
@@ -135,6 +144,8 @@ const LAUNCH_ORDER = [
 ];
 export function updateMemberStartup(id, roleName, update) {
     const r = readRoom(id);
+    if (r.state === 'closing' || r.state === 'closed')
+        throw new RoomStateError(`room ${id} is ${r.state}; member provisioning is fenced`);
     const seat = r.member_seats.find(candidate => candidate.role_name === roleName);
     if (!seat)
         throw new RoomStateError(`room ${id} has no recorded member ${roleName}`);
@@ -151,6 +162,8 @@ export function updateMemberStartup(id, roleName, update) {
 }
 export function activateRoom(id) {
     const r = readRoom(id);
+    if (r.state === 'closing' || r.state === 'closed')
+        throw new RoomStateError(`room ${id} is ${r.state}; activation is fenced`);
     r.state = 'active';
     r.saga = { phase: 'completed', step_index: 0 };
     delete r.provisioning_detail;

package/dist/rooms-tasks/task-state.d.ts

@@ -1,3 +1,4 @@
+import type { ArchivedMemberAbsence } from './types.js';
 import type { TaskRecord, TaskState, TaskOrigin, TaskTemplateRef, TaskOutcome, TaskMemberRole, TaskTerminalIntent, TaskDeletionActor, TaskDeletionMemberPhase } from './types.js';
 export declare const tasksDir: () => string;
 export declare class TaskStateError extends Error {
@@ -74,6 +75,7 @@ export interface TaskDeletionReceipt {
     original_state: TaskState;
     room_id?: string;
     member_count: number;
+    archived_absences?: ArchivedMemberAbsence[];
     settled_at?: string;
     result?: 'deleted';
 }
@@ -122,6 +124,10 @@ export declare function advanceTaskDeletionMember(id: string, name: string, phas
 interface SeatEvidence {
     role_name: string;
     identity_cid?: string;
+    launch?: {
+        launch_id?: string;
+        action_id?: string;
+    };
     retirement?: {
         phase: TaskDeletionMemberPhase;
         launch_id: string;
@@ -146,10 +152,14 @@ export declare function upsertTaskDeletionMembersFromSeats(id: string, seats: Re
  *
  * The room saga is trusted for phase jumps, but partial or corrupt retained
  * records must not become false success: every seat must be identity_absent;
- * a real launch requires archive evidence; an identity-less seat is accepted
- * only via the never-launched proof.
+ * a real launch requires archive evidence; an identity-less seat requires
+ * never-launched proof or a freshly verified archived-absence checkpoint.
+ */
+export declare function importTaskDeletionRetirementEvidence(id: string, seats: ReadonlyArray<SeatEvidence>, proofs?: ReadonlyArray<ArchivedMemberAbsence>): TaskRecord;
+/** Settlement-only checkpoint, under the task-operation lock after fresh archive verification.
+ * From here retries still verify live absence, but owned archives may be consumed.
  */
-export declare function importTaskDeletionRetirementEvidence(id: string, seats: ReadonlyArray<SeatEvidence>): TaskRecord;
+export declare function beginTaskWorkspaceCleanup(id: string): void;
 /**
  * Physically remove a deletion-pending task record. Settlement-only: callers
  * must have completed member retirement and room cleanup first. Missing