@ours.network/fleet 1.1.0-nightly.9 → 1.1.0

package/dist/rooms-tasks/provision.js

@@ -1,19 +1,26 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
 import { parse } from 'yaml';
 import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, activateRoom, getRoomRecord, } from './room-state.js';
 import { activateTask, updateTaskMembers, blockTask, unblockTask, getTask, } from './task-state.js';
+import { storedRoomLaunchPolicy } from './types.js';
 import { spawnTemp } from '../spawn.js';
-import { findRole, loadConfig } from '../config.js';
+import { effectivePermissionMode } from '../permissions.js';
+import { selectionOrigin, summarizeResolvedLaunch, } from '../lifecycle-summary.js';
+import { canonicalJson } from '../canonical-json.js';
+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 { withFileLock } from '../atomic-file.js';
+import { TASK_OPERATION_LOCK_STALE_MS, taskOperationLockPath } from './terminal.js';
+import { TaskStateError, taskDeletionState } from './task-state.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';
-import { recordFleetAuditPresentation } from '../fleet-command-audit.js';
 export function getBinPath() {
     try {
         return realpathSync(process.argv[1]);
@@ -22,42 +29,9 @@ export function getBinPath() {
         return process.argv[1];
     }
 }
-function canonicalJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonicalJson).join(',')}]`;
-    if (value && typeof value === 'object')
-        return `{${Object.entries(value)
-            .sort(([a], [b]) => a.localeCompare(b))
-            .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(',')}}`;
-    return JSON.stringify(value);
-}
-function selectionSummary(selection) {
-    if ('ref' in selection)
-        return `ref:${selection.ref} (reference)`;
-    return `inline:sha256:${createHash('sha256').update(canonicalJson(selection.inline)).digest('hex').slice(0, 16)} (inline)`;
-}
-function permissionSummary(definition) {
-    const permissions = definition.permissions;
-    if (!permissions)
-        return undefined;
-    return `approval=${permissions.approval},filesystem=${permissions.filesystem},unattended=${permissions.unattended}`;
-}
 function launchDefinition(definition) {
-    const selectionEvidence = (selection) => 'ref' in selection ? { kind: 'ref', id: selection.ref } : {
-        kind: 'inline', fingerprint: `sha256:${createHash('sha256')
-            .update(canonicalJson(selection.inline)).digest('hex').slice(0, 16)}`,
-    };
     return {
-        projection: {
-            brain: selectionEvidence(definition.brain), role: selectionEvidence(definition.role),
-            ...(definition.permissions ? { permissions: {
-                    approval: definition.permissions.approval,
-                    filesystem: definition.permissions.filesystem,
-                    unattended: definition.permissions.unattended,
-                } } : {}),
-            operationalFields: Object.keys(definition)
-                .filter(key => key !== 'brain' && key !== 'role').sort(),
-        },
+        projection: redactLaunchDefinition(definition),
         fingerprint: createHash('sha256').update(canonicalJson(definition)).digest('hex'),
     };
 }
@@ -81,8 +55,27 @@ async function spawnRoomMember(options, binPath) {
         statePath: result.statePath,
         creationActionId: result.creationActionId,
         callerRole: result.caller,
+        ...(result.configuration ? { configuration: result.configuration } : {}),
     };
 }
+/**
+ * Launch-boundary capture: the exact ResolvedRole the spawn persisted,
+ * whitelisted into the operator-facing presentation. Capture is required for
+ * every launched room member — launchMatches has already proved role.yaml
+ * readable, and effectivePermissionMode is total over registered harnesses —
+ * so a failure here is a capture defect and must surface, not degrade to the
+ * legacy rendering.
+ */
+function presentationFromStatePath(statePath, settings, coworkRole) {
+    const resolved = parse(readFileSync(join(statePath, 'role.yaml'), 'utf8'));
+    return summarizeResolvedLaunch(resolved, {
+        role: selectionOrigin(settings.definition.role),
+        brain: selectionOrigin(settings.definition.brain),
+        template: settings.template,
+        permissionMode: effectivePermissionMode(resolved),
+        missionFallback: coworkRole,
+    });
+}
 function shortId(id) { return id.slice(0, 8); }
 function expandMembers(template, prefix) {
     const result = [];
@@ -92,39 +85,41 @@ function expandMembers(template, prefix) {
                 name: `${prefix}-${slot.slot}-${i}`,
                 slot: slot.slot,
                 coworkRole: slot.role,
-                agent: structuredClone(slot.agent),
+                agentTemplate: slot.agent_template,
+                launchDefinitionId: slot.launch_definition_id ?? slot.agent_template,
+                agentTemplateHash: slot.agent_template_hash,
+                loopSource: slot.loop_source ?? 'omitted',
             });
         }
     }
     return result;
 }
-function settingsFor(member, cfg) {
-    if (!('ref' in member.agent)) {
-        const role = member.agent.role;
-        if (cfg.files[0] && existsSync(cfg.files[0]) && statSync(cfg.files[0]).isFile())
-            loadConfig(cfg.files[0], { additionalAgent: {
-                    id: `RoomPreflight${member.name.replace(/[^A-Za-z0-9_-]/g, '')}`.slice(0, 64),
-                    definition: member.agent,
-                } });
-        return { definition: structuredClone(member.agent),
-            ...('inline' in role && typeof role.inline.persona === 'string'
-                ? { persona: role.inline.persona } : {}) };
-    }
-    const refRole = findRole(cfg, member.agent.ref);
-    const definition = cfg.agentDefinitions?.[member.agent.ref];
+function settingsFor(member, cfg, sealed) {
+    const definition = sealed
+        ? sealed[member.launchDefinitionId]
+        : cfg.agentTemplates?.[member.agentTemplate];
     if (!definition)
-        throw new Error(`Agent '${member.agent.ref}' has no canonical definition`);
+        throw new Error(sealed
+            ? `Sealed Agent definition '${member.launchDefinitionId}' not found`
+            : `Agent Template '${member.agentTemplate}' not found`);
+    const role = definition.role;
     return {
         definition: structuredClone(definition),
-        persona: refRole.persona,
+        ...('inline' in role && typeof role.inline.persona === 'string'
+            ? { persona: role.inline.persona } : {}),
+        template: member.agentTemplate,
+        templateHash: member.agentTemplateHash
+            ?? createHash('sha256').update(canonicalJson(definition)).digest('hex'),
+        loopSource: member.loopSource,
     };
 }
-function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid) {
+function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid, anonymous) {
     return buildRoomMemberTask({
         taskId: input.taskId,
         roomId: input.roomId,
         roomIdentityCid,
         ownerSeatCid,
+        anonymous,
         goal: input.goal,
         brief: input.brief,
         contract: input.template.contract,
@@ -139,7 +134,7 @@ function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCi
         })),
     });
 }
-function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid, expectedInviteId) {
+function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid, expectedInviteId, anonymous = false) {
     const provenance = readProvenance(dir);
     if (provenance?.creationActionId !== actionId || provenance.role !== member.name)
         return false;
@@ -151,6 +146,7 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
             && startup.room_identity_cid === roomIdentityCid
             && startup.identity_name === member.name
             && startup.role === member.coworkRole
+            && (startup.anonymous ?? false) === anonymous
             && sha256Text(startup.task ?? '') === taskSha
             && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
             && typeof startup.invite === 'string'
@@ -161,21 +157,22 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
     }
 }
 async function retainRunningLaunch(input) {
-    const { provision, member, task, roomIdentityCid } = input;
+    const { provision, member, settings, task, roomIdentityCid } = input;
     let seat = getRoomRecord(provision.roomId).member_seats
         .find(candidate => candidate.role_name === member.name);
     const dir = agentDir(member.name, true);
     const taskSha = sha256Text(task);
+    const anonymous = storedRoomLaunchPolicy(getRoomRecord(provision.roomId)?.room_policy).anonymous;
     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)) {
+        if (!seat.launch.action_id || !launchMatches(dir, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id, anonymous)) {
             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);
+                && launchMatches(dir, member, provenance.creationActionId, taskSha, provision.roomId, roomIdentityCid, seat.invite_id, anonymous);
             if (!adoptable)
                 throw new Error(`existing launch for ${member.name} does not match its durable intent`);
             updateMemberStartup(provision.roomId, member.name, { launch: {
@@ -193,9 +190,14 @@ async function retainRunningLaunch(input) {
             throw new Error(`existing launch for ${member.name} has unknown liveness`);
         const retainedLaunch = seat.launch;
         if (live === 'running') {
+            // A crash between spawn and the seat update (or a pre-upgrade launch)
+            // can retain a running member without a captured presentation; backfill
+            // it from the same persisted resolved role the match was proved against.
+            const presentation = retainedLaunch.presentation
+                ?? presentationFromStatePath(dir, settings, member.coworkRole);
             updateMemberStartup(provision.roomId, member.name, { launch: {
                     ...retainedLaunch, state: 'launched', launch_id: supervisor.launchId,
-                    updated_at: new Date().toISOString(),
+                    presentation, updated_at: new Date().toISOString(),
                 } });
             return true;
         }
@@ -210,7 +212,7 @@ async function retainRunningLaunch(input) {
         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, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
+        if (!launchMatches(archive, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id, anonymous)) {
             throw new Error(`archive for disappeared ${member.name} does not match its durable intent`);
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
@@ -222,7 +224,7 @@ async function retainRunningLaunch(input) {
         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, taskSha, provision.roomId, roomIdentityCid, seat.invite_id)) {
+        if (!archive || !launchMatches(archive.path, member, seat.launch.action_id, taskSha, provision.roomId, roomIdentityCid, seat.invite_id, anonymous)) {
             throw new Error(`launch intent for ${member.name} has no exact live or terminated archive evidence`);
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
@@ -232,7 +234,25 @@ 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) {
     const { provision, member, settings, startup } = input;
     const seat = getRoomRecord(provision.roomId).member_seats
         .find(candidate => candidate.role_name === member.name);
@@ -247,6 +267,7 @@ async function launchMember(input) {
     updateMemberStartup(provision.roomId, member.name, { launch: {
             state: 'intent', attempt, action_id: actionId, mission_sha256: taskSha,
             agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
+            agent_template: settings.template, agent_template_hash: settings.templateHash,
             ...(proxyCaller ? { caller_role: proxyCaller } : {}),
             updated_at: new Date().toISOString(),
         } });
@@ -256,6 +277,9 @@ async function launchMember(input) {
             temp: true,
             identity: member.name,
             agentDefinition: settings.definition,
+            ...(settings.loopSource === 'cli' && settings.definition.loops === undefined
+                ? { noLoops: true } : {}),
+            loopSource: settings.loopSource,
             surface: 'agent',
             creationActionId: actionId,
             roomMemberStartup: startup,
@@ -266,36 +290,38 @@ async function launchMember(input) {
             updateMemberStartup(provision.roomId, member.name, { launch: {
                     state: 'intent', attempt, action_id: launched.creationActionId,
                     mission_sha256: taskSha, agent_definition: agentDefinition,
-                    agent_fingerprint: agentFingerprint, updated_at: new Date().toISOString(),
+                    agent_fingerprint: agentFingerprint,
+                    agent_template: settings.template, agent_template_hash: settings.templateHash,
+                    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)) {
+        if (!supervisor || supervisor.role !== member.name || !launchMatches(launchedDir, member, launched.creationActionId, taskSha, provision.roomId, startup.room_identity_cid, startup.invite_id, startup.anonymous ?? false)) {
             throw new Error(`new launch for ${member.name} did not persist matching provenance`);
         }
+        const presentation = launched.configuration
+            ? { ...launched.configuration, template: settings.template,
+                ...(launched.configuration.mission ? {} : { mission: member.coworkRole }) }
+            : presentationFromStatePath(launchedDir, settings, member.coworkRole);
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'launched', attempt, action_id: launched.creationActionId, mission_sha256: taskSha,
                 agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
+                agent_template: settings.template, agent_template_hash: settings.templateHash,
+                presentation,
                 ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
                 launch_id: supervisor.launchId, updated_at: new Date().toISOString(),
             } });
-        recordFleetAuditPresentation({ kind: 'agent_started', id: member.name, name: member.name,
-            lifetime: 'temporary', brain: selectionSummary(settings.definition.brain),
-            role: selectionSummary(settings.definition.role), harness: 'resolved', session: 'acp',
-            permissions: permissionSummary(settings.definition), parent: provision.roomId,
-            actionId: launched.creationActionId, inherited: [] });
     }
     catch (error) {
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'failed', attempt, action_id: effectiveActionId, mission_sha256: taskSha,
                 agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
+                agent_template: settings.template, agent_template_hash: settings.templateHash,
                 ...(proxyCaller ? { caller_role: proxyCaller } : {}),
                 updated_at: new Date().toISOString(),
                 error: error instanceof Error ? error.message : String(error),
             } });
-        recordFleetAuditPresentation({ kind: 'lifecycle_failure', resource: 'Agent', id: member.name,
-            state: 'failed', category: 'readiness_failed', eventId: effectiveActionId });
         throw error;
     }
 }
@@ -313,9 +339,10 @@ function exactCoworkSeat(observed, member, expectedInviteId) {
     }
     return seat;
 }
-function reconcileMemberSeats(roomId, members, observed) {
+function reconcileMemberSeats(roomId, members, observed, ownerSeatCid) {
     const current = getRoomRecord(roomId);
-    let complete = true;
+    let complete = !ownerSeatCid || observed.some(seat => seat.identity_cid.toLowerCase() === ownerSeatCid.toLowerCase()
+        && seat.seat_state === 'active');
     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);
@@ -333,24 +360,35 @@ function reconcileMemberSeats(roomId, members, observed) {
     updateMemberSeats(roomId, seats);
     return { complete, seats };
 }
+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)})`);
+}
 export async function provisionMembers(input) {
     const { cfg, cowork, roomId, taskId, template } = input;
+    // Deletion-epoch pre-check; each member launch re-checks under the lock.
+    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)}`;
     const members = expandMembers(template, prefix);
     // Resolve every Agent before persisting launch intent or touching Cowork membership.
-    const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg)]));
+    const sealed = template.launch_snapshot_hash
+        ? readLaunchSnapshot(template.launch_snapshot_hash) : undefined;
+    const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg, sealed)]));
     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 ownerSeatCid = existing.owner_seat_cid ?? null;
+    const roomPolicy = storedRoomLaunchPolicy(existing.room_policy);
     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);
         updateMemberSeats(roomId, members.map(member => {
-            const evidence = launchDefinition(settings.get(member.name).definition);
+            const memberSettings = settings.get(member.name);
+            const evidence = launchDefinition(memberSettings.definition);
             return ({
                 role_name: member.name,
                 slot: member.slot,
@@ -358,6 +396,8 @@ export async function provisionMembers(input) {
                 seat_state: 'pending',
                 launch: { state: 'pending', attempt: 0,
                     agent_definition: evidence.projection, agent_fingerprint: evidence.fingerprint,
+                    agent_template: memberSettings.template,
+                    agent_template_hash: memberSettings.templateHash,
                     updated_at: new Date().toISOString() },
             });
         }));
@@ -370,7 +410,7 @@ export async function provisionMembers(input) {
                 throw new Error(`Agent definition drift for ${member.name}; durable launch intent does not match current configuration`);
         }
     }
-    const tasks = new Map(members.map(member => [member.name, roomTask(input, member, settings.get(member.name), members, roomIdentityCid, ownerSeatCid)]));
+    const tasks = new Map(members.map(member => [member.name, roomTask(input, member, settings.get(member.name), members, roomIdentityCid, ownerSeatCid, roomPolicy.anonymous)]));
     const policy = {
         timeoutMs: input.startupWait?.timeoutMs ?? 60_000,
         initialDelayMs: input.startupWait?.initialDelayMs ?? 250,
@@ -381,20 +421,23 @@ export async function provisionMembers(input) {
     advanceSaga(roomId, 'join_role_groups', 4);
     try {
         const initialRoom = await cowork.recoverRoom(roomId);
-        reconcileMemberSeats(roomId, members, initialRoom.seats);
+        assertCoworkRoomPolicy(initialRoom, roomPolicy.anonymous);
+        reconcileMemberSeats(roomId, members, initialRoom.seats, existing.owner_seat_cid);
         for (const member of members) {
             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,
+                    provision: input, member, settings: settings.get(member.name), task, roomIdentityCid,
                 })) {
                     throw new Error(`active Cowork seat ${member.name} has no matching live Fleet launch`);
                 }
                 continue;
             }
-            if (await retainRunningLaunch({ provision: input, member, task, roomIdentityCid }))
+            if (await retainRunningLaunch({
+                provision: input, member, settings: settings.get(member.name), task, roomIdentityCid,
+            }))
                 continue;
             const issued = await cowork.issueInvite(roomId, {
                 mode: 'one_time', role: member.coworkRole, min_accepts: 1,
@@ -415,6 +458,7 @@ export async function provisionMembers(input) {
                         role: member.coworkRole,
                         task,
                         owner_seat_cid: ownerSeatCid,
+                        anonymous: roomPolicy.anonymous,
                     },
                 });
             }
@@ -426,9 +470,18 @@ export async function provisionMembers(input) {
     }
     catch (error) {
         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, reason);
+        setSagaError(roomId, reason, 'Member invite or launch failed. Inspect role logs, then retry with `task start`.', 'member_failed');
+        if (taskId) {
+            // A deletion-pending (or already-terminal) task rejects the block
+            // overlay; the original launch failure must still propagate.
+            try {
+                blockTask(taskId, reason);
+            }
+            catch (blockError) {
+                if (!(blockError instanceof TaskStateError))
+                    throw blockError;
+            }
+        }
         throw error;
     }
     advanceSaga(roomId, 'wait_seats', 5);
@@ -436,7 +489,8 @@ export async function provisionMembers(input) {
     let delay = policy.initialDelayMs;
     for (;;) {
         const remote = await cowork.recoverRoom(roomId);
-        const reconciled = reconcileMemberSeats(roomId, members, remote.seats);
+        assertCoworkRoomPolicy(remote, roomPolicy.anonymous);
+        const reconciled = reconcileMemberSeats(roomId, members, remote.seats, ownerSeatCid ?? undefined);
         if (reconciled.complete)
             break;
         if (policy.now() >= deadline) {
@@ -447,6 +501,15 @@ export async function provisionMembers(input) {
         await policy.sleep(delay);
         delay = Math.min(policy.maxDelayMs, Math.max(delay + 1, delay * 2));
     }
+    // Admission alone is insufficient: every expected member must still have
+    // the exact live launch that owns its authenticated Cowork seat.
+    for (const member of members) {
+        if (!await retainRunningLaunch({
+            provision: input, member, settings: settings.get(member.name),
+            task: tasks.get(member.name), roomIdentityCid,
+        }))
+            throw new Error(`active Cowork seat ${member.name} has no matching live Fleet launch`);
+    }
     if (taskId) {
         const taskMembers = getRoomRecord(roomId).member_seats.map(seat => {
             if (!seat.identity_cid)

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

@@ -9,6 +9,7 @@ export interface CreateRoomInput {
     room_identity_cid?: string;
     task_id?: string;
     template_snapshot?: import('./types.js').TemplateSnapshot;
+    room_policy?: import('./types.js').RoomLaunchPolicy;
 }
 export declare function createRoomRecord(input: CreateRoomInput): RoomOrchestrationRecord;
 export declare function getRoomRecord(id: string): RoomOrchestrationRecord | undefined;

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 { storedRoomLaunchPolicy } from './types.js';
+import { releaseLaunchSnapshot } from './launch-snapshot.js';
 export const roomsDir = () => join(stateRoot(), 'rooms');
 function roomPath(id) { return join(roomsDir(), `${id}.json`); }
 export class RoomStateError extends Error {
@@ -18,8 +20,13 @@ function writeRoom(record) {
 }
 export function createRoomRecord(input) {
     const existing = getRoomRecord(input.room_id);
-    if (existing)
+    if (existing) {
+        const before = storedRoomLaunchPolicy(existing.room_policy);
+        const requested = storedRoomLaunchPolicy(input.room_policy);
+        if (JSON.stringify(before) !== JSON.stringify(requested))
+            throw new RoomStateError(`room ${input.room_id} launch policy mismatch`);
         return existing;
+    }
     const record = {
         room_id: input.room_id,
         room_name: input.room_name,
@@ -27,6 +34,7 @@ export function createRoomRecord(input) {
         room_identity_cid: input.room_identity_cid,
         task_id: input.task_id,
         template_snapshot: input.template_snapshot,
+        room_policy: input.room_policy,
         saga: { phase: 'persist_intent', step_index: 0 },
         member_seats: [],
         state: 'provisioning',
@@ -46,8 +54,11 @@ export function getRoomRecord(id) {
 /** Remove a terminal orchestration record from the live room inventory. */
 export function deleteRoomRecord(id) {
     const path = roomPath(id);
+    const hash = getRoomRecord(id)?.template_snapshot?.launch_snapshot_hash;
     if (existsSync(path))
         rmSync(path);
+    if (hash)
+        releaseLaunchSnapshot(hash);
 }
 export function listRoomRecords(filter) {
     const dir = roomsDir();

package/dist/rooms-tasks/task-room-name.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Cowork room identities are named `ours-cowork:<room name>` and both the
+ * room and identity contracts count NFC-normalized Unicode code points.
+ * Keeping the complete task ID inside that shared budget makes every derived
+ * name stable, directly correlated, and unique even when the title is empty,
+ * sanitized, or truncated.
+ */
+export declare const COWORK_ROOM_IDENTITY_PREFIX = "ours-cowork:";
+export declare const COWORK_IDENTITY_NAME_MAX_CODE_POINTS = 64;
+export declare const TASK_ROOM_NAME_MAX_CODE_POINTS: number;
+/** Canonical Cowork room name for a Fleet task; never mutates the task title. */
+export declare function deriveTaskRoomName(title: string, taskId: string): string;

package/dist/rooms-tasks/task-room-name.js

@@ -0,0 +1,61 @@
+/**
+ * Cowork room identities are named `ours-cowork:<room name>` and both the
+ * room and identity contracts count NFC-normalized Unicode code points.
+ * Keeping the complete task ID inside that shared budget makes every derived
+ * name stable, directly correlated, and unique even when the title is empty,
+ * sanitized, or truncated.
+ */
+export const COWORK_ROOM_IDENTITY_PREFIX = 'ours-cowork:';
+export const COWORK_IDENTITY_NAME_MAX_CODE_POINTS = 64;
+export const TASK_ROOM_NAME_MAX_CODE_POINTS = COWORK_IDENTITY_NAME_MAX_CODE_POINTS
+    - Array.from(COWORK_ROOM_IDENTITY_PREFIX).length;
+const TASK_ID_PATTERN = /^[0-9a-z]{9}[0-9a-f]{8}$/;
+const FORBIDDEN = /[\\/\p{Cc}\p{Cf}\p{Cs}\p{Zl}\p{Zp}]/u;
+const DASH_SEPARATOR = /\p{Pd}/u;
+const WHITESPACE = /\s/u;
+const FALLBACK_TITLE = 'Task';
+function sanitizeTitle(title) {
+    const normalized = title.normalize('NFC');
+    let result = '';
+    let pending;
+    for (const character of normalized) {
+        if (FORBIDDEN.test(character) || DASH_SEPARATOR.test(character)) {
+            pending = 'separator';
+        }
+        else if (WHITESPACE.test(character)) {
+            if (pending !== 'separator')
+                pending = 'space';
+        }
+        else {
+            if (result && pending)
+                result += pending === 'separator' ? ' - ' : ' ';
+            result += character;
+            pending = undefined;
+        }
+    }
+    return result;
+}
+/** Truncate to a code-point budget without cutting an extended grapheme. */
+function graphemeBound(value, maxCodePoints) {
+    const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+    let result = '';
+    let length = 0;
+    for (const { segment } of segmenter.segment(value)) {
+        const segmentLength = Array.from(segment).length;
+        if (length + segmentLength > maxCodePoints)
+            break;
+        result += segment;
+        length += segmentLength;
+    }
+    return result.trimEnd();
+}
+/** Canonical Cowork room name for a Fleet task; never mutates the task title. */
+export function deriveTaskRoomName(title, taskId) {
+    if (!TASK_ID_PATTERN.test(taskId))
+        throw new Error(`invalid canonical task ID: ${taskId}`);
+    const suffix = ` [${taskId}]`;
+    const titleBudget = TASK_ROOM_NAME_MAX_CODE_POINTS - Array.from(suffix).length;
+    const readable = sanitizeTitle(title);
+    const bounded = graphemeBound(readable || FALLBACK_TITLE, titleBudget) || FALLBACK_TITLE;
+    return `${bounded}${suffix}`;
+}