@ours.network/fleet 1.0.1 → 1.0.3

package/dist/rooms-tasks/provision.js

@@ -1,13 +1,15 @@
 import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { parse } from 'yaml';
-import { attachOursClient, } from '@ours.network/sdk/client';
-import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, updateRoomRoleBriefing, updateRoomHistoryCursor, activateRoom, getRoomRecord, } from './room-state.js';
-import { activateTask, updateTaskMembers, failTask, blockTask, unblockTask, getTask, } from './task-state.js';
+import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, activateRoom, getRoomRecord, } from './room-state.js';
+import { activateTask, updateTaskMembers, blockTask, unblockTask, getTask, } from './task-state.js';
 import { spawnTemp } from '../spawn.js';
 import { findRole } from '../config.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 { buildRoomMemberCharter, reconcileBriefingHistory, sha256Text, } from './member-startup.js';
+import { buildRoomMemberTask, sha256Text } from './member-startup.js';
 import { agentDir } from '../paths.js';
 import { readProvenance } from '../creation.js';
 import { readTempSupervisor, secureStoppedTempArchive, tempArchiveForCreationAction, tempSupervisorLiveness, } from '../temp-lifecycle.js';
@@ -19,6 +21,28 @@ export function getBinPath() {
         return process.argv[1];
     }
 }
+async function spawnRoomMember(options, binPath) {
+    const stateDir = process.env[FLEET_PROXY_STATE_DIR_ENV];
+    if (!stateDir)
+        return {
+            statePath: await spawnTemp(options, binPath),
+            creationActionId: options.creationActionId,
+        };
+    const response = await controlRequest(stateDir, { command: 'fleet_spawn', spawn: options }, 10 * 60_000);
+    if (!response.ok) {
+        throw new SessionControlError(response.kind ?? 'backend', response.error ?? 'managed room member spawn failed');
+    }
+    const result = response.result;
+    const expectedCaller = process.env[FLEET_PROXY_CALLER_ENV];
+    if (expectedCaller && result.caller !== expectedCaller) {
+        throw new Error(`fleet proxy caller mismatch: expected '${expectedCaller}', got '${result.caller}'`);
+    }
+    return {
+        statePath: result.statePath,
+        creationActionId: result.creationActionId,
+        callerRole: result.caller,
+    };
+}
 function shortId(id) { return id.slice(0, 8); }
 function expandMembers(template, prefix) {
     const result = [];
@@ -35,135 +59,90 @@ function expandMembers(template, prefix) {
     }
     return result;
 }
-async function createMemberIdentity(name, bio) {
-    const client = await attachOursClient({
-        env: process.env,
-        leaseToken: `ours-fleet-member-create-${process.pid}-${randomUUID()}`,
-        clientPid: process.pid,
-    });
-    try {
-        const result = await client.createIdentity({
-            name,
-            bio,
-            exposeLocal: true,
-            localAutoAccept: true,
-        });
-        return { cid: result.info.cid, client };
-    }
-    finally {
-        await client.releaseLease();
-    }
-}
-async function removeMemberIdentity(name) {
-    try {
-        const client = await attachOursClient({
-            env: process.env,
-            leaseToken: `ours-fleet-member-cleanup-${process.pid}-${randomUUID()}`,
-            clientPid: process.pid,
-        });
-        try {
-            await client.removeIdentity({ name });
-        }
-        finally {
-            await client.releaseLease();
-        }
-    }
-    catch { /* best-effort cleanup */ }
-}
-async function redeemRoomInviteAsMember(member, invite, roomIdentityCid) {
-    const client = await attachOursClient({
-        env: process.env,
-        leaseToken: `ours-fleet-member-admit-${process.pid}-${randomUUID()}`,
-        clientPid: process.pid,
-    });
-    try {
-        const bound = await client.chooseIdentity({ name: member.name, force: false });
-        if (bound.cid.toLowerCase() !== member.cid.toLowerCase()) {
-            throw new Error(`member ${member.name} identity CID mismatch: expected ${member.cid}, found ${bound.cid}`);
-        }
-        const added = await client.addContact({ invite });
-        if (added.cid.toLowerCase() !== roomIdentityCid.toLowerCase()) {
-            throw new Error(`member ${member.name} invite resolved to ${added.cid}; expected room ${roomIdentityCid}`);
-        }
-    }
-    finally {
-        await client.releaseLease().catch(() => { });
-    }
-}
 function settingsFor(member, cfg) {
     let refRole;
     try {
         refRole = findRole(cfg, member.roleRef);
     }
     catch { /* no ref role */ }
+    const permissions = member.overrides?.permissions;
     return {
         model: member.overrides?.model ?? refRole?.model,
         harness: member.overrides?.harness ?? refRole?.harness,
         cwd: member.overrides?.cwd ?? refRole?.cwd,
         persona: member.overrides?.persona ?? refRole?.persona,
+        approval: permissions?.approval,
+        filesystem: permissions?.filesystem,
+        unattended: permissions?.unattended,
     };
 }
