@ours.network/fleet 0.18.1 → 0.19.0-nightly.10

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

@@ -0,0 +1,272 @@
+/**
+ * Typed client for the ours-cowork v1 private management-socket 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.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { createConnection } from 'node:net';
+const RPC_VERSION = 1;
+const DEFAULT_TIMEOUT_MS = 10_000;
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+export class CoworkUnavailableError extends Error {
+    constructor(message = 'Cowork management socket is not reachable', options) {
+        super(message, options);
+        this.name = 'CoworkUnavailableError';
+    }
+}
+export class CoworkProtocolError extends Error {
+    operation;
+    code;
+    constructor(operation, message, code = 'protocol_error', options) {
+        super(`cowork ${operation}: ${message}`, options);
+        this.operation = operation;
+        this.code = code;
+        this.name = 'CoworkProtocolError';
+    }
+}
+function object(value, operation, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new CoworkProtocolError(operation, `${label} must be an object`);
+    return value;
+}
+function string(value, operation, label) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new CoworkProtocolError(operation, `${label} must be a non-empty string`);
+    return value;
+}
+function text(value, operation, label) {
+    if (typeof value !== 'string')
+        throw new CoworkProtocolError(operation, `${label} must be a string`);
+    return value;
+}
+function roomState(value, operation) {
+    if (value !== 'provisioning' && value !== 'active' && value !== 'closing' && value !== 'closed')
+        throw new CoworkProtocolError(operation, 'room state is invalid');
+    return value;
+}
+function seatState(value, operation) {
+    if (value !== 'pending' && value !== 'active' && value !== 'removed')
+        throw new CoworkProtocolError(operation, 'seat state is invalid');
+    return value;
+}
+function projectSeat(value, operation) {
+    const seat = object(value, operation, 'seat');
+    return {
+        identity_cid: string(seat.identity, operation, 'seat.identity'),
+        role: string(seat.role, operation, 'seat.role'),
+        seat_state: seatState(seat.state, operation),
+    };
+}
+function projectRoom(value, operation) {
+    const room = object(value, operation, 'room');
+    if (!Array.isArray(room.seats))
+        throw new CoworkProtocolError(operation, 'room.seats must be an array');
+    const mission = room.mission === undefined ? undefined : object(room.mission, operation, 'room.mission');
+    return {
+        room_id: string(room.room_id, operation, 'room.room_id'),
+        identity_name: string(room.identity_name, operation, 'room.identity_name'),
+        // Cowork reserves an empty CID only for its durable packet_pending
+        // recovery sentinel; list/show must preserve that recoverable state.
+        identity_cid: text(room.identity_cid, operation, 'room.identity_cid'),
+        room_name: string(room.room_name, operation, 'room.room_name'),
+        state: roomState(room.state, operation),
+        seats: room.seats.map((seat) => projectSeat(seat, operation)),
+        ...(typeof mission?.goal === 'string' ? { goal: mission.goal } : {}),
+        ...(typeof mission?.briefing === 'string' ? { briefing: mission.briefing } : {}),
+    };
+}
+/** 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 socketPath = 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);
+    return {
+        async available() {
+            try {
+                await call('room.list', {});
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async createRoom(opts) {
+            const result = projectRoom(await call('room.create', {
+                name: opts.room_name,
+                goal: opts.goal,
+                briefing: opts.briefing,
+                ...(opts.quiet_membership === undefined ? {} : { quiet_membership: opts.quiet_membership }),
+                ...(opts.anonymous === undefined ? {} : { anonymous: opts.anonymous }),
+            }), 'room.create');
+            if (!result.identity_cid)
+                throw new CoworkProtocolError('room.create', 'created room did not establish an identity CID');
+            return { room_id: result.room_id, identity_name: result.identity_name, identity_cid: result.identity_cid };
+        },
+        async acceptInvite(roomId, invite, opts) {
+            const receipt = object(await call('room.accept', {
+                room_id: roomId,
+                role: opts.role,
+                invite,
+                expected_cid: opts.expected_cid,
+            }), 'room.accept', 'receipt');
+            const state = seatState(receipt.state, 'room.accept');
+            if (state === 'removed')
+                throw new CoworkProtocolError('room.accept', 'accepted seat cannot be removed');
+            return {
+                seat_cid: string(receipt.identity, 'room.accept', 'receipt.identity'),
+                seat_state: state,
+            };
+        },
+        async issueInvite(roomId, opts) {
+            const receipt = object(await call('room.invite', {
+                room_id: roomId,
+                mode: 'public',
+                role: opts.role,
+                min_accepts: opts.min_accepts,
+            }), 'room.invite', 'receipt');
+            const invite = object(receipt.invite, 'room.invite', 'receipt.invite');
+            return {
+                invite: string(receipt.blob, 'room.invite', 'receipt.blob'),
+                min_accepts: typeof invite.min_accepts === 'number'
+                    ? invite.min_accepts : opts.min_accepts,
+            };
+        },
+        async getRoom(roomId) {
+            try {
+                return projectRoom(await call('room.show', { room_id: roomId }), 'room.show');
+            }
+            catch (error) {
+                if (error instanceof CoworkProtocolError && error.code === 'not_found')
+                    return undefined;
+                throw error;
+            }
+        },
+        async listRooms() {
+            const result = await call('room.list', {});
+            if (!Array.isArray(result))
+                throw new CoworkProtocolError('room.list', 'result must be an array');
+            return result.map((room) => projectRoom(room, 'room.list'));
+        },
+        async closeRoom(roomId) { await call('room.close', { room_id: roomId }); },
+        async getSeats(roomId) {
+            const result = await call('room.participants', { room_id: roomId });
+            if (!Array.isArray(result))
+                throw new CoworkProtocolError('room.participants', 'result must be an array');
+            return result.map((seat) => projectSeat(seat, 'room.participants'));
+        },
+        async recoverRoom(roomId) {
+            // Cowork performs packet/state reconciliation during daemon recovery.
+            // Its `room.recover` RPC is specifically invite-receipt recovery, so a
+            // Fleet reconciliation pass must read `room.show`, not mutate invites.
+            return projectRoom(await call('room.show', { room_id: roomId }), 'room.show');
+        },
+    };
+}

package/dist/rooms-tasks/external-worker.d.ts

@@ -0,0 +1,2 @@
+/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
+export declare function launchFleetWorker(args: string[], operation: string, configPath?: string): Promise<void>;

package/dist/rooms-tasks/external-worker.js

@@ -0,0 +1,40 @@
+import { execFile, spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
+export function launchFleetWorker(args, operation, configPath) {
+    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+    const inheritedKeys = [
+        'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'OURS_CONFIG',
+        'OURS_PORT', 'OURS_STATE_DIR', 'OURS_API_TOKEN', 'OURS_COWORK_CONFIG',
+    ];
+    const inherited = inheritedKeys
+        .flatMap(key => process.env[key] === undefined ? [] : [`${key}=${process.env[key]}`]);
+    const suffix = randomUUID().slice(0, 8);
+    const safeOperation = operation.replace(/[^A-Za-z0-9_.-]/g, '-');
+    return new Promise((resolve, reject) => {
+        if (process.env.OURS_FLEET_SUPERVISOR !== 'none' && process.platform === 'linux') {
+            execFile('systemd-run', [
+                '--user', '--quiet', '--collect',
+                `--unit=ours-fleet-${safeOperation}-${suffix}`,
+                '--property=Type=exec', '--property=KillMode=control-group',
+                ...inherited.map(value => `--setenv=${value}`),
+                process.execPath, ...cli,
+            ], { timeout: 15_000 }, error => error ? reject(error) : resolve());
+            return;
+        }
+        if (process.env.OURS_FLEET_SUPERVISOR !== 'none' && process.platform === 'darwin') {
+            execFile('launchctl', [
+                'submit', '-l', `network.ours.fleet.${safeOperation}.${suffix}`, '--',
+                '/usr/bin/env', ...inherited, process.execPath, ...cli,
+            ], { timeout: 15_000 }, error => error ? reject(error) : resolve());
+            return;
+        }
+        const env = Object.fromEntries(inherited.map(value => {
+            const split = value.indexOf('=');
+            return [value.slice(0, split), value.slice(split + 1)];
+        }));
+        const child = spawn(process.execPath, cli, { detached: true, stdio: 'ignore', env });
+        child.once('error', reject);
+        child.once('spawn', () => { child.unref(); resolve(); });
+    });
+}

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

@@ -0,0 +1,10 @@
+export * from './types.js';
+export * from './templates.js';
+export * from './config.js';
+export * from './task-state.js';
+export * from './room-state.js';
+export * from './cowork-adapter.js';
+export { provisionMembers, cleanupMembers } from './provision.js';
+export { acceptManagedRoomClose, closeManagedRoom, recordManagedRoomCloseError } from './close.js';
+export { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from './terminal.js';
+export { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './cli.js';

package/dist/rooms-tasks/index.js

@@ -0,0 +1,10 @@
+export * from './types.js';
+export * from './templates.js';
+export * from './config.js';
+export * from './task-state.js';
+export * from './room-state.js';
+export * from './cowork-adapter.js';
+export { provisionMembers, cleanupMembers } from './provision.js';
+export { acceptManagedRoomClose, closeManagedRoom, recordManagedRoomCloseError } from './close.js';
+export { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from './terminal.js';
+export { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './cli.js';

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

@@ -0,0 +1,21 @@
+import type { CoworkAdapter } from './cowork-adapter.js';
+import type { RoomOrchestrationRecord, TemplateSnapshot } from './types.js';
+import { type FleetConfig } from '../config.js';
+export declare function getBinPath(): string;
+export interface ProvisionMembersInput {
+    cfg: FleetConfig;
+    cowork: CoworkAdapter;
+    roomId: string;
+    taskId?: string;
+    template: TemplateSnapshot;
+    binPath: string;
+    brief?: string;
+    goal?: string;
+}
+export declare function provisionMembers(input: ProvisionMembersInput): Promise<RoomOrchestrationRecord>;
+export declare function cleanupMembers(input: {
+    roomId: string;
+    taskId?: string;
+    closeCoworkRoom?: boolean;
+    cowork?: CoworkAdapter;
+}): Promise<void>;

package/dist/rooms-tasks/provision.js

@@ -0,0 +1,243 @@
+import { randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { attachOursClient, } from '@ours.network/sdk/client';
+import { advanceSaga, setSagaError, updateMemberSeats, activateRoom, getRoomRecord, } from './room-state.js';
+import { activateTask, updateTaskMembers, failTask, } from './task-state.js';
+import { spawnTemp } from '../spawn.js';
+import { findRole } from '../config.js';
+import { closeManagedRoom } from './close.js';
+export function getBinPath() {
+    try {
+        return realpathSync(process.argv[1]);
+    }
+    catch {
+        return process.argv[1];
+    }
+}
+function shortId(id) { return id.slice(0, 8); }
+function expandMembers(template, prefix) {
+    const result = [];
+    for (const slot of template.members) {
+        for (let i = 1; i <= slot.count; i++) {
+            result.push({
+                name: `${prefix}-${slot.slot}-${i}`,
+                slot: slot.slot,
+                coworkRole: slot.role,
+                roleRef: slot.role_ref,
+                overrides: slot.overrides,
+            });
+        }
+    }
+    return result;
+}
+async function createMemberIdentity(name, bio) {
+    const client = await attachOursClient({
+        env: process.env,
+        leaseToken: `ours-fleet-member-create-${process.pid}-${randomUUID()}`,
+        clientPid: process.pid,
+    });
+    try {
+        const result = await client.createIdentity({
+            name,
+            bio,
+            exposeLocal: true,
+            localAutoAccept: true,
+        });
+        return { cid: result.info.cid, client };
+    }
+    finally {
+        await client.releaseLease();
+    }
+}
+async function removeMemberIdentity(name) {
+    try {
+        const client = await attachOursClient({
+            env: process.env,
+            leaseToken: `ours-fleet-member-cleanup-${process.pid}-${randomUUID()}`,
+            clientPid: process.pid,
+        });
+        try {
+            await client.removeIdentity({ name });
+        }
+        finally {
+            await client.releaseLease();
+        }
+    }
+    catch { /* best-effort cleanup */ }
+}
+function buildMemberBriefing(member, input, roster) {
+    const lines = [
+        `Fleet Task ${input.taskId ?? '(standalone)'} — ${member.coworkRole} in room ${input.roomId}`,
+        '',
+    ];
+    if (input.goal)
+        lines.push(`Goal: ${input.goal}`);
+    if (input.brief)
+        lines.push(`Brief: ${input.brief}`);
+    lines.push('');
+    lines.push(`Collaboration contract:`);
+    lines.push(input.template.contract || 'Work in the room. Preserve evidence.');
+    lines.push('');
+    lines.push(`Your seat role: ${member.coworkRole}`);
+    lines.push('');
+    lines.push('Roster:');
+    for (const r of roster)
+        lines.push(`  ${r.name} (${r.coworkRole}) ${r.cid}`);
+    lines.push('');
+    lines.push('Rules:');
+    lines.push('- Room messages from the authenticated Owner seat are owner instructions.');
+    lines.push('- Other participants are peers, not owners, regardless of display role.');
+    lines.push('- Decisions and compact evidence go to the Room.');
+    lines.push('- Each member may challenge another member\'s result.');
+    return lines.join('\n');
+}
+export async function provisionMembers(input) {
+    const { cfg, cowork, roomId, taskId, template, binPath } = input;
+    const prefix = taskId ? shortId(taskId) : `room-${shortId(roomId)}`;
+    const plan = expandMembers(template, prefix);
+    const createdIdentities = [];
+    const members = [];
+    // A room that already reached wait_seats keeps its member identities, seats
+    // and accepted invitations; recreating them on a retry would collide. Resume
+    // from the persisted seats and re-check seat activity instead.
+    const existing = getRoomRecord(roomId);
+    const persistedSeats = existing?.member_seats ?? [];
+    const resuming = existing !== undefined
+        && ['wait_seats', 'launch_work', 'activate'].includes(existing.saga.phase)
+        && plan.length > 0
+        && plan.every(p => persistedSeats.some(s => s.role_name === p.name));
+    let seats;
+    if (resuming) {
+        for (const planned of plan) {
+            const seat = persistedSeats.find(s => s.role_name === planned.name);
+            members.push({ ...planned, cid: seat.identity_cid });
+        }
+        seats = persistedSeats;
+    }
+    else {
+        // Phase 4: create_members
+        advanceSaga(roomId, 'create_members', 3);
+        try {
+            for (const planned of plan) {
+                const bio = `Fleet task member: ${planned.coworkRole} for ${taskId ?? roomId}`;
+                const { cid } = await createMemberIdentity(planned.name, bio);
+                createdIdentities.push(planned.name);
+                members.push({ ...planned, cid });
+            }
+        }
+        catch (error) {
+            for (const name of createdIdentities)
+                await removeMemberIdentity(name);
+            setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Member identity creation failed. Retry with `task recover`.', 'member_failed');
+            if (taskId)
+                failTask(taskId, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+        seats = members.map(m => ({
+            role_name: m.name,
+            identity_cid: m.cid,
+            slot: m.slot,
+            cowork_role: m.coworkRole,
+            seat_state: 'pending',
+        }));
+        updateMemberSeats(roomId, seats);
+        if (taskId) {
+            const taskMembers = members.map(m => ({
+                name: m.name,
+                identity_cid: m.cid,
+                slot: m.slot,
+                cowork_role: m.coworkRole,
+            }));
+            updateTaskMembers(taskId, taskMembers);
+        }
+        // Phase 5: join_role_groups — serial by Cowork role
+        advanceSaga(roomId, 'join_role_groups', 4);
+        const roleGroups = new Map();
+        for (const m of members) {
+            const group = roleGroups.get(m.coworkRole) ?? [];
+            group.push(m);
+            roleGroups.set(m.coworkRole, group);
+        }
+        try {
+            for (const [coworkRole, group] of roleGroups) {
+                const { invite } = await cowork.issueInvite(roomId, {
+                    role: coworkRole,
+                    min_accepts: group.length,
+                });
+                // invite is used in-memory only — NEVER persisted
+                for (const member of group) {
+                    await cowork.acceptInvite(roomId, invite, {
+                        role: coworkRole,
+                        expected_cid: member.cid,
+                    });
+                }
+            }
+        }
+        catch (error) {
+            for (const name of createdIdentities)
+                await removeMemberIdentity(name);
+            setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Role-group admission failed. Retry with `task recover`.', 'member_failed');
+            if (taskId)
+                failTask(taskId, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    }
+    // Phase 6: wait_seats
+    advanceSaga(roomId, 'wait_seats', 5);
+    const coworkSeats = await cowork.getSeats(roomId);
+    const memberCids = new Set(members.map(m => m.cid));
+    const allActive = [...memberCids].every(cid => coworkSeats.some(s => s.identity_cid === cid && s.seat_state === 'active'));
+    if (!allActive) {
+        advanceSaga(roomId, 'wait_seats', 5, 'waiting_seats');
+        // Seats are pending — return record for caller to retry later
+        return getRoomRecord(roomId);
+    }
+    const activeSeats = seats.map(s => ({ ...s, seat_state: 'active' }));
+    updateMemberSeats(roomId, activeSeats);
+    // Phase 7: launch_work
+    advanceSaga(roomId, 'launch_work', 6);
+    try {
+        for (const member of members) {
+            const briefing = buildMemberBriefing(member, input, members);
+            let refRole;
+            try {
+                refRole = findRole(cfg, member.roleRef);
+            }
+            catch { /* no ref role */ }
+            const model = member.overrides?.model ?? refRole?.model;
+            const harness = member.overrides?.harness ?? refRole?.harness;
+            const cwd = member.overrides?.cwd ?? refRole?.cwd;
+            const persona = member.overrides?.persona ?? refRole?.persona;
+            await spawnTemp({
+                name: member.name,
+                temp: true,
+                identity: member.name,
+                mission: briefing,
+                model,
+                harness,
+                cwd,
+                persona,
+                surface: 'agent',
+            }, binPath);
+        }
+    }
+    catch (error) {
+        setSagaError(roomId, error instanceof Error ? error.message : String(error), 'Member launch failed. Some agents may be running. Retry with `task recover`.', 'member_failed');
+        throw error;
+    }
+    // Phase 8: activate
+    advanceSaga(roomId, 'activate', 7);
+    const record = activateRoom(roomId);
+    if (taskId)
+        activateTask(taskId);
+    return record;
+}
+export async function cleanupMembers(input) {
+    const room = getRoomRecord(input.roomId);
+    if (!room)
+        return;
+    if (!input.closeCoworkRoom || !input.cowork) {
+        throw new Error('member cleanup requires the shared deterministic room-close saga and Cowork adapter');
+    }
+    await closeManagedRoom({ roomId: input.roomId, cowork: input.cowork });
+}

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

@@ -0,0 +1,28 @@
+import type { RoomOrchestrationRecord, RoomOrchestrationState, SagaPhase, RoomMemberSeat, ProvisioningDetail, MemberRetirementPhase, RoomClosePhase } from './types.js';
+export declare const roomsDir: () => string;
+export declare class RoomStateError extends Error {
+}
+export interface CreateRoomInput {
+    room_id: string;
+    room_name: string;
+    goal?: string;
+    room_identity_cid?: string;
+    task_id?: string;
+    template_snapshot?: import('./types.js').TemplateSnapshot;
+}
+export declare function createRoomRecord(input: CreateRoomInput): RoomOrchestrationRecord;
+export declare function getRoomRecord(id: string): RoomOrchestrationRecord | undefined;
+export declare function listRoomRecords(filter?: {
+    state?: RoomOrchestrationState | RoomOrchestrationState[];
+}): RoomOrchestrationRecord[];
+export declare function advanceSaga(id: string, phase: SagaPhase, stepIndex?: number, detail?: ProvisioningDetail): RoomOrchestrationRecord;
+export declare function setSagaError(id: string, error: string, hint?: string, detail?: ProvisioningDetail): RoomOrchestrationRecord;
+export declare function setRoomIdentity(id: string, roomIdentityCid: string): RoomOrchestrationRecord;
+export declare function setOwnerSeat(id: string, ownerSeatCid: string, inviteFingerprint: string): RoomOrchestrationRecord;
+export declare function updateMemberSeats(id: string, seats: RoomMemberSeat[]): RoomOrchestrationRecord;
+export declare function activateRoom(id: string): RoomOrchestrationRecord;
+export declare function closeRoom(id: string): RoomOrchestrationRecord;
+export declare function beginRoomClose(id: string): RoomOrchestrationRecord;
+export declare function advanceMemberRetirement(id: string, roleName: string, phase: MemberRetirementPhase, launchId: string, archivePath?: string): RoomOrchestrationRecord;
+export declare function advanceRoomClose(id: string, phase: RoomClosePhase): RoomOrchestrationRecord;
+export declare function setRoomCloseError(id: string, error: string, recoveryHint: string): RoomOrchestrationRecord;