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

package/dist/owner-channel/channel.js

@@ -419,7 +419,9 @@ export class OwnerChannel {
             ]), deadlineAt);
             if (superseded())
                 throw new Error('owner recovery epoch superseded');
-            await this.recoveryStage('close', this.client.close(), deadlineAt);
+            // A daemon reconnect is not terminal ownership evidence. Keep the same
+            // owner ID and its temporary/permanent bindings while replacing transport.
+            await this.recoveryStage('close', this.client.close({ releaseLease: false }), deadlineAt);
             if (superseded())
                 throw new Error('owner recovery epoch superseded');
             try {
@@ -450,7 +452,7 @@ export class OwnerChannel {
                 // its disposal; the recorded quiescence debt gates the next retry.
                 if (!this.recoveryQuiescence) {
                     try {
-                        await this.recoveryStage('close_after_failure', this.client.close(), deadlineAt);
+                        await this.recoveryStage('close_after_failure', this.client.close({ releaseLease: false }), deadlineAt);
                     }
                     catch (closeError) {
                         this.logError('recovery client close failed', closeError);
@@ -1121,6 +1123,13 @@ export class OwnerChannel {
             const retrieved = unread.length
                 ? parseRetrievedAttachments(await this.client.getFiles(unread.map(file => file.wireId)), unread)
                 : [];
+            // getFiles returns daemon-local paths, which need not exist in Fleet's
+            // filesystem (for example with an HTTP daemon in a container). Fetch
+            // through the bound client and keep the daemon's integrity metadata for
+            // admission below; never trust or remap the returned filesystem path.
+            for (const file of retrieved) {
+                file.path = await writeRecoveredAttachment(requestDir, file.wireId, await this.client.fetchFile(file.wireId));
+            }
             for (const file of historyRecovered) {
                 if (!group.recovery)
                     throw new Error('unexpected read attachment without recovery route');
@@ -1134,8 +1143,7 @@ export class OwnerChannel {
             await mkdir(outbox, { recursive: true, mode: 0o700 });
             const activityCursor = this.latestEventSeq(this.options.session.eventsSince(0));
             const queued = await queueSessionPrompt(this.options.session, this.ownerAttachmentPrompt(sender, originWireId, requestId, admitted, group.caption), {
-                interrupt: this.options.config.interrupt,
-                ...(this.options.config.interrupt ? { interruptSource: 'owner' } : {}),
+                ...this.ownerPromptPolicy(),
                 origin: { kind: 'owner', requestId,
                     ...(group.caption ? { displayText: String(group.caption.text ?? '') } : {}) },
             });
@@ -1261,8 +1269,7 @@ export class OwnerChannel {
         const activityCursor = this.latestEventSeq(this.options.session.eventsSince(0));
         try {
             queued = await queueSessionPrompt(this.options.session, this.ownerPrompt(sender, text, wireId), {
-                interrupt: this.options.config.interrupt,
-                ...(this.options.config.interrupt ? { interruptSource: 'owner' } : {}),
+                ...this.ownerPromptPolicy(),
                 origin: { kind: 'owner', requestId, displayText: text },
             });
         }
@@ -1307,6 +1314,14 @@ export class OwnerChannel {
         this.completionTasks.add(task);
         return true;
     }
+    ownerPromptPolicy() {
+        if (this.options.startupPending?.())
+            return { interrupt: false, steer: true };
+        return {
+            interrupt: this.options.config.interrupt,
+            ...(this.options.config.interrupt ? { interruptSource: 'owner' } : {}),
+        };
+    }
     /**
      * Deterministic command path: the message never becomes an agent prompt.
      * Authorization already happened — the managed-agent relay branch and the
@@ -1760,6 +1775,13 @@ export class OwnerChannel {
             const retrieved = unread.length
                 ? parseRetrievedAttachments(await this.client.getFiles(unread.map(file => file.wireId)), unread)
                 : [];
+            // getFiles returns daemon-local paths, which need not exist in Fleet's
+            // filesystem (for example with an HTTP daemon in a container). Fetch
+            // through the bound client and keep the daemon's integrity metadata for
+            // admission below; never trust or remap the returned filesystem path.
+            for (const file of retrieved) {
+                file.path = await writeRecoveredAttachment(requestDir, file.wireId, await this.client.fetchFile(file.wireId));
+            }
             for (const file of historyRecovered) {
                 if (!group.recovery)
                     throw new Error('unexpected read attachment without recovery route');

package/dist/owner-channel/ours-client.d.ts

@@ -92,8 +92,10 @@ export interface OursOps {
         filename: string;
         replyToWireId?: string;
     }): Promise<void>;
-    /** Release the daemon lease and stop. Never throws. */
-    close(): Promise<void>;
+    /** Dispose transport; terminal release is default and rejects if cleanup is incomplete. */
+    close(options?: {
+        releaseLease?: boolean;
+    }): Promise<void>;
 }
 /**
  * The typed error code of a daemon operation, or undefined when the failure was
@@ -120,14 +122,17 @@ export interface OursSdkClientDeps {
  * its own and hands it back in `close()`. That replaces the connector proxy's
  * shell-PID fence, which existed because a supervised attempt had to make its
  * lease reclaimable while the supervisor itself stayed alive: an explicit
- * release does that deterministically, and `clientPid` still covers the case
- * where the whole supervisor dies without unwinding.
+ * terminal release does that deterministically. Recovery disposes only the
+ * transport and retains this owner ID and its bindings. Explicit daemon identity selects external
+ * ownership in either layout; PID-based legacy attachment remains temporary.
+ * Failed external release preserves unknown ownership until exact terminal evidence.
  */
 export declare class OursSdkClient implements OursOps {
     private readonly env;
     private readonly log;
     private readonly deps;
     private client?;
+    private terminalReleasePending;
     private readonly leaseToken;
     constructor(env?: Record<string, string>, log?: (line: string) => void, deps?: OursSdkClientDeps);
     start(): Promise<void>;
@@ -161,7 +166,9 @@ export declare class OursSdkClient implements OursOps {
         filename: string;
         replyToWireId?: string;
     }): Promise<void>;
-    close(): Promise<void>;
+    close(options?: {
+        releaseLease?: boolean;
+    }): Promise<void>;
     private ops;
 }
 export {};

package/dist/owner-channel/ours-client.js

@@ -1,6 +1,8 @@
 import { randomUUID } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
-import { extname } from 'node:path';
+import { extname, join } from 'node:path';
+import { readDaemonConfig, resolveEndpoint } from '../monitor.js';
+import { readClientProfile } from '../client-profile.js';
 import { OursError, attachOursClient, } from '@ours.network/sdk/client';
 /** Any failure of a daemon operation. Never carries a message body or a token. */
 export class OursDaemonError extends Error {
@@ -106,14 +108,18 @@ export const OURS_BOUND_ELSEWHERE = 'BOUND_ELSEWHERE';
  * its own and hands it back in `close()`. That replaces the connector proxy's
  * shell-PID fence, which existed because a supervised attempt had to make its
  * lease reclaimable while the supervisor itself stayed alive: an explicit
- * release does that deterministically, and `clientPid` still covers the case
- * where the whole supervisor dies without unwinding.
+ * terminal release does that deterministically. Recovery disposes only the
+ * transport and retains this owner ID and its bindings. Explicit daemon identity selects external
+ * ownership in either layout; PID-based legacy attachment remains temporary.
+ * Failed external release preserves unknown ownership until exact terminal evidence.
  */
 export class OursSdkClient {
     env;
     log;
     deps;
     client;
+    // Disposing a transport does not discharge this owner's terminal cleanup.
+    terminalReleasePending = false;
     leaseToken = `ours-fleet-owner-${process.pid}-${randomUUID()}`;
     constructor(env = {}, log = () => undefined, deps = {}) {
         this.env = env;
@@ -124,16 +130,28 @@ export class OursSdkClient {
         if (this.client)
             return;
         const environment = { ...process.env, ...this.env };
-        // SDK 2's supported application path resolves endpoint, state root, and
-        // token as one coherent selection, proves the daemon's state root before
-        // sending credentials, and only then constructs the client.
-        const options = {
+        const profile = readClientProfile(environment);
+        // Reuse existing connection configuration. Identity selection checks the
+        // daemon capability before reading the client's protected token delivery file.
+        const endpoint = !profile && environment.OURS_DAEMON_ID
+            ? resolveEndpoint(environment, false) : undefined;
+        const token = endpoint ? environment.OURS_API_TOKEN?.trim() || readDaemonConfig(environment).apiToken : undefined;
+        const options = profile ? {
+            endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath,
+            sessionMode: 'external', leaseToken: this.leaseToken, env: {},
+        } : endpoint ? {
+            endpoint: endpoint.origin, expectedInstanceId: environment.OURS_DAEMON_ID,
+            sessionMode: 'external', leaseToken: this.leaseToken,
+            ...(token ? { token } : { credentialPath: join(endpoint.stateDir, 'daemon-token') }),
+        } : {
             env: environment,
             leaseToken: this.leaseToken,
             clientPid: process.pid,
             fetch: notificationDeadlineFetch(this.deps.fetch ?? globalThis.fetch, this.deps.notificationRequestDeadlineMs ?? NOTIFICATION_REQUEST_DEADLINE_MS),
         };
         this.client = await (this.deps.attachClient?.(options) ?? attachOursClient(options));
+        this.terminalReleasePending = true;
     }
     async bindIdentity(name) {
         // force is pinned off: the owner channel never evicts another live session
@@ -162,7 +180,10 @@ export class OursSdkClient {
         return this.ops().getHistoryItem({ wire_id: wireId });
     }
     watchNotifications(identity, options) {
-        return this.ops().watchNotifications(identity, options);
+        return this.ops().watchNotifications(identity, {
+            ...options,
+            requestTimeoutMs: this.deps.notificationRequestDeadlineMs ?? NOTIFICATION_REQUEST_DEADLINE_MS,
+        });
     }
     async listIncomingFiles() {
         return this.ops().listIncomingFiles();
@@ -211,19 +232,34 @@ export class OursSdkClient {
             throw new OursSendRefusedError(`the daemon did not send the file (${verdict.kind}): the contact's end-to-end `
                 + 'session must be re-established after an upgrade; files are not queued');
     }
-    async close() {
+    async close(options = {}) {
+        const terminal = options.releaseLease !== false;
+        // A failed recovery may have disposed its client before normal shutdown.
+        // Reattach the same owner through ordinary verified selection; no rebind is
+        // needed to release it, and a failed attach must not be reported as closed.
+        if (terminal && !this.client && this.terminalReleasePending)
+            await this.start();
         const client = this.client;
         this.client = undefined;
         if (!client)
             return;
         // Handing the lease back is what lets a successor bind this identity without
-        // waiting for the supervisor to exit. A failure here is not fatal — the
-        // daemon still reclaims the lease when this process dies.
+        // waiting for the supervisor to exit. External failure remains unknown;
+        // it is not permission to infer owner death or fall back to daemon PID checks.
         try {
-            await client.releaseLease();
+            if (terminal) {
+                const result = await client.releaseLease();
+                if (result.failed > 0)
+                    throw new OursDaemonError('daemon lease release incomplete');
+                this.terminalReleasePending = false;
+            }
         }
         catch (error) {
             this.log(`lease release failed: ${error?.message ?? String(error)}`);
+            throw error;
+        }
+        finally {
+            await client.close();
         }
     }
     ops() {

package/dist/rooms-tasks/archived-absence.d.ts

@@ -0,0 +1,8 @@
+import type { ArchivedMemberAbsence, RoomMemberSeat } from './types.js';
+/** Revalidate live facts; a persisted timestamp is never cleanup authority. */
+export declare function verifyArchivedAbsence(proof: ArchivedMemberAbsence): Promise<void>;
+/** After the verified archive has been consumed by explicit workspace deletion,
+ * still fence replacement live state and a recreated daemon identity on every retry.
+ */
+export declare function verifyArchivedMemberStillAbsent(proof: ArchivedMemberAbsence): Promise<void>;
+export declare function proveArchivedAbsence(seat: RoomMemberSeat): Promise<ArchivedMemberAbsence>;

package/dist/rooms-tasks/archived-absence.js

@@ -0,0 +1,48 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { agentDir } from '../paths.js';
+import { tempArchiveForLaunch, tempArchiveForCreationAction, tempSupervisorLiveness } from '../temp-lifecycle.js';
+import { assertMemberIdentityAbsent } from './close.js';
+/** Revalidate live facts; a persisted timestamp is never cleanup authority. */
+export async function verifyArchivedAbsence(proof) {
+    const absent = () => {
+        if (existsSync(agentDir(proof.name, true)))
+            throw new Error('Archived member has replacement live state');
+    };
+    absent();
+    const archive = tempArchiveForLaunch(proof.name, proof.launch_id);
+    const action = tempArchiveForCreationAction(proof.name, proof.action_id);
+    if (!archive || archive !== proof.archive_path || action?.path !== archive
+        || action.launchId !== proof.launch_id
+        || readFileSync(join(archive, '.identity'), 'utf8').trim() !== proof.name)
+        throw new Error('Archived member absence ownership proof mismatch');
+    if (await tempSupervisorLiveness(archive) !== 'stopped')
+        throw new Error('Archived member supervisor absence is not proven');
+    await verifyArchivedMemberStillAbsent(proof);
+}
+/** After the verified archive has been consumed by explicit workspace deletion,
+ * still fence replacement live state and a recreated daemon identity on every retry.
+ */
+export async function verifyArchivedMemberStillAbsent(proof) {
+    const absent = () => {
+        if (existsSync(agentDir(proof.name, true)))
+            throw new Error('Archived member has replacement live state');
+    };
+    absent();
+    await assertMemberIdentityAbsent({
+        role_name: proof.name, slot: 'archived', cowork_role: 'archived', seat_state: 'removed',
+    });
+    absent();
+}
+export async function proveArchivedAbsence(seat) {
+    if (seat.identity_cid || seat.retirement?.phase !== 'identity_absent'
+        || !seat.launch?.launch_id || !seat.launch.action_id
+        || seat.launch.launch_id !== seat.retirement.launch_id || !seat.retirement.archive_path)
+        throw new Error('Missing exact archived member absence evidence');
+    const proof = {
+        name: seat.role_name, launch_id: seat.launch.launch_id, action_id: seat.launch.action_id,
+        archive_path: seat.retirement.archive_path, checked_at: new Date().toISOString(),
+    };
+    await verifyArchivedAbsence(proof);
+    return proof;
+}

package/dist/rooms-tasks/cli.js

@@ -1152,7 +1152,7 @@ export function registerTaskCommands(parent, cOpt) {
                 const app = taskRoomService(opts.configuration);
                 for (;;) {
                     const before = app.taskProvisioningOutcome(id);
-                    if (before.kind !== 'in_progress') {
+                    if (before.kind !== 'in_progress' || before.next_action) {
                         await presentDetachedProvisioningOutcome(before);
                         return;
                     }

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

@@ -2,6 +2,8 @@ import { withFileLock } from '../atomic-file.js';
 import { type TempLifecycleDeps } from '../temp-lifecycle.js';
 import { type CoworkAdapter } from './cowork-adapter.js';
 import type { RoomMemberSeat, RoomOrchestrationRecord } from './types.js';
+export declare const CLOSE_LOCK_STALE_MS: number;
+export declare function roomCloseLockPath(roomId: string): string;
 export interface RoomCloseDeps {
     inspectMember?(seat: RoomMemberSeat): Promise<{
         launchId: string;
@@ -19,6 +21,7 @@ export declare function waitForLivenessAbsent(role: string, launchId: string, li
 /** Report whether any daemon identity — under any name — carries this exact CID. */
 export declare function identityCidPresent(cid: string): Promise<boolean>;
 export declare function removeExactMemberIdentity(seat: RoomMemberSeat): Promise<void>;
+export declare function assertMemberIdentityAbsent(seat: RoomMemberSeat): Promise<void>;
 /** One forward-only room close saga shared by every Fleet entry point. */
 export declare function acceptManagedRoomClose(roomId: string): Promise<RoomOrchestrationRecord>;
 export declare function recordManagedRoomCloseError(roomId: string, error: string, recoveryHint: string): Promise<RoomOrchestrationRecord>;

package/dist/rooms-tasks/close.js

@@ -1,16 +1,19 @@
+import { deleteWorkspace, assertWorkspaceDeletable } from './workspace.js';
+import { collectWorkspaceArchives } from './workspace-artifacts.js';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { attachOursClient } from '@ours.network/sdk/client';
 import { withFileLock } from '../atomic-file.js';
 import { agentDir, stateRoot } from '../paths.js';
-import { readTempSupervisor, secureStoppedTempArchive, stopTempSupervisor, tempSupervisorLiveness, } from '../temp-lifecycle.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;
+export const CLOSE_LOCK_STALE_MS = 5 * 60_000;
 const STOP_POLLS = 50;
 const STOP_POLL_MS = 100;
-function roomCloseLockPath(roomId) {
+export function roomCloseLockPath(roomId) {
     return join(stateRoot(), 'locks', 'room-close', encodeURIComponent(roomId));
 }
 function errorText(error) {
@@ -54,16 +57,28 @@ export async function waitForLivenessAbsent(role, launchId, lifecycleDeps = {})
     throw new Error(`temporary role '${role}' did not reach proven stopped liveness`);
 }
 async function withIdentityClient(work) {
-    const client = await attachOursClient({
+    const profile = readClientProfile(process.env);
+    const leaseToken = `ours-fleet-room-close-${process.pid}-${randomUUID()}`;
+    const client = await attachOursClient(profile ? {
+        endpoint: profile.endpoint,
+        expectedInstanceId: profile.expectedInstanceId,
+        credentialPath: profile.credentialPath,
+        sessionMode: 'external', env: {}, leaseToken,
+    } : {
         env: process.env,
-        leaseToken: `ours-fleet-room-close-${process.pid}-${randomUUID()}`,
+        leaseToken,
         clientPid: process.pid,
     });
     try {
         return await work(client);
     }
     finally {
-        await client.releaseLease().catch(() => { });
+        try {
+            await client.releaseLease().catch(() => { });
+        }
+        finally {
+            await client.close();
+        }
     }
 }
 function listedIdentity(rows, name) {
@@ -106,11 +121,57 @@ export async function removeExactMemberIdentity(seat) {
         }
     });
 }
+export async function assertMemberIdentityAbsent(seat) {
+    await withIdentityClient(async (client) => {
+        const rows = await client.listIdentities();
+        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; refusing retirement`);
+        }
+    });
+}
 async function retireMember(roomId, seat, deps) {
     let room = getRoomRecord(roomId);
     let current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
     let retirement = current.retirement;
+    if (retirement?.phase === 'identity_absent') {
+        if (current.launch?.launch_id && current.launch.launch_id !== retirement.launch_id) {
+            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`);
+            await assertMemberIdentityAbsent(current);
+        }
+        return;
+    }
     if (!retirement) {
+        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?.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`);
+                if (await tempSupervisorLiveness(archived) !== 'stopped')
+                    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 assertMemberIdentityAbsent(current);
+                const latest = getRoomRecord(roomId)?.member_seats.find(seat => seat.role_name === current.role_name);
+                if (existsSync(agentDir(current.role_name, true))
+                    || latest?.launch?.launch_id !== current.launch.launch_id
+                    || latest?.launch?.action_id !== current.launch.action_id
+                    || latest?.identity_cid !== current.identity_cid)
+                    throw new Error(`room member '${current.role_name}' changed during archived retirement proof`);
+                advanceMemberRetirement(roomId, current.role_name, 'identity_absent', current.launch.launch_id, archived);
+                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`);
@@ -159,8 +220,6 @@ export async function closeManagedRoom(input) {
         try {
             if (room.close?.phase === 'retire_members') {
                 for (const seat of room.member_seats) {
-                    if (seat.retirement?.phase === 'identity_absent')
-                        continue;
                     await retireMember(input.roomId, seat, deps);
                 }
                 room = advanceRoomClose(input.roomId, 'close_cowork');
@@ -180,6 +239,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);
         }
@@ -197,13 +259,29 @@ 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;
-    }
-    deleteRoomRecord(input.roomId);
-    return { room_id: input.roomId, deleted: true };
+    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);
+            }
+            deleteRoomRecord(input.roomId);
+            return { room_id: input.roomId, deleted: true };
+        }
+        catch (error) {
+            setRoomCloseError(input.roomId, errorText(error), `Fix the cleanup error and explicitly retry room delete ${input.roomId} ${input.roomId}.`);
+            throw error;
+        }
+    }, {}, CLOSE_LOCK_STALE_MS);
 }

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

@@ -58,6 +58,10 @@ export interface CoworkAdapter {
         briefing: string;
         quiet_membership?: boolean;
         anonymous?: boolean;
+        activation_requirements?: Array<{
+            role: string;
+            count: number;
+        }>;
     }): Promise<CoworkRoomCreateResult>;
     acceptInvite(roomId: string, invite: string, opts: {
         role: string;

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

@@ -8,6 +8,8 @@ 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;
@@ -275,10 +277,15 @@ function rpcCall(socketPath, method, params, timeoutMs, connect) {
     });
 }
 export function createCoworkAdapter(options = {}) {
-    const socketPath = resolveCoworkSocketPath(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);
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const connect = options.connect ?? ((path) => createConnection(path));
-    const call = (method, params) => rpcCall(socketPath, method, params, timeoutMs, connect);
+    const call = (method, params) => remote ? coworkHttpCall(remote, method, params, timeoutMs) : rpcCall(socketPath, method, params, timeoutMs, connect);
     return {
         async available() {
             try {
@@ -296,6 +303,7 @@ export function createCoworkAdapter(options = {}) {
                 briefing: opts.briefing,
                 ...(opts.quiet_membership === undefined ? {} : { quiet_membership: opts.quiet_membership }),
                 ...(opts.anonymous === undefined ? {} : { anonymous: opts.anonymous }),
+                ...(opts.activation_requirements === undefined ? {} : { activation_requirements: opts.activation_requirements }),
             }), 'room.create');
             if (!result.identity_cid)
                 throw new CoworkProtocolError('room.create', 'created room did not establish an identity CID');

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

@@ -0,0 +1,3 @@
+import type { ExplicitClientProfile } from '../client-profile.js';
+/** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
+export declare function coworkHttpCall(profile: ExplicitClientProfile, method: string, params: Record<string, unknown>, timeoutMs: number): Promise<unknown>;

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

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