-async function roomHistory(cowork, roomId) {
-    const records = [];
-    let after = getRoomRecord(roomId)?.history_cursor ?? 0;
-    for (let page = 0; page < 100; page++) {
-        const next = await cowork.getHistory(roomId, { after, limit: 200 });
-        records.push(...next.records);
-        if (next.raw_count === 0)
-            return { records, cursor: after, exhausted: true };
-        if (next.next_after <= after)
-            throw new Error('Cowork room history cursor did not advance');
-        after = next.next_after;
-        if (next.raw_count < 200)
-            return { records, cursor: after, exhausted: true };
-    }
-    return { records, cursor: after, exhausted: false };
-}
-async function assertCurrentRoleBriefings(cowork, roomId, definitions) {
-    const room = await cowork.getRoom(roomId);
-    if (!room)
-        throw new Error(`Cowork room ${roomId} is missing during briefing verification`);
-    for (const [role, expected] of definitions) {
-        const current = room.role_briefings[role];
-        if (!current || current.text !== expected.text
-            || sha256Text(current.text) !== expected.sha256
-            || (expected.version !== undefined && current.version !== expected.version)) {
-            throw new Error(`Cowork current role briefing drift for ${role}`);
-        }
-    }
-}
-function startupMission(gate) {
-    return [
-        'Complete the dedicated room startup gate in briefing.md before readiness.',
-        `Expected room ${gate.room_id} (${gate.room_identity_cid}), role ${gate.briefing_role},`,
-        `briefing version ${gate.briefing_version}, sha256 ${gate.briefing_sha256}.`,
-    ].join(' ');
+function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid) {
+    return buildRoomMemberTask({
+        taskId: input.taskId,
+        roomId: input.roomId,
+        roomIdentityCid,
+        ownerSeatCid,
+        goal: input.goal,
+        brief: input.brief,
+        contract: input.template.contract,
+        member: {
+            role_name: member.name,
+            cowork_role: member.coworkRole,
+            persona: settings.persona,
+        },
+        roster: members.map(candidate => ({
+            role_name: candidate.name,
+            cowork_role: candidate.coworkRole,
+        })),
+    });
 }
-function launchMatches(dir, member, actionId, missionSha, gate) {
+function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid, expectedInviteId) {
     const provenance = readProvenance(dir);
     if (provenance?.creationActionId !== actionId || provenance.role !== member.name)
         return false;
     try {
         const role = parse(readFileSync(`${dir}/role.yaml`, 'utf8'));
+        const startup = role.roomMemberStartup;
         return role.identity === member.name
             && typeof role.mission === 'string'
-            && sha256Text(role.mission) === missionSha
-            && JSON.stringify(role.roomStartupGate) === JSON.stringify(gate);
+            && sha256Text(role.mission) === taskSha
+            && startup?.room_id === roomId
+            && startup.room_identity_cid === roomIdentityCid
+            && startup.identity_name === member.name
+            && startup.role === member.coworkRole
+            && startup.task === role.mission
+            && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
+            && typeof startup.invite === 'string'
+            && startup.invite.length > 0;
     }
     catch {
         return false;
     }
 }
