@ours.network/fleet 1.0.2 → 1.0.4

package/dist/owner-channel/commands.js

@@ -4,6 +4,7 @@ import { RoomStateError } from '../rooms-tasks/room-state.js';
 import { TaskStateError } from '../rooms-tasks/task-state.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from '../rooms-tasks/markdown.js';
 import { OWNER_COMMENT_LABEL, ownerNotices } from './notices.js';
+import { TaskRoomApplicationError } from '../application/task-room-service.js';
 /** A malformed invocation; the dispatcher answers it with annotated help. */
 class OwnerCommandUsageError extends Error {
 }
@@ -53,6 +54,12 @@ function ownerTaskFailure(error) {
     };
 }
 function ownerRoomFailure(error) {
+    if (error instanceof TaskRoomApplicationError
+        && (error.code === 'room_not_found' || error.code === 'room_record_not_found'))
+        return {
+            kind: 'not_found', detail: `Room ${error.fields.room} was not found.`,
+            action: 'Run /room list to find a valid room ID.',
+        };
     if (error instanceof RoomStateError) {
         const missing = /^room not found: ([A-Za-z0-9_-]{1,128})$/u.exec(error.message);
         if (missing)
@@ -228,9 +235,8 @@ export const ownerCommands = [
         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);
+            const tasks = ctx.listTasks(stateFilter && stateFilter !== 'all' ? { state: stateFilter } : undefined);
             await ctx.reply(renderMarkdownList({
                 icon: '📋', title: 'Tasks', empty: 'No tasks found.',
                 records: tasks.map(taskListRecord),
@@ -250,8 +256,7 @@ export const ownerCommands = [
             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 { task: t } = ctx.getTask(id);
                 await ctx.reply(renderMarkdownResult({
                     icon: '📋', title: 'Task details',
                     fields: [
@@ -278,14 +283,9 @@ export const ownerCommands = [
                         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 t = await ctx.createTask({
+                            title: titleParts.join(' '), origin: { type: 'owner_channel' },
+                            backlog, template, noRoom, brief: trailingLines,
                         });
                         await ctx.reply(taskAction('Task created', t, [
                             { label: 'Title', value: t.title },
@@ -295,7 +295,6 @@ export const ownerCommands = [
                         break;
                     }
                     case 'list': {
-                        const { listTasks } = await import('../rooms-tasks/task-state.js');
                         const filter = rest[0];
                         const stateMap = {
                             backlog: 'backlog', active: 'active', blocked: 'active',
@@ -304,7 +303,7 @@ export const ownerCommands = [
                         const stateFilter = filter && stateMap[filter]
                             ? { state: stateMap[filter] }
                             : undefined;
-                        const tasks = listTasks(stateFilter);
+                        const tasks = ctx.listTasks(stateFilter);
                         if (filter === 'blocked') {
                             const blocked = tasks.filter(t => t.blocked);
                             await ctx.reply(renderMarkdownList({
@@ -328,33 +327,29 @@ export const ownerCommands = [
                     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]);
+                        const t = await ctx.startTask(rest[0]);
                         await ctx.reply(taskAction('Task started', t));
                         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);
+                        const t = ctx.blockTask(rest[0], reason);
                         await ctx.reply(taskAction('Task blocked', t, [{ label: 'Reason', value: 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]);
+                        const t = ctx.unblockTask(rest[0]);
                         await ctx.reply(taskAction('Task unblocked', t));
                         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]);
+                        const t = ctx.reviewTask(rest[0]);
                         await ctx.reply(taskAction('Task ready for review', t));
                         break;
                     }
@@ -374,8 +369,7 @@ export const ownerCommands = [
                     case 'delete': {
                         if (rest.length !== 2 || rest[0] !== rest[1])
                             throw new OwnerCommandUsageError('destructive: /task delete <id> <id> — provide the task ID twice');
-                        const { deleteTask } = await import('../rooms-tasks/task-state.js');
-                        const deleted = deleteTask(rest[0]);
+                        const deleted = ctx.deleteTask(rest[0]);
                         await ctx.reply(renderMarkdownResult({
                             icon: '🗑️', title: deleted ? 'Task deleted' : 'Task already absent',
                             fields: [{ label: 'ID', value: rest[0], kind: 'code' }],
@@ -385,40 +379,7 @@ export const ownerCommands = [
                     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}`);
-                        }
-                        await ctx.reply(renderMarkdownResult({
-                            icon: '🛟', title: 'Task recovery',
-                            fields: [
-                                { label: 'Task', value: t.task_id, kind: 'code' },
-                                { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
-                                ...(room ? [
-                                    { label: 'Room', value: room.room_id, kind: 'code' },
-                                    { label: 'Room status', value: roomStatus(room.state), kind: 'markdown' },
-                                    { label: 'Saga', value: room.saga.phase, kind: 'code' },
-                                ] : []),
-                            ],
-                            sections: hints.length
-                                ? [{ heading: 'Next steps', items: hints }]
-                                : [{ heading: 'Result', items: ['No automated recovery action is available.'] }],
-                        }));
+                        await ctx.recoverTask(rest[0]);
                         break;
                     }
                     default:
@@ -442,11 +403,11 @@ export const ownerCommands = [
     {
         name: 'rooms', summary: 'list rooms',
         execute: noArgs('/rooms', async (ctx) => {
-            const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
-            const rooms = listRoomRecords().filter(room => room.state === 'active' || room.state === 'provisioning');
+            const rooms = await ctx.listRoomQueries();
             await ctx.reply(renderMarkdownList({
                 icon: '🏠', title: 'Rooms', empty: 'No rooms found.',
-                records: rooms.map(roomListRecord),
+                records: rooms.map(room => `${roomStatus(room.state)} ${markdownCode(room.room_id)} — ${markdownProse(room.room_name)}`
+                    + (room.orchestration?.task_id ? ` — Task ${markdownCode(room.orchestration.task_id)}` : '')),
             }));
         }),
     },
@@ -463,24 +424,28 @@ export const ownerCommands = [
             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 || r.state === 'closing' || r.state === 'closed')
-                    return ctx.reply(renderMarkdownFailure({
-                        kind: 'not_found', subject: `/room show ${id}`,
-                        detail: `Room ${id} was not found.`, action: 'Run /room list to find a valid room ID.',
-                    }));
+                let detail;
+                try {
+                    detail = await ctx.getRoomQuery(id);
+                }
+                catch (error) {
+                    if (!(error instanceof TaskRoomApplicationError && error.code === 'room_not_found'))
+                        throw error;
+                    return ctx.reply(renderMarkdownFailure({ kind: 'not_found', subject: `/room show ${id}`,
+                        detail: `Room ${id} was not found.`, action: 'Run /room list to find a valid room ID.' }));
+                }
+                const { room, orchestration: r } = detail;
                 await ctx.reply(renderMarkdownResult({
                     icon: '🏠', title: 'Room details',
                     fields: [
-                        { label: 'ID', value: r.room_id, kind: 'code' },
-                        { label: 'Name', value: r.room_name },
-                        { label: 'Status', value: roomStatus(r.state), kind: 'markdown' },
-                        { label: 'Saga', value: `${r.saga.phase} (step ${r.saga.step_index})` },
-                        ...(r.task_id ? [{ label: 'Task', value: r.task_id, kind: 'code' }] : []),
-                        ...(r.provisioning_detail ? [{ label: 'Detail', value: r.provisioning_detail }] : []),
-                        ...(r.saga.error ? [{ label: 'Last error', value: 'Provisioning failure recorded; inspect role logs.' }] : []),
-                        { label: 'Created', value: r.created_at, kind: 'code' },
+                        { label: 'ID', value: room.room_id, kind: 'code' },
+                        { label: 'Name', value: room.room_name },
+                        { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
+                        ...(r ? [{ label: 'Saga', value: `${r.saga.phase} (step ${r.saga.step_index})` }] : []),
+                        ...(r?.task_id ? [{ label: 'Task', value: r.task_id, kind: 'code' }] : []),
+                        ...(r?.provisioning_detail ? [{ label: 'Detail', value: r.provisioning_detail }] : []),
+                        ...(r?.saga.error ? [{ label: 'Last error', value: 'Provisioning failure recorded; inspect role logs.' }] : []),
+                        ...(r ? [{ label: 'Created', value: r.created_at, kind: 'code' }] : []),
                     ],
                 }));
             };
@@ -492,22 +457,16 @@ export const ownerCommands = [
                         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)
+                        let r;
+                        try {
+                            r = await ctx.createRoom({ name: nameParts.join(' '), template: templateName,
+                                goal: roomTrailingLines });
+                        }
+                        catch (error) {
+                            if (error instanceof TaskRoomApplicationError && error.code === 'template_not_found')
                                 throw new OwnerCommandUsageError(`unknown template: ${templateName}`);
-                            templateSnapshot = snapshotTemplate(tpl);
+                            throw error;
                         }
-                        const r = createRoomRecord({
-                            room_id: randomUUID().replace(/-/g, '').slice(0, 16),
-                            room_name: nameParts.join(' '),
-                            ...(templateSnapshot ? { template_snapshot: templateSnapshot } : {}),
-                            ...(roomTrailingLines ? { goal: roomTrailingLines } : {}),
-                        });
                         await ctx.reply(roomAction('Room created', r, [
                             { label: 'Name', value: r.room_name },
                             ...(templateName ? [{ label: 'Template', value: templateName, kind: 'code' }] : []),
@@ -515,14 +474,14 @@ export const ownerCommands = [
                         break;
                     }
                     case 'list': {
-                        const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
                         const filter = rest[0];
-                        let rooms = listRoomRecords().filter(room => room.state === 'active' || room.state === 'provisioning');
-                        if (filter === 'active')
-                            rooms = rooms.filter(r => r.state === 'active');
+                        if (filter && !['active', 'provisioning', 'all'].includes(filter))
+                            throw new OwnerCommandUsageError('usage: /room list [active|provisioning|all]');
+                        const rooms = await ctx.listRoomQueries(filter === 'active' || filter === 'provisioning' ? { state: filter } : undefined);
                         await ctx.reply(renderMarkdownList({
                             icon: '🏠', title: 'Rooms', empty: 'No rooms found.',
-                            records: rooms.map(roomListRecord),
+                            records: rooms.map(room => `${roomStatus(room.state)} ${markdownCode(room.room_id)} — ${markdownProse(room.room_name)}`
+                                + (room.orchestration?.task_id ? ` — Task ${markdownCode(room.orchestration.task_id)}` : '')),
                         }));
                         break;
                     }
@@ -542,32 +501,7 @@ export const ownerCommands = [
                     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(renderMarkdownFailure({
-                                kind: 'not_found', subject: `/room recover ${rest[0]}`,
-                                detail: `Room ${rest[0]} was not found.`, action: 'Run /room list to find a valid room ID.',
-                            }));
-                            break;
-                        }
-                        if (r.state === 'closing' || r.state === 'closed') {
-                            await ctx.closeRoom(r.room_id);
-                            break;
-                        }
-                        await ctx.reply(renderMarkdownResult({
-                            icon: '🛟', title: 'Room recovery',
-                            fields: [
-                                { label: 'Room', value: r.room_id, kind: 'code' },
-                                { label: 'Status', value: roomStatus(r.state), kind: 'markdown' },
-                                { label: 'Saga', value: r.saga.phase, kind: 'code' },
-                                ...(r.saga.error ? [{ label: 'Last error', value: 'Provisioning failure recorded; inspect role logs.' }] : []),
-                                ...(r.provisioning_detail ? [{ label: 'Detail', value: r.provisioning_detail }] : []),
-                            ],
-                            sections: [{ heading: 'Next step', items: [r.saga.error
-                                            ? 'Run ours-fleet room recover from the CLI for full recovery.'
-                                            : 'No recovery action is needed.'] }],
-                        }));
+                        await ctx.recoverRoom(rest[0]);
                         break;
                     }
                     default:
@@ -592,8 +526,7 @@ export const ownerCommands = [
         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({});
+            const templates = ctx.listTemplateQueries();
             if (!templates.length)
                 return ctx.reply('📐 No templates.');
             const lines = templates.map(t => {
@@ -613,10 +546,15 @@ export const ownerCommands = [
             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)
+                let t;
+                try {
+                    t = ctx.getTemplateQuery(nameStr);
+                }
+                catch (error) {
+                    if (!(error instanceof TaskRoomApplicationError && error.code === 'template_not_found'))
+                        throw error;
                     return ctx.reply(`⚠️ template not found: ${nameStr}`);
+                }
                 const lines = [
                     `📐 Template: ${t.name}@${t.version}`,
                     `Description: ${t.description}`,
@@ -635,8 +573,7 @@ export const ownerCommands = [
                     break;
                 }
                 case 'list': {
-                    const { listTemplates } = await import('../rooms-tasks/templates.js');
-                    const templates = listTemplates({});
+                    const templates = ctx.listTemplateQueries();
                     if (!templates.length)
                         return ctx.reply('📐 No templates.');
                     const lines = templates.map(t => {
@@ -710,5 +647,6 @@ export function fleetCliOps(role, configPath) {
         }),
         closeRoom: roomId => launchFleetWorker(['room', '_delete', roomId], `room-delete-${roomId}`, configPath),
         settleTask: taskId => launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, configPath),
+        recoverTask: taskId => launchFleetWorker(['task', '_recover', taskId], `task-recover-${taskId}`, configPath),
     };
 }