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

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "0.19.0-nightly.3",
-  "buildId": "c969df19c5f2",
-  "commit": "1cfdb94ec5bc493c83c72f62dd70c669c78b9e68",
+  "version": "0.19.0-nightly.4",
+  "buildId": "27ab2ac6d2c0",
+  "commit": "0213a2667a2d24e14297f7364f42880997451742",
   "dirty": true,
-  "builtAt": "2026-08-23T10:19:42.625Z",
+  "builtAt": "2026-08-23T12:52:41.918Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/doctor.js

@@ -106,6 +106,126 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 ok: true,
                 detail: `warning: ${diagnostic.message}`,
             });
+    // ── Rooms/tasks checks (§5.3) ────────────────────────────────────────
+    if (loaded.ok && loaded.rooms) {
+        const rooms = loaded.rooms;
+        // Cowork socket reachability
+        const coworkConfig = rooms.cowork?.config;
+        try {
+            const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
+            const adapter = createCoworkAdapter({ configPath: coworkConfig });
+            const reachable = await adapter.available();
+            checks.push({
+                name: 'cowork', ok: reachable,
+                detail: reachable
+                    ? 'management socket reachable'
+                    : `management socket unreachable${coworkConfig ? ` (config: ${coworkConfig})` : ''}`,
+            });
+        }
+        catch (e) {
+            checks.push({
+                name: 'cowork', ok: false,
+                detail: `management socket error${coworkConfig ? ` (config: ${coworkConfig})` : ''}: ${e?.message ?? e}`,
+            });
+        }
+        // Owner CID shape
+        const cidOk = /^[0-9a-fA-F]{64}$/.test(rooms.owner.expected_cid);
+        checks.push({
+            name: 'rooms: owner CID', ok: cidOk,
+            detail: cidOk ? 'valid 64-hex CID' : `invalid CID shape: ${rooms.owner.expected_cid.slice(0, 16)}...`,
+        });
+        // Invite presence (never content)
+        checks.push({
+            name: 'rooms: owner invite',
+            ok: !!loaded.ownerInviteFingerprint,
+            detail: loaded.ownerInviteFingerprint
+                ? `present (fingerprint: ${loaded.ownerInviteFingerprint.slice(0, 12)}...)`
+                : 'not configured — room owner attachment will use waiting_owner_invite',
+        });
+        // Template validity and referenced role validity
+        const { listTemplates, resolveTemplate } = await import('./rooms-tasks/templates.js');
+        const customs = loaded.roomTemplates ?? {};
+        const templates = listTemplates(customs);
+        const roleNames = new Set(roles.map(r => r.name));
+        for (const t of templates) {
+            const badRefs = t.members
+                .filter(m => m.role_ref && !roleNames.has(m.role_ref))
+                .map(m => m.role_ref);
+            if (badRefs.length) {
+                checks.push({
+                    name: `template: ${t.name}@${t.version}`,
+                    ok: true,
+                    detail: `warning: role_ref(s) ${badRefs.join(', ')} not found in configured roles`,
+                });
+            }
+        }
+        // Default template validity
+        const defaultTemplate = loaded.rooms.defaults?.template
+            ?? loaded.tasks?.default_room_template;
+        if (defaultTemplate) {
+            const resolved = resolveTemplate(defaultTemplate, customs);
+            checks.push({
+                name: 'rooms: default template',
+                ok: !!resolved,
+                detail: resolved
+                    ? `${resolved.name}@${resolved.version}`
+                    : `template '${defaultTemplate}' not found`,
+            });
+        }
+        // Shared-daemon selection coherence
+        if (rooms.cowork?.config) {
+            const { existsSync: exists } = await import('node:fs');
+            const configOk = exists(rooms.cowork.config);
+            checks.push({
+                name: 'rooms: cowork config', ok: configOk,
+                detail: configOk
+                    ? `cowork config at ${rooms.cowork.config}`
+                    : `cowork config not found: ${rooms.cowork.config}`,
+            });
+        }
+        // Hard prerelease capability check
+        try {
+            const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
+            const adapter = createCoworkAdapter({ configPath: coworkConfig });
+            const roomList = await adapter.listRooms();
+            checks.push({
+                name: 'rooms: capability', ok: true,
+                detail: `cowork room management operational (${roomList.length} room(s))`,
+            });
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            const isProto = msg.includes('protocol') || msg.includes('invalid');
+            checks.push({
+                name: 'rooms: capability', ok: false,
+                detail: isProto
+                    ? `cowork does not support room management protocol — upgrade ours-cowork to prerelease`
+                    : `room management check failed: ${msg}`,
+            });
+        }
+        // Stale task/room warnings
+        try {
+            const { listTasks } = await import('./rooms-tasks/task-state.js');
+            const { listRoomRecords } = await import('./rooms-tasks/room-state.js');
+            const tasks = listTasks();
+            const roomRecords = listRoomRecords();
+            const roomIds = new Set(roomRecords.map(r => r.room_id));
+            const taskIds = new Set(tasks.map(t => t.task_id));
+            const orphanedTasks = tasks.filter(t => t.room_id && !roomIds.has(t.room_id));
+            const orphanedRooms = roomRecords.filter(r => r.task_id && !taskIds.has(r.task_id));
+            if (orphanedTasks.length)
+                checks.push({
+                    name: 'rooms: stale tasks', ok: true,
+                    detail: `warning: ${orphanedTasks.length} task(s) reference missing rooms: ${orphanedTasks.map(t => t.task_id).join(', ')}`,
+                });
+            if (orphanedRooms.length)
+                checks.push({
+                    name: 'rooms: stale rooms', ok: true,
+                    detail: `warning: ${orphanedRooms.length} room(s) reference missing tasks: ${orphanedRooms.map(r => r.room_id).join(', ')}`,
+                });
+        }
+        catch { /* state dir may not exist yet */ }
+    }
     if (roles.length === 0 || roles.some(role => (role.session ?? 'tmux') === 'tmux')) {
         const tmux = await exec('tmux', ['-V']);
         checks.push({
@@ -405,7 +525,11 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
 function loadConfigResult(configPath, yamlMode) {
     try {
         const cfg = loadConfig(configPath, { yamlMode });
-        return { ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics };
+        return {
+            ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics,
+            rooms: cfg.rooms, roomTemplates: cfg.roomTemplates, tasks: cfg.tasks,
+            ownerInviteFingerprint: cfg.ownerInviteFingerprint,
+        };
     }
     catch (e) {
         return { ok: false, error: e instanceof Error ? e.message : String(e) };

package/dist/owner-channel/commands.js

@@ -159,14 +159,20 @@ export const ownerCommands = [
         },
     },
     {
-        name: 'task', usage: '/task <id>',
-        summary: 'show task details',
+        name: 'task',
+        usage: '/task <create|list|show|start|block|unblock|review|done|cancel|recover> ...',
+        summary: 'task lifecycle subcommands',
         execute: async (ctx, args) => {
             if (!args)
-                throw new OwnerCommandUsageError('usage: /task <id>');
-            const { getTask } = await import('../rooms-tasks/task-state.js');
-            try {
-                const t = getTask(args.trim());
+                throw new OwnerCommandUsageError('usage: /task <subcommand> <id>');
+            const argLines = args.trim().split('\n');
+            const firstLineTokens = argLines[0].trim().split(/\s+/);
+            const sub = firstLineTokens[0];
+            const rest = firstLineTokens.slice(1);
+            const trailingLines = argLines.slice(1).join('\n').trim() || undefined;
+            const showTask = async (id) => {
+                const { getTask } = await import('../rooms-tasks/task-state.js');
+                const t = getTask(id);
                 const lines = [
                     `📋 Task: ${t.task_id}`,
                     `Title: ${t.title}`,
@@ -177,8 +183,157 @@ export const ownerCommands = [
                     `Created: ${t.created_at}`,
                 ];
                 await ctx.reply(lines.join('\n'));
+            };
+            try {
+                switch (sub) {
+                    case 'create': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task create [--backlog] [--template=<name>|--no-room] <title>');
+                        const backlog = rest.includes('--backlog');
+                        const tplFlag = rest.find(r => r.startsWith('--template='));
+                        const template = tplFlag ? tplFlag.slice('--template='.length) : undefined;
+                        const noRoom = rest.includes('--no-room');
+                        const titleParts = rest.filter(r => r !== '--backlog' && !r.startsWith('--template=') && r !== '--no-room');
+                        if (!titleParts.length)
+                            throw new OwnerCommandUsageError('usage: /task create [--backlog] [--template=<name>|--no-room] <title>');
+                        const { createTask } = await import('../rooms-tasks/task-state.js');
+                        const t = createTask({
+                            title: titleParts.join(' '),
+                            origin: { type: 'owner_channel' },
+                            start: !backlog,
+                            ...(template ? { template: { name: template, version: 1, content_hash: '' } } : {}),
+                            ...(noRoom ? { no_room: true } : {}),
+                            ...(trailingLines ? { brief: trailingLines } : {}),
+                        });
+                        const lines = [`Task ${t.task_id} created · ${t.state}`];
+                        if (template)
+                            lines.push(`Template: ${template}`);
+                        if (noRoom)
+                            lines.push('No room requested');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    case 'list': {
+                        const { listTasks } = await import('../rooms-tasks/task-state.js');
+                        const filter = rest[0];
+                        const stateMap = {
+                            backlog: 'backlog', active: 'active', blocked: 'active',
+                            done: 'done', all: ['backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'],
+                        };
+                        const stateFilter = filter && stateMap[filter]
+                            ? { state: stateMap[filter] }
+                            : undefined;
+                        const tasks = listTasks(stateFilter);
+                        if (filter === 'blocked') {
+                            const blocked = tasks.filter(t => t.blocked);
+                            if (!blocked.length) {
+                                await ctx.reply('📋 No blocked tasks.');
+                                break;
+                            }
+                            const lines = blocked.map(t => `${t.task_id}  ${t.state}  ${t.title}  [BLOCKED: ${t.blocked.reason}]`);
+                            await ctx.reply(tail(`📋 Blocked tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                            break;
+                        }
+                        if (!tasks.length) {
+                            await ctx.reply('📋 No tasks.');
+                            break;
+                        }
+                        const lines = tasks.map(t => `${t.task_id}  ${t.state}  ${t.title}${t.blocked ? ` [BLOCKED]` : ''}`);
+                        await ctx.reply(tail(`📋 Tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                        break;
+                    }
+                    case 'show': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task show <id>');
+                        await showTask(rest[0]);
+                        break;
+                    }
+                    case 'start': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task start <id>');
+                        const { startTask } = await import('../rooms-tasks/task-state.js');
+                        const t = startTask(rest[0]);
+                        await ctx.reply(`✅ Task ${t.task_id} → provisioning`);
+                        break;
+                    }
+                    case 'block': {
+                        if (!rest[0] || !rest[1])
+                            throw new OwnerCommandUsageError('usage: /task block <id> <reason>');
+                        const { blockTask } = await import('../rooms-tasks/task-state.js');
+                        const reason = rest.slice(1).join(' ');
+                        const t = blockTask(rest[0], reason);
+                        await ctx.reply(`🚧 Task ${t.task_id} blocked: ${reason}`);
+                        break;
+                    }
+                    case 'unblock': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task unblock <id>');
+                        const { unblockTask } = await import('../rooms-tasks/task-state.js');
+                        const t = unblockTask(rest[0]);
+                        await ctx.reply(`✅ Task ${t.task_id} unblocked`);
+                        break;
+                    }
+                    case 'review': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task review <id>');
+                        const { reviewTask } = await import('../rooms-tasks/task-state.js');
+                        const t = reviewTask(rest[0]);
+                        await ctx.reply(`📝 Task ${t.task_id} → review`);
+                        break;
+                    }
+                    case 'done': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task done <id> [summary]');
+                        const { completeTask } = await import('../rooms-tasks/task-state.js');
+                        const summary = rest.slice(1).join(' ') || undefined;
+                        const t = completeTask(rest[0], summary ? { summary } : undefined);
+                        await ctx.reply(`✅ Task ${t.task_id} → done`);
+                        break;
+                    }
+                    case 'cancel': {
+                        if (rest.length < 2 || rest[0] !== rest[1])
+                            throw new OwnerCommandUsageError('destructive: /task cancel <id> <id> — provide the task ID twice');
+                        const { cancelTask } = await import('../rooms-tasks/task-state.js');
+                        const t = cancelTask(rest[0]);
+                        await ctx.reply(`🗑️ Task ${t.task_id} → cancelled`);
+                        break;
+                    }
+                    case 'recover': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task recover <id>');
+                        const { getTask } = await import('../rooms-tasks/task-state.js');
+                        const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const t = getTask(rest[0]);
+                        const room = t.room_id ? getRoomRecord(t.room_id) : undefined;
+                        const hints = [];
+                        if (t.state === 'provisioning' && room) {
+                            if (room.provisioning_detail === 'waiting_cowork')
+                                hints.push('Cowork socket unreachable');
+                            if (room.provisioning_detail === 'waiting_owner_invite')
+                                hints.push('Owner invite missing or invalid');
+                            if (room.provisioning_detail === 'owner_cid_mismatch')
+                                hints.push('Owner CID mismatch');
+                            if (room.provisioning_detail === 'member_failed')
+                                hints.push(`Member failed at step ${room.saga.step_index}`);
+                        }
+                        const lines = [`Task ${t.task_id} · ${t.state}`];
+                        if (room)
+                            lines.push(`Room ${room.room_id} · ${room.state} · saga: ${room.saga.phase}`);
+                        if (hints.length)
+                            lines.push(`Hints: ${hints.join('; ')}`);
+                        else
+                            lines.push('No automated recovery actions available.');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    default:
+                        // bare /task <id> → show
+                        await showTask(sub);
+                }
             }
             catch (e) {
+                if (e instanceof OwnerCommandUsageError)
+                    throw e;
                 await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
             }
         },
@@ -195,30 +350,125 @@ export const ownerCommands = [
         }),
     },
     {
-        name: 'room', usage: '/room <id>',
-        summary: 'show room details',
+        name: 'room',
+        usage: '/room <create|list|show|close|recover> ...',
+        summary: 'room lifecycle subcommands',
         execute: async (ctx, args) => {
             if (!args)
-                throw new OwnerCommandUsageError('usage: /room <id>');
-            const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
-            const r = getRoomRecord(args.trim());
-            if (!r)
-                return ctx.reply(`⚠️ room not found: ${args.trim()}`);
-            const lines = [
-                `🏠 Room: ${r.room_id}`,
-                `Name: ${r.room_name}`,
-                `State: ${r.state}`,
-                `Saga: ${r.saga.phase} (step ${r.saga.step_index})`,
-                ...(r.task_id ? [`Task: ${r.task_id}`] : []),
-                ...(r.provisioning_detail ? [`Detail: ${r.provisioning_detail}`] : []),
-                ...(r.saga.error ? [`Error: ${r.saga.error}`] : []),
-                `Created: ${r.created_at}`,
-            ];
-            await ctx.reply(lines.join('\n'));
+                throw new OwnerCommandUsageError('usage: /room <subcommand> <id>');
+            const argLines = args.trim().split('\n');
+            const firstLineTokens = argLines[0].trim().split(/\s+/);
+            const sub = firstLineTokens[0];
+            const rest = firstLineTokens.slice(1);
+            const roomTrailingLines = argLines.slice(1).join('\n').trim() || undefined;
+            const showRoom = async (id) => {
+                const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                const r = getRoomRecord(id);
+                if (!r)
+                    return ctx.reply(`⚠️ room not found: ${id}`);
+                const lines = [
+                    `🏠 Room: ${r.room_id}`,
+                    `Name: ${r.room_name}`,
+                    `State: ${r.state}`,
+                    `Saga: ${r.saga.phase} (step ${r.saga.step_index})`,
+                    ...(r.task_id ? [`Task: ${r.task_id}`] : []),
+                    ...(r.provisioning_detail ? [`Detail: ${r.provisioning_detail}`] : []),
+                    ...(r.saga.error ? [`Error: ${r.saga.error}`] : []),
+                    `Created: ${r.created_at}`,
+                ];
+                await ctx.reply(lines.join('\n'));
+            };
+            try {
+                switch (sub) {
+                    case 'create': {
+                        const tplFlag = rest.find(r => r.startsWith('--template='));
+                        const templateName = tplFlag?.slice('--template='.length);
+                        const nameParts = rest.filter(r => !r.startsWith('--'));
+                        if (!nameParts.length)
+                            throw new OwnerCommandUsageError('usage: /room create --template=<name> <room name>');
+                        const { randomUUID } = await import('node:crypto');
+                        const { createRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const { resolveTemplate, snapshotTemplate } = await import('../rooms-tasks/templates.js');
+                        let templateSnapshot;
+                        if (templateName) {
+                            const tpl = resolveTemplate(templateName, {});
+                            if (!tpl)
+                                throw new OwnerCommandUsageError(`unknown template: ${templateName}`);
+                            templateSnapshot = snapshotTemplate(tpl);
+                        }
+                        const r = createRoomRecord({
+                            room_id: randomUUID().replace(/-/g, '').slice(0, 16),
+                            room_name: nameParts.join(' '),
+                            ...(templateSnapshot ? { template_snapshot: templateSnapshot } : {}),
+                            ...(roomTrailingLines ? { goal: roomTrailingLines } : {}),
+                        });
+                        const lines = [`🏠 Room ${r.room_id} created · ${r.state}`];
+                        if (templateName)
+                            lines.push(`Template: ${templateName}`);
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    case 'list': {
+                        const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
+                        const filter = rest[0];
+                        let rooms = listRoomRecords();
+                        if (filter === 'active')
+                            rooms = rooms.filter(r => r.state === 'active');
+                        if (!rooms.length) {
+                            await ctx.reply('🏠 No rooms.');
+                            break;
+                        }
+                        const lines = rooms.map(r => `${r.room_id}  ${r.state}  ${r.room_name}${r.task_id ? ` (task: ${r.task_id})` : ''}`);
+                        await ctx.reply(tail(`🏠 Rooms:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                        break;
+                    }
+                    case 'show': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /room show <id>');
+                        await showRoom(rest[0]);
+                        break;
+                    }
+                    case 'close': {
+                        if (rest.length < 2 || rest[0] !== rest[1])
+                            throw new OwnerCommandUsageError('destructive: /room close <id> <id> — provide the room ID twice');
+                        const { closeRoom } = await import('../rooms-tasks/room-state.js');
+                        const r = closeRoom(rest[0]);
+                        await ctx.reply(`🔒 Room ${r.room_id} → closed`);
+                        break;
+                    }
+                    case 'recover': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /room recover <id>');
+                        const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const r = getRoomRecord(rest[0]);
+                        if (!r) {
+                            await ctx.reply(`⚠️ room not found: ${rest[0]}`);
+                            break;
+                        }
+                        const lines = [`🏠 Room ${r.room_id} · ${r.state} · saga: ${r.saga.phase}`];
+                        if (r.saga.error)
+                            lines.push(`Error: ${r.saga.error}`);
+                        if (r.provisioning_detail)
+                            lines.push(`Detail: ${r.provisioning_detail}`);
+                        lines.push(r.saga.error ? 'Run `ours-fleet room recover` from CLI for full recovery.' : 'No recovery needed.');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    default:
+                        // bare /room <id> → show
+                        await showRoom(sub);
+                }
+            }
+            catch (e) {
+                if (e instanceof OwnerCommandUsageError)
+                    throw e;
+                await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
+            }
         },
     },
     {
-        name: 'templates', summary: 'list available room templates',
+        name: 'templates', aliases: ['template-list'],
+        summary: 'list available room templates',
         execute: noArgs('/templates', async (ctx) => {
             const { listTemplates } = await import('../rooms-tasks/templates.js');
             const templates = listTemplates({});
@@ -231,6 +481,55 @@ export const ownerCommands = [
             await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
         }),
     },
+    {
+        name: 'template',
+        usage: '/template <show|list> <name[@version]>',
+        summary: 'template subcommands (show, list)',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /template show <name[@version]>');
+            const parts = args.trim().split(/\s+/);
+            const sub = parts[0];
+            const showTemplate = async (nameStr) => {
+                const { resolveTemplate } = await import('../rooms-tasks/templates.js');
+                const t = resolveTemplate(nameStr, {});
+                if (!t)
+                    return ctx.reply(`⚠️ template not found: ${nameStr}`);
+                const lines = [
+                    `📐 Template: ${t.name}@${t.version}`,
+                    `Description: ${t.description}`,
+                    ...(t.builtin ? ['Source: built-in'] : []),
+                    ...(t.contract ? [`Contract: ${t.contract}`] : []),
+                    'Members:',
+                    ...t.members.map(m => `  ${m.slot} (${m.role}) ×${m.count} → role_ref: ${m.role_ref}`),
+                ];
+                await ctx.reply(lines.join('\n'));
+            };
+            switch (sub) {
+                case 'show': {
+                    if (!parts[1])
+                        throw new OwnerCommandUsageError('usage: /template show <name[@version]>');
+                    await showTemplate(parts[1]);
+                    break;
+                }
+                case 'list': {
+                    const { listTemplates } = await import('../rooms-tasks/templates.js');
+                    const templates = listTemplates({});
+                    if (!templates.length)
+                        return ctx.reply('📐 No templates.');
+                    const lines = templates.map(t => {
+                        const tag = t.builtin ? ' (built-in)' : '';
+                        return `${t.name}@${t.version}${tag}  ${t.description}`;
+                    });
+                    await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
+                    break;
+                }
+                default:
+                    // bare /template <name> → show
+                    await showTemplate(sub);
+            }
+        },
+    },
 ];
 /** Trimmed slash-prefixed text is a command attempt and is never forwarded. */
 export const isOwnerCommandText = (text) => text.trim().startsWith('/');

package/dist/rooms-tasks/cli.js

@@ -1,8 +1,9 @@
 import { readFileSync } from 'node:fs';
 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, updateTaskRoom, } from './task-state.js';
-import { createRoomRecord, getRoomRecord, listRoomRecords, closeRoom as closeRoomRecord, advanceSaga, setOwnerSeat, setSagaError, } 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);
@@ -71,7 +72,25 @@ async function provisionRoom(cfg, input) {
             throw error;
         }
     }
-    return advanceSaga(record.room_id, 'create_members', 3);
+    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');
@@ -387,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;
@@ -409,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;
@@ -427,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 = {
@@ -448,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));
@@ -580,6 +645,27 @@ export function registerRoomCommands(parent, cOpt) {
             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(`Room ${id} — ${room.room_name}`);
+            console.log(`Local console: ${url}`);
+        }
+        catch (e) {
+            die(e);
+        }
+    });
     cOpt(roomCmd.command('members <id>'))
         .description('show room members')
         .option('--json', 'JSON output')
@@ -669,6 +755,30 @@ export function registerRoomCommands(parent, cOpt) {
                 actions.push('Check ours-cowork service status');
             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: cowork, orchestration: r ?? null, recovery_actions: actions }, null, 2));
                 return;

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

@@ -4,4 +4,5 @@ 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 { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './cli.js';

package/dist/rooms-tasks/index.js

@@ -4,4 +4,5 @@ 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 { 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,229 @@
+import { randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { attachOursClient, } from '@ours.network/sdk/client';
+import { advanceSaga, setSagaError, updateMemberSeats, activateRoom, getRoomRecord, closeRoom as closeRoomRecord, } from './room-state.js';
+import { activateTask, updateTaskMembers, failTask, } from './task-state.js';
+import { spawnTemp } from '../spawn.js';
+import { findRole } from '../config.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 = [];
+    // 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;
+    }
+    const 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;
+    for (const seat of room.member_seats) {
+        await removeMemberIdentity(seat.role_name);
+    }
+    if (input.closeCoworkRoom && input.cowork) {
+        try {
+            await input.cowork.closeRoom(input.roomId);
+        }
+        catch { /* best-effort */ }
+    }
+    closeRoomRecord(input.roomId);
+}

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;
+    goal?: 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,
+        goal: input.goal,
         room_identity_cid: input.room_identity_cid,
         task_id: input.task_id,
         template_snapshot: input.template_snapshot,

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

@@ -10,6 +10,7 @@ export interface CreateTaskInput {
     origin: TaskOrigin;
     idempotency_key?: string;
     start?: boolean;
+    no_room?: boolean;
     room_id?: string;
 }
 export declare function createTask(input: CreateTaskInput): TaskRecord;

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

@@ -50,6 +50,7 @@ export function createTask(input) {
         brief_file: input.brief_file,
         state,
         template: input.template,
+        no_room: input.no_room || undefined,
         room_id: input.room_id,
         member_roles: [],
         origin: input.origin,

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

@@ -39,6 +39,7 @@ export interface TaskRecord {
     state: TaskState;
     blocked?: TaskBlocked;
     template?: TaskTemplateRef;
+    no_room?: boolean;
     room_id?: string;
     room_identity_cid?: string;
     member_roles: TaskMemberRole[];
@@ -69,6 +70,7 @@ export interface RoomOrchestrationRecord {
     room_id: string;
     room_identity_cid?: string;
     room_name: string;
+    goal?: string;
     task_id?: string;
     template_snapshot?: TemplateSnapshot;
     saga: SagaCursor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.19.0-nightly.3",
+  "version": "0.19.0-nightly.4",
   "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",