-async function ensureLaunch(input) {
-    const { provision, member, settings, gate } = input;
+async function retainRunningLaunch(input) {
+    const { provision, member, task, roomIdentityCid } = input;
     let seat = getRoomRecord(provision.roomId).member_seats
         .find(candidate => candidate.role_name === member.name);
-    const mission = startupMission(gate);
-    const missionSha = sha256Text(mission);
     const dir = agentDir(member.name, true);
-    if ((seat.launch?.state === 'intent' || seat.launch?.state === 'launched') && existsSync(dir)) {
-        if (!seat.launch.action_id || !launchMatches(dir, member, seat.launch.action_id, seat.launch.mission_sha256 ?? '', gate)) {
-            throw new Error(`existing launch for ${member.name} does not match its durable intent`);
+    const taskSha = sha256Text(task);
+    if ((seat.launch?.state === 'intent' || seat.launch?.state === 'launched'
+        || seat.launch?.state === 'failed') && existsSync(dir)) {
+        if (!seat.launch.action_id || !launchMatches(dir, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
+            const provenance = readProvenance(dir);
+            const adoptable = (seat.launch.state === 'intent' || seat.launch.state === 'failed')
+                && Boolean(seat.launch.caller_role)
+                && provenance?.surface === 'agent'
+                && provenance.callerRole === seat.launch.caller_role
+                && typeof provenance.creationActionId === 'string'
+                && launchMatches(dir, member, provenance.creationActionId, taskSha, provision.roomId, roomIdentityCid, seat.invite_id);
+            if (!adoptable)
+                throw new Error(`existing launch for ${member.name} does not match its durable intent`);
+            updateMemberStartup(provision.roomId, member.name, { launch: {
+                    ...seat.launch, state: 'intent', action_id: provenance.creationActionId,
+                    updated_at: new Date().toISOString(),
+                } });
+            seat = getRoomRecord(provision.roomId).member_seats
+                .find(candidate => candidate.role_name === member.name);
         }
         const supervisor = readTempSupervisor(dir);
         if (!supervisor || supervisor.role !== member.name)
@@ -171,209 +150,165 @@ async function ensureLaunch(input) {
         const live = await tempSupervisorLiveness(dir);
         if (live === 'unknown')
             throw new Error(`existing launch for ${member.name} has unknown liveness`);
+        const retainedLaunch = seat.launch;
         if (live === 'running') {
             updateMemberStartup(provision.roomId, member.name, { launch: {
-                    ...seat.launch, state: 'launched', launch_id: supervisor.launchId,
+                    ...retainedLaunch, state: 'launched', launch_id: supervisor.launchId,
                     updated_at: new Date().toISOString(),
                 } });
-            return;
+            return true;
         }
         await secureStoppedTempArchive(member.name, supervisor.launchId);
         updateMemberStartup(provision.roomId, member.name, { launch: {
-                ...seat.launch, state: 'stopped', launch_id: supervisor.launchId,
+                ...retainedLaunch, state: 'stopped', launch_id: supervisor.launchId,
                 updated_at: new Date().toISOString(),
             } });
-        seat = getRoomRecord(provision.roomId).member_seats
-            .find(candidate => candidate.role_name === member.name);
+        return false;
     }
-    else if (seat.launch?.state === 'launched' && !existsSync(dir)) {
+    if (seat.launch?.state === 'launched' && !existsSync(dir)) {
         if (!seat.launch.launch_id || !seat.launch.action_id)
             throw new Error(`missing durable launch identity for disappeared ${member.name}`);
         const archive = await secureStoppedTempArchive(member.name, seat.launch.launch_id);
-        if (!launchMatches(archive, member, seat.launch.action_id, missionSha, gate))
+        if (!launchMatches(archive, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
             throw new Error(`archive for disappeared ${member.name} does not match its durable intent`);
+        }
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 ...seat.launch, state: 'stopped', updated_at: new Date().toISOString(),
             } });
-        seat = getRoomRecord(provision.roomId).member_seats
-            .find(candidate => candidate.role_name === member.name);
+        return false;
     }
-    else if (seat.launch?.state === 'intent' && !existsSync(dir)) {
+    if (seat.launch?.state === 'intent' && !existsSync(dir)) {
         if (!seat.launch.action_id)
             throw new Error(`missing action ID for disappeared launch intent ${member.name}`);
         const archive = tempArchiveForCreationAction(member.name, seat.launch.action_id);
-        if (!archive || !launchMatches(archive.path, member, seat.launch.action_id, missionSha, gate)) {
+        if (!archive || !launchMatches(archive.path, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
             throw new Error(`launch intent for ${member.name} has no exact live or terminated archive evidence`);
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 ...seat.launch, state: 'stopped', launch_id: archive.launchId,
                 updated_at: new Date().toISOString(),
             } });
-        seat = getRoomRecord(provision.roomId).member_seats
-            .find(candidate => candidate.role_name === member.name);
     }
-    const actionId = seat.launch?.state === 'intent' && seat.launch.action_id
-        ? seat.launch.action_id : randomUUID();
-    const attempt = seat.launch?.state === 'intent'
-        ? seat.launch.attempt : (seat.launch?.attempt ?? 0) + 1;
+    return false;
+}
+async function launchMember(input) {
+    const { provision, member, settings, startup } = input;
+    const seat = getRoomRecord(provision.roomId).member_seats
+        .find(candidate => candidate.role_name === member.name);
+    const actionId = randomUUID();
+    let effectiveActionId = actionId;
+    const attempt = (seat.launch?.attempt ?? 0) + 1;
+    const taskSha = sha256Text(startup.task);
+    const proxyCaller = process.env[FLEET_PROXY_STATE_DIR_ENV]
+        ? process.env[FLEET_PROXY_CALLER_ENV] : undefined;
     updateMemberStartup(provision.roomId, member.name, { launch: {
-            state: 'intent', attempt, action_id: actionId, mission_sha256: missionSha,
+            state: 'intent', attempt, action_id: actionId, mission_sha256: taskSha,
+            ...(proxyCaller ? { caller_role: proxyCaller } : {}),
             updated_at: new Date().toISOString(),
         } });
-    const launchedDir = await spawnTemp({
-        name: member.name, temp: true, identity: member.name, mission,
-        model: settings.model, harness: settings.harness, cwd: settings.cwd,
-        surface: 'agent', creationActionId: actionId, roomStartupGate: gate,
-    }, provision.binPath);
-    const supervisor = readTempSupervisor(launchedDir);
-    if (!supervisor || supervisor.role !== member.name
-        || !launchMatches(launchedDir, member, actionId, missionSha, gate)) {
-        throw new Error(`new launch for ${member.name} did not persist matching provenance`);
+    try {
+        const launched = await spawnRoomMember({
+            name: member.name,
+            temp: true,
+            identity: member.name,
+            mission: startup.task,
+            model: settings.model,
+            harness: settings.harness,
+            cwd: settings.cwd,
+            approval: settings.approval,
+            filesystem: settings.filesystem,
+            unattended: settings.unattended,
+            surface: 'agent',
+            creationActionId: actionId,
+            roomMemberStartup: startup,
+        }, provision.binPath);
+        const launchedDir = launched.statePath;
+        effectiveActionId = launched.creationActionId;
+        if (launched.creationActionId !== actionId) {
+            updateMemberStartup(provision.roomId, member.name, { launch: {
+                    state: 'intent', attempt, action_id: launched.creationActionId,
+                    mission_sha256: taskSha, updated_at: new Date().toISOString(),
+                    ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
+                } });
+        }
+        const supervisor = readTempSupervisor(launchedDir);
+        if (!supervisor || supervisor.role !== member.name || !launchMatches(launchedDir, member, launched.creationActionId, taskSha, provision.roomId, startup.room_identity_cid, startup.invite_id)) {
+            throw new Error(`new launch for ${member.name} did not persist matching provenance`);
+        }
+        updateMemberStartup(provision.roomId, member.name, { launch: {
+                state: 'launched', attempt, action_id: launched.creationActionId, mission_sha256: taskSha,
+                ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
+                launch_id: supervisor.launchId, updated_at: new Date().toISOString(),
+            } });
+    }
+    catch (error) {
+        updateMemberStartup(provision.roomId, member.name, { launch: {
+                state: 'failed', attempt, action_id: effectiveActionId, mission_sha256: taskSha,
+                ...(proxyCaller ? { caller_role: proxyCaller } : {}),
+                updated_at: new Date().toISOString(),
+                error: error instanceof Error ? error.message : String(error),
+            } });
+        throw error;
     }
-    updateMemberStartup(provision.roomId, member.name, { launch: {
-            state: 'launched', attempt, action_id: actionId, mission_sha256: missionSha,
-            launch_id: supervisor.launchId, updated_at: new Date().toISOString(),
-        } });
+}
+function exactCoworkSeat(observed, member, expectedInviteId) {
+    const named = observed.filter(seat => seat.display_name === member.name && seat.seat_state !== 'removed');
+    if (named.length > 1)
+        throw new Error(`Cowork has multiple live seats named ${member.name}`);
+    const seat = named[0];
+    if (!seat)
+        return undefined;
+    if (seat.role !== member.coworkRole)
+        throw new Error(`Cowork seat ${member.name} has role ${seat.role}; expected ${member.coworkRole}`);
+    if (expectedInviteId && seat.invite_id !== expectedInviteId) {
+        throw new Error(`Cowork seat ${member.name} used invite ${seat.invite_id}; expected ${expectedInviteId}`);
+    }
+    return seat;
+}
+function reconcileMemberSeats(roomId, members, observed) {
+    const current = getRoomRecord(roomId);
+    let complete = true;
+    const seats = current.member_seats.map(seat => {
+        const member = members.find(candidate => candidate.name === seat.role_name);
+        const found = exactCoworkSeat(observed, member, seat.invite_id);
+        if (!found || found.seat_state !== 'active') {
+            complete = false;
+            return seat;
+        }
+        return {
+            ...seat,
+            identity_cid: found.identity_cid,
+            invite_id: found.invite_id,
+            seat_state: 'active',
+        };
+    });
+    updateMemberSeats(roomId, seats);
+    return { complete, seats };
 }
 export async function provisionMembers(input) {
-    const { cfg, cowork, roomId, taskId, template, binPath } = input;
+    const { cfg, cowork, roomId, taskId, template } = input;
     const prefix = taskId ? shortId(taskId) : `room-${shortId(roomId)}`;
-    const plan = expandMembers(template, prefix);
-    const createdIdentities = [];
-    const members = [];
+    const members = expandMembers(template, prefix);
     const existing = getRoomRecord(roomId);
     if (!existing?.room_identity_cid)
         throw new Error(`room ${roomId} has no pinned room identity CID`);
     const roomIdentityCid = existing.room_identity_cid;
-    const persistedSeats = existing?.member_seats ?? [];
-    const resuming = plan.length > 0
-        && plan.every(p => persistedSeats.some(s => s.role_name === p.name));
-    let seats;
-    if (resuming) {
-        for (const planned of plan) {
-            const seat = persistedSeats.find(s => s.role_name === planned.name);
-            members.push({ ...planned, cid: seat.identity_cid });
-        }
-        seats = persistedSeats.map(seat => ({
-            ...seat,
-            launch: seat.launch ?? {
-                state: 'pending', attempt: 0, updated_at: existing.created_at,
-            },
-            briefing: seat.briefing ?? {
-                role: seat.cowork_role, state: 'pending', rejected_ack_count: 0,
-            },
-        }));
-        updateMemberSeats(roomId, seats);
-    }
-    else {
-        // create_members saga phase
+    const ownerSeatCid = existing.owner_seat_cid ?? null;
+    const persistedNames = new Set(existing.member_seats.map(seat => seat.role_name));
+    const resuming = members.length > 0
+        && members.every(member => persistedNames.has(member.name));
+    if (!resuming) {
         advanceSaga(roomId, 'create_members', 3);
-        try {
-            for (const planned of plan) {
-                const bio = `Fleet task member: ${planned.coworkRole} for ${taskId ?? roomId}`;
-                const { cid } = await createMemberIdentity(planned.name, bio);
-                createdIdentities.push(planned.name);
-                members.push({ ...planned, cid });
-            }
-        }
-        catch (error) {
-            for (const name of createdIdentities)
-                await removeMemberIdentity(name);
-            setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Member identity creation failed. Retry with `task recover`.', 'member_failed');
-            if (taskId)
-                failTask(taskId, error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-        seats = members.map(m => ({
-            role_name: m.name,
-            identity_cid: m.cid,
-            slot: m.slot,
-            cowork_role: m.coworkRole,
+        updateMemberSeats(roomId, members.map(member => ({
+            role_name: member.name,
+            slot: member.slot,
+            cowork_role: member.coworkRole,
             seat_state: 'pending',
             launch: { state: 'pending', attempt: 0, updated_at: new Date().toISOString() },
-            briefing: {
-                role: m.coworkRole, state: 'pending', rejected_ack_count: 0,
-            },
-        }));
-        updateMemberSeats(roomId, seats);
-        if (taskId) {
-            const taskMembers = members.map(m => ({
-                name: m.name,
-                identity_cid: m.cid,
-                slot: m.slot,
-                cowork_role: m.coworkRole,
-            }));
-            updateTaskMembers(taskId, taskMembers);
-        }
+        })));
     }
     const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg)]));
-    const roster = members.map(member => ({
-        role_name: member.name, cowork_role: member.coworkRole, identity_cid: member.cid,
-    }));
-    const definitions = new Map();
-    for (const member of members) {
-        const durable = getRoomRecord(roomId).role_briefings?.[member.coworkRole];
-        const text = durable?.text ?? buildRoomMemberCharter({
-            taskId, roomId, roomIdentityCid: existing.room_identity_cid,
-            ownerSeatCid: existing.owner_seat_cid ?? null,
-            goal: input.goal, brief: input.brief, contract: template.contract,
-            member: { ...roster.find(role => role.role_name === member.name),
-                persona: settings.get(member.name)?.persona },
-            roster,
-        });
-        const sha256 = sha256Text(text);
-        if (durable && durable.sha256 !== sha256)
-            throw new Error(`persisted role briefing hash mismatch for ${member.coworkRole}`);
-        const known = definitions.get(member.coworkRole);
-        if (known && known.text !== text) {
-            throw new Error(`members sharing Cowork role ${member.coworkRole} produced different briefing bytes`);
-        }
-        definitions.set(member.coworkRole, { text, sha256 });
-    }
-    advanceSaga(roomId, 'configure_briefings', 4);
-    const remoteRoom = await cowork.getRoom(roomId);
-    if (!remoteRoom)
-        throw new Error(`Cowork room ${roomId} is missing during briefing configuration`);
-    for (const [role, definition] of definitions) {
-        const current = getRoomRecord(roomId).role_briefings?.[role];
-        const attempt = (current?.attempts ?? 0) + 1;
-        updateRoomRoleBriefing(roomId, role, {
-            role, ...definition, ...(current?.version ? { version: current.version } : {}),
-            state: 'pending', attempts: attempt,
-            updated_at: new Date().toISOString(),
-        });
-        try {
-            const remote = remoteRoom.role_briefings[role];
-            if (remote && (remote.text !== definition.text
-                || sha256Text(remote.text) !== definition.sha256
-                || (current?.version !== undefined && remote.version !== current.version))) {
-                throw new Error(`Cowork current role briefing drift for ${role}`);
-            }
-            if (!remote && current?.version !== undefined)
-                throw new Error(`Cowork current role briefing is missing for ${role}`);
-            const configured = remote ?? await cowork.setRoleBriefing(roomId, {
-                role, text: definition.text,
-            });
-            if (configured.text !== definition.text)
-                throw new Error(`Cowork returned different briefing bytes for role ${role}`);
-            updateRoomRoleBriefing(roomId, role, {
-                role, ...definition, version: configured.version, state: 'configured',
-                attempts: attempt, updated_at: configured.updated_at,
-            });
-        }
-        catch (error) {
-            updateRoomRoleBriefing(roomId, role, {
-                role, ...definition, ...(current?.version ? { version: current.version } : {}),
-                state: 'failed', attempts: attempt,
-                updated_at: new Date().toISOString(),
-                last_error: error instanceof Error ? error.message : String(error),
-            });
-            setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Role briefing configuration failed. Retry task or room recover.', 'member_failed');
-            if (taskId)
-                blockTask(taskId, error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-    }
+    const tasks = new Map(members.map(member => [member.name, roomTask(input, member, settings.get(member.name), members, roomIdentityCid, ownerSeatCid)]));
     const policy = {
         timeoutMs: input.startupWait?.timeoutMs ?? 60_000,
         initialDelayMs: input.startupWait?.initialDelayMs ?? 250,
@@ -381,178 +316,91 @@ export async function provisionMembers(input) {
         now: input.startupWait?.now ?? Date.now,
         sleep: input.startupWait?.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms))),
     };
-    advanceSaga(roomId, 'join_role_groups', 5);
+    advanceSaga(roomId, 'join_role_groups', 4);
     try {
-        const observedSeats = await cowork.getSeats(roomId);
+        const initialRoom = await cowork.recoverRoom(roomId);
+        reconcileMemberSeats(roomId, members, initialRoom.seats);
         for (const member of members) {
-            const observed = observedSeats.find(seat => seat.identity_cid === member.cid
-                && seat.seat_state !== 'removed');
-            if (observed && observed.role !== member.coworkRole)
-                throw new Error(`Cowork seat ${member.cid} has role ${observed.role}; expected ${member.coworkRole}`);
-        }
-        const admitted = new Set(observedSeats
-            .filter(seat => seat.seat_state !== 'removed').map(seat => seat.identity_cid));
-        const roleGroups = new Map();
-        for (const member of members.filter(candidate => !admitted.has(candidate.cid))) {
-            roleGroups.set(member.coworkRole, [
-                ...(roleGroups.get(member.coworkRole) ?? []), member,
-            ]);
-        }
-        const issuance = await Promise.allSettled([...roleGroups].map(async ([coworkRole, group]) => ({
-            coworkRole,
-            group,
-            ...await cowork.issueInvite(roomId, { role: coworkRole, min_accepts: group.length }),
-        })));
-        const admissions = issuance.flatMap(result => result.status === 'fulfilled' ? [result.value] : []);
-        const issuanceFailure = issuance.find(result => result.status === 'rejected');
-        if (issuanceFailure?.status === 'rejected') {
-            const cleanup = await Promise.allSettled(admissions.map(admission => cowork.revokeInvite(roomId, admission.invite_id)));
-            const cleanupFailures = cleanup.filter(result => result.status === 'rejected');
-            if (cleanupFailures.length > 0) {
-                throw new AggregateError([issuanceFailure.reason, ...cleanupFailures.map(result => result.reason)], 'role descriptor issuance failed and one or more issued descriptors could not be revoked');
-            }
-            throw issuanceFailure.reason;
-        }
-        const redemptions = await Promise.allSettled(admissions.flatMap(({ group, invite }) => group.map(member => redeemRoomInviteAsMember(member, invite, roomIdentityCid))));
-        const redemptionFailure = redemptions.find(result => result.status === 'rejected');
-        if (redemptionFailure?.status === 'rejected') {
-            const cleanup = await Promise.allSettled(admissions.map(admission => cowork.revokeInvite(roomId, admission.invite_id)));
-            const cleanupFailures = cleanup.filter(result => result.status === 'rejected');
-            if (cleanupFailures.length > 0) {
-                throw new AggregateError([redemptionFailure.reason, ...cleanupFailures.map(result => result.reason)], 'member invite redemption failed and one or more issued descriptors could not be revoked');
-            }
-            throw redemptionFailure.reason;
-        }
-        const deadline = policy.now() + policy.timeoutMs;
-        let delay = policy.initialDelayMs;
-        for (;;) {
-            const reconciled = await cowork.recoverRoom(roomId);
-            const waiting = members.some(member => {
-                const seat = reconciled.seats.find(candidate => candidate.identity_cid === member.cid && candidate.seat_state !== 'removed');
-                if (seat && seat.role !== member.coworkRole) {
-                    throw new Error(`Cowork seat ${member.cid} has role ${seat.role}; expected ${member.coworkRole}`);
+            const task = tasks.get(member.name);
+            const currentSeat = getRoomRecord(roomId).member_seats
+                .find(seat => seat.role_name === member.name);
+            if (currentSeat.seat_state === 'active') {
+                if (!await retainRunningLaunch({
+                    provision: input, member, task, roomIdentityCid,
+                })) {
+                    throw new Error(`active Cowork seat ${member.name} has no matching live Fleet launch`);
                 }
-                return !seat;
+                continue;
+            }
+            if (await retainRunningLaunch({ provision: input, member, task, roomIdentityCid }))
+                continue;
+            const issued = await cowork.issueInvite(roomId, {
+                mode: 'one_time', role: member.coworkRole, min_accepts: 1,
             });
-            if (!waiting)
-                break;
-            if (policy.now() >= deadline) {
-                throw new Error('Cowork did not authenticate every required room seat after invite redemption');
+            const seats = getRoomRecord(roomId).member_seats.map(seat => seat.role_name === member.name ? { ...seat, invite_id: issued.invite_id } : seat);
+            updateMemberSeats(roomId, seats);
+            try {
+                await launchMember({
+                    provision: input,
+                    member,
+                    settings: settings.get(member.name),
+                    startup: {
+                        room_id: roomId,
+                        room_identity_cid: roomIdentityCid,
+                        identity_name: member.name,
+                        invite_id: issued.invite_id,
+                        invite: issued.invite,
+                        role: member.coworkRole,
+                        task,
+                        owner_seat_cid: ownerSeatCid,
+                    },
+                });
+            }
+            catch (error) {
+                await cowork.revokeInvite(roomId, issued.invite_id).catch(() => { });
+                throw error;
             }
-            await policy.sleep(delay);
-            delay = Math.min(policy.maxDelayMs, Math.max(delay + 1, delay * 2));
         }
     }
     catch (error) {
-        setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Role-group admission failed. Retry with `task recover`.', 'member_failed');
+        const reason = error instanceof Error ? error.message : String(error);
+        setSagaError(roomId, reason, 'Member invite or launch failed. Retry with `task recover`.', 'member_failed');
         if (taskId)
-            blockTask(taskId, error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-    if (taskId && getTask(taskId).blocked)
-        unblockTask(taskId);
-    advanceSaga(roomId, 'wait_seats', 6);
-    const coworkSeats = await cowork.getSeats(roomId);
-    const memberCids = new Set(members.map(m => m.cid));
-    const allActive = [...memberCids].every(cid => coworkSeats.some(s => s.identity_cid === cid
-        && s.role === members.find(member => member.cid === cid)?.coworkRole
-        && s.seat_state === 'active'));
-    if (!allActive) {
-        advanceSaga(roomId, 'wait_seats', 6, 'waiting_seats');
-        // Seats are pending — return record for caller to retry later
-        return getRoomRecord(roomId);
-    }
-    const activeSeats = seats.map(s => ({ ...s, seat_state: 'active' }));
-    updateMemberSeats(roomId, activeSeats);
-    advanceSaga(roomId, 'launch_work', 7);
-    try {
-        for (const member of members) {
-            const definition = getRoomRecord(roomId).role_briefings?.[member.coworkRole];
-            if (!definition?.version)
-                throw new Error(`role ${member.coworkRole} briefing is not configured`);
-            await ensureLaunch({
-                provision: input, member, settings: settings.get(member.name),
-                gate: {
-                    room_id: roomId, room_identity_cid: existing.room_identity_cid,
-                    briefing_role: member.coworkRole, briefing_version: definition.version,
-                    briefing_sha256: definition.sha256,
-                    owner_seat_cid: existing.owner_seat_cid ?? null,
-                },
-            });
-        }
-    }
-    catch (error) {
-        setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Member launch failed. Some agents may be running. Retry with `task recover`.', 'member_failed');
+            blockTask(taskId, reason);
         throw error;
     }
+    advanceSaga(roomId, 'wait_seats', 5);
     const deadline = policy.now() + policy.timeoutMs;
     let delay = policy.initialDelayMs;
     for (;;) {
-        const history = await roomHistory(cowork, roomId);
-        let allAcknowledged = true;
-        let relayFailed = false;
-        for (const member of members) {
-            const currentRoom = getRoomRecord(roomId);
-            const definition = currentRoom.role_briefings[member.coworkRole];
-            const previous = currentRoom.member_seats
-                .find(seat => seat.role_name === member.name).briefing;
-            const result = reconcileBriefingHistory(history.records, {
-                roomId, roomIdentityCid: existing.room_identity_cid,
-                ownerSeatCid: existing.owner_seat_cid ?? null,
-                memberCid: member.cid, role: member.coworkRole,
-                version: definition.version, sha256: definition.sha256,
-            }, previous);
-            if (result.drift) {
-                setSagaError(roomId, result.drift, 'Cowork role briefing history drifted; inspect current room briefing state.', 'uncertain');
-                if (taskId)
-                    blockTask(taskId, result.drift);
-                throw new Error(result.drift);
-            }
-            updateMemberStartup(roomId, member.name, { briefing: result.briefing });
-            allAcknowledged &&= result.briefing.state === 'acknowledged';
-            relayFailed ||= result.briefing.state === 'relay_failed';
-        }
-        updateRoomHistoryCursor(roomId, history.cursor);
-        if (!history.exhausted) {
-            const reason = 'Cowork history backlog exceeded 20,000 raw records in one pass; '
-                + 'cursor progress was preserved, retry recovery to continue.';
-            setSagaError(roomId, reason, reason, 'uncertain');
-            throw new Error(reason);
-        }
-        if (relayFailed) {
-            const reason = 'Cowork recorded terminal send_failed for a role briefing; '
-                + 'same-version redelivery requires Cowork support or seat replacement.';
-            advanceSaga(roomId, 'wait_briefing_acks', 8, 'briefing_delivery_failed');
-            setSagaError(roomId, reason, reason, 'briefing_delivery_failed');
-            if (taskId)
-                blockTask(taskId, reason);
-            return getRoomRecord(roomId);
-        }
-        if (allAcknowledged)
+        const remote = await cowork.recoverRoom(roomId);
+        const reconciled = reconcileMemberSeats(roomId, members, remote.seats);
+        if (reconciled.complete)
             break;
         if (policy.now() >= deadline) {
-            advanceSaga(roomId, 'wait_briefing_acks', 8, 'waiting_briefing_acks');
+            advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
             return getRoomRecord(roomId);
         }
-        advanceSaga(roomId, 'wait_briefing_acks', 8, 'waiting_briefing_acks');
+        advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
         await policy.sleep(delay);
         delay = Math.min(policy.maxDelayMs, Math.max(delay + 1, delay * 2));
     }
-    const finalDefinitions = new Map([...definitions].map(([role, definition]) => {
-        const persisted = getRoomRecord(roomId).role_briefings[role];
-        return [role, { ...definition, version: persisted.version }];
-    }));
-    try {
-        await assertCurrentRoleBriefings(cowork, roomId, finalDefinitions);
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        setSagaError(roomId, reason, 'Cowork current role briefing drifted before activation; inspect room state.', 'uncertain');
-        if (taskId)
-            blockTask(taskId, reason);
-        throw error;
+    if (taskId) {
+        const taskMembers = getRoomRecord(roomId).member_seats.map(seat => {
+            if (!seat.identity_cid)
+                throw new Error(`active room member ${seat.role_name} has no authenticated identity CID`);
+            return {
+                name: seat.role_name,
+                identity_cid: seat.identity_cid,
+                slot: seat.slot,
+                cowork_role: seat.cowork_role,
+            };
+        });
+        updateTaskMembers(taskId, taskMembers);
+        if (getTask(taskId).blocked)
+            unblockTask(taskId);
     }
-    advanceSaga(roomId, 'activate', 9);
+    advanceSaga(roomId, 'activate', 6);
     const record = activateRoom(roomId);
     if (taskId)
         activateTask(taskId);