@ours.network/fleet 0.19.0-nightly.2 → 0.19.0-nightly.4

package/dist/rooms-tasks/cli.js

@@ -1,8 +1,10 @@
 import { readFileSync } from 'node:fs';
-import { loadConfig } from '../config.js';
+import { loadConfig, ConfigError } from '../config.js';
+import { provisionMembers, cleanupMembers, getBinPath } from './provision.js';
 import { resolveTemplate, listTemplates, snapshotTemplate, hashTemplate, } from './templates.js';
-import { createTask, getTask, listTasks, startTask, blockTask, unblockTask, reviewTask, completeTask, cancelTask, } from './task-state.js';
-import { createRoomRecord, getRoomRecord, listRoomRecords, closeRoom as closeRoomRecord, } from './room-state.js';
+import { createTask, getTask, listTasks, startTask, activateTask, blockTask, unblockTask, reviewTask, completeTask, cancelTask, updateTaskRoom, } from './task-state.js';
+import { createRoomRecord, getRoomRecord, listRoomRecords, closeRoom as closeRoomRecord, advanceSaga, setOwnerSeat, setSagaError, activateRoom, } from './room-state.js';
+import { createCoworkAdapter, CoworkProtocolError, CoworkUnavailableError } from './cowork-adapter.js';
 function die(e) {
     const msg = e instanceof Error ? e.message : String(e);
     process.stderr.write(`error: ${msg}\n`);
@@ -14,6 +16,82 @@ function loadCfg(opts) {
 function allTemplates(cfg) {
     return cfg.roomTemplates ?? {};
 }
+function coworkFor(cfg) {
+    if (!cfg.rooms || cfg.rooms.provider !== 'cowork')
+        throw new ConfigError('rooms: configure provider: cowork before creating or querying rooms');
+    return createCoworkAdapter({ configPath: cfg.rooms.cowork?.config });
+}
+function resolveRoomTemplate(cfg, name) {
+    if (!name)
+        return undefined;
+    const template = resolveTemplate(name, allTemplates(cfg));
+    if (!template)
+        throw new Error(`template not found: ${name}`);
+    return snapshotTemplate(template);
+}
+async function provisionRoom(cfg, input) {
+    const rooms = cfg.rooms;
+    if (!rooms)
+        throw new ConfigError('rooms: configuration is required');
+    const attachOwner = rooms.defaults?.attach_owner !== false;
+    if (attachOwner && !cfg.ownerInvite)
+        throw new ConfigError('rooms.owner: public_invite or public_invite_file is required when attach_owner is enabled');
+    const cowork = coworkFor(cfg);
+    const goal = input.goal?.trim() || input.name;
+    const briefing = input.brief?.trim() || input.template?.contract?.trim() || goal;
+    const created = await cowork.createRoom({
+        room_name: input.name,
+        goal,
+        briefing,
+        quiet_membership: input.template?.room?.quiet_membership,
+        anonymous: input.template?.room?.anonymous,
+    });
+    let record = createRoomRecord({
+        room_id: created.room_id,
+        room_name: input.name,
+        room_identity_cid: created.identity_cid,
+        task_id: input.taskId,
+        template_snapshot: input.template,
+    });
+    input.onCreated?.(record);
+    record = advanceSaga(record.room_id, 'create_room', 1);
+    if (attachOwner) {
+        try {
+            record = advanceSaga(record.room_id, 'attach_owner', 2);
+            const accepted = await cowork.acceptInvite(record.room_id, cfg.ownerInvite, {
+                role: rooms.owner.role,
+                expected_cid: rooms.owner.expected_cid,
+            });
+            record = setOwnerSeat(record.room_id, accepted.seat_cid, cfg.ownerInviteFingerprint ?? '');
+        }
+        catch (error) {
+            const mismatch = error instanceof CoworkProtocolError && /CID|expected/i.test(error.message);
+            setSagaError(record.room_id, error instanceof Error ? error.message : String(error), mismatch
+                ? 'Verify rooms.owner.expected_cid and rotate the configured invite if necessary.'
+                : 'Rotate rooms.owner.public_invite or public_invite_file, then run room recover.', mismatch ? 'owner_cid_mismatch' : 'waiting_owner_invite');
+            throw error;
+        }
+    }
+    record = advanceSaga(record.room_id, 'create_members', 3);
+    if (input.template && input.template.members.length > 0) {
+        record = await provisionMembers({
+            cfg,
+            cowork,
+            roomId: record.room_id,
+            taskId: input.taskId,
+            template: input.template,
+            binPath: getBinPath(),
+            brief: input.brief,
+            goal: input.goal,
+        });
+    }
+    else {
+        record = activateRoom(record.room_id);
+        if (input.taskId)
+            activateTask(input.taskId);
+    }
+    return record;
+}
 export function registerTemplateCommands(parent, cOpt) {
     const templateCmd = parent.command('template').description('room template operations');
     cOpt(templateCmd.command('list'))
@@ -114,7 +192,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--no-room', 'create task without a room')
         .option('--idempotency-key <key>', 'idempotency key')
         .option('--json', 'JSON output')
-        .action((opts) => {
+        .action(async (opts) => {
         try {
             const cfg = loadCfg(opts);
             let templateRef;
@@ -138,7 +216,7 @@ export function registerTaskCommands(parent, cOpt) {
                 brief = readFileSync(opts.briefFile, 'utf8');
             }
             const origin = { type: 'cli' };
-            const record = createTask({
+            let record = createTask({
                 title: opts.title,
                 brief,
                 brief_file: opts.briefFile,
@@ -147,6 +225,28 @@ export function registerTaskCommands(parent, cOpt) {
                 idempotency_key: opts.idempotencyKey,
                 start: !opts.backlog,
             });
+            if (!opts.backlog && opts.room !== false && templateRef && !record.room_id) {
+                const template = resolveRoomTemplate(cfg, templateRef.name);
+                try {
+                    await provisionRoom(cfg, {
+                        name: opts.title,
+                        goal: opts.title,
+                        brief,
+                        template,
+                        taskId: record.task_id,
+                        onCreated: room => {
+                            record = updateTaskRoom(record.task_id, room.room_id, room.room_identity_cid);
+                        },
+                    });
+                    record = getTask(record.task_id);
+                }
+                catch (error) {
+                    if (error instanceof CoworkUnavailableError) {
+                        blockTask(record.task_id, 'Cowork management socket is unavailable');
+                    }
+                    throw error;
+                }
+            }
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: record }, null, 2));
                 return;
@@ -224,12 +324,29 @@ export function registerTaskCommands(parent, cOpt) {
             die(e);
         }
     });
-    taskCmd.command('start <id>')
+    cOpt(taskCmd.command('start <id>'))
         .description('start a backlog task')
         .option('--json', 'JSON output')
-        .action((id, opts) => {
+        .action(async (id, opts) => {
         try {
-            const t = startTask(id);
+            const cfg = loadCfg(opts);
+            let t = startTask(id);
+            if (t.template && !t.room_id) {
+                const template = resolveRoomTemplate(cfg, t.template.name);
+                if (!template || template.content_hash !== t.template.content_hash)
+                    throw new Error(`task template snapshot no longer matches ${t.template.name}@${t.template.version}`);
+                await provisionRoom(cfg, {
+                    name: t.title,
+                    goal: t.title,
+                    brief: t.brief,
+                    template,
+                    taskId: t.task_id,
+                    onCreated: room => {
+                        t = updateTaskRoom(t.task_id, room.room_id, room.room_identity_cid);
+                    },
+                });
+                t = getTask(t.task_id);
+            }
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -289,18 +406,32 @@ export function registerTaskCommands(parent, cOpt) {
             die(e);
         }
     });
-    taskCmd.command('done <id>')
+    cOpt(taskCmd.command('done <id>'))
         .description('complete a task')
         .option('--summary <text>', 'completion summary')
         .option('--summary-file <path>', 'completion summary from file')
         .option('--json', 'JSON output')
-        .action((id, opts) => {
+        .action(async (id, opts) => {
         try {
             let summary = opts.summary;
             if (opts.summaryFile)
                 summary = readFileSync(opts.summaryFile, 'utf8');
             const outcome = summary ? { summary } : undefined;
             const t = completeTask(id, outcome);
+            if (t.room_id) {
+                const cfg = loadCfg(opts);
+                const shouldClose = cfg.tasks?.close_room_on_done
+                    ?? cfg.rooms?.defaults?.close_when_task_done
+                    ?? false;
+                if (shouldClose) {
+                    try {
+                        await coworkFor(cfg).closeRoom(t.room_id);
+                        closeRoomRecord(t.room_id);
+                    }
+                    catch { /* room close is best-effort on task done */ }
+                    await cleanupMembers({ roomId: t.room_id, taskId: id }).catch(() => { });
+                }
+            }
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -311,14 +442,23 @@ export function registerTaskCommands(parent, cOpt) {
             die(e);
         }
     });
-    taskCmd.command('cancel <id> <confirm-id>')
+    cOpt(taskCmd.command('cancel <id> <confirm-id>'))
         .description('cancel a task (requires ID twice for confirmation)')
         .option('--json', 'JSON output')
-        .action((id, confirmId, opts) => {
+        .action(async (id, confirmId, opts) => {
         try {
             if (id !== confirmId)
                 die(new Error('confirmation ID must match task ID'));
             const t = cancelTask(id);
+            if (t.room_id) {
+                const cfg = loadCfg(opts);
+                await cleanupMembers({
+                    roomId: t.room_id,
+                    taskId: id,
+                    closeCoworkRoom: true,
+                    cowork: coworkFor(cfg),
+                }).catch(() => { });
+            }
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: t }, null, 2));
                 return;
@@ -329,11 +469,12 @@ export function registerTaskCommands(parent, cOpt) {
             die(e);
         }
     });
-    taskCmd.command('recover <id>')
+    cOpt(taskCmd.command('recover <id>'))
         .description('attempt to recover a stuck task')
         .option('--json', 'JSON output')
-        .action((id, opts) => {
+        .action(async (id, opts) => {
         try {
+            const cfg = loadCfg(opts);
             const t = getTask(id);
             const room = t.room_id ? getRoomRecord(t.room_id) : undefined;
             const result = {
@@ -350,6 +491,28 @@ export function registerTaskCommands(parent, cOpt) {
                     result.recovery_actions.push('Owner CID mismatch — verify rooms.owner.expected_cid matches Messenger identity');
                 if (room.provisioning_detail === 'member_failed')
                     result.recovery_actions.push(`Member creation failed at saga step ${room.saga.step_index} — inspect and retry`);
+                const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
+                if (resumable.includes(room.saga.phase)) {
+                    const template = t.template ? resolveRoomTemplate(cfg, t.template.name) : undefined;
+                    if (template) {
+                        try {
+                            await provisionMembers({
+                                cfg,
+                                cowork: coworkFor(cfg),
+                                roomId: room.room_id,
+                                taskId: t.task_id,
+                                template,
+                                binPath: getBinPath(),
+                                brief: t.brief,
+                                goal: t.title,
+                            });
+                            result.recovery_actions.push('Provisioning resumed successfully');
+                        }
+                        catch (error) {
+                            result.recovery_actions.push(`Resume failed: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                    }
+                }
             }
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, ...result }, null, 2));
@@ -382,13 +545,12 @@ export function registerRoomCommands(parent, cOpt) {
         .option('--brief <text>', 'room briefing')
         .option('--brief-file <path>', 'room briefing from file')
         .option('--json', 'JSON output')
-        .action((opts) => {
+        .action(async (opts) => {
         try {
             const cfg = loadCfg(opts);
             let brief = opts.brief;
             if (opts.briefFile)
                 brief = readFileSync(opts.briefFile, 'utf8');
-            const roomId = `room-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
             let templateSnapshot;
             if (opts.template) {
                 const t = resolveTemplate(opts.template, allTemplates(cfg));
@@ -396,10 +558,11 @@ export function registerRoomCommands(parent, cOpt) {
                     die(new Error(`template not found: ${opts.template}`));
                 templateSnapshot = snapshotTemplate(t);
             }
-            const record = createRoomRecord({
-                room_id: roomId,
-                room_name: opts.name,
-                template_snapshot: templateSnapshot,
+            const record = await provisionRoom(cfg, {
+                name: opts.name,
+                goal: opts.goal,
+                brief,
+                template: templateSnapshot,
             });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, room: record }, null, 2));
@@ -413,17 +576,22 @@ export function registerRoomCommands(parent, cOpt) {
             die(e);
         }
     });
-    roomCmd.command('list')
+    cOpt(roomCmd.command('list'))
         .description('list rooms')
         .option('--state <state>', 'filter by state (active|provisioning|closing|closed|all)')
         .option('--json', 'JSON output')
-        .action((opts) => {
+        .action(async (opts) => {
         try {
+            const cfg = loadCfg(opts);
             let stateFilter;
             if (opts.state && opts.state !== 'all') {
                 stateFilter = opts.state;
             }
-            const rooms = listRoomRecords(stateFilter ? { state: stateFilter } : undefined);
+            const local = new Map(listRoomRecords().map(room => [room.room_id, room]));
+            const coworkRooms = await coworkFor(cfg).listRooms();
+            const rooms = coworkRooms
+                .filter(room => !stateFilter || room.state === stateFilter)
+                .map(room => ({ ...room, orchestration: local.get(room.room_id) ?? null }));
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, rooms }, null, 2));
                 return;
@@ -433,122 +601,189 @@ export function registerRoomCommands(parent, cOpt) {
                 return;
             }
             for (const r of rooms)
-                console.log(`${r.room_id}  ${r.state}  ${r.room_name}${r.task_id ? ` (task: ${r.task_id})` : ''}`);
+                console.log(`${r.room_id}  ${r.state}  ${r.room_name}${r.orchestration?.task_id ? ` (task: ${r.orchestration.task_id})` : ''}`);
         }
         catch (e) {
             die(e);
         }
     });
-    roomCmd.command('show <id>')
+    cOpt(roomCmd.command('show <id>'))
         .description('show room details')
         .option('--json', 'JSON output')
-        .action((id, opts) => {
+        .action(async (id, opts) => {
         try {
-            const r = getRoomRecord(id);
-            if (!r)
+            const cfg = loadCfg(opts);
+            const cowork = await coworkFor(cfg).getRoom(id);
+            if (!cowork)
                 die(new Error(`room not found: ${id}`));
+            const r = getRoomRecord(id);
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, room: r }, null, 2));
+                console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null }, null, 2));
                 return;
             }
-            console.log(`Room: ${r.room_id}`);
-            console.log(`Name: ${r.room_name}`);
-            console.log(`State: ${r.state}`);
-            if (r.task_id)
+            console.log(`Room: ${cowork.room_id}`);
+            console.log(`Name: ${cowork.room_name}`);
+            console.log(`State: ${cowork.state}`);
+            console.log(`Identity CID: ${cowork.identity_cid}`);
+            if (r?.task_id)
                 console.log(`Task: ${r.task_id}`);
-            if (r.room_identity_cid)
-                console.log(`Identity CID: ${r.room_identity_cid}`);
-            console.log(`Saga: ${r.saga.phase} (step ${r.saga.step_index})`);
-            if (r.provisioning_detail)
+            if (r)
+                console.log(`Saga: ${r.saga.phase} (step ${r.saga.step_index})`);
+            if (r?.provisioning_detail)
                 console.log(`Detail: ${r.provisioning_detail}`);
-            if (r.saga.error)
+            if (r?.saga.error)
                 console.log(`Error: ${r.saga.error}`);
-            if (r.member_seats.length) {
+            if (cowork.seats.length) {
                 console.log('Members:');
-                for (const s of r.member_seats)
-                    console.log(`  ${s.role_name} (${s.cowork_role}) ${s.seat_state}`);
+                for (const s of cowork.seats)
+                    console.log(`  ${s.identity_cid} (${s.role}) ${s.seat_state}`);
+            }
+            if (r)
+                console.log(`Tracked by Fleet since: ${r.created_at}`);
+        }
+        catch (e) {
+            die(e);
+        }
+    });
+    cOpt(roomCmd.command('open <id>'))
+        .description('open room in Cowork local console')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            const cfg = loadCfg(opts);
+            const room = await coworkFor(cfg).getRoom(id);
+            if (!room)
+                die(new Error(`room not found: ${id}`));
+            const url = `http://localhost:4460/room/${id}`;
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, room_id: id, url, room_name: room.room_name }, null, 2));
+                return;
             }
-            console.log(`Created: ${r.created_at}`);
-            if (r.activated_at)
-                console.log(`Activated: ${r.activated_at}`);
-            if (r.closed_at)
-                console.log(`Closed: ${r.closed_at}`);
+            console.log(`Room ${id} — ${room.room_name}`);
+            console.log(`Local console: ${url}`);
         }
         catch (e) {
             die(e);
         }
     });
-    roomCmd.command('members <id>')
+    cOpt(roomCmd.command('members <id>'))
         .description('show room members')
         .option('--json', 'JSON output')
-        .action((id, opts) => {
+        .action(async (id, opts) => {
         try {
+            const cfg = loadCfg(opts);
             const r = getRoomRecord(id);
-            if (!r)
-                die(new Error(`room not found: ${id}`));
+            const members = await coworkFor(cfg).getSeats(id);
             if (opts.json) {
                 console.log(JSON.stringify({
                     schema_version: 1,
-                    room_id: r.room_id,
-                    members: r.member_seats,
-                    owner_seat_cid: r.owner_seat_cid ?? null,
+                    room_id: id,
+                    members,
+                    owner_seat_cid: r?.owner_seat_cid ?? null,
                 }, null, 2));
                 return;
             }
-            console.log(`Room ${r.room_id} — ${r.room_name}`);
-            if (r.owner_seat_cid)
+            console.log(`Room ${id}${r ? ` — ${r.room_name}` : ''}`);
+            if (r?.owner_seat_cid)
                 console.log(`Owner: ${r.owner_seat_cid}`);
-            if (!r.member_seats.length) {
+            if (!members.length) {
                 console.log('No members.');
                 return;
             }
-            for (const s of r.member_seats)
-                console.log(`  ${s.role_name} (${s.cowork_role}) ${s.seat_state} ${s.identity_cid}`);
+            for (const s of members)
+                console.log(`  ${s.identity_cid} (${s.role}) ${s.seat_state}`);
         }
         catch (e) {
             die(e);
         }
     });
-    roomCmd.command('close <id> <confirm-id>')
+    cOpt(roomCmd.command('close <id> <confirm-id>'))
         .description('close a room (requires ID twice for confirmation)')
         .option('--json', 'JSON output')
-        .action((id, confirmId, opts) => {
+        .action(async (id, confirmId, opts) => {
         try {
             if (id !== confirmId)
                 die(new Error('confirmation ID must match room ID'));
-            const r = closeRoomRecord(id);
+            const cfg = loadCfg(opts);
+            await coworkFor(cfg).closeRoom(id);
+            const existing = getRoomRecord(id);
+            const r = existing ? closeRoomRecord(id) : undefined;
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, room: r }, null, 2));
+                console.log(JSON.stringify({ schema_version: 1, room_id: id, state: 'closed', orchestration: r ?? null }, null, 2));
                 return;
             }
-            console.log(`Room ${r.room_id} · closed`);
+            console.log(`Room ${id} · closed`);
         }
         catch (e) {
             die(e);
         }
     });
-    roomCmd.command('recover <id>')
+    cOpt(roomCmd.command('recover <id>'))
         .description('attempt to recover a stuck room')
         .option('--json', 'JSON output')
-        .action((id, opts) => {
+        .action(async (id, opts) => {
         try {
-            const r = getRoomRecord(id);
-            if (!r)
-                die(new Error(`room not found: ${id}`));
+            const cfg = loadCfg(opts);
+            const adapter = coworkFor(cfg);
+            const cowork = await adapter.recoverRoom(id);
+            let r = getRoomRecord(id);
+            if (r && !r.owner_seat_cid
+                && (r.provisioning_detail === 'waiting_owner_invite'
+                    || r.provisioning_detail === 'owner_cid_mismatch')) {
+                const expected = cfg.rooms.owner.expected_cid.toLowerCase();
+                const existing = (await adapter.getSeats(id))
+                    .find(seat => seat.identity_cid.toLowerCase() === expected && seat.seat_state !== 'removed');
+                if (!existing && !cfg.ownerInvite)
+                    throw new ConfigError('rooms.owner: configure public_invite or public_invite_file before recovery');
+                let acceptedCid = existing?.identity_cid;
+                if (!acceptedCid) {
+                    const accepted = await adapter.acceptInvite(id, cfg.ownerInvite, {
+                        role: cfg.rooms.owner.role,
+                        expected_cid: cfg.rooms.owner.expected_cid,
+                    });
+                    acceptedCid = accepted.seat_cid;
+                }
+                setOwnerSeat(id, acceptedCid, cfg.ownerInviteFingerprint ?? '');
+                r = advanceSaga(id, 'create_members', 3);
+            }
             const actions = [];
-            if (r.saga.error)
+            if (r?.saga.error)
                 actions.push(`Last error: ${r.saga.error}`);
-            if (r.saga.recovery_hint)
+            if (r?.saga.recovery_hint)
                 actions.push(r.saga.recovery_hint);
-            if (r.provisioning_detail === 'waiting_cowork')
+            if (r?.provisioning_detail === 'waiting_cowork')
                 actions.push('Check ours-cowork service status');
-            if (r.provisioning_detail === 'waiting_owner_invite')
+            if (r?.provisioning_detail === 'waiting_owner_invite')
                 actions.push('Rotate rooms.owner.public_invite in config, then re-run recover');
+            if (r && r.state === 'provisioning') {
+                const resumable = ['create_members', 'join_role_groups', 'wait_seats', 'launch_work', 'activate'];
+                if (resumable.includes(r.saga.phase) && r.template_snapshot) {
+                    try {
+                        const template = resolveRoomTemplate(cfg, r.template_snapshot.name);
+                        if (template) {
+                            await provisionMembers({
+                                cfg,
+                                cowork: adapter,
+                                roomId: r.room_id,
+                                taskId: r.task_id,
+                                template,
+                                binPath: getBinPath(),
+                                goal: r.room_name,
+                            });
+                            r = getRoomRecord(id);
+                            actions.push('Provisioning resumed successfully');
+                        }
+                    }
+                    catch (error) {
+                        actions.push(`Resume failed: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+            }
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, room: r, recovery_actions: actions }, null, 2));
+                console.log(JSON.stringify({ schema_version: 1, room: cowork, orchestration: r ?? null, recovery_actions: actions }, null, 2));
                 return;
             }
-            console.log(`Room ${r.room_id} · ${r.state} · saga: ${r.saga.phase}`);
+            console.log(`Room ${cowork.room_id} · ${cowork.state}${r ? ` · saga: ${r.saga.phase}` : ''}`);
             if (actions.length) {
                 console.log('Recovery:');
                 for (const a of actions)

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

@@ -1,17 +1,10 @@
 /**
- * Cowork private management-socket adapter.
+ * Typed client for the ours-cowork v1 private management-socket protocol.
  *
- * Fleet orchestrates tasks/rooms but Cowork owns room state. This adapter
- * communicates with Cowork via its Unix management socket using versioned
- * JSON RPC. All methods fail closed: if Cowork is unreachable or returns
- * an unexpected response, the operation fails rather than guessing.
- *
- * BLOCKED: The management socket protocol is defined in ours-cowork but
- * the exact prerelease wire format needs verification. This adapter
- * defines the interface Fleet needs and provides a fail-closed stub
- * that reports the blocker. Replace the stub with socket calls once
- * the Cowork management socket contract is verified.
+ * 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 type { Socket } from 'node:net';
 export interface CoworkRoomCreateResult {
     room_id: string;
     identity_name: string;
@@ -44,8 +37,8 @@ export interface CoworkAdapter {
     available(): Promise<boolean>;
     createRoom(opts: {
         room_name: string;
-        goal?: string;
-        briefing?: string;
+        goal: string;
+        briefing: string;
         quiet_membership?: boolean;
         anonymous?: boolean;
     }): Promise<CoworkRoomCreateResult>;
@@ -57,24 +50,28 @@ export interface CoworkAdapter {
         role: string;
         min_accepts: number;
     }): Promise<CoworkInviteResult>;
-    acceptAsIdentity(roomId: string, invite: string, identityCid: string, opts: {
-        role: string;
-    }): Promise<CoworkInviteAcceptResult>;
     getRoom(roomId: string): Promise<CoworkRoomInfo | undefined>;
     listRooms(): Promise<CoworkRoomInfo[]>;
     closeRoom(roomId: string): Promise<void>;
     getSeats(roomId: string): Promise<CoworkSeatInfo[]>;
+    recoverRoom(roomId: string): Promise<CoworkRoomInfo>;
 }
 export declare class CoworkUnavailableError extends Error {
-    constructor(message?: string);
+    constructor(message?: string, options?: ErrorOptions);
 }
 export declare class CoworkProtocolError extends Error {
     readonly operation: string;
-    constructor(operation: string, message: string);
+    readonly code: string;
+    constructor(operation: string, message: string, code?: string, options?: ErrorOptions);
 }
-/**
- * Fail-closed stub adapter. Every method throws CoworkUnavailableError.
- * This is the correct behavior until the Cowork management socket
- * integration is verified against the prerelease wire format.
- */
-export declare function createStubAdapter(): CoworkAdapter;
+export interface CoworkAdapterOptions {
+    configPath?: string;
+    socketPath?: string;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+    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;