@ours.network/fleet 1.0.0 → 1.0.1

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.0.0",
-  "buildId": "76df3ad96722",
-  "commit": "2bd6fc54e4f3e0d65c2e6b7258a3635557e868fb",
+  "version": "1.0.1",
+  "buildId": "bb9ae2d6a815",
+  "commit": "52468879ecc67b45ddeb632f195ac8ee895a8b1d",
   "dirty": false,
-  "builtAt": "2026-08-24T15:55:27.110Z",
+  "builtAt": "2026-08-25T07:16:56.275Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/rooms-tasks/close.js

@@ -100,6 +100,14 @@ async function retireMember(roomId, seat, deps) {
     let current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
     let retirement = current.retirement;
     if (!retirement) {
+        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`);
+            }
+            await (deps.removeIdentity ?? removeExactMemberIdentity)(current);
+            advanceMemberRetirement(roomId, current.role_name, 'identity_absent', 'never-launched');
+            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);

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

@@ -17,6 +17,7 @@ export interface CoworkInviteAcceptResult {
 }
 export interface CoworkInviteResult {
     invite: string;
+    invite_id: string;
     min_accepts: number;
 }
 export interface CoworkSeatInfo {
@@ -63,6 +64,7 @@ export interface CoworkAdapter {
         role: string;
         min_accepts: number;
     }): Promise<CoworkInviteResult>;
+    revokeInvite(roomId: string, inviteId: string): Promise<void>;
     setRoleBriefing(roomId: string, opts: {
         role: string;
         text: string;

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

@@ -318,10 +318,14 @@ export function createCoworkAdapter(options = {}) {
             const invite = object(receipt.invite, 'room.invite', 'receipt.invite');
             return {
                 invite: string(receipt.blob, 'room.invite', 'receipt.blob'),
+                invite_id: string(invite.invite_id, 'room.invite', 'receipt.invite.invite_id'),
                 min_accepts: typeof invite.min_accepts === 'number'
                     ? invite.min_accepts : opts.min_accepts,
             };
         },
+        async revokeInvite(roomId, inviteId) {
+            await call('room.revoke', { room_id: roomId, invite_id: inviteId });
+        },
         async setRoleBriefing(roomId, opts) {
             const result = object(await call('room.briefing.role.set', {
                 room_id: roomId, role: opts.role, text: opts.text,

package/dist/rooms-tasks/provision.js

@@ -70,6 +70,26 @@ async function removeMemberIdentity(name) {
     }
     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 {
@@ -224,6 +244,7 @@ export async function provisionMembers(input) {
     const existing = getRoomRecord(roomId);
     if (!existing?.room_identity_cid)
         throw new Error(`room ${roomId} has no pinned room identity CID`);
+    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));
@@ -353,6 +374,13 @@ export async function provisionMembers(input) {
             throw error;
         }
     }
+    const policy = {
+        timeoutMs: input.startupWait?.timeoutMs ?? 60_000,
+        initialDelayMs: input.startupWait?.initialDelayMs ?? 250,
+        maxDelayMs: input.startupWait?.maxDelayMs ?? 2_000,
+        now: input.startupWait?.now ?? Date.now,
+        sleep: input.startupWait?.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms))),
+    };
     advanceSaga(roomId, 'join_role_groups', 5);
     try {
         const observedSeats = await cowork.getSeats(roomId);
@@ -370,15 +398,49 @@ export async function provisionMembers(input) {
                 ...(roleGroups.get(member.coworkRole) ?? []), member,
             ]);
         }
-        for (const [coworkRole, group] of roleGroups) {
-            const { invite } = await cowork.issueInvite(roomId, {
-                role: coworkRole, min_accepts: group.length,
+        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}`);
+                }
+                return !seat;
             });
-            for (const member of group) {
-                await cowork.acceptInvite(roomId, invite, {
-                    role: coworkRole, expected_cid: member.cid,
-                });
+            if (!waiting)
+                break;
+            if (policy.now() >= deadline) {
+                throw new Error('Cowork did not authenticate every required room seat after invite redemption');
             }
+            await policy.sleep(delay);
+            delay = Math.min(policy.maxDelayMs, Math.max(delay + 1, delay * 2));
         }
     }
     catch (error) {
@@ -423,13 +485,6 @@ export async function provisionMembers(input) {
         setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Member launch failed. Some agents may be running. Retry with `task recover`.', 'member_failed');
         throw error;
     }
-    const policy = {
-        timeoutMs: input.startupWait?.timeoutMs ?? 60_000,
-        initialDelayMs: input.startupWait?.initialDelayMs ?? 250,
-        maxDelayMs: input.startupWait?.maxDelayMs ?? 2_000,
-        now: input.startupWait?.now ?? Date.now,
-        sleep: input.startupWait?.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms))),
-    };
     const deadline = policy.now() + policy.timeoutMs;
     let delay = policy.initialDelayMs;
     for (;;) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux or ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",