@ours.network/fleet 0.19.0-nightly.13 → 0.19.0-nightly.14

package/dist/owner-channel/commands.js

@@ -1,11 +1,92 @@
 import { execFile, spawn } from 'node:child_process';
 import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
+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';
 /** A malformed invocation; the dispatcher answers it with annotated help. */
 class OwnerCommandUsageError extends Error {
 }
 const MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 const REPLY_MAX_CHARS = 3_500;
+const taskListRecord = (task) => `${taskStatus(task.state)} ${markdownCode(task.task_id)} — ${markdownProse(task.title)}`
+    + (task.blocked ? ` — 🚧 Blocked: ${markdownProse(task.blocked.reason)}` : '');
+const roomListRecord = (room) => `${roomStatus(room.state)} ${markdownCode(room.room_id)} — ${markdownProse(room.room_name)}`
+    + (room.task_id ? ` — Task ${markdownCode(room.task_id)}` : '');
+const TASK_STATE_WORD = '(?:backlog|provisioning|active|review|done|cancelled|failed)';
+const SAFE_ID_WORD = '[A-Za-z0-9_-]{1,128}';
+function isKnownOwnerTaskState(message) {
+    return [
+        new RegExp(`^cannot transition from '${TASK_STATE_WORD}' to '${TASK_STATE_WORD}'$`, 'u'),
+        new RegExp(`^task ${SAFE_ID_WORD} has a pending '(?:done|cancelled)' terminal intent$`, 'u'),
+        new RegExp(`^cannot (?:block|cancel) a '${TASK_STATE_WORD}' task$`, 'u'),
+        /^task is not blocked$/u,
+        new RegExp(`^task ${SAFE_ID_WORD} already has a conflicting '(?:done|cancelled)' terminal intent$`, 'u'),
+        new RegExp(`^task ${SAFE_ID_WORD} is already in terminal state '${TASK_STATE_WORD}'$`, 'u'),
+        new RegExp(`^cannot delete a '${TASK_STATE_WORD}' task; only 'done' tasks can be deleted$`, 'u'),
+    ].some(pattern => pattern.test(message));
+}
+function isKnownOwnerRoomState(message) {
+    return [
+        new RegExp(`^room ${SAFE_ID_WORD} is not closing$`, 'u'),
+        new RegExp(`^room ${SAFE_ID_WORD} has no recorded member .{1,128}$`, 'u'),
+        new RegExp(`^room ${SAFE_ID_WORD} close cannot move backward to [A-Za-z_]+$`, 'u'),
+    ].some(pattern => pattern.test(message));
+}
+function ownerTaskFailure(error) {
+    if (error instanceof TaskStateError) {
+        const missing = /^task not found: ([A-Za-z0-9_-]{1,128})$/u.exec(error.message);
+        if (missing)
+            return {
+                kind: 'not_found', detail: `Task ${missing[1]} was not found.`,
+                action: 'Run /task list to find a valid task ID.',
+            };
+        if (isKnownOwnerTaskState(error.message))
+            return {
+                kind: 'state', detail: 'The current task state does not allow that action.',
+                action: 'Run /task show <id> to inspect the current task state.',
+            };
+    }
+    return {
+        kind: 'unexpected',
+        action: 'Retry once; if it repeats, inspect the role logs.',
+    };
+}
+function ownerRoomFailure(error) {
+    if (error instanceof RoomStateError) {
+        const missing = /^room not found: ([A-Za-z0-9_-]{1,128})$/u.exec(error.message);
+        if (missing)
+            return {
+                kind: 'not_found', detail: `Room ${missing[1]} was not found.`,
+                action: 'Run /room list to find a valid room ID.',
+            };
+        if (isKnownOwnerRoomState(error.message))
+            return {
+                kind: 'state', detail: 'The current room state does not allow that action.',
+                action: 'Run /room show <id> to inspect the current room state.',
+            };
+    }
+    return {
+        kind: 'unexpected',
+        action: 'Retry once; if it repeats, inspect the role logs.',
+    };
+}
+const taskAction = (title, task, fields = []) => renderMarkdownResult({
+    icon: '📋', title,
+    fields: [
+        { label: 'ID', value: task.task_id, kind: 'code' },
+        { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
+        ...fields,
+    ],
+});
+const roomAction = (title, room, fields = []) => renderMarkdownResult({
+    icon: '🏠', title,
+    fields: [
+        { label: 'ID', value: room.room_id, kind: 'code' },
+        { label: 'Status', value: roomStatus(room.state), kind: 'markdown' },
+        ...fields,
+    ],
+});
 const strip = (value, max) => String(value).replace(/[\u0000-\u001f\u007f]/g, ' ').slice(0, max);
 /** Like `strip`, but keeps newlines so multi-line listings stay readable. */
 const stripMultiline = (value, max) => String(value).replace(/[\u0000-\u0009\u000b-\u001f\u007f]/g, ' ').slice(0, max);
@@ -150,13 +231,10 @@ export const ownerCommands = [
             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));
