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

package/dist/owner-channel/channel.js

@@ -6,6 +6,7 @@ import { DEFAULT_OWNER_ATTACHMENT_MIME, canonicalCid, } from '../config.js';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, interruptOutcome, } from '../session/types.js';
 import { VERSION } from '../version.js';
+import { renderMarkdownFailure, renderMarkdownResult, taskStatus, } from '../rooms-tasks/markdown.js';
 import { dispatchOwnerCommand, fleetCliOps, isOwnerCommandText, } from './commands.js';
 import { OURS_BOUND_ELSEWHERE, OursSdkClient, oursErrorCode, } from './ours-client.js';
 import { ownerNotices, } from './notices.js';
@@ -195,10 +196,13 @@ export class OwnerChannel {
                 ? ' with interruption'
                 : event.monitor.interrupt === 'after_tool' ? ' with after-tool steering' : '';
             const monitor = `${event.monitor.mode} monitor${monitorPolicy}`;
+            const permission = event.permissionMode
+                ? `; permission ${event.permissionMode.fleetMode}, native ${event.permissionMode.nativeMode}`
+                : '';
             const inherited = event.inherited.length
                 ? ` Supervisor inherited omitted defaults: ${event.inherited.join(', ')}.` : '';
             await this.sendProactiveMessage(`🧑‍💻 ${event.caller} spawned ${event.lifetime} agent ${event.role} `
-                + `(${event.harness}/${event.session}${model}; ${monitor}).${inherited}`, `fleet-spawn\0${event.creationActionId}`, 0);
+                + `(${event.harness}/${event.session}${model}; ${monitor}${permission}).${inherited}`, `fleet-spawn\0${event.creationActionId}`, 0);
         });
         this.managementTail = run.then(() => undefined, () => undefined);
         return run;
@@ -789,17 +793,13 @@ export class OwnerChannel {
             outbox = this.outboxDir(originWireId);
             await mkdir(outbox, { recursive: true, mode: 0o700 });
             const activityCursor = this.latestEventSeq(this.options.session.eventsSince(0));
-            const queued = await this.options.session.queuePrompt(this.ownerAttachmentPrompt(sender, originWireId, requestId, outbox, admitted, group.caption), {
+            const queued = await this.options.session.queuePrompt(this.ownerAttachmentPrompt(sender, originWireId, requestId, admitted, group.caption), {
                 interrupt: this.options.config.interrupt,
                 ...(this.options.config.interrupt ? { interruptSource: 'owner' } : {}),
                 origin: { kind: 'owner', requestId,
                     ...(group.caption ? { displayText: String(group.caption.text ?? '') } : {}) },
             });
-            const accepted = this.options.config.interrupt
-                ? ownerNotices.receivedInterrupting()
-                : queued.queuedBehind > 0
-                    ? ownerNotices.receivedQueued(queued.queuedBehind)
-                    : ownerNotices.receivedStarted();
+            const accepted = this.acceptanceNotice(queued);
             handledWireIds.forEach(wire => this.inFlight.add(wire));
             const receipt = this.send(sender.id, accepted, originWireId).then(() => undefined).catch(error => {
                 this.logError(`attachment request ${requestId.slice(0, 12)} acceptance notice failed`, error);
@@ -918,7 +918,7 @@ export class OwnerChannel {
         let queued;
         const activityCursor = this.latestEventSeq(this.options.session.eventsSince(0));
         try {
-            queued = await this.options.session.queuePrompt(this.ownerPrompt(sender, text, wireId, outbox), {
+            queued = await this.options.session.queuePrompt(this.ownerPrompt(sender, text, wireId), {
                 interrupt: this.options.config.interrupt,
                 ...(this.options.config.interrupt ? { interruptSource: 'owner' } : {}),
                 origin: { kind: 'owner', requestId, displayText: text },
@@ -940,14 +940,7 @@ export class OwnerChannel {
             this.state.remember(wireId);
             return true;
         }
-        // Interrupting the live turn does not remove prompts which were already
-        // accepted into the ACP queue. Never claim this request is running while
-        // the session itself says earlier work remains ahead of it.
-        const accepted = queued.queuedBehind > 0
-            ? ownerNotices.receivedQueued(queued.queuedBehind)
-            : this.options.config.interrupt
-                ? ownerNotices.receivedInterrupting()
-                : ownerNotices.receivedStarted();
+        const accepted = this.acceptanceNotice(queued);
         this.inFlight.add(wireId);
         const receipt = this.send(sender.id, accepted, wireId).then(() => undefined).catch(error => {
             this.logError(`request ${requestId.slice(0, 12)} acceptance notice failed`, error);
@@ -1055,7 +1048,11 @@ export class OwnerChannel {
     async closeRoomFromOwner(sender, roomId, wireId) {
         const { acceptManagedRoomClose, recordManagedRoomCloseError } = await import('../rooms-tasks/close.js');
         await acceptManagedRoomClose(roomId);
-        await this.send(sender.id, `🗑️ Room ${roomId} deletion accepted/pending`, wireId);
+        await this.send(sender.id, renderMarkdownFailure({
+            kind: 'pending', subject: `/room delete ${roomId} ${roomId}`,
+            detail: 'The deletion request was accepted and is still being settled.',
+            action: `Run /room recover ${roomId} if deletion remains pending.`,
+        }), wireId);
         this.state.remember(wireId);
         try {
             await this.fleetOps.closeRoom(roomId);
@@ -1074,11 +1071,21 @@ export class OwnerChannel {
             taskId, kind, roomId: task.room_id, outcome,
         });
         if (accepted.terminal_intent?.status === 'settled') {
-            await this.send(sender.id, `✅ Task ${taskId} → ${accepted.state}`, wireId);
+            await this.send(sender.id, renderMarkdownResult({
+                icon: '📋', title: 'Task terminal action complete',
+                fields: [
+                    { label: 'ID', value: taskId, kind: 'code' },
+                    { label: 'Status', value: taskStatus(accepted.state), kind: 'markdown' },
+                ],
+            }), wireId);
             this.state.remember(wireId);
             return;
         }
-        await this.send(sender.id, `⏳ Task ${taskId} terminal intent accepted/pending`, wireId);
+        await this.send(sender.id, renderMarkdownFailure({
+            kind: 'pending', subject: `/task ${kind === 'done' ? 'done' : 'cancel'} ${taskId}`,
+            detail: 'The terminal request was accepted and is still being settled.',
+            action: `Run /task recover ${taskId} if it remains pending.`,
+        }), wireId);
         this.state.remember(wireId);
         try {
             await this.fleetOps.settleTask(taskId);
@@ -1374,6 +1381,32 @@ export class OwnerChannel {
     authorizationIntegrity() {
         return this.options.config.agent ? { ok: true } : this.authorizations.integrity();
     }
+    /**
+     * Report what the session actually did with the prompt, not what the config
+     * asked for. `interrupt: true` used to be reported as "your request
+     * interrupted the previous task" unconditionally; the session now answers
+     * whether anything was cancelled, whether the request is queued behind
+     * earlier prompts, or whether it is held until the current task reaches a
+     * safe stopping point. Backends that report no delivery state keep the old
+     * queuedBehind-based wording.
+     */
+    acceptanceNotice(queued) {
+        switch (queued.delivery) {
+            case 'interrupted': return ownerNotices.receivedInterrupting();
+            case 'deferred': return ownerNotices.receivedDeferred();
+            case 'queued': return ownerNotices.receivedQueued(Math.max(1, queued.queuedBehind));
+            case 'started': return ownerNotices.receivedStarted();
+            default:
+                // Interrupting the live turn does not remove prompts which were already
+                // accepted into the ACP queue. Never claim this request is running while
+                // the session itself says earlier work remains ahead of it.
+                return queued.queuedBehind > 0
+                    ? ownerNotices.receivedQueued(queued.queuedBehind)
+                    : this.options.config.interrupt
+                        ? ownerNotices.receivedInterrupting()
+                        : ownerNotices.receivedStarted();
+        }
+    }
     async complete(active, outbox, queued, activityCursor) {
         const progressMs = this.options.config.progress_interval_ms;
         let lastSeq = activityCursor;
@@ -1574,7 +1607,7 @@ export class OwnerChannel {
             throw new Error('commentary appears to contain secret, reasoning, or raw tool content');
         return message;
     }
-    ownerAttachmentPrompt(sender, wireId, requestId, outbox, files, caption) {
+    ownerAttachmentPrompt(sender, wireId, requestId, files, caption) {
         const lines = [
             '[fleet-owner]',
             `Authenticated owner ${safeField(sender.name, 160)} (${sender.id}) sent owner-channel attachment request ${wireId}.`,
@@ -1598,10 +1631,13 @@ export class OwnerChannel {
                     lines.push(`- voice transcript status: ${transcription?.status ?? 'unavailable'}`, `- voice transcript fallback: audio path above; category ${transcription?.errorCategory ?? 'not_provided'}`);
             }
         }
-        lines.push('Answer in your final assistant response; fleet routes it only to the authenticated sender and correlates it to the originating file wire.', `To attach response files, write regular files only to: ${outbox}`);
+        lines.push('Answer in your final assistant response; fleet routes it only to the authenticated sender and correlates it to the originating file wire.', 
+        // send_file is the only delivery route an agent is given: a tool call either
+        // delivers or reports an error, where a file written to disk does neither.
+        'To send the owner a file — now or later in this turn — call ours `send_file`:', `contact: ${this.options.config.identity}`, 'and the path of the finished file. Fleet routes it to the authenticated owner.', 'A file written anywhere else is not delivered and nothing will report that it was not.', 'Use descriptive unique filenames. Send nothing the owner did not request or should not receive.');
         return lines.join('\n');
     }
-    ownerPrompt(sender, text, wireId, outbox) {
+    ownerPrompt(sender, text, wireId) {
         return [
             '[fleet-owner]',
             `Authenticated owner ${sender.name} (${sender.id}) sent owner-channel message ${wireId}.`,
@@ -1615,10 +1651,13 @@ export class OwnerChannel {
             ] : [
                 'Managed-agent outbound relay is not configured; do not send intermediate or proactive owner-channel messages.',
             ]),
-            'To attach files to your response, copy each finished file directly into this fleet outbox:',
-            outbox,
-            'Fleet sends every regular file in that directory to the authenticated owner, correlated to this request.',
-            'Use descriptive unique filenames. Put nothing there that the owner did not request or should not receive.',
+            // send_file is the only delivery route an agent is given: a tool call either
+            // delivers or reports an error, where a file written to disk does neither.
+            'To send the owner a file — now or later in this turn — call ours `send_file`:',
+            `contact: ${this.options.config.identity}`,
+            'and the path of the finished file. Fleet routes it to the authenticated owner.',
+            'A file written anywhere else is not delivered and nothing will report that it was not.',
+            'Use descriptive unique filenames. Send nothing the owner did not request or should not receive.',
             '',
             text || '(empty message)',
         ].join('\n');

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;

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. */