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

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "0.19.0-nightly.2",
-  "buildId": "13880d55bd06",
-  "commit": "ccf83082de238e6dc8ddb1bc557d2b7ffc7e816f",
+  "version": "0.19.0-nightly.3",
+  "buildId": "c969df19c5f2",
+  "commit": "1cfdb94ec5bc493c83c72f62dd70c669c78b9e68",
   "dirty": true,
-  "builtAt": "2026-08-23T08:33:08.792Z",
+  "builtAt": "2026-08-23T10:19:42.625Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/config.d.ts

@@ -170,6 +170,12 @@ export interface FleetConfig {
     tasks?: import('./rooms-tasks/types.js').TasksConfig;
     /** SHA-256 fingerprint of the resolved owner invite (never the invite itself). */
     ownerInviteFingerprint?: string;
+    /**
+     * Resolved owner invite for immediate private-IPC use only. This property is
+     * deliberately non-enumerable so config dumps and JSON output cannot expose
+     * the bearer credential.
+     */
+    ownerInvite?: string;
 }
 export declare class ConfigError extends Error {
 }

package/dist/config.js

@@ -276,6 +276,7 @@ export function loadConfig(configPath, options = {}) {
     // top-level (room_templates merge by name, last writer wins).
     let rooms;
     let ownerInviteFingerprint;
+    let ownerInvite;
     let roomTemplates;
     let tasks;
     for (const { file, doc } of docs) {
@@ -284,6 +285,7 @@ export function loadConfig(configPath, options = {}) {
                 throw new ConfigError(`rooms: defined in multiple files; last: ${file}`);
             const validated = validateRoomsConfig(deepSub(doc.rooms, vars), vars, file);
             ownerInviteFingerprint = validated._invite?.fingerprint;
+            ownerInvite = validated._invite?.value;
             const { _invite: _, ...clean } = validated;
             rooms = clean;
         }
@@ -297,11 +299,20 @@ export function loadConfig(configPath, options = {}) {
             tasks = validateTasksConfig(deepSub(doc.tasks, vars), file);
         }
     }
-    return {
+    const result = {
         roles, vars, defaults, files, startStaggerMs, diagnostics, watchdogs,
         loops: resolvedLoops.loops,
         rooms, roomTemplates, tasks, ownerInviteFingerprint,
     };
+    if (ownerInvite !== undefined) {
+        Object.defineProperty(result, 'ownerInvite', {
+            value: ownerInvite,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+    }
+    return result;
 }
 /**
  * Canonical form of a 64-hex container ID for authorization decisions. Hex

package/dist/rooms-tasks/cli.js

@@ -1,8 +1,9 @@
 import { readFileSync } from 'node:fs';
-import { loadConfig } from '../config.js';
+import { loadConfig, ConfigError } from '../config.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, blockTask, unblockTask, reviewTask, completeTask, cancelTask, updateTaskRoom, } from './task-state.js';
+import { createRoomRecord, getRoomRecord, listRoomRecords, closeRoom as closeRoomRecord, advanceSaga, setOwnerSeat, setSagaError, } 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 +15,64 @@ 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;
+        }
+    }
+    return advanceSaga(record.room_id, 'create_members', 3);
+}
 export function registerTemplateCommands(parent, cOpt) {
     const templateCmd = parent.command('template').description('room template operations');
     cOpt(templateCmd.command('list'))
@@ -114,7 +173,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 +197,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 +206,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 +305,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;
@@ -382,13 +480,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 +493,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 +511,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 +536,144 @@ 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}`);
             }
-            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}`);
+            if (r)
+                console.log(`Tracked by Fleet since: ${r.created_at}`);
         }
         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 (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;

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

@@ -1,48 +1,272 @@
 /**
- * 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 { 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') {
-        super(message);
+    constructor(message = 'Cowork management socket is not reachable', options) {
+        super(message, options);
+        this.name = 'CoworkUnavailableError';
     }
 }
 export class CoworkProtocolError extends Error {
     operation;
-    constructor(operation, message) {
-        super(`cowork ${operation}: ${message}`);
+    code;
+    constructor(operation, message, code = 'protocol_error', options) {
+        super(`cowork ${operation}: ${message}`, options);
         this.operation = operation;
+        this.code = code;
+        this.name = 'CoworkProtocolError';
     }
 }
-/**
- * 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 function createStubAdapter() {
-    const unavailable = (op) => {
-        throw new CoworkUnavailableError(`Cowork adapter not yet connected: ${op}. ` +
-            'Blocker: Cowork management socket wire format must be verified against ours-cowork/prerelease.');
+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() { return false; },
-        async createRoom() { return unavailable('createRoom'); },
-        async acceptInvite() { return unavailable('acceptInvite'); },
-        async issueInvite() { return unavailable('issueInvite'); },
-        async acceptAsIdentity() { return unavailable('acceptAsIdentity'); },
-        async getRoom() { return unavailable('getRoom'); },
-        async listRooms() { return unavailable('listRooms'); },
-        async closeRoom() { return unavailable('closeRoom'); },
-        async getSeats() { return unavailable('getSeats'); },
+        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/room-state.d.ts

@@ -5,6 +5,7 @@ export declare class RoomStateError extends Error {
 export interface CreateRoomInput {
     room_id: string;
     room_name: string;
+    room_identity_cid?: string;
     task_id?: string;
     template_snapshot?: import('./types.js').TemplateSnapshot;
 }

package/dist/rooms-tasks/room-state.js

@@ -23,6 +23,7 @@ export function createRoomRecord(input) {
     const record = {
         room_id: input.room_id,
         room_name: input.room_name,
+        room_identity_cid: input.room_identity_cid,
         task_id: input.task_id,
         template_snapshot: input.template_snapshot,
         saga: { phase: 'persist_intent', step_index: 0 },

package/package.json

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