@ours.network/fleet 1.2.0-nightly.8 → 1.2.0-nightly.81

package/dist/rooms-tasks/close.js

@@ -1,14 +1,23 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { detachDeletedRoom } from './task-state.js';
+import { binderKey } from '../agent-ours/state.js';
+import { assertMemberNotPermanent } from './member-ownership.js';
+import { retireTaskMemberService } from './task-service-retirement.js';
+import { eraseMemberArtifacts } from './erasure.js';
+import { deleteWorkspace, assertWorkspaceDeletable } from './workspace.js';
+import { collectWorkspaceArchives } from './workspace-artifacts.js';
+import { existsSync, lstatSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
+import { parse } from 'yaml';
+import { privateRuntimeRoot, releaseManagedAgent } from '../agent-ours/service.js';
 import { attachOursClient } from '@ours.network/sdk/client';
 import { withFileLock } from '../atomic-file.js';
 import { agentDir, stateRoot } from '../paths.js';
 import { readClientProfile } from '../client-profile.js';
 import { readTempSupervisor, secureStoppedTempArchive, stopTempSupervisor, tempSupervisorLiveness, tempArchiveForLaunch, tempArchiveForCreationAction, } from '../temp-lifecycle.js';
 import { CoworkProtocolError } from './cowork-adapter.js';
-import { advanceMemberRetirement, advanceRoomClose, beginRoomClose, closeRoom, deleteRoomRecord, getRoomRecord, listRoomRecords, setRoomCloseError, } from './room-state.js';
-const CLOSE_LOCK_STALE_MS = 5 * 60_000;
+import { advanceMemberRetirement, advanceRoomClose, beginRoomClose, closeRoom, deleteRoomRecord, getRoomRecord, listRoomRecords, setRoomCloseError, recordRetirementMemberCids, } from './room-state.js';
+export const CLOSE_LOCK_STALE_MS = 5 * 60_000;
 const STOP_POLLS = 50;
 const STOP_POLL_MS = 100;
 export function roomCloseLockPath(roomId) {
@@ -20,6 +29,20 @@ function errorText(error) {
 function exactMemberIdentity(seat) {
     const dir = agentDir(seat.role_name, true);
     const identityPath = join(dir, '.identity');
+    if (existsSync(dir) && !existsSync(identityPath) && seat.launch?.action_id && seat.launch.launch_id) {
+        const supervisor = readTempSupervisor(dir);
+        let creation;
+        try {
+            creation = JSON.parse(readFileSync(join(dir, 'creation.json'), 'utf8'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        if (supervisor?.role === seat.role_name && supervisor.launchId === seat.launch.launch_id
+            && creation?.role === seat.role_name && creation.creationActionId === seat.launch.action_id)
+            return;
+    }
     if (!existsSync(dir) || !existsSync(identityPath)) {
         throw new Error(`room member '${seat.role_name}' has no live Fleet temp-state identity proof; refusing retirement`);
     }
@@ -29,9 +52,11 @@ function exactMemberIdentity(seat) {
     }
 }
 export async function inspectMember(seat) {
+    assertMemberNotPermanent(seat.role_name);
     exactMemberIdentity(seat);
     const supervisor = readTempSupervisor(agentDir(seat.role_name, true));
-    if (!supervisor || supervisor.role !== seat.role_name) {
+    if (!supervisor || supervisor.role !== seat.role_name
+        || (seat.launch?.launch_id && supervisor.launchId !== seat.launch.launch_id)) {
         throw new Error(`room member '${seat.role_name}' has no exact Fleet supervisor ownership proof`);
     }
     return { launchId: supervisor.launchId };
@@ -57,15 +82,11 @@ export async function waitForLivenessAbsent(role, launchId, lifecycleDeps = {})
 async function withIdentityClient(work) {
     const profile = readClientProfile(process.env);
     const leaseToken = `ours-fleet-room-close-${process.pid}-${randomUUID()}`;
-    const client = await attachOursClient(profile ? {
+    const client = await attachOursClient({
         endpoint: profile.endpoint,
         expectedInstanceId: profile.expectedInstanceId,
         credentialPath: profile.credentialPath,
         sessionMode: 'external', env: {}, leaseToken,
-    } : {
-        env: process.env,
-        leaseToken,
-        clientPid: process.pid,
     });
     try {
         return await work(client);
@@ -89,18 +110,69 @@ export async function identityCidPresent(cid) {
         return rows.some(row => 'cid' in row && row.cid.toLowerCase() === cid.toLowerCase());
     });
 }
+/** A managed temporary identity belongs to its durable external lease even
+ * after worker exit. Retire that exact logical owner before generic removal. */
+async function releaseRetainedMemberRuntime(seat) {
+    const live = agentDir(seat.role_name, true);
+    const source = existsSync(live) ? live
+        : (seat.launch?.launch_id ? tempArchiveForLaunch(seat.role_name, seat.launch.launch_id) : undefined);
+    if (!source) {
+        if (seat.launch?.task_supervised)
+            throw Error('MEMBER_RUNTIME_RETIREMENT_SOURCE_MISSING');
+        return;
+    }
+    const path = join(source, 'role.yaml');
+    if (!existsSync(path))
+        return; // pre-managed compatibility evidence has no runtime
+    const stat = lstatSync(path);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 256 * 1024)
+        throw Error('MEMBER_RUNTIME_UNSAFE_PROOF');
+    const role = parse(readFileSync(path, 'utf8'));
+    const profile = readClientProfile({ ...process.env, ...role.env });
+    const runtime = join(privateRuntimeRoot(), binderKey(profile.expectedInstanceId, seat.role_name));
+    const metadata = readTempSupervisor(source);
+    if (!existsSync(join(runtime, 'instance.json'))) {
+        if (metadata?.kind === 'fleet-managed')
+            throw Error('MEMBER_RUNTIME_RETIREMENT_MISSING');
+        return;
+    }
+    const creationPath = join(source, 'creation.json'), creationStat = lstatSync(creationPath);
+    if (!creationStat.isFile() || creationStat.isSymbolicLink() || creationStat.size > 256 * 1024)
+        throw Error('MEMBER_RUNTIME_UNSAFE_PROOF');
+    const creation = JSON.parse(readFileSync(creationPath, 'utf8'));
+    if (role.name !== seat.role_name || role.identity !== seat.role_name || !seat.identity_cid
+        || !seat.launch?.action_id || !seat.launch.launch_id || creation.role !== seat.role_name
+        || creation.creationActionId !== seat.launch.action_id || metadata?.role !== seat.role_name
+        || metadata.launchId !== seat.launch.launch_id
+        || (metadata.taskOwner && metadata.taskOwner.creationActionId !== seat.launch.action_id))
+        throw Error('MEMBER_RUNTIME_RETIREMENT_MISMATCH');
+    await releaseManagedAgent(role, { cid: seat.identity_cid, action: seat.launch.action_id });
+}
 export async function removeExactMemberIdentity(seat) {
+    assertMemberNotPermanent(seat.role_name);
     await withIdentityClient(async (client) => {
-        const before = listedIdentity(await client.listIdentities(), seat.role_name);
-        if (!before)
+        const rows = await client.listIdentities();
+        const before = listedIdentity(rows, seat.role_name);
+        if (!before) {
+            if (rows.some(row => row.name === seat.role_name || (seat.identity_cid && 'cid' in row
+                && row.cid.toLowerCase() === seat.identity_cid.toLowerCase())))
+                throw new Error(`room member '${seat.role_name}' identity absence is not proven`);
+            // A terminal release can remove the SDK identity before its response is
+            // recorded. Finish the exact retained launch's release journal on retry.
+            if (existsSync(agentDir(seat.role_name, true)) || (seat.launch?.launch_id
+                && tempArchiveForLaunch(seat.role_name, seat.launch.launch_id)))
+                await releaseRetainedMemberRuntime(seat);
             return;
+        }
         if (!seat.identity_cid) {
-            throw new Error(`room member '${seat.role_name}' exists without a recorded authenticated CID; refusing removal`);
+            throw new Error(`room member '${seat.role_name}' exists without a recorded authenticated CID; identity absence is not proven; refusing removal`);
         }
         if (before.cid?.toLowerCase() !== seat.identity_cid.toLowerCase()) {
-            throw new Error(`room member '${seat.role_name}' identity CID mismatch: recorded ${seat.identity_cid}, found ${before.cid ?? 'none'}`);
+            throw new Error(`room member '${seat.role_name}' identity absence is not proven: CID mismatch: recorded ${seat.identity_cid}, found ${before.cid ?? 'none'}`);
         }
+        await releaseRetainedMemberRuntime(seat);
         try {
+            assertMemberNotPermanent(seat.role_name);
             await client.removeIdentity({ name: seat.role_name });
         }
         catch (error) {
@@ -113,8 +185,9 @@ export async function removeExactMemberIdentity(seat) {
             if (after)
                 throw error;
         }
-        const after = listedIdentity(await client.listIdentities(), seat.role_name);
-        if (after) {
+        const after = await client.listIdentities();
+        if (after.some(row => row.name === seat.role_name || (seat.identity_cid && 'cid' in row
+            && row.cid.toLowerCase() === seat.identity_cid.toLowerCase()))) {
             throw new Error(`room member '${seat.role_name}' identity still exists after remove_identity`);
         }
     });
@@ -128,14 +201,24 @@ export async function assertMemberIdentityAbsent(seat) {
         }
     });
 }
+async function retireMemberRegistration(room, current, deps) {
+    if (room.task_id)
+        await (deps.retireTaskService ?? retireTaskMemberService)(current.role_name, {
+            taskId: room.task_id, creationActionId: current.launch?.action_id,
+            taskSupervised: current.launch?.task_supervised,
+            ...(current.launch?.launch_id ? { launchId: current.launch.launch_id } : {}),
+        });
+}
 async function retireMember(roomId, seat, deps) {
+    assertMemberNotPermanent(seat.role_name);
     let room = getRoomRecord(roomId);
     let current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
+    await retireMemberRegistration(room, current, deps);
     let retirement = current.retirement;
     if (retirement?.phase === 'identity_absent') {
-        if (current.launch?.launch_id && current.launch.launch_id !== retirement.launch_id) {
+        if (!deps.inspectMember) {
             if (existsSync(agentDir(current.role_name, true)))
-                throw new Error(`room member '${current.role_name}' has a replacement launch after retirement; retire that exact temporary role before retrying`);
+                throw new Error('Retired member has replacement launch live state');
             await assertMemberIdentityAbsent(current);
         }
         return;
@@ -144,6 +227,8 @@ async function retireMember(roomId, seat, deps) {
         if (!existsSync(agentDir(current.role_name, true)) && current.launch?.launch_id && current.launch.action_id) {
             const archived = tempArchiveForLaunch(current.role_name, current.launch.launch_id);
             const created = tempArchiveForCreationAction(current.role_name, current.launch.action_id);
+            if (archived && (!created || created.path !== archived || created.launchId !== current.launch.launch_id))
+                throw new Error('Archived member creation ownership mismatch');
             if (archived && created?.path === archived && created.launchId === current.launch.launch_id) {
                 if (readFileSync(join(archived, '.identity'), 'utf8').trim() !== current.role_name)
                     throw new Error(`room member '${current.role_name}' archive identity mismatch`);
@@ -151,6 +236,7 @@ async function retireMember(roomId, seat, deps) {
                     throw new Error(`room member '${current.role_name}' archived supervisor is not proven stopped`);
                 // A terminated launch can archive itself before room retirement begins.
                 // Accept its exact durable provenance only when no identity needs removal.
+                await (deps.removeIdentity ?? removeExactMemberIdentity)(current);
                 await assertMemberIdentityAbsent(current);
                 const latest = getRoomRecord(roomId)?.member_seats.find(seat => seat.role_name === current.role_name);
                 if (existsSync(agentDir(current.role_name, true))
@@ -162,14 +248,6 @@ async function retireMember(roomId, seat, deps) {
                 return;
             }
         }
-        if (current.launch?.state === 'failed' && !existsSync(agentDir(current.role_name, true))) {
-            // A failure before applyRole (for example invite-secret validation) has
-            // no supervisor to stop or archive. Settle only proven absence; this
-            // path never removes an identity based on missing local evidence.
-            await assertMemberIdentityAbsent(current);
-            advanceMemberRetirement(roomId, current.role_name, 'identity_absent', 'failed-launch-absent');
-            return;
-        }
         if (current.launch?.state === 'pending' && current.launch.attempt === 0) {
             if (existsSync(agentDir(current.role_name, true))) {
                 throw new Error(`never-launched room member '${current.role_name}' unexpectedly has Fleet temp state`);
@@ -178,12 +256,31 @@ async function retireMember(roomId, seat, deps) {
             advanceMemberRetirement(roomId, current.role_name, 'identity_absent', 'never-launched');
             return;
         }
+        if (!deps.inspectMember && !existsSync(agentDir(current.role_name, true))) {
+            await (deps.removeIdentity ?? removeExactMemberIdentity)(current);
+            if (existsSync(agentDir(current.role_name, true)))
+                throw new Error(`room member '${current.role_name}' acquired replacement state during retirement`);
+            advanceMemberRetirement(roomId, current.role_name, 'identity_absent', 'absent-verified');
+            return;
+        }
         const ownership = await (deps.inspectMember ?? inspectMember)(current);
         room = advanceMemberRetirement(roomId, current.role_name, 'stop_requested', ownership.launchId);
         current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
         retirement = current.retirement;
     }
+    if (['stop_requested', 'liveness_absent', 'archive_secured'].includes(retirement.phase) && !deps.requestStop
+        && !existsSync(agentDir(current.role_name, true))) {
+        const archive = tempArchiveForLaunch(current.role_name, retirement.launch_id);
+        if (archive && await tempSupervisorLiveness(archive) !== 'stopped')
+            throw new Error('Archived supervisor is not proven stopped');
+        await (deps.removeIdentity ?? removeExactMemberIdentity)(current);
+        await assertMemberIdentityAbsent(current);
+        advanceMemberRetirement(roomId, current.role_name, 'identity_absent', retirement.launch_id, archive, !archive);
+        return;
+    }
     if (retirement.phase === 'stop_requested') {
+        if (!deps.inspectMember && (await inspectMember(current)).launchId !== retirement.launch_id)
+            throw new Error('Member launch changed before stop');
         await (deps.requestStop ?? (async (role) => { await stopTempSupervisor(role); }))(current.role_name);
         await (deps.waitForLivenessAbsent ?? waitForLivenessAbsent)(current.role_name, retirement.launch_id);
         room = advanceMemberRetirement(roomId, current.role_name, 'liveness_absent', retirement.launch_id);
@@ -213,17 +310,35 @@ export async function closeManagedRoom(input) {
     const lock = deps.lock ?? withFileLock;
     return lock(roomCloseLockPath(input.roomId), async () => {
         let room = beginRoomClose(input.roomId);
-        if (room.state === 'closed')
+        if (room.state === 'closed') {
+            for (const seat of room.member_seats) {
+                assertMemberNotPermanent(seat.role_name);
+                await retireMemberRegistration(room, seat, deps);
+            }
+            if (!deps.inspectMember)
+                for (const seat of room.member_seats) {
+                    if (existsSync(agentDir(seat.role_name, true)))
+                        throw new Error('Closed room has replacement live state');
+                    await assertMemberIdentityAbsent(seat);
+                }
             return room;
+        }
         try {
             if (room.close?.phase === 'retire_members') {
+                room = await recoverMemberCids(room, input.cowork);
                 for (const seat of room.member_seats) {
                     await retireMember(input.roomId, seat, deps);
                 }
                 room = advanceRoomClose(input.roomId, 'close_cowork');
             }
             if (room.close?.phase === 'close_cowork') {
-                await input.cowork.closeRoom(input.roomId);
+                try {
+                    await input.cowork.closeRoom(input.roomId);
+                }
+                catch (error) {
+                    if (!(error instanceof CoworkProtocolError && error.code === 'not_found'))
+                        throw error;
+                }
             }
             return closeRoom(input.roomId);
         }
@@ -237,6 +352,9 @@ export async function closeManagedRoom(input) {
 export async function deleteLegacyClosedRooms(input) {
     const deleted = [];
     for (const room of listRoomRecords({ state: 'closed' })) {
+        // This compatibility sweep is retirement, never explicit workspace deletion.
+        if (room.workspace)
+            continue;
         try {
             await input.cowork.deleteRoom(room.room_id);
         }
@@ -253,14 +371,84 @@ export async function deleteLegacyClosedRooms(input) {
 }
 /** Retire live resources through the existing cursor, then delete retained state. */
 export async function deleteManagedRoom(input) {
-    await closeManagedRoom(input);
-    try {
-        await input.cowork.deleteRoom(input.roomId);
-    }
-    catch (error) {
-        setRoomCloseError(input.roomId, errorText(error), `Retry 'ours-fleet room delete ${input.roomId} ${input.roomId}'.`);
-        throw error;
+    if (getRoomRecord(input.roomId))
+        await closeManagedRoom(input);
+    return withFileLock(roomCloseLockPath(input.roomId), async () => {
+        try {
+            try {
+                await input.cowork.deleteRoom(input.roomId);
+            }
+            catch (error) {
+                // An earlier explicit delete may have removed the remote room before
+                // local filesystem cleanup failed. Never restore it or repeat creation.
+                if (!(error instanceof CoworkProtocolError && error.code === 'not_found'))
+                    throw error;
+            }
+            const retained = getRoomRecord(input.roomId);
+            if (retained?.workspace && !retained.task_id) {
+                assertWorkspaceDeletable(retained.workspace, 'room', input.roomId);
+                collectWorkspaceArchives(retained.workspace);
+                deleteWorkspace(retained.workspace, 'room', input.roomId);
+            }
+            if (retained)
+                await eraseMemberArtifacts('room', input.roomId, retained.member_seats, [input.roomId]);
+            if (retained?.task_id)
+                detachDeletedRoom(retained.task_id, input.roomId);
+            deleteRoomRecord(input.roomId);
+            return { room_id: input.roomId, deleted: true };
+        }
+        catch (error) {
+            if (getRoomRecord(input.roomId))
+                setRoomCloseError(input.roomId, errorText(error), `Fix the cleanup error and explicitly retry room delete ${input.roomId} ${input.roomId}.`);
+            throw error;
+        }
+    }, {}, CLOSE_LOCK_STALE_MS);
+}
+/** Recover only an authenticated seat tied to this exact room and issued invite.
+ * Display names and the current daemon name inventory are never binding proof.
+ */
+async function recoverMemberCids(room, cowork) {
+    if (!room.member_seats.some(seat => !seat.identity_cid))
+        return room;
+    const profile = room.member_seats.some(seat => seat.launch?.action_id) ? readClientProfile(process.env) : undefined;
+    let remote;
+    if (cowork.getRoom && room.room_identity_cid) {
+        try {
+            remote = await cowork.getRoom(room.room_id);
+        }
+        catch (error) {
+            if (!(error instanceof CoworkProtocolError && error.code === 'not_found'))
+                throw error;
+        }
+        if (remote && (remote.room_id !== room.room_id || remote.identity_cid.toLowerCase() !== room.room_identity_cid.toLowerCase()))
+            throw new Error('Room identity mismatch during deletion recovery');
     }
-    deleteRoomRecord(input.roomId);
-    return { room_id: input.roomId, deleted: true };
+    const seats = room.member_seats.map(seat => {
+        let runtimeCid;
+        if (profile && seat.launch?.action_id) {
+            const dir = join(stateRoot(), 'private-ours', binderKey(profile.expectedInstanceId, seat.role_name));
+            try {
+                const state = JSON.parse(readFileSync(join(dir, 'state.json'), 'utf8'));
+                const instance = JSON.parse(readFileSync(join(dir, 'instance.json'), 'utf8'));
+                if (state.name === seat.role_name && state.daemon === profile.expectedInstanceId
+                    && state.lifetime === 'temporary' && state.action === seat.launch.action_id
+                    && instance.role === seat.role_name && instance.temporary === true && instance.instance === state.instance)
+                    runtimeCid = state.cid;
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        const matches = seat.invite_id ? remote?.seats.filter(value => value.invite_id === seat.invite_id && value.role === seat.cowork_role) ?? [] : [];
+        if (matches.length > 1)
+            throw new Error('Ambiguous authenticated member identity during deletion recovery');
+        const candidates = [seat.identity_cid, runtimeCid, matches[0]?.identity_cid].filter((v) => !!v);
+        if (candidates.some(cid => !/^[a-f0-9]{64}$/i.test(cid)))
+            throw new Error('Invalid authenticated member CID');
+        if (new Set(candidates.map(cid => cid.toLowerCase())).size > 1)
+            throw new Error('Contradictory authenticated member CID evidence');
+        return candidates.length ? { ...seat, identity_cid: candidates[0] } : seat;
+    });
+    return recordRetirementMemberCids(room.room_id, seats);
 }

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

@@ -4,7 +4,7 @@ export declare class RoomsTasksConfigError extends Error {
     constructor(path: string, message: string);
 }
 export declare function fingerprint(invite: string): string;
-export declare function validateRoomsConfig(raw: unknown, vars: Record<string, string>, path: string): RoomsConfig & {
+export declare function validateRoomsConfig(raw: unknown, vars: Record<string, string>, path: string, deferredInviteFile?: string): RoomsConfig & {
     _invite?: {
         value: string;
         fingerprint: string;

package/dist/rooms-tasks/config.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
 import { createHash } from 'node:crypto';
 import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, TEMPLATE_ROOM_KEYS as TRK, } from './types.js';
 const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
@@ -18,7 +19,7 @@ function rejectUnknown(obj, allowed, path, section) {
 export function fingerprint(invite) {
     return createHash('sha256').update(invite.trim()).digest('hex');
 }
-function resolveInvite(owner, vars, path) {
+function resolveInvite(owner, vars, path, deferredInviteFile) {
     const inline = owner.public_invite;
     const file = owner.public_invite_file;
     if (inline && file)
@@ -28,6 +29,10 @@ function resolveInvite(owner, vars, path) {
     let raw;
     if (file) {
         const resolved = file.replace(/\$\{(\w+)\}/g, (m, k) => (k in vars ? String(vars[k]) : m));
+        // Tunnel setup writes this one file itself after enrollment; until then it may be absent.
+        // Only the literal absolute path counts: a relative spelling that happens to reach it does not.
+        if (!existsSync(resolved) && deferredInviteFile !== undefined && isAbsolute(deferredInviteFile) && resolved === deferredInviteFile)
+            return undefined;
         if (!existsSync(resolved))
             throw new RoomsTasksConfigError(path, `rooms.owner.public_invite_file: not found: ${resolved}`);
         raw = readFileSync(resolved, 'utf8').trim();
@@ -39,7 +44,7 @@ function resolveInvite(owner, vars, path) {
         throw new RoomsTasksConfigError(path, 'rooms.owner: invite is empty');
     return { value: raw, fingerprint: fingerprint(raw) };
 }
-export function validateRoomsConfig(raw, vars, path) {
+export function validateRoomsConfig(raw, vars, path, deferredInviteFile) {
     if (!isPlainObject(raw))
         throw new RoomsTasksConfigError(path, 'rooms: must be a mapping');
     // Migration-only input: provider selection was exposed before rooms shipped,
@@ -54,7 +59,9 @@ export function validateRoomsConfig(raw, vars, path) {
         if (!isPlainObject(raw.cowork))
             throw new RoomsTasksConfigError(path, 'rooms.cowork: must be a mapping');
         rejectUnknown(raw.cowork, RCK, path, 'rooms.cowork');
-        cowork = { config: raw.cowork.config };
+        if (raw.cowork.config !== undefined)
+            throw new RoomsTasksConfigError(path, 'rooms.cowork.config is no longer supported; remove it and configure ~/.ours-client/profile.json for all services');
+        cowork = {};
     }
     if (!isPlainObject(raw.owner))
         throw new RoomsTasksConfigError(path, 'rooms.owner: required and must be a mapping');
@@ -66,7 +73,7 @@ export function validateRoomsConfig(raw, vars, path) {
     if (!CID_RE.test(expectedCid))
         throw new RoomsTasksConfigError(path, 'rooms.owner.expected_cid: must be exactly 64 hexadecimal characters');
     const ownerRole = raw.owner.role ?? 'Owner';
-    const invite = resolveInvite(raw.owner, vars, path);
+    const invite = resolveInvite(raw.owner, vars, path, deferredInviteFile);
     const owner = {
         provider: ownerProvider,
         expected_cid: expectedCid.toLowerCase(),

package/dist/rooms-tasks/cowork-adapter.d.ts

@@ -1,8 +1,8 @@
 /**
- * Typed client for the ours-cowork v1 private management-socket protocol.
+ * Typed client for the ours-cowork v1 gateway management protocol.
  *
  * Cowork owns room state. Fleet only invokes the versioned JSON RPC exposed
- * by Cowork's Unix socket and projects the response into orchestration data.
+ * through the shared HTTP gateway and projects the response into orchestration data.
  */
 import type { Socket } from 'node:net';
 import type { RoomHistoryEvidence } from './types.js';
@@ -93,7 +93,16 @@ export interface CoworkAdapter {
     recoverRoom(roomId: string): Promise<CoworkRoomInfo>;
 }
 export declare class CoworkUnavailableError extends Error {
-    constructor(message?: string, options?: ErrorOptions);
+    /**
+     * True only when the failure is a dependency that may still be starting
+     * (connection refused/reset, timeout, a gateway 502/503/504 without an RPC
+     * body). Selection, capability, credential and permission failures are
+     * never retryable, whatever transport reported them.
+     */
+    readonly retryable: boolean;
+    constructor(message?: string, options?: ErrorOptions & {
+        retryable?: boolean;
+    });
 }
 export declare class CoworkProtocolError extends Error {
     readonly operation: string;
@@ -108,6 +117,4 @@ export interface CoworkAdapterOptions {
     home?: string;
     connect?: (path: string) => Socket;
 }
-/** Resolve the same config/state inputs as ours-cowork and return its Unix socket. */
-export declare function resolveCoworkSocketPath(options?: CoworkAdapterOptions): string;
 export declare function createCoworkAdapter(options?: CoworkAdapterOptions): CoworkAdapter;

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

@@ -1,22 +1,24 @@
 /**
- * Typed client for the ours-cowork v1 private management-socket protocol.
+ * Typed client for the ours-cowork v1 gateway management protocol.
  *
  * Cowork owns room state. Fleet only invokes the versioned JSON RPC exposed
- * by Cowork's Unix socket and projects the response into orchestration data.
+ * through the shared HTTP gateway and projects the response into orchestration data.
  */
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { createConnection } from 'node:net';
 import { readClientProfile } from '../client-profile.js';
 import { coworkHttpCall } from './cowork-http.js';
-const RPC_VERSION = 1;
 const DEFAULT_TIMEOUT_MS = 30_000;
-const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
 export class CoworkUnavailableError extends Error {
-    constructor(message = 'Cowork management socket is not reachable', options) {
+    /**
+     * True only when the failure is a dependency that may still be starting
+     * (connection refused/reset, timeout, a gateway 502/503/504 without an RPC
+     * body). Selection, capability, credential and permission failures are
+     * never retryable, whatever transport reported them.
+     */
+    retryable;
+    constructor(message = 'Cowork gateway management is not reachable', options) {
         super(message, options);
         this.name = 'CoworkUnavailableError';
+        this.retryable = options?.retryable === true;
     }
 }
 export class CoworkProtocolError extends Error {
@@ -171,121 +173,13 @@ function projectHistoryRecord(value) {
     }
     return undefined;
 }
-/** Resolve the same config/state inputs as ours-cowork and return its Unix socket. */
-export function resolveCoworkSocketPath(options = {}) {
-    if (options.socketPath)
-        return resolve(options.socketPath);
-    const env = options.env ?? process.env;
-    const home = options.home ?? homedir();
-    const configuredPath = options.configPath ?? env.OURS_COWORK_CONFIG;
-    const configPath = resolve(configuredPath ?? join(home, '.ours-cowork', 'config.json'));
-    let stateDir = resolve(home, '.ours-cowork');
-    if (existsSync(configPath)) {
-        let parsed;
-        try {
-            parsed = JSON.parse(readFileSync(configPath, 'utf8'));
-        }
-        catch (error) {
-            throw new CoworkProtocolError('config', `malformed config at ${configPath}`, 'invalid_config', { cause: error });
-        }
-        const config = object(parsed, 'config', 'config');
-        if (config.version !== 1 || typeof config.stateDir !== 'string' || !config.stateDir)
-            throw new CoworkProtocolError('config', `invalid Cowork v1 config at ${configPath}`, 'invalid_config');
-        stateDir = resolve(config.stateDir);
-    }
-    else if (configuredPath !== undefined) {
-        throw new CoworkProtocolError('config', `configured Cowork config does not exist: ${configPath}`, 'invalid_config');
-    }
-    if (env.OURS_COWORK_STATE_DIR)
-        stateDir = resolve(env.OURS_COWORK_STATE_DIR);
-    return join(stateDir, 'management.sock');
-}
-function rpcCall(socketPath, method, params, timeoutMs, connect) {
-    const id = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    const request = `${JSON.stringify({ version: RPC_VERSION, id, method, params })}\n`;
-    return new Promise((resolveCall, rejectCall) => {
-        const socket = connect(socketPath);
-        let bytes = '';
-        let size = 0;
-        let settled = false;
-        let connected = false;
-        const finishError = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            socket.destroy();
-            rejectCall(error);
-        };
-        const timer = setTimeout(() => finishError(new CoworkUnavailableError(connected ? 'Cowork did not answer the management socket' : 'Cowork management socket is not reachable')), timeoutMs);
-        socket.setEncoding('utf8');
-        socket.once('connect', () => {
-            connected = true;
-            socket.write(request);
-        });
-        socket.on('data', (chunk) => {
-            if (settled)
-                return;
-            const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-            size += Buffer.byteLength(text);
-            if (size > MAX_RESPONSE_BYTES) {
-                finishError(new CoworkProtocolError(method, 'response exceeded 4 MiB'));
-                return;
-            }
-            bytes += text;
-            const newline = bytes.indexOf('\n');
-            if (newline < 0)
-                return;
-            if (bytes.slice(newline + 1).trim() !== '') {
-                finishError(new CoworkProtocolError(method, 'daemon returned more than one response'));
-                return;
-            }
-            let response;
-            try {
-                response = object(JSON.parse(bytes.slice(0, newline)), method, 'RPC response');
-            }
-            catch (error) {
-                finishError(error instanceof CoworkProtocolError
-                    ? error : new CoworkProtocolError(method, 'daemon returned malformed JSON', 'protocol_error', { cause: error }));
-                return;
-            }
-            if (response.version !== RPC_VERSION || response.id !== id
-                || (Object.hasOwn(response, 'error') === Object.hasOwn(response, 'result'))) {
-                finishError(new CoworkProtocolError(method, 'daemon returned an invalid RPC response'));
-                return;
-            }
-            settled = true;
-            clearTimeout(timer);
-            socket.destroy();
-            if (Object.hasOwn(response, 'error')) {
-                const error = object(response.error, method, 'RPC error');
-                rejectCall(new CoworkProtocolError(method, typeof error.message === 'string' ? error.message : 'unknown RPC error', typeof error.code === 'string' ? error.code : 'rpc_error'));
-            }
-            else {
-                resolveCall(response.result);
-            }
-        });
-        socket.once('end', () => {
-            if (!settled)
-                finishError(new CoworkProtocolError(method, 'daemon closed without a complete response'));
-        });
-        socket.once('error', (error) => {
-            if (!settled)
-                finishError(new CoworkUnavailableError(error.code === 'EACCES' || error.code === 'EPERM'
-                    ? 'Cowork management socket access denied' : 'Cowork management socket is not reachable', { cause: error }));
-        });
-    });
-}
 export function createCoworkAdapter(options = {}) {
     const env = options.env ?? process.env;
-    const explicitLocal = options.socketPath !== undefined || options.configPath !== undefined
-        || env.OURS_COWORK_CONFIG !== undefined || !!env.OURS_COWORK_STATE_DIR;
-    const profile = explicitLocal ? undefined : readClientProfile({ ...env, HOME: options.home ?? env.HOME });
-    const remote = profile?.serverUrl ? profile : undefined;
-    const socketPath = remote ? undefined : resolveCoworkSocketPath(options);
+    if (options.socketPath !== undefined || options.configPath !== undefined)
+        throw new CoworkProtocolError('config', 'Local Cowork selectors are unsupported; configure the shared gateway client profile', 'invalid_config');
+    const profile = readClientProfile({ ...env, HOME: options.home ?? env.HOME });
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    const connect = options.connect ?? ((path) => createConnection(path));
-    const call = (method, params) => remote ? coworkHttpCall(remote, method, params, timeoutMs) : rpcCall(socketPath, method, params, timeoutMs, connect);
+    const call = (method, params) => coworkHttpCall(profile, method, params, timeoutMs);
     return {
         async available() {
             try {