+            await ctx.reply(renderMarkdownList({
+                icon: '📋', title: 'Tasks', empty: 'No tasks found.',
+                records: tasks.map(taskListRecord),
+            }));
         },
     },
     {
@@ -174,16 +252,19 @@ export const ownerCommands = [
             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'));
+                await ctx.reply(renderMarkdownResult({
+                    icon: '📋', title: 'Task details',
+                    fields: [
+                        { label: 'ID', value: t.task_id, kind: 'code' },
+                        { label: 'Title', value: t.title },
+                        { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
+                        ...(t.blocked ? [{ label: 'Blocked', value: t.blocked.reason }] : []),
+                        ...(t.template ? [{ label: 'Template', value: `${t.template.name}@${t.template.version}`, kind: 'code' }] : []),
+                        ...(t.room_id ? [{ label: 'Room', value: t.room_id, kind: 'code' }] : []),
+                        { label: 'Origin', value: t.origin.type },
+                        { label: 'Created', value: t.created_at, kind: 'code' },
+                    ],
+                }));
             };
             try {
                 switch (sub) {
@@ -206,12 +287,11 @@ export const ownerCommands = [
                             ...(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'));
+                        await ctx.reply(taskAction('Task created', t, [
+                            { label: 'Title', value: t.title },
+                            ...(template ? [{ label: 'Template', value: template, kind: 'code' }] : []),
+                            ...(noRoom ? [{ label: 'Room', value: 'Not requested' }] : []),
+                        ]));
                         break;
                     }
                     case 'list': {
@@ -227,20 +307,16 @@ export const ownerCommands = [
                         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.');
+                            await ctx.reply(renderMarkdownList({
+                                icon: '🚧', title: 'Blocked tasks', empty: 'No blocked tasks found.',
+                                records: blocked.map(taskListRecord),
+                            }));
                             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));
+                        await ctx.reply(renderMarkdownList({
+                            icon: '📋', title: 'Tasks', empty: 'No tasks found.',
+                            records: tasks.map(taskListRecord),
+                        }));
                         break;
                     }
                     case 'show': {
@@ -254,7 +330,7 @@ export const ownerCommands = [
                             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`);
+                        await ctx.reply(taskAction('Task started', t));
                         break;
                     }
                     case 'block': {
@@ -263,7 +339,7 @@ export const ownerCommands = [
                         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}`);
+                        await ctx.reply(taskAction('Task blocked', t, [{ label: 'Reason', value: reason }]));
                         break;
                     }
                     case 'unblock': {
@@ -271,7 +347,7 @@ export const ownerCommands = [
                             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`);
+                        await ctx.reply(taskAction('Task unblocked', t));
                         break;
                     }
                     case 'review': {
@@ -279,7 +355,7 @@ export const ownerCommands = [
                             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`);
+                        await ctx.reply(taskAction('Task ready for review', t));
                         break;
                     }
                     case 'done': {
@@ -300,9 +376,10 @@ export const ownerCommands = [
                             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]);
-                        await ctx.reply(deleted
-                            ? `🗑️ Task ${rest[0]} deleted from backlog`
-                            : `🗑️ Task ${rest[0]} already absent`);
+                        await ctx.reply(renderMarkdownResult({
+                            icon: '🗑️', title: deleted ? 'Task deleted' : 'Task already absent',
+                            fields: [{ label: 'ID', value: rest[0], kind: 'code' }],
+                        }));
                         break;
                     }
                     case 'recover': {
@@ -327,14 +404,21 @@ export const ownerCommands = [
                             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'));
+                        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.'] }],
+                        }));
                         break;
                     }
                     default:
@@ -345,7 +429,13 @@ export const ownerCommands = [
             catch (e) {
                 if (e instanceof OwnerCommandUsageError)
                     throw e;
-                await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
+                const failure = ownerTaskFailure(e);
+                await ctx.reply(renderMarkdownFailure({
+                    kind: failure.kind,
+                    subject: `/task ${sub}`,
+                    ...(failure.detail ? { detail: failure.detail } : {}),
+                    action: failure.action,
+                }));
             }
         },
     },
@@ -354,10 +444,10 @@ export const ownerCommands = [
         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');
-            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));
+            await ctx.reply(renderMarkdownList({
+                icon: '🏠', title: 'Rooms', empty: 'No rooms found.',
+                records: rooms.map(roomListRecord),
+            }));
         }),
     },
     {
@@ -376,18 +466,23 @@ export const ownerCommands = [
                 const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
                 const r = getRoomRecord(id);
                 if (!r || r.state === 'closing' || r.state === 'closed')
-                    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'));
+                    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.',
+                    }));
+                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' },
+                    ],
+                }));
             };
             try {
                 switch (sub) {
@@ -413,10 +508,10 @@ export const ownerCommands = [
                             ...(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'));
+                        await ctx.reply(roomAction('Room created', r, [
+                            { label: 'Name', value: r.room_name },
+                            ...(templateName ? [{ label: 'Template', value: templateName, kind: 'code' }] : []),
+                        ]));
                         break;
                     }
                     case 'list': {
@@ -425,12 +520,10 @@ export const ownerCommands = [
                         let rooms = listRoomRecords().filter(room => room.state === 'active' || room.state === 'provisioning');
                         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));
+                        await ctx.reply(renderMarkdownList({
+                            icon: '🏠', title: 'Rooms', empty: 'No rooms found.',
+                            records: rooms.map(roomListRecord),
+                        }));
                         break;
                     }
                     case 'show': {
@@ -452,20 +545,29 @@ export const ownerCommands = [
                         const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
                         const r = getRoomRecord(rest[0]);
                         if (!r) {
-                            await ctx.reply(`⚠️ room not found: ${rest[0]}`);
+                            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;
                         }
-                        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'));
+                        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.'] }],
+                        }));
                         break;
                     }
                     default:
@@ -476,7 +578,13 @@ export const ownerCommands = [
             catch (e) {
                 if (e instanceof OwnerCommandUsageError)
                     throw e;
-                await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
+                const failure = ownerRoomFailure(e);
+                await ctx.reply(renderMarkdownFailure({
+                    kind: failure.kind,
+                    subject: `/room ${sub}`,
+                    ...(failure.detail ? { detail: failure.detail } : {}),
+                    action: failure.action,
+                }));
             }
         },
     },
@@ -575,7 +683,10 @@ export async function dispatchOwnerCommand(text, ctx) {
     }
     catch (error) {
         if (error instanceof OwnerCommandUsageError)
-            return ctx.reply(ownerCommandHelp(error.message));
+            return ctx.reply(renderMarkdownFailure({
+                kind: 'usage', subject: token, detail: error.message,
+                action: `Use ${command.usage ?? `/${command.name}`} or run /help.`,
+            }));
         // The failure notice carries no internal detail; the channel logs it.
         await ctx.reply(ownerNotices.commandFailed(command.usage ?? `/${command.name}`));
         throw error;