@ours.network/fleet 0.19.0-nightly.9 → 1.0.0

package/dist/owner-channel/commands.js

@@ -1,10 +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);
@@ -149,18 +231,15 @@ 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),
+            }));
         },
     },
     {
         name: 'task',
-        usage: '/task <create|list|show|start|block|unblock|review|done|cancel|recover> ...',
+        usage: '/task <create|list|show|start|block|unblock|review|done|cancel|delete|recover> ...',
         summary: 'task lifecycle subcommands',
         execute: async (ctx, args) => {
             if (!args)
@@ -173,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) {
@@ -205,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': {
@@ -226,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': {
@@ -253,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': {
@@ -262,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': {
@@ -270,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': {
@@ -278,24 +355,31 @@ 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': {
                         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`);
+                        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');
-                        const { cancelTask } = await import('../rooms-tasks/task-state.js');
-                        const t = cancelTask(rest[0]);
-                        await ctx.reply(`🗑️ Task ${t.task_id} → cancelled`);
+                        await ctx.terminalTask(rest[0], 'cancelled');
+                        break;
+                    }
+                    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]);
+                        await ctx.reply(renderMarkdownResult({
+                            icon: '🗑️', title: deleted ? 'Task deleted' : 'Task already absent',
+                            fields: [{ label: 'ID', value: rest[0], kind: 'code' }],
+                        }));
                         break;
                     }
                     case 'recover': {
@@ -304,6 +388,10 @@ export const ownerCommands = [
                         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) {
@@ -316,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:
@@ -334,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,
+                }));
             }
         },
     },
@@ -342,16 +443,16 @@ 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();
-            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));
+            const rooms = listRoomRecords().filter(room => room.state === 'active' || room.state === 'provisioning');
+            await ctx.reply(renderMarkdownList({
+                icon: '🏠', title: 'Rooms', empty: 'No rooms found.',
+                records: rooms.map(roomListRecord),
+            }));
         }),
     },
     {
         name: 'room',
-        usage: '/room <create|list|show|close|recover> ...',
+        usage: '/room <create|list|show|delete|close|recover> ...',
         summary: 'room lifecycle subcommands',
         execute: async (ctx, args) => {
             if (!args)
@@ -364,19 +465,24 @@ export const ownerCommands = [
             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'));
+                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.',
+                    }));
+                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) {
@@ -402,24 +508,22 @@ 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': {
                         const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
                         const filter = rest[0];
-                        let rooms = listRoomRecords();
+                        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': {
@@ -428,12 +532,11 @@ export const ownerCommands = [
                         await showRoom(rest[0]);
                         break;
                     }
+                    case 'delete':
                     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`);
+                            throw new OwnerCommandUsageError(`destructive: /room ${sub} <id> <id> — provide the room ID twice`);
+                        await ctx.closeRoom(rest[0]);
                         break;
                     }
                     case 'recover': {
@@ -442,16 +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:
@@ -462,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,
+                }));
             }
         },
     },
@@ -561,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;
@@ -583,5 +708,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', '_delete', roomId], `room-delete-${roomId}`, configPath),
+        settleTask: taskId => launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, configPath),
     };
 }

package/dist/owner-channel/notices.d.ts

@@ -22,6 +22,13 @@ export declare const ownerNotices: {
     receivedStarted: () => string;
     receivedQueued: (queuedBehind: number) => string;
     receivedInterrupting: () => string;
+    /**
+     * The honest answer when the agent is mid-task and pre-empting it would have
+     * corrupted the conversation. Says "not started yet" rather than borrowing
+     * `receivedInterrupting`'s claim that something was cancelled for this
+     * request.
+     */
+    receivedDeferred: () => string;
     status: (role: string, snapshot: SessionSnapshot) => string;
     interrupted: (role: string) => string;
     /** The turn IS cancelled — say how, without implying the owner must retry. */

package/dist/owner-channel/notices.js

@@ -26,6 +26,15 @@ export const ownerNotices = {
     receivedInterrupting: () => "ℹ️ Message received. The agent's previous task was interrupted to prioritize "
         + 'this request, and it is now working on a response. '
         + 'The response will arrive in this channel when ready.',
+    /**
+     * The honest answer when the agent is mid-task and pre-empting it would have
+     * corrupted the conversation. Says "not started yet" rather than borrowing
+     * `receivedInterrupting`'s claim that something was cancelled for this
+     * request.
+     */
+    receivedDeferred: () => 'ℹ️ Message received and held. The agent is in the middle of a task that '
+        + 'cannot be interrupted safely; this request starts as soon as that work '
+        + 'reaches a stopping point. The response will arrive in this channel when ready.',
     status: (role, snapshot) => `📊 ${role} status: ${snapshot.readiness}; session is ${snapshot.alive ? 'online' : 'offline'}.`,
     interrupted: (role) => `🛑 Interrupt sent to ${role}'s active turn.`,
     /** The turn IS cancelled — say how, without implying the owner must retry. */