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

package/dist/owner-channel/commands.js

@@ -1,4 +1,5 @@
 import { execFile, spawn } from 'node:child_process';
+import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
 import { OWNER_COMMENT_LABEL, ownerNotices } from './notices.js';
 /** A malformed invocation; the dispatcher answers it with annotated help. */
 class OwnerCommandUsageError extends Error {
@@ -142,6 +143,396 @@ export const ownerCommands = [
         name: 'version', summary: 'report the fleet version',
         execute: noArgs('/version', async (ctx) => ctx.reply(`ℹ️ ours-fleet ${ctx.version}`)),
     },
+    {
+        name: 'tasks', usage: '/tasks [state]',
+        summary: 'list tasks (optionally filter by state)',
+        execute: async (ctx, args) => {
+            const { listTasks } = await import('../rooms-tasks/task-state.js');
+            const stateFilter = args?.trim() || undefined;
+            const tasks = listTasks(stateFilter && stateFilter !== 'all' ? { state: stateFilter } : undefined);
+            if (!tasks.length)
+                return ctx.reply('📋 No tasks.');
+            const lines = tasks.map(t => {
+                const blocked = t.blocked ? ` [BLOCKED: ${t.blocked.reason}]` : '';
+                return `${t.task_id}  ${t.state}${blocked}  ${t.title}`;
+            });
+            await ctx.reply(tail(`📋 Tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+        },
+    },
+    {
+        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 <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}`,
+                    `State: ${t.state}${t.blocked ? ` [BLOCKED: ${t.blocked.reason}]` : ''}`,
+                    ...(t.template ? [`Template: ${t.template.name}@${t.template.version}`] : []),
+                    ...(t.room_id ? [`Room: ${t.room_id}`] : []),
+                    `Origin: ${t.origin.type}`,
+                    `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 summary = rest.slice(1).join(' ') || undefined;
+                        await ctx.terminalTask(rest[0], 'done', summary ? { summary } : undefined);
+                        break;
+                    }
+                    case 'cancel': {
+                        if (rest.length < 2 || rest[0] !== rest[1])
+                            throw new OwnerCommandUsageError('destructive: /task cancel <id> <id> — provide the task ID twice');
+                        await ctx.terminalTask(rest[0], '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]);
+                        if (t.terminal_intent?.status === 'pending') {
+                            await ctx.terminalTask(t.task_id, t.terminal_intent.kind, t.terminal_intent.outcome);
+                            break;
+                        }
+                        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)}`);
+            }
+        },
+    },
+    {
+        name: 'rooms', summary: 'list rooms',
+        execute: noArgs('/rooms', async (ctx) => {
+            const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
+            const rooms = listRoomRecords();
+            if (!rooms.length)
+                return ctx.reply('🏠 No rooms.');
+            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));
+        }),
+    },
+    {
+        name: 'room',
+        usage: '/room <create|list|show|close|recover> ...',
+        summary: 'room lifecycle subcommands',
+        execute: async (ctx, args) => {
+            if (!args)
+                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');
+                        await ctx.closeRoom(rest[0]);
+                        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;
+                        }
+                        if (r.state === 'closing') {
+                            await ctx.closeRoom(r.room_id);
+                            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', aliases: ['template-list'],
+        summary: 'list available room templates',
+        execute: noArgs('/templates', async (ctx) => {
+            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')}`);
+        }),
+    },
+    {
+        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('/');
@@ -195,5 +586,7 @@ export function fleetCliOps(role, configPath) {
         list: () => new Promise((resolve, reject) => {
             execFile(process.execPath, [process.argv[1], 'ls'], { timeout: 15_000, maxBuffer: 256 * 1024 }, (error, stdout) => error ? reject(error) : resolve(String(stdout).trim()));
         }),
+        closeRoom: roomId => launchFleetWorker(['room', '_close', roomId], `room-close-${roomId}`, configPath),
+        settleTask: taskId => launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, configPath),
     };
 }

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

@@ -0,0 +1,4 @@
+import type { Command } from 'commander';
+export declare function registerTemplateCommands(parent: Command, cOpt: (cmd: Command) => Command): void;
+export declare function registerTaskCommands(parent: Command, cOpt: (cmd: Command) => Command): void;
+export declare function registerRoomCommands(parent: Command, cOpt: (cmd: Command) => Command